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



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

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.itkIndexPython
import itk.itkSizePython
import itk.pyBasePython
import itk.itkOffsetPython
import itk.itkImageToImageFilterBPython
import itk.itkImageRegionPython
import itk.ITKCommonBasePython
import itk.itkMatrixPython
import itk.vnl_matrix_fixedPython
import itk.vnl_vectorPython
import itk.stdcomplexPython
import itk.vnl_matrixPython
import itk.itkPointPython
import itk.vnl_vector_refPython
import itk.itkFixedArrayPython
import itk.itkVectorPython
import itk.itkCovariantVectorPython
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
import itk.itkImageToImageFilterAPython

def itkScanlineFilterCommonICVF22ISS2_New():
    return itkScanlineFilterCommonICVF22ISS2.New()

class itkScanlineFilterCommonICVF22ISS2(object):
    r"""Proxy of C++ itkScanlineFilterCommonICVF22ISS2 class."""

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkScanlineFilterCommonICVF22ISS2_Pointer"""
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF22ISS2___New_orig__()
    SameDimension = _itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF22ISS2_SameDimension
    

    def __init__(self, enclosingFilter):
        r"""
        __init__(self, enclosingFilter) -> itkScanlineFilterCommonICVF22ISS2

        Parameters
        ----------
        enclosingFilter: itkImageToImageFilterICVF22ISS2 *

        """
        _itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF22ISS2_swiginit(self, _itkScanlineFilterCommonPython.new_itkScanlineFilterCommonICVF22ISS2(enclosingFilter))
    __swig_destroy__ = _itkScanlineFilterCommonPython.delete_itkScanlineFilterCommonICVF22ISS2

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

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

        """
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF22ISS2_cast(obj)

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

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

          itkScanlineFilterCommonICVF22ISS2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkScanlineFilterCommonICVF22ISS2 in _itkScanlineFilterCommonPython:
_itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF22ISS2_swigregister(itkScanlineFilterCommonICVF22ISS2)

def itkScanlineFilterCommonICVF22IUC2_New():
    return itkScanlineFilterCommonICVF22IUC2.New()

class itkScanlineFilterCommonICVF22IUC2(object):
    r"""Proxy of C++ itkScanlineFilterCommonICVF22IUC2 class."""

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkScanlineFilterCommonICVF22IUC2_Pointer"""
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF22IUC2___New_orig__()
    SameDimension = _itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF22IUC2_SameDimension
    

    def __init__(self, enclosingFilter):
        r"""
        __init__(self, enclosingFilter) -> itkScanlineFilterCommonICVF22IUC2

        Parameters
        ----------
        enclosingFilter: itkImageToImageFilterICVF22IUC2 *

        """
        _itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF22IUC2_swiginit(self, _itkScanlineFilterCommonPython.new_itkScanlineFilterCommonICVF22IUC2(enclosingFilter))
    __swig_destroy__ = _itkScanlineFilterCommonPython.delete_itkScanlineFilterCommonICVF22IUC2

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

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

        """
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF22IUC2_cast(obj)

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

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

          itkScanlineFilterCommonICVF22IUC2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkScanlineFilterCommonICVF22IUC2 in _itkScanlineFilterCommonPython:
_itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF22IUC2_swigregister(itkScanlineFilterCommonICVF22IUC2)

def itkScanlineFilterCommonICVF23ISS3_New():
    return itkScanlineFilterCommonICVF23ISS3.New()

class itkScanlineFilterCommonICVF23ISS3(object):
    r"""Proxy of C++ itkScanlineFilterCommonICVF23ISS3 class."""

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkScanlineFilterCommonICVF23ISS3_Pointer"""
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF23ISS3___New_orig__()
    SameDimension = _itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF23ISS3_SameDimension
    

    def __init__(self, enclosingFilter):
        r"""
        __init__(self, enclosingFilter) -> itkScanlineFilterCommonICVF23ISS3

        Parameters
        ----------
        enclosingFilter: itkImageToImageFilterICVF23ISS3 *

        """
        _itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF23ISS3_swiginit(self, _itkScanlineFilterCommonPython.new_itkScanlineFilterCommonICVF23ISS3(enclosingFilter))
    __swig_destroy__ = _itkScanlineFilterCommonPython.delete_itkScanlineFilterCommonICVF23ISS3

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

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

        """
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF23ISS3_cast(obj)

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

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

          itkScanlineFilterCommonICVF23ISS3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkScanlineFilterCommonICVF23ISS3 in _itkScanlineFilterCommonPython:
_itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF23ISS3_swigregister(itkScanlineFilterCommonICVF23ISS3)

def itkScanlineFilterCommonICVF23IUC3_New():
    return itkScanlineFilterCommonICVF23IUC3.New()

class itkScanlineFilterCommonICVF23IUC3(object):
    r"""Proxy of C++ itkScanlineFilterCommonICVF23IUC3 class."""

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkScanlineFilterCommonICVF23IUC3_Pointer"""
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF23IUC3___New_orig__()
    SameDimension = _itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF23IUC3_SameDimension
    

    def __init__(self, enclosingFilter):
        r"""
        __init__(self, enclosingFilter) -> itkScanlineFilterCommonICVF23IUC3

        Parameters
        ----------
        enclosingFilter: itkImageToImageFilterICVF23IUC3 *

        """
        _itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF23IUC3_swiginit(self, _itkScanlineFilterCommonPython.new_itkScanlineFilterCommonICVF23IUC3(enclosingFilter))
    __swig_destroy__ = _itkScanlineFilterCommonPython.delete_itkScanlineFilterCommonICVF23IUC3

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

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

        """
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF23IUC3_cast(obj)

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

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

          itkScanlineFilterCommonICVF23IUC3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkScanlineFilterCommonICVF23IUC3 in _itkScanlineFilterCommonPython:
_itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF23IUC3_swigregister(itkScanlineFilterCommonICVF23IUC3)

def itkScanlineFilterCommonICVF32ISS2_New():
    return itkScanlineFilterCommonICVF32ISS2.New()

class itkScanlineFilterCommonICVF32ISS2(object):
    r"""Proxy of C++ itkScanlineFilterCommonICVF32ISS2 class."""

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkScanlineFilterCommonICVF32ISS2_Pointer"""
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF32ISS2___New_orig__()
    SameDimension = _itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF32ISS2_SameDimension
    

    def __init__(self, enclosingFilter):
        r"""
        __init__(self, enclosingFilter) -> itkScanlineFilterCommonICVF32ISS2

        Parameters
        ----------
        enclosingFilter: itkImageToImageFilterICVF32ISS2 *

        """
        _itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF32ISS2_swiginit(self, _itkScanlineFilterCommonPython.new_itkScanlineFilterCommonICVF32ISS2(enclosingFilter))
    __swig_destroy__ = _itkScanlineFilterCommonPython.delete_itkScanlineFilterCommonICVF32ISS2

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

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

        """
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF32ISS2_cast(obj)

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

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

          itkScanlineFilterCommonICVF32ISS2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkScanlineFilterCommonICVF32ISS2 in _itkScanlineFilterCommonPython:
_itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF32ISS2_swigregister(itkScanlineFilterCommonICVF32ISS2)

def itkScanlineFilterCommonICVF32IUC2_New():
    return itkScanlineFilterCommonICVF32IUC2.New()

class itkScanlineFilterCommonICVF32IUC2(object):
    r"""Proxy of C++ itkScanlineFilterCommonICVF32IUC2 class."""

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkScanlineFilterCommonICVF32IUC2_Pointer"""
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF32IUC2___New_orig__()
    SameDimension = _itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF32IUC2_SameDimension
    

    def __init__(self, enclosingFilter):
        r"""
        __init__(self, enclosingFilter) -> itkScanlineFilterCommonICVF32IUC2

        Parameters
        ----------
        enclosingFilter: itkImageToImageFilterICVF32IUC2 *

        """
        _itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF32IUC2_swiginit(self, _itkScanlineFilterCommonPython.new_itkScanlineFilterCommonICVF32IUC2(enclosingFilter))
    __swig_destroy__ = _itkScanlineFilterCommonPython.delete_itkScanlineFilterCommonICVF32IUC2

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

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

        """
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF32IUC2_cast(obj)

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

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

          itkScanlineFilterCommonICVF32IUC2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkScanlineFilterCommonICVF32IUC2 in _itkScanlineFilterCommonPython:
_itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF32IUC2_swigregister(itkScanlineFilterCommonICVF32IUC2)

def itkScanlineFilterCommonICVF33ISS3_New():
    return itkScanlineFilterCommonICVF33ISS3.New()

class itkScanlineFilterCommonICVF33ISS3(object):
    r"""Proxy of C++ itkScanlineFilterCommonICVF33ISS3 class."""

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkScanlineFilterCommonICVF33ISS3_Pointer"""
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF33ISS3___New_orig__()
    SameDimension = _itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF33ISS3_SameDimension
    

    def __init__(self, enclosingFilter):
        r"""
        __init__(self, enclosingFilter) -> itkScanlineFilterCommonICVF33ISS3

        Parameters
        ----------
        enclosingFilter: itkImageToImageFilterICVF33ISS3 *

        """
        _itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF33ISS3_swiginit(self, _itkScanlineFilterCommonPython.new_itkScanlineFilterCommonICVF33ISS3(enclosingFilter))
    __swig_destroy__ = _itkScanlineFilterCommonPython.delete_itkScanlineFilterCommonICVF33ISS3

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

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

        """
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF33ISS3_cast(obj)

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

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

          itkScanlineFilterCommonICVF33ISS3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkScanlineFilterCommonICVF33ISS3 in _itkScanlineFilterCommonPython:
_itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF33ISS3_swigregister(itkScanlineFilterCommonICVF33ISS3)

def itkScanlineFilterCommonICVF33IUC3_New():
    return itkScanlineFilterCommonICVF33IUC3.New()

class itkScanlineFilterCommonICVF33IUC3(object):
    r"""Proxy of C++ itkScanlineFilterCommonICVF33IUC3 class."""

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkScanlineFilterCommonICVF33IUC3_Pointer"""
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF33IUC3___New_orig__()
    SameDimension = _itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF33IUC3_SameDimension
    

    def __init__(self, enclosingFilter):
        r"""
        __init__(self, enclosingFilter) -> itkScanlineFilterCommonICVF33IUC3

        Parameters
        ----------
        enclosingFilter: itkImageToImageFilterICVF33IUC3 *

        """
        _itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF33IUC3_swiginit(self, _itkScanlineFilterCommonPython.new_itkScanlineFilterCommonICVF33IUC3(enclosingFilter))
    __swig_destroy__ = _itkScanlineFilterCommonPython.delete_itkScanlineFilterCommonICVF33IUC3

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

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

        """
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF33IUC3_cast(obj)

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

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

          itkScanlineFilterCommonICVF33IUC3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkScanlineFilterCommonICVF33IUC3 in _itkScanlineFilterCommonPython:
_itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF33IUC3_swigregister(itkScanlineFilterCommonICVF33IUC3)

def itkScanlineFilterCommonICVF42ISS2_New():
    return itkScanlineFilterCommonICVF42ISS2.New()

class itkScanlineFilterCommonICVF42ISS2(object):
    r"""Proxy of C++ itkScanlineFilterCommonICVF42ISS2 class."""

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkScanlineFilterCommonICVF42ISS2_Pointer"""
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF42ISS2___New_orig__()
    SameDimension = _itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF42ISS2_SameDimension
    

    def __init__(self, enclosingFilter):
        r"""
        __init__(self, enclosingFilter) -> itkScanlineFilterCommonICVF42ISS2

        Parameters
        ----------
        enclosingFilter: itkImageToImageFilterICVF42ISS2 *

        """
        _itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF42ISS2_swiginit(self, _itkScanlineFilterCommonPython.new_itkScanlineFilterCommonICVF42ISS2(enclosingFilter))
    __swig_destroy__ = _itkScanlineFilterCommonPython.delete_itkScanlineFilterCommonICVF42ISS2

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

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

        """
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF42ISS2_cast(obj)

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

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

          itkScanlineFilterCommonICVF42ISS2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkScanlineFilterCommonICVF42ISS2 in _itkScanlineFilterCommonPython:
_itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF42ISS2_swigregister(itkScanlineFilterCommonICVF42ISS2)

def itkScanlineFilterCommonICVF42IUC2_New():
    return itkScanlineFilterCommonICVF42IUC2.New()

class itkScanlineFilterCommonICVF42IUC2(object):
    r"""Proxy of C++ itkScanlineFilterCommonICVF42IUC2 class."""

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkScanlineFilterCommonICVF42IUC2_Pointer"""
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF42IUC2___New_orig__()
    SameDimension = _itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF42IUC2_SameDimension
    

    def __init__(self, enclosingFilter):
        r"""
        __init__(self, enclosingFilter) -> itkScanlineFilterCommonICVF42IUC2

        Parameters
        ----------
        enclosingFilter: itkImageToImageFilterICVF42IUC2 *

        """
        _itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF42IUC2_swiginit(self, _itkScanlineFilterCommonPython.new_itkScanlineFilterCommonICVF42IUC2(enclosingFilter))
    __swig_destroy__ = _itkScanlineFilterCommonPython.delete_itkScanlineFilterCommonICVF42IUC2

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

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

        """
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF42IUC2_cast(obj)

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

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

          itkScanlineFilterCommonICVF42IUC2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkScanlineFilterCommonICVF42IUC2 in _itkScanlineFilterCommonPython:
_itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF42IUC2_swigregister(itkScanlineFilterCommonICVF42IUC2)

def itkScanlineFilterCommonICVF43ISS3_New():
    return itkScanlineFilterCommonICVF43ISS3.New()

class itkScanlineFilterCommonICVF43ISS3(object):
    r"""Proxy of C++ itkScanlineFilterCommonICVF43ISS3 class."""

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkScanlineFilterCommonICVF43ISS3_Pointer"""
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF43ISS3___New_orig__()
    SameDimension = _itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF43ISS3_SameDimension
    

    def __init__(self, enclosingFilter):
        r"""
        __init__(self, enclosingFilter) -> itkScanlineFilterCommonICVF43ISS3

        Parameters
        ----------
        enclosingFilter: itkImageToImageFilterICVF43ISS3 *

        """
        _itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF43ISS3_swiginit(self, _itkScanlineFilterCommonPython.new_itkScanlineFilterCommonICVF43ISS3(enclosingFilter))
    __swig_destroy__ = _itkScanlineFilterCommonPython.delete_itkScanlineFilterCommonICVF43ISS3

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

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

        """
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF43ISS3_cast(obj)

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

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

          itkScanlineFilterCommonICVF43ISS3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkScanlineFilterCommonICVF43ISS3 in _itkScanlineFilterCommonPython:
_itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF43ISS3_swigregister(itkScanlineFilterCommonICVF43ISS3)

def itkScanlineFilterCommonICVF43IUC3_New():
    return itkScanlineFilterCommonICVF43IUC3.New()

class itkScanlineFilterCommonICVF43IUC3(object):
    r"""Proxy of C++ itkScanlineFilterCommonICVF43IUC3 class."""

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkScanlineFilterCommonICVF43IUC3_Pointer"""
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF43IUC3___New_orig__()
    SameDimension = _itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF43IUC3_SameDimension
    

    def __init__(self, enclosingFilter):
        r"""
        __init__(self, enclosingFilter) -> itkScanlineFilterCommonICVF43IUC3

        Parameters
        ----------
        enclosingFilter: itkImageToImageFilterICVF43IUC3 *

        """
        _itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF43IUC3_swiginit(self, _itkScanlineFilterCommonPython.new_itkScanlineFilterCommonICVF43IUC3(enclosingFilter))
    __swig_destroy__ = _itkScanlineFilterCommonPython.delete_itkScanlineFilterCommonICVF43IUC3

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

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

        """
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF43IUC3_cast(obj)

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

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

          itkScanlineFilterCommonICVF43IUC3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkScanlineFilterCommonICVF43IUC3 in _itkScanlineFilterCommonPython:
_itkScanlineFilterCommonPython.itkScanlineFilterCommonICVF43IUC3_swigregister(itkScanlineFilterCommonICVF43IUC3)

def itkScanlineFilterCommonIF2IF2_New():
    return itkScanlineFilterCommonIF2IF2.New()

class itkScanlineFilterCommonIF2IF2(object):
    r"""Proxy of C++ itkScanlineFilterCommonIF2IF2 class."""

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkScanlineFilterCommonIF2IF2_Pointer"""
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonIF2IF2___New_orig__()
    SameDimension = _itkScanlineFilterCommonPython.itkScanlineFilterCommonIF2IF2_SameDimension
    

    def __init__(self, enclosingFilter):
        r"""
        __init__(self, enclosingFilter) -> itkScanlineFilterCommonIF2IF2

        Parameters
        ----------
        enclosingFilter: itkImageToImageFilterIF2IF2 *

        """
        _itkScanlineFilterCommonPython.itkScanlineFilterCommonIF2IF2_swiginit(self, _itkScanlineFilterCommonPython.new_itkScanlineFilterCommonIF2IF2(enclosingFilter))
    __swig_destroy__ = _itkScanlineFilterCommonPython.delete_itkScanlineFilterCommonIF2IF2

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

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

        """
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonIF2IF2_cast(obj)

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

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

          itkScanlineFilterCommonIF2IF2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkScanlineFilterCommonIF2IF2 in _itkScanlineFilterCommonPython:
_itkScanlineFilterCommonPython.itkScanlineFilterCommonIF2IF2_swigregister(itkScanlineFilterCommonIF2IF2)

def itkScanlineFilterCommonIF3IF3_New():
    return itkScanlineFilterCommonIF3IF3.New()

class itkScanlineFilterCommonIF3IF3(object):
    r"""Proxy of C++ itkScanlineFilterCommonIF3IF3 class."""

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkScanlineFilterCommonIF3IF3_Pointer"""
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonIF3IF3___New_orig__()
    SameDimension = _itkScanlineFilterCommonPython.itkScanlineFilterCommonIF3IF3_SameDimension
    

    def __init__(self, enclosingFilter):
        r"""
        __init__(self, enclosingFilter) -> itkScanlineFilterCommonIF3IF3

        Parameters
        ----------
        enclosingFilter: itkImageToImageFilterIF3IF3 *

        """
        _itkScanlineFilterCommonPython.itkScanlineFilterCommonIF3IF3_swiginit(self, _itkScanlineFilterCommonPython.new_itkScanlineFilterCommonIF3IF3(enclosingFilter))
    __swig_destroy__ = _itkScanlineFilterCommonPython.delete_itkScanlineFilterCommonIF3IF3

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

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

        """
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonIF3IF3_cast(obj)

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

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

          itkScanlineFilterCommonIF3IF3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkScanlineFilterCommonIF3IF3 in _itkScanlineFilterCommonPython:
_itkScanlineFilterCommonPython.itkScanlineFilterCommonIF3IF3_swigregister(itkScanlineFilterCommonIF3IF3)

def itkScanlineFilterCommonISS2ISS2_New():
    return itkScanlineFilterCommonISS2ISS2.New()

class itkScanlineFilterCommonISS2ISS2(object):
    r"""Proxy of C++ itkScanlineFilterCommonISS2ISS2 class."""

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkScanlineFilterCommonISS2ISS2_Pointer"""
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonISS2ISS2___New_orig__()
    SameDimension = _itkScanlineFilterCommonPython.itkScanlineFilterCommonISS2ISS2_SameDimension
    

    def __init__(self, enclosingFilter):
        r"""
        __init__(self, enclosingFilter) -> itkScanlineFilterCommonISS2ISS2

        Parameters
        ----------
        enclosingFilter: itkImageToImageFilterISS2ISS2 *

        """
        _itkScanlineFilterCommonPython.itkScanlineFilterCommonISS2ISS2_swiginit(self, _itkScanlineFilterCommonPython.new_itkScanlineFilterCommonISS2ISS2(enclosingFilter))
    __swig_destroy__ = _itkScanlineFilterCommonPython.delete_itkScanlineFilterCommonISS2ISS2

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

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

        """
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonISS2ISS2_cast(obj)

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

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

          itkScanlineFilterCommonISS2ISS2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkScanlineFilterCommonISS2ISS2 in _itkScanlineFilterCommonPython:
_itkScanlineFilterCommonPython.itkScanlineFilterCommonISS2ISS2_swigregister(itkScanlineFilterCommonISS2ISS2)

def itkScanlineFilterCommonISS2IUC2_New():
    return itkScanlineFilterCommonISS2IUC2.New()

class itkScanlineFilterCommonISS2IUC2(object):
    r"""Proxy of C++ itkScanlineFilterCommonISS2IUC2 class."""

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkScanlineFilterCommonISS2IUC2_Pointer"""
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonISS2IUC2___New_orig__()
    SameDimension = _itkScanlineFilterCommonPython.itkScanlineFilterCommonISS2IUC2_SameDimension
    

    def __init__(self, enclosingFilter):
        r"""
        __init__(self, enclosingFilter) -> itkScanlineFilterCommonISS2IUC2

        Parameters
        ----------
        enclosingFilter: itkImageToImageFilterISS2IUC2 *

        """
        _itkScanlineFilterCommonPython.itkScanlineFilterCommonISS2IUC2_swiginit(self, _itkScanlineFilterCommonPython.new_itkScanlineFilterCommonISS2IUC2(enclosingFilter))
    __swig_destroy__ = _itkScanlineFilterCommonPython.delete_itkScanlineFilterCommonISS2IUC2

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

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

        """
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonISS2IUC2_cast(obj)

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

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

          itkScanlineFilterCommonISS2IUC2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkScanlineFilterCommonISS2IUC2 in _itkScanlineFilterCommonPython:
_itkScanlineFilterCommonPython.itkScanlineFilterCommonISS2IUC2_swigregister(itkScanlineFilterCommonISS2IUC2)

def itkScanlineFilterCommonISS2IUL2_New():
    return itkScanlineFilterCommonISS2IUL2.New()

class itkScanlineFilterCommonISS2IUL2(object):
    r"""Proxy of C++ itkScanlineFilterCommonISS2IUL2 class."""

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkScanlineFilterCommonISS2IUL2_Pointer"""
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonISS2IUL2___New_orig__()
    SameDimension = _itkScanlineFilterCommonPython.itkScanlineFilterCommonISS2IUL2_SameDimension
    

    def __init__(self, enclosingFilter):
        r"""
        __init__(self, enclosingFilter) -> itkScanlineFilterCommonISS2IUL2

        Parameters
        ----------
        enclosingFilter: itkImageToImageFilterISS2IUL2 *

        """
        _itkScanlineFilterCommonPython.itkScanlineFilterCommonISS2IUL2_swiginit(self, _itkScanlineFilterCommonPython.new_itkScanlineFilterCommonISS2IUL2(enclosingFilter))
    __swig_destroy__ = _itkScanlineFilterCommonPython.delete_itkScanlineFilterCommonISS2IUL2

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

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

        """
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonISS2IUL2_cast(obj)

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

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

          itkScanlineFilterCommonISS2IUL2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkScanlineFilterCommonISS2IUL2 in _itkScanlineFilterCommonPython:
_itkScanlineFilterCommonPython.itkScanlineFilterCommonISS2IUL2_swigregister(itkScanlineFilterCommonISS2IUL2)

def itkScanlineFilterCommonISS3ISS3_New():
    return itkScanlineFilterCommonISS3ISS3.New()

class itkScanlineFilterCommonISS3ISS3(object):
    r"""Proxy of C++ itkScanlineFilterCommonISS3ISS3 class."""

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkScanlineFilterCommonISS3ISS3_Pointer"""
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonISS3ISS3___New_orig__()
    SameDimension = _itkScanlineFilterCommonPython.itkScanlineFilterCommonISS3ISS3_SameDimension
    

    def __init__(self, enclosingFilter):
        r"""
        __init__(self, enclosingFilter) -> itkScanlineFilterCommonISS3ISS3

        Parameters
        ----------
        enclosingFilter: itkImageToImageFilterISS3ISS3 *

        """
        _itkScanlineFilterCommonPython.itkScanlineFilterCommonISS3ISS3_swiginit(self, _itkScanlineFilterCommonPython.new_itkScanlineFilterCommonISS3ISS3(enclosingFilter))
    __swig_destroy__ = _itkScanlineFilterCommonPython.delete_itkScanlineFilterCommonISS3ISS3

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

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

        """
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonISS3ISS3_cast(obj)

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

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

          itkScanlineFilterCommonISS3ISS3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkScanlineFilterCommonISS3ISS3 in _itkScanlineFilterCommonPython:
_itkScanlineFilterCommonPython.itkScanlineFilterCommonISS3ISS3_swigregister(itkScanlineFilterCommonISS3ISS3)

def itkScanlineFilterCommonISS3IUC3_New():
    return itkScanlineFilterCommonISS3IUC3.New()

class itkScanlineFilterCommonISS3IUC3(object):
    r"""Proxy of C++ itkScanlineFilterCommonISS3IUC3 class."""

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkScanlineFilterCommonISS3IUC3_Pointer"""
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonISS3IUC3___New_orig__()
    SameDimension = _itkScanlineFilterCommonPython.itkScanlineFilterCommonISS3IUC3_SameDimension
    

    def __init__(self, enclosingFilter):
        r"""
        __init__(self, enclosingFilter) -> itkScanlineFilterCommonISS3IUC3

        Parameters
        ----------
        enclosingFilter: itkImageToImageFilterISS3IUC3 *

        """
        _itkScanlineFilterCommonPython.itkScanlineFilterCommonISS3IUC3_swiginit(self, _itkScanlineFilterCommonPython.new_itkScanlineFilterCommonISS3IUC3(enclosingFilter))
    __swig_destroy__ = _itkScanlineFilterCommonPython.delete_itkScanlineFilterCommonISS3IUC3

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

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

        """
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonISS3IUC3_cast(obj)

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

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

          itkScanlineFilterCommonISS3IUC3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkScanlineFilterCommonISS3IUC3 in _itkScanlineFilterCommonPython:
_itkScanlineFilterCommonPython.itkScanlineFilterCommonISS3IUC3_swigregister(itkScanlineFilterCommonISS3IUC3)

def itkScanlineFilterCommonISS3IUL3_New():
    return itkScanlineFilterCommonISS3IUL3.New()

class itkScanlineFilterCommonISS3IUL3(object):
    r"""Proxy of C++ itkScanlineFilterCommonISS3IUL3 class."""

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkScanlineFilterCommonISS3IUL3_Pointer"""
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonISS3IUL3___New_orig__()
    SameDimension = _itkScanlineFilterCommonPython.itkScanlineFilterCommonISS3IUL3_SameDimension
    

    def __init__(self, enclosingFilter):
        r"""
        __init__(self, enclosingFilter) -> itkScanlineFilterCommonISS3IUL3

        Parameters
        ----------
        enclosingFilter: itkImageToImageFilterISS3IUL3 *

        """
        _itkScanlineFilterCommonPython.itkScanlineFilterCommonISS3IUL3_swiginit(self, _itkScanlineFilterCommonPython.new_itkScanlineFilterCommonISS3IUL3(enclosingFilter))
    __swig_destroy__ = _itkScanlineFilterCommonPython.delete_itkScanlineFilterCommonISS3IUL3

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

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

        """
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonISS3IUL3_cast(obj)

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

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

          itkScanlineFilterCommonISS3IUL3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkScanlineFilterCommonISS3IUL3 in _itkScanlineFilterCommonPython:
_itkScanlineFilterCommonPython.itkScanlineFilterCommonISS3IUL3_swigregister(itkScanlineFilterCommonISS3IUL3)

def itkScanlineFilterCommonIUC2ISS2_New():
    return itkScanlineFilterCommonIUC2ISS2.New()

class itkScanlineFilterCommonIUC2ISS2(object):
    r"""Proxy of C++ itkScanlineFilterCommonIUC2ISS2 class."""

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkScanlineFilterCommonIUC2ISS2_Pointer"""
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonIUC2ISS2___New_orig__()
    SameDimension = _itkScanlineFilterCommonPython.itkScanlineFilterCommonIUC2ISS2_SameDimension
    

    def __init__(self, enclosingFilter):
        r"""
        __init__(self, enclosingFilter) -> itkScanlineFilterCommonIUC2ISS2

        Parameters
        ----------
        enclosingFilter: itkImageToImageFilterIUC2ISS2 *

        """
        _itkScanlineFilterCommonPython.itkScanlineFilterCommonIUC2ISS2_swiginit(self, _itkScanlineFilterCommonPython.new_itkScanlineFilterCommonIUC2ISS2(enclosingFilter))
    __swig_destroy__ = _itkScanlineFilterCommonPython.delete_itkScanlineFilterCommonIUC2ISS2

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

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

        """
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonIUC2ISS2_cast(obj)

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

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

          itkScanlineFilterCommonIUC2ISS2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkScanlineFilterCommonIUC2ISS2 in _itkScanlineFilterCommonPython:
_itkScanlineFilterCommonPython.itkScanlineFilterCommonIUC2ISS2_swigregister(itkScanlineFilterCommonIUC2ISS2)

def itkScanlineFilterCommonIUC2IUC2_New():
    return itkScanlineFilterCommonIUC2IUC2.New()

class itkScanlineFilterCommonIUC2IUC2(object):
    r"""Proxy of C++ itkScanlineFilterCommonIUC2IUC2 class."""

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkScanlineFilterCommonIUC2IUC2_Pointer"""
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonIUC2IUC2___New_orig__()
    SameDimension = _itkScanlineFilterCommonPython.itkScanlineFilterCommonIUC2IUC2_SameDimension
    

    def __init__(self, enclosingFilter):
        r"""
        __init__(self, enclosingFilter) -> itkScanlineFilterCommonIUC2IUC2

        Parameters
        ----------
        enclosingFilter: itkImageToImageFilterIUC2IUC2 *

        """
        _itkScanlineFilterCommonPython.itkScanlineFilterCommonIUC2IUC2_swiginit(self, _itkScanlineFilterCommonPython.new_itkScanlineFilterCommonIUC2IUC2(enclosingFilter))
    __swig_destroy__ = _itkScanlineFilterCommonPython.delete_itkScanlineFilterCommonIUC2IUC2

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

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

        """
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonIUC2IUC2_cast(obj)

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

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

          itkScanlineFilterCommonIUC2IUC2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkScanlineFilterCommonIUC2IUC2 in _itkScanlineFilterCommonPython:
_itkScanlineFilterCommonPython.itkScanlineFilterCommonIUC2IUC2_swigregister(itkScanlineFilterCommonIUC2IUC2)

def itkScanlineFilterCommonIUC2IUL2_New():
    return itkScanlineFilterCommonIUC2IUL2.New()

class itkScanlineFilterCommonIUC2IUL2(object):
    r"""Proxy of C++ itkScanlineFilterCommonIUC2IUL2 class."""

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkScanlineFilterCommonIUC2IUL2_Pointer"""
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonIUC2IUL2___New_orig__()
    SameDimension = _itkScanlineFilterCommonPython.itkScanlineFilterCommonIUC2IUL2_SameDimension
    

    def __init__(self, enclosingFilter):
        r"""
        __init__(self, enclosingFilter) -> itkScanlineFilterCommonIUC2IUL2

        Parameters
        ----------
        enclosingFilter: itkImageToImageFilterIUC2IUL2 *

        """
        _itkScanlineFilterCommonPython.itkScanlineFilterCommonIUC2IUL2_swiginit(self, _itkScanlineFilterCommonPython.new_itkScanlineFilterCommonIUC2IUL2(enclosingFilter))
    __swig_destroy__ = _itkScanlineFilterCommonPython.delete_itkScanlineFilterCommonIUC2IUL2

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

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

        """
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonIUC2IUL2_cast(obj)

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

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

          itkScanlineFilterCommonIUC2IUL2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkScanlineFilterCommonIUC2IUL2 in _itkScanlineFilterCommonPython:
_itkScanlineFilterCommonPython.itkScanlineFilterCommonIUC2IUL2_swigregister(itkScanlineFilterCommonIUC2IUL2)

def itkScanlineFilterCommonIUC3ISS3_New():
    return itkScanlineFilterCommonIUC3ISS3.New()

class itkScanlineFilterCommonIUC3ISS3(object):
    r"""Proxy of C++ itkScanlineFilterCommonIUC3ISS3 class."""

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkScanlineFilterCommonIUC3ISS3_Pointer"""
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonIUC3ISS3___New_orig__()
    SameDimension = _itkScanlineFilterCommonPython.itkScanlineFilterCommonIUC3ISS3_SameDimension
    

    def __init__(self, enclosingFilter):
        r"""
        __init__(self, enclosingFilter) -> itkScanlineFilterCommonIUC3ISS3

        Parameters
        ----------
        enclosingFilter: itkImageToImageFilterIUC3ISS3 *

        """
        _itkScanlineFilterCommonPython.itkScanlineFilterCommonIUC3ISS3_swiginit(self, _itkScanlineFilterCommonPython.new_itkScanlineFilterCommonIUC3ISS3(enclosingFilter))
    __swig_destroy__ = _itkScanlineFilterCommonPython.delete_itkScanlineFilterCommonIUC3ISS3

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

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

        """
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonIUC3ISS3_cast(obj)

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

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

          itkScanlineFilterCommonIUC3ISS3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkScanlineFilterCommonIUC3ISS3 in _itkScanlineFilterCommonPython:
_itkScanlineFilterCommonPython.itkScanlineFilterCommonIUC3ISS3_swigregister(itkScanlineFilterCommonIUC3ISS3)

def itkScanlineFilterCommonIUC3IUC3_New():
    return itkScanlineFilterCommonIUC3IUC3.New()

class itkScanlineFilterCommonIUC3IUC3(object):
    r"""Proxy of C++ itkScanlineFilterCommonIUC3IUC3 class."""

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkScanlineFilterCommonIUC3IUC3_Pointer"""
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonIUC3IUC3___New_orig__()
    SameDimension = _itkScanlineFilterCommonPython.itkScanlineFilterCommonIUC3IUC3_SameDimension
    

    def __init__(self, enclosingFilter):
        r"""
        __init__(self, enclosingFilter) -> itkScanlineFilterCommonIUC3IUC3

        Parameters
        ----------
        enclosingFilter: itkImageToImageFilterIUC3IUC3 *

        """
        _itkScanlineFilterCommonPython.itkScanlineFilterCommonIUC3IUC3_swiginit(self, _itkScanlineFilterCommonPython.new_itkScanlineFilterCommonIUC3IUC3(enclosingFilter))
    __swig_destroy__ = _itkScanlineFilterCommonPython.delete_itkScanlineFilterCommonIUC3IUC3

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

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

        """
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonIUC3IUC3_cast(obj)

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

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

          itkScanlineFilterCommonIUC3IUC3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkScanlineFilterCommonIUC3IUC3 in _itkScanlineFilterCommonPython:
_itkScanlineFilterCommonPython.itkScanlineFilterCommonIUC3IUC3_swigregister(itkScanlineFilterCommonIUC3IUC3)

def itkScanlineFilterCommonIUC3IUL3_New():
    return itkScanlineFilterCommonIUC3IUL3.New()

class itkScanlineFilterCommonIUC3IUL3(object):
    r"""Proxy of C++ itkScanlineFilterCommonIUC3IUL3 class."""

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkScanlineFilterCommonIUC3IUL3_Pointer"""
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonIUC3IUL3___New_orig__()
    SameDimension = _itkScanlineFilterCommonPython.itkScanlineFilterCommonIUC3IUL3_SameDimension
    

    def __init__(self, enclosingFilter):
        r"""
        __init__(self, enclosingFilter) -> itkScanlineFilterCommonIUC3IUL3

        Parameters
        ----------
        enclosingFilter: itkImageToImageFilterIUC3IUL3 *

        """
        _itkScanlineFilterCommonPython.itkScanlineFilterCommonIUC3IUL3_swiginit(self, _itkScanlineFilterCommonPython.new_itkScanlineFilterCommonIUC3IUL3(enclosingFilter))
    __swig_destroy__ = _itkScanlineFilterCommonPython.delete_itkScanlineFilterCommonIUC3IUL3

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

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

        """
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonIUC3IUL3_cast(obj)

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

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

          itkScanlineFilterCommonIUC3IUL3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkScanlineFilterCommonIUC3IUL3 in _itkScanlineFilterCommonPython:
_itkScanlineFilterCommonPython.itkScanlineFilterCommonIUC3IUL3_swigregister(itkScanlineFilterCommonIUC3IUL3)

def itkScanlineFilterCommonIVF22ISS2_New():
    return itkScanlineFilterCommonIVF22ISS2.New()

class itkScanlineFilterCommonIVF22ISS2(object):
    r"""Proxy of C++ itkScanlineFilterCommonIVF22ISS2 class."""

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkScanlineFilterCommonIVF22ISS2_Pointer"""
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF22ISS2___New_orig__()
    SameDimension = _itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF22ISS2_SameDimension
    

    def __init__(self, enclosingFilter):
        r"""
        __init__(self, enclosingFilter) -> itkScanlineFilterCommonIVF22ISS2

        Parameters
        ----------
        enclosingFilter: itkImageToImageFilterIVF22ISS2 *

        """
        _itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF22ISS2_swiginit(self, _itkScanlineFilterCommonPython.new_itkScanlineFilterCommonIVF22ISS2(enclosingFilter))
    __swig_destroy__ = _itkScanlineFilterCommonPython.delete_itkScanlineFilterCommonIVF22ISS2

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

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

        """
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF22ISS2_cast(obj)

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

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

          itkScanlineFilterCommonIVF22ISS2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkScanlineFilterCommonIVF22ISS2 in _itkScanlineFilterCommonPython:
_itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF22ISS2_swigregister(itkScanlineFilterCommonIVF22ISS2)

def itkScanlineFilterCommonIVF22IUC2_New():
    return itkScanlineFilterCommonIVF22IUC2.New()

class itkScanlineFilterCommonIVF22IUC2(object):
    r"""Proxy of C++ itkScanlineFilterCommonIVF22IUC2 class."""

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkScanlineFilterCommonIVF22IUC2_Pointer"""
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF22IUC2___New_orig__()
    SameDimension = _itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF22IUC2_SameDimension
    

    def __init__(self, enclosingFilter):
        r"""
        __init__(self, enclosingFilter) -> itkScanlineFilterCommonIVF22IUC2

        Parameters
        ----------
        enclosingFilter: itkImageToImageFilterIVF22IUC2 *

        """
        _itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF22IUC2_swiginit(self, _itkScanlineFilterCommonPython.new_itkScanlineFilterCommonIVF22IUC2(enclosingFilter))
    __swig_destroy__ = _itkScanlineFilterCommonPython.delete_itkScanlineFilterCommonIVF22IUC2

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

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

        """
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF22IUC2_cast(obj)

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

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

          itkScanlineFilterCommonIVF22IUC2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkScanlineFilterCommonIVF22IUC2 in _itkScanlineFilterCommonPython:
_itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF22IUC2_swigregister(itkScanlineFilterCommonIVF22IUC2)

def itkScanlineFilterCommonIVF23ISS3_New():
    return itkScanlineFilterCommonIVF23ISS3.New()

class itkScanlineFilterCommonIVF23ISS3(object):
    r"""Proxy of C++ itkScanlineFilterCommonIVF23ISS3 class."""

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkScanlineFilterCommonIVF23ISS3_Pointer"""
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF23ISS3___New_orig__()
    SameDimension = _itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF23ISS3_SameDimension
    

    def __init__(self, enclosingFilter):
        r"""
        __init__(self, enclosingFilter) -> itkScanlineFilterCommonIVF23ISS3

        Parameters
        ----------
        enclosingFilter: itkImageToImageFilterIVF23ISS3 *

        """
        _itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF23ISS3_swiginit(self, _itkScanlineFilterCommonPython.new_itkScanlineFilterCommonIVF23ISS3(enclosingFilter))
    __swig_destroy__ = _itkScanlineFilterCommonPython.delete_itkScanlineFilterCommonIVF23ISS3

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

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

        """
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF23ISS3_cast(obj)

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

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

          itkScanlineFilterCommonIVF23ISS3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkScanlineFilterCommonIVF23ISS3 in _itkScanlineFilterCommonPython:
_itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF23ISS3_swigregister(itkScanlineFilterCommonIVF23ISS3)

def itkScanlineFilterCommonIVF23IUC3_New():
    return itkScanlineFilterCommonIVF23IUC3.New()

class itkScanlineFilterCommonIVF23IUC3(object):
    r"""Proxy of C++ itkScanlineFilterCommonIVF23IUC3 class."""

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkScanlineFilterCommonIVF23IUC3_Pointer"""
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF23IUC3___New_orig__()
    SameDimension = _itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF23IUC3_SameDimension
    

    def __init__(self, enclosingFilter):
        r"""
        __init__(self, enclosingFilter) -> itkScanlineFilterCommonIVF23IUC3

        Parameters
        ----------
        enclosingFilter: itkImageToImageFilterIVF23IUC3 *

        """
        _itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF23IUC3_swiginit(self, _itkScanlineFilterCommonPython.new_itkScanlineFilterCommonIVF23IUC3(enclosingFilter))
    __swig_destroy__ = _itkScanlineFilterCommonPython.delete_itkScanlineFilterCommonIVF23IUC3

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

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

        """
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF23IUC3_cast(obj)

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

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

          itkScanlineFilterCommonIVF23IUC3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkScanlineFilterCommonIVF23IUC3 in _itkScanlineFilterCommonPython:
_itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF23IUC3_swigregister(itkScanlineFilterCommonIVF23IUC3)

def itkScanlineFilterCommonIVF32ISS2_New():
    return itkScanlineFilterCommonIVF32ISS2.New()

class itkScanlineFilterCommonIVF32ISS2(object):
    r"""Proxy of C++ itkScanlineFilterCommonIVF32ISS2 class."""

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkScanlineFilterCommonIVF32ISS2_Pointer"""
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF32ISS2___New_orig__()
    SameDimension = _itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF32ISS2_SameDimension
    

    def __init__(self, enclosingFilter):
        r"""
        __init__(self, enclosingFilter) -> itkScanlineFilterCommonIVF32ISS2

        Parameters
        ----------
        enclosingFilter: itkImageToImageFilterIVF32ISS2 *

        """
        _itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF32ISS2_swiginit(self, _itkScanlineFilterCommonPython.new_itkScanlineFilterCommonIVF32ISS2(enclosingFilter))
    __swig_destroy__ = _itkScanlineFilterCommonPython.delete_itkScanlineFilterCommonIVF32ISS2

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

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

        """
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF32ISS2_cast(obj)

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

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

          itkScanlineFilterCommonIVF32ISS2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkScanlineFilterCommonIVF32ISS2 in _itkScanlineFilterCommonPython:
_itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF32ISS2_swigregister(itkScanlineFilterCommonIVF32ISS2)

def itkScanlineFilterCommonIVF32IUC2_New():
    return itkScanlineFilterCommonIVF32IUC2.New()

class itkScanlineFilterCommonIVF32IUC2(object):
    r"""Proxy of C++ itkScanlineFilterCommonIVF32IUC2 class."""

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkScanlineFilterCommonIVF32IUC2_Pointer"""
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF32IUC2___New_orig__()
    SameDimension = _itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF32IUC2_SameDimension
    

    def __init__(self, enclosingFilter):
        r"""
        __init__(self, enclosingFilter) -> itkScanlineFilterCommonIVF32IUC2

        Parameters
        ----------
        enclosingFilter: itkImageToImageFilterIVF32IUC2 *

        """
        _itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF32IUC2_swiginit(self, _itkScanlineFilterCommonPython.new_itkScanlineFilterCommonIVF32IUC2(enclosingFilter))
    __swig_destroy__ = _itkScanlineFilterCommonPython.delete_itkScanlineFilterCommonIVF32IUC2

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

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

        """
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF32IUC2_cast(obj)

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

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

          itkScanlineFilterCommonIVF32IUC2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkScanlineFilterCommonIVF32IUC2 in _itkScanlineFilterCommonPython:
_itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF32IUC2_swigregister(itkScanlineFilterCommonIVF32IUC2)

def itkScanlineFilterCommonIVF33ISS3_New():
    return itkScanlineFilterCommonIVF33ISS3.New()

class itkScanlineFilterCommonIVF33ISS3(object):
    r"""Proxy of C++ itkScanlineFilterCommonIVF33ISS3 class."""

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkScanlineFilterCommonIVF33ISS3_Pointer"""
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF33ISS3___New_orig__()
    SameDimension = _itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF33ISS3_SameDimension
    

    def __init__(self, enclosingFilter):
        r"""
        __init__(self, enclosingFilter) -> itkScanlineFilterCommonIVF33ISS3

        Parameters
        ----------
        enclosingFilter: itkImageToImageFilterIVF33ISS3 *

        """
        _itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF33ISS3_swiginit(self, _itkScanlineFilterCommonPython.new_itkScanlineFilterCommonIVF33ISS3(enclosingFilter))
    __swig_destroy__ = _itkScanlineFilterCommonPython.delete_itkScanlineFilterCommonIVF33ISS3

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

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

        """
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF33ISS3_cast(obj)

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

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

          itkScanlineFilterCommonIVF33ISS3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkScanlineFilterCommonIVF33ISS3 in _itkScanlineFilterCommonPython:
_itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF33ISS3_swigregister(itkScanlineFilterCommonIVF33ISS3)

def itkScanlineFilterCommonIVF33IUC3_New():
    return itkScanlineFilterCommonIVF33IUC3.New()

class itkScanlineFilterCommonIVF33IUC3(object):
    r"""Proxy of C++ itkScanlineFilterCommonIVF33IUC3 class."""

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkScanlineFilterCommonIVF33IUC3_Pointer"""
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF33IUC3___New_orig__()
    SameDimension = _itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF33IUC3_SameDimension
    

    def __init__(self, enclosingFilter):
        r"""
        __init__(self, enclosingFilter) -> itkScanlineFilterCommonIVF33IUC3

        Parameters
        ----------
        enclosingFilter: itkImageToImageFilterIVF33IUC3 *

        """
        _itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF33IUC3_swiginit(self, _itkScanlineFilterCommonPython.new_itkScanlineFilterCommonIVF33IUC3(enclosingFilter))
    __swig_destroy__ = _itkScanlineFilterCommonPython.delete_itkScanlineFilterCommonIVF33IUC3

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

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

        """
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF33IUC3_cast(obj)

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

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

          itkScanlineFilterCommonIVF33IUC3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkScanlineFilterCommonIVF33IUC3 in _itkScanlineFilterCommonPython:
_itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF33IUC3_swigregister(itkScanlineFilterCommonIVF33IUC3)

def itkScanlineFilterCommonIVF42ISS2_New():
    return itkScanlineFilterCommonIVF42ISS2.New()

class itkScanlineFilterCommonIVF42ISS2(object):
    r"""Proxy of C++ itkScanlineFilterCommonIVF42ISS2 class."""

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkScanlineFilterCommonIVF42ISS2_Pointer"""
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF42ISS2___New_orig__()
    SameDimension = _itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF42ISS2_SameDimension
    

    def __init__(self, enclosingFilter):
        r"""
        __init__(self, enclosingFilter) -> itkScanlineFilterCommonIVF42ISS2

        Parameters
        ----------
        enclosingFilter: itkImageToImageFilterIVF42ISS2 *

        """
        _itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF42ISS2_swiginit(self, _itkScanlineFilterCommonPython.new_itkScanlineFilterCommonIVF42ISS2(enclosingFilter))
    __swig_destroy__ = _itkScanlineFilterCommonPython.delete_itkScanlineFilterCommonIVF42ISS2

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

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

        """
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF42ISS2_cast(obj)

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

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

          itkScanlineFilterCommonIVF42ISS2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkScanlineFilterCommonIVF42ISS2 in _itkScanlineFilterCommonPython:
_itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF42ISS2_swigregister(itkScanlineFilterCommonIVF42ISS2)

def itkScanlineFilterCommonIVF42IUC2_New():
    return itkScanlineFilterCommonIVF42IUC2.New()

class itkScanlineFilterCommonIVF42IUC2(object):
    r"""Proxy of C++ itkScanlineFilterCommonIVF42IUC2 class."""

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkScanlineFilterCommonIVF42IUC2_Pointer"""
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF42IUC2___New_orig__()
    SameDimension = _itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF42IUC2_SameDimension
    

    def __init__(self, enclosingFilter):
        r"""
        __init__(self, enclosingFilter) -> itkScanlineFilterCommonIVF42IUC2

        Parameters
        ----------
        enclosingFilter: itkImageToImageFilterIVF42IUC2 *

        """
        _itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF42IUC2_swiginit(self, _itkScanlineFilterCommonPython.new_itkScanlineFilterCommonIVF42IUC2(enclosingFilter))
    __swig_destroy__ = _itkScanlineFilterCommonPython.delete_itkScanlineFilterCommonIVF42IUC2

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

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

        """
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF42IUC2_cast(obj)

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

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

          itkScanlineFilterCommonIVF42IUC2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkScanlineFilterCommonIVF42IUC2 in _itkScanlineFilterCommonPython:
_itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF42IUC2_swigregister(itkScanlineFilterCommonIVF42IUC2)

def itkScanlineFilterCommonIVF43ISS3_New():
    return itkScanlineFilterCommonIVF43ISS3.New()

class itkScanlineFilterCommonIVF43ISS3(object):
    r"""Proxy of C++ itkScanlineFilterCommonIVF43ISS3 class."""

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkScanlineFilterCommonIVF43ISS3_Pointer"""
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF43ISS3___New_orig__()
    SameDimension = _itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF43ISS3_SameDimension
    

    def __init__(self, enclosingFilter):
        r"""
        __init__(self, enclosingFilter) -> itkScanlineFilterCommonIVF43ISS3

        Parameters
        ----------
        enclosingFilter: itkImageToImageFilterIVF43ISS3 *

        """
        _itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF43ISS3_swiginit(self, _itkScanlineFilterCommonPython.new_itkScanlineFilterCommonIVF43ISS3(enclosingFilter))
    __swig_destroy__ = _itkScanlineFilterCommonPython.delete_itkScanlineFilterCommonIVF43ISS3

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

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

        """
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF43ISS3_cast(obj)

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

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

          itkScanlineFilterCommonIVF43ISS3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkScanlineFilterCommonIVF43ISS3 in _itkScanlineFilterCommonPython:
_itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF43ISS3_swigregister(itkScanlineFilterCommonIVF43ISS3)

def itkScanlineFilterCommonIVF43IUC3_New():
    return itkScanlineFilterCommonIVF43IUC3.New()

class itkScanlineFilterCommonIVF43IUC3(object):
    r"""Proxy of C++ itkScanlineFilterCommonIVF43IUC3 class."""

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkScanlineFilterCommonIVF43IUC3_Pointer"""
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF43IUC3___New_orig__()
    SameDimension = _itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF43IUC3_SameDimension
    

    def __init__(self, enclosingFilter):
        r"""
        __init__(self, enclosingFilter) -> itkScanlineFilterCommonIVF43IUC3

        Parameters
        ----------
        enclosingFilter: itkImageToImageFilterIVF43IUC3 *

        """
        _itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF43IUC3_swiginit(self, _itkScanlineFilterCommonPython.new_itkScanlineFilterCommonIVF43IUC3(enclosingFilter))
    __swig_destroy__ = _itkScanlineFilterCommonPython.delete_itkScanlineFilterCommonIVF43IUC3

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

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

        """
        return _itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF43IUC3_cast(obj)

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

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

          itkScanlineFilterCommonIVF43IUC3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkScanlineFilterCommonIVF43IUC3 in _itkScanlineFilterCommonPython:
_itkScanlineFilterCommonPython.itkScanlineFilterCommonIVF43IUC3_swigregister(itkScanlineFilterCommonIVF43IUC3)

