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



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

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.itkInPlaceImageFilterBPython
import itk.itkImageToImageFilterBPython
import itk.itkImageRegionPython
import itk.itkSizePython
import itk.pyBasePython
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.itkIndexPython
import itk.itkOffsetPython
import itk.itkImageSourcePython
import itk.itkImagePython
import itk.itkRGBPixelPython
import itk.itkSymmetricSecondRankTensorPython
import itk.itkRGBAPixelPython
import itk.itkImageSourceCommonPython
import itk.itkVectorImagePython
import itk.itkVariableLengthVectorPython
import itk.itkPhasedArray3DSpecialCoordinatesImagePython
import itk.itkImageToImageFilterCommonPython

def itkVectorMagnitudeImageFilterICVF22IF2_Superclass_New():
    return itkVectorMagnitudeImageFilterICVF22IF2_Superclass.New()

class itkVectorMagnitudeImageFilterICVF22IF2_Superclass(itk.itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF22IF2):
    r"""Proxy of C++ itkVectorMagnitudeImageFilterICVF22IF2_Superclass class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorMagnitudeImageFilterICVF22IF2_Superclass_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF22IF2_Superclass___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorMagnitudeImageFilterICVF22IF2_Superclass_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF22IF2_Superclass_Clone(self)
    __swig_destroy__ = _itkVectorMagnitudeImageFilterPython.delete_itkVectorMagnitudeImageFilterICVF22IF2_Superclass

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

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

        """
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF22IF2_Superclass_cast(obj)

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

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

          itkVectorMagnitudeImageFilterICVF22IF2_Superclass.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorMagnitudeImageFilterICVF22IF2_Superclass in _itkVectorMagnitudeImageFilterPython:
_itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF22IF2_Superclass_swigregister(itkVectorMagnitudeImageFilterICVF22IF2_Superclass)

def itkVectorMagnitudeImageFilterICVF22ISS2_Superclass_New():
    return itkVectorMagnitudeImageFilterICVF22ISS2_Superclass.New()

class itkVectorMagnitudeImageFilterICVF22ISS2_Superclass(itk.itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF22ISS2):
    r"""Proxy of C++ itkVectorMagnitudeImageFilterICVF22ISS2_Superclass class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorMagnitudeImageFilterICVF22ISS2_Superclass_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF22ISS2_Superclass___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorMagnitudeImageFilterICVF22ISS2_Superclass_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF22ISS2_Superclass_Clone(self)
    __swig_destroy__ = _itkVectorMagnitudeImageFilterPython.delete_itkVectorMagnitudeImageFilterICVF22ISS2_Superclass

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

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

        """
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF22ISS2_Superclass_cast(obj)

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

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

          itkVectorMagnitudeImageFilterICVF22ISS2_Superclass.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorMagnitudeImageFilterICVF22ISS2_Superclass in _itkVectorMagnitudeImageFilterPython:
_itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF22ISS2_Superclass_swigregister(itkVectorMagnitudeImageFilterICVF22ISS2_Superclass)

def itkVectorMagnitudeImageFilterICVF22IUC2_Superclass_New():
    return itkVectorMagnitudeImageFilterICVF22IUC2_Superclass.New()

class itkVectorMagnitudeImageFilterICVF22IUC2_Superclass(itk.itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF22IUC2):
    r"""Proxy of C++ itkVectorMagnitudeImageFilterICVF22IUC2_Superclass class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorMagnitudeImageFilterICVF22IUC2_Superclass_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF22IUC2_Superclass___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorMagnitudeImageFilterICVF22IUC2_Superclass_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF22IUC2_Superclass_Clone(self)
    __swig_destroy__ = _itkVectorMagnitudeImageFilterPython.delete_itkVectorMagnitudeImageFilterICVF22IUC2_Superclass

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

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

        """
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF22IUC2_Superclass_cast(obj)

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

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

          itkVectorMagnitudeImageFilterICVF22IUC2_Superclass.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorMagnitudeImageFilterICVF22IUC2_Superclass in _itkVectorMagnitudeImageFilterPython:
_itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF22IUC2_Superclass_swigregister(itkVectorMagnitudeImageFilterICVF22IUC2_Superclass)

def itkVectorMagnitudeImageFilterICVF23IF3_Superclass_New():
    return itkVectorMagnitudeImageFilterICVF23IF3_Superclass.New()

class itkVectorMagnitudeImageFilterICVF23IF3_Superclass(itk.itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF23IF3):
    r"""Proxy of C++ itkVectorMagnitudeImageFilterICVF23IF3_Superclass class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorMagnitudeImageFilterICVF23IF3_Superclass_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF23IF3_Superclass___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorMagnitudeImageFilterICVF23IF3_Superclass_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF23IF3_Superclass_Clone(self)
    __swig_destroy__ = _itkVectorMagnitudeImageFilterPython.delete_itkVectorMagnitudeImageFilterICVF23IF3_Superclass

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

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

        """
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF23IF3_Superclass_cast(obj)

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

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

          itkVectorMagnitudeImageFilterICVF23IF3_Superclass.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorMagnitudeImageFilterICVF23IF3_Superclass in _itkVectorMagnitudeImageFilterPython:
_itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF23IF3_Superclass_swigregister(itkVectorMagnitudeImageFilterICVF23IF3_Superclass)

def itkVectorMagnitudeImageFilterICVF23ISS3_Superclass_New():
    return itkVectorMagnitudeImageFilterICVF23ISS3_Superclass.New()

class itkVectorMagnitudeImageFilterICVF23ISS3_Superclass(itk.itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF23ISS3):
    r"""Proxy of C++ itkVectorMagnitudeImageFilterICVF23ISS3_Superclass class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorMagnitudeImageFilterICVF23ISS3_Superclass_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF23ISS3_Superclass___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorMagnitudeImageFilterICVF23ISS3_Superclass_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF23ISS3_Superclass_Clone(self)
    __swig_destroy__ = _itkVectorMagnitudeImageFilterPython.delete_itkVectorMagnitudeImageFilterICVF23ISS3_Superclass

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

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

        """
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF23ISS3_Superclass_cast(obj)

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

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

          itkVectorMagnitudeImageFilterICVF23ISS3_Superclass.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorMagnitudeImageFilterICVF23ISS3_Superclass in _itkVectorMagnitudeImageFilterPython:
_itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF23ISS3_Superclass_swigregister(itkVectorMagnitudeImageFilterICVF23ISS3_Superclass)

def itkVectorMagnitudeImageFilterICVF23IUC3_Superclass_New():
    return itkVectorMagnitudeImageFilterICVF23IUC3_Superclass.New()

class itkVectorMagnitudeImageFilterICVF23IUC3_Superclass(itk.itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF23IUC3):
    r"""Proxy of C++ itkVectorMagnitudeImageFilterICVF23IUC3_Superclass class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorMagnitudeImageFilterICVF23IUC3_Superclass_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF23IUC3_Superclass___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorMagnitudeImageFilterICVF23IUC3_Superclass_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF23IUC3_Superclass_Clone(self)
    __swig_destroy__ = _itkVectorMagnitudeImageFilterPython.delete_itkVectorMagnitudeImageFilterICVF23IUC3_Superclass

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

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

        """
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF23IUC3_Superclass_cast(obj)

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

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

          itkVectorMagnitudeImageFilterICVF23IUC3_Superclass.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorMagnitudeImageFilterICVF23IUC3_Superclass in _itkVectorMagnitudeImageFilterPython:
_itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF23IUC3_Superclass_swigregister(itkVectorMagnitudeImageFilterICVF23IUC3_Superclass)

def itkVectorMagnitudeImageFilterICVF32IF2_Superclass_New():
    return itkVectorMagnitudeImageFilterICVF32IF2_Superclass.New()

class itkVectorMagnitudeImageFilterICVF32IF2_Superclass(itk.itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF32IF2):
    r"""Proxy of C++ itkVectorMagnitudeImageFilterICVF32IF2_Superclass class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorMagnitudeImageFilterICVF32IF2_Superclass_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF32IF2_Superclass___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorMagnitudeImageFilterICVF32IF2_Superclass_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF32IF2_Superclass_Clone(self)
    __swig_destroy__ = _itkVectorMagnitudeImageFilterPython.delete_itkVectorMagnitudeImageFilterICVF32IF2_Superclass

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

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

        """
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF32IF2_Superclass_cast(obj)

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

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

          itkVectorMagnitudeImageFilterICVF32IF2_Superclass.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorMagnitudeImageFilterICVF32IF2_Superclass in _itkVectorMagnitudeImageFilterPython:
_itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF32IF2_Superclass_swigregister(itkVectorMagnitudeImageFilterICVF32IF2_Superclass)

def itkVectorMagnitudeImageFilterICVF32ISS2_Superclass_New():
    return itkVectorMagnitudeImageFilterICVF32ISS2_Superclass.New()

class itkVectorMagnitudeImageFilterICVF32ISS2_Superclass(itk.itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF32ISS2):
    r"""Proxy of C++ itkVectorMagnitudeImageFilterICVF32ISS2_Superclass class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorMagnitudeImageFilterICVF32ISS2_Superclass_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF32ISS2_Superclass___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorMagnitudeImageFilterICVF32ISS2_Superclass_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF32ISS2_Superclass_Clone(self)
    __swig_destroy__ = _itkVectorMagnitudeImageFilterPython.delete_itkVectorMagnitudeImageFilterICVF32ISS2_Superclass

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

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

        """
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF32ISS2_Superclass_cast(obj)

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

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

          itkVectorMagnitudeImageFilterICVF32ISS2_Superclass.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorMagnitudeImageFilterICVF32ISS2_Superclass in _itkVectorMagnitudeImageFilterPython:
_itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF32ISS2_Superclass_swigregister(itkVectorMagnitudeImageFilterICVF32ISS2_Superclass)

def itkVectorMagnitudeImageFilterICVF32IUC2_Superclass_New():
    return itkVectorMagnitudeImageFilterICVF32IUC2_Superclass.New()

class itkVectorMagnitudeImageFilterICVF32IUC2_Superclass(itk.itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF32IUC2):
    r"""Proxy of C++ itkVectorMagnitudeImageFilterICVF32IUC2_Superclass class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorMagnitudeImageFilterICVF32IUC2_Superclass_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF32IUC2_Superclass___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorMagnitudeImageFilterICVF32IUC2_Superclass_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF32IUC2_Superclass_Clone(self)
    __swig_destroy__ = _itkVectorMagnitudeImageFilterPython.delete_itkVectorMagnitudeImageFilterICVF32IUC2_Superclass

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

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

        """
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF32IUC2_Superclass_cast(obj)

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

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

          itkVectorMagnitudeImageFilterICVF32IUC2_Superclass.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorMagnitudeImageFilterICVF32IUC2_Superclass in _itkVectorMagnitudeImageFilterPython:
_itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF32IUC2_Superclass_swigregister(itkVectorMagnitudeImageFilterICVF32IUC2_Superclass)

def itkVectorMagnitudeImageFilterICVF33IF3_Superclass_New():
    return itkVectorMagnitudeImageFilterICVF33IF3_Superclass.New()

class itkVectorMagnitudeImageFilterICVF33IF3_Superclass(itk.itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF33IF3):
    r"""Proxy of C++ itkVectorMagnitudeImageFilterICVF33IF3_Superclass class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorMagnitudeImageFilterICVF33IF3_Superclass_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF33IF3_Superclass___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorMagnitudeImageFilterICVF33IF3_Superclass_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF33IF3_Superclass_Clone(self)
    __swig_destroy__ = _itkVectorMagnitudeImageFilterPython.delete_itkVectorMagnitudeImageFilterICVF33IF3_Superclass

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

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

        """
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF33IF3_Superclass_cast(obj)

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

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

          itkVectorMagnitudeImageFilterICVF33IF3_Superclass.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorMagnitudeImageFilterICVF33IF3_Superclass in _itkVectorMagnitudeImageFilterPython:
_itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF33IF3_Superclass_swigregister(itkVectorMagnitudeImageFilterICVF33IF3_Superclass)

def itkVectorMagnitudeImageFilterICVF33ISS3_Superclass_New():
    return itkVectorMagnitudeImageFilterICVF33ISS3_Superclass.New()

class itkVectorMagnitudeImageFilterICVF33ISS3_Superclass(itk.itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF33ISS3):
    r"""Proxy of C++ itkVectorMagnitudeImageFilterICVF33ISS3_Superclass class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorMagnitudeImageFilterICVF33ISS3_Superclass_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF33ISS3_Superclass___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorMagnitudeImageFilterICVF33ISS3_Superclass_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF33ISS3_Superclass_Clone(self)
    __swig_destroy__ = _itkVectorMagnitudeImageFilterPython.delete_itkVectorMagnitudeImageFilterICVF33ISS3_Superclass

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

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

        """
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF33ISS3_Superclass_cast(obj)

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

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

          itkVectorMagnitudeImageFilterICVF33ISS3_Superclass.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorMagnitudeImageFilterICVF33ISS3_Superclass in _itkVectorMagnitudeImageFilterPython:
_itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF33ISS3_Superclass_swigregister(itkVectorMagnitudeImageFilterICVF33ISS3_Superclass)

def itkVectorMagnitudeImageFilterICVF33IUC3_Superclass_New():
    return itkVectorMagnitudeImageFilterICVF33IUC3_Superclass.New()

class itkVectorMagnitudeImageFilterICVF33IUC3_Superclass(itk.itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF33IUC3):
    r"""Proxy of C++ itkVectorMagnitudeImageFilterICVF33IUC3_Superclass class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorMagnitudeImageFilterICVF33IUC3_Superclass_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF33IUC3_Superclass___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorMagnitudeImageFilterICVF33IUC3_Superclass_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF33IUC3_Superclass_Clone(self)
    __swig_destroy__ = _itkVectorMagnitudeImageFilterPython.delete_itkVectorMagnitudeImageFilterICVF33IUC3_Superclass

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

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

        """
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF33IUC3_Superclass_cast(obj)

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

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

          itkVectorMagnitudeImageFilterICVF33IUC3_Superclass.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorMagnitudeImageFilterICVF33IUC3_Superclass in _itkVectorMagnitudeImageFilterPython:
_itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF33IUC3_Superclass_swigregister(itkVectorMagnitudeImageFilterICVF33IUC3_Superclass)

def itkVectorMagnitudeImageFilterICVF42IF2_Superclass_New():
    return itkVectorMagnitudeImageFilterICVF42IF2_Superclass.New()

class itkVectorMagnitudeImageFilterICVF42IF2_Superclass(itk.itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF42IF2):
    r"""Proxy of C++ itkVectorMagnitudeImageFilterICVF42IF2_Superclass class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorMagnitudeImageFilterICVF42IF2_Superclass_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF42IF2_Superclass___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorMagnitudeImageFilterICVF42IF2_Superclass_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF42IF2_Superclass_Clone(self)
    __swig_destroy__ = _itkVectorMagnitudeImageFilterPython.delete_itkVectorMagnitudeImageFilterICVF42IF2_Superclass

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

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

        """
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF42IF2_Superclass_cast(obj)

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

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

          itkVectorMagnitudeImageFilterICVF42IF2_Superclass.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorMagnitudeImageFilterICVF42IF2_Superclass in _itkVectorMagnitudeImageFilterPython:
_itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF42IF2_Superclass_swigregister(itkVectorMagnitudeImageFilterICVF42IF2_Superclass)

def itkVectorMagnitudeImageFilterICVF42ISS2_Superclass_New():
    return itkVectorMagnitudeImageFilterICVF42ISS2_Superclass.New()

class itkVectorMagnitudeImageFilterICVF42ISS2_Superclass(itk.itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF42ISS2):
    r"""Proxy of C++ itkVectorMagnitudeImageFilterICVF42ISS2_Superclass class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorMagnitudeImageFilterICVF42ISS2_Superclass_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF42ISS2_Superclass___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorMagnitudeImageFilterICVF42ISS2_Superclass_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF42ISS2_Superclass_Clone(self)
    __swig_destroy__ = _itkVectorMagnitudeImageFilterPython.delete_itkVectorMagnitudeImageFilterICVF42ISS2_Superclass

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

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

        """
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF42ISS2_Superclass_cast(obj)

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

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

          itkVectorMagnitudeImageFilterICVF42ISS2_Superclass.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorMagnitudeImageFilterICVF42ISS2_Superclass in _itkVectorMagnitudeImageFilterPython:
_itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF42ISS2_Superclass_swigregister(itkVectorMagnitudeImageFilterICVF42ISS2_Superclass)

def itkVectorMagnitudeImageFilterICVF42IUC2_Superclass_New():
    return itkVectorMagnitudeImageFilterICVF42IUC2_Superclass.New()

class itkVectorMagnitudeImageFilterICVF42IUC2_Superclass(itk.itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF42IUC2):
    r"""Proxy of C++ itkVectorMagnitudeImageFilterICVF42IUC2_Superclass class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorMagnitudeImageFilterICVF42IUC2_Superclass_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF42IUC2_Superclass___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorMagnitudeImageFilterICVF42IUC2_Superclass_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF42IUC2_Superclass_Clone(self)
    __swig_destroy__ = _itkVectorMagnitudeImageFilterPython.delete_itkVectorMagnitudeImageFilterICVF42IUC2_Superclass

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

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

        """
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF42IUC2_Superclass_cast(obj)

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

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

          itkVectorMagnitudeImageFilterICVF42IUC2_Superclass.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorMagnitudeImageFilterICVF42IUC2_Superclass in _itkVectorMagnitudeImageFilterPython:
_itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF42IUC2_Superclass_swigregister(itkVectorMagnitudeImageFilterICVF42IUC2_Superclass)

def itkVectorMagnitudeImageFilterICVF43IF3_Superclass_New():
    return itkVectorMagnitudeImageFilterICVF43IF3_Superclass.New()

class itkVectorMagnitudeImageFilterICVF43IF3_Superclass(itk.itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF43IF3):
    r"""Proxy of C++ itkVectorMagnitudeImageFilterICVF43IF3_Superclass class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorMagnitudeImageFilterICVF43IF3_Superclass_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF43IF3_Superclass___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorMagnitudeImageFilterICVF43IF3_Superclass_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF43IF3_Superclass_Clone(self)
    __swig_destroy__ = _itkVectorMagnitudeImageFilterPython.delete_itkVectorMagnitudeImageFilterICVF43IF3_Superclass

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

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

        """
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF43IF3_Superclass_cast(obj)

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

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

          itkVectorMagnitudeImageFilterICVF43IF3_Superclass.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorMagnitudeImageFilterICVF43IF3_Superclass in _itkVectorMagnitudeImageFilterPython:
_itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF43IF3_Superclass_swigregister(itkVectorMagnitudeImageFilterICVF43IF3_Superclass)

def itkVectorMagnitudeImageFilterICVF43ISS3_Superclass_New():
    return itkVectorMagnitudeImageFilterICVF43ISS3_Superclass.New()

class itkVectorMagnitudeImageFilterICVF43ISS3_Superclass(itk.itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF43ISS3):
    r"""Proxy of C++ itkVectorMagnitudeImageFilterICVF43ISS3_Superclass class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorMagnitudeImageFilterICVF43ISS3_Superclass_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF43ISS3_Superclass___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorMagnitudeImageFilterICVF43ISS3_Superclass_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF43ISS3_Superclass_Clone(self)
    __swig_destroy__ = _itkVectorMagnitudeImageFilterPython.delete_itkVectorMagnitudeImageFilterICVF43ISS3_Superclass

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

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

        """
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF43ISS3_Superclass_cast(obj)

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

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

          itkVectorMagnitudeImageFilterICVF43ISS3_Superclass.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorMagnitudeImageFilterICVF43ISS3_Superclass in _itkVectorMagnitudeImageFilterPython:
_itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF43ISS3_Superclass_swigregister(itkVectorMagnitudeImageFilterICVF43ISS3_Superclass)

def itkVectorMagnitudeImageFilterICVF43IUC3_Superclass_New():
    return itkVectorMagnitudeImageFilterICVF43IUC3_Superclass.New()

class itkVectorMagnitudeImageFilterICVF43IUC3_Superclass(itk.itkInPlaceImageFilterBPython.itkInPlaceImageFilterICVF43IUC3):
    r"""Proxy of C++ itkVectorMagnitudeImageFilterICVF43IUC3_Superclass class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorMagnitudeImageFilterICVF43IUC3_Superclass_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF43IUC3_Superclass___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorMagnitudeImageFilterICVF43IUC3_Superclass_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF43IUC3_Superclass_Clone(self)
    __swig_destroy__ = _itkVectorMagnitudeImageFilterPython.delete_itkVectorMagnitudeImageFilterICVF43IUC3_Superclass

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

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

        """
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF43IUC3_Superclass_cast(obj)

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

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

          itkVectorMagnitudeImageFilterICVF43IUC3_Superclass.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorMagnitudeImageFilterICVF43IUC3_Superclass in _itkVectorMagnitudeImageFilterPython:
_itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF43IUC3_Superclass_swigregister(itkVectorMagnitudeImageFilterICVF43IUC3_Superclass)

def itkVectorMagnitudeImageFilterICVF22IF2_New():
    return itkVectorMagnitudeImageFilterICVF22IF2.New()

class itkVectorMagnitudeImageFilterICVF22IF2(itkVectorMagnitudeImageFilterICVF22IF2_Superclass):
    r"""Proxy of C++ itkVectorMagnitudeImageFilterICVF22IF2 class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorMagnitudeImageFilterICVF22IF2_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF22IF2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorMagnitudeImageFilterICVF22IF2_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF22IF2_Clone(self)
    InputHasNumericTraitsCheck = _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF22IF2_InputHasNumericTraitsCheck
    
    __swig_destroy__ = _itkVectorMagnitudeImageFilterPython.delete_itkVectorMagnitudeImageFilterICVF22IF2

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

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

        """
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF22IF2_cast(obj)

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

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

          itkVectorMagnitudeImageFilterICVF22IF2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorMagnitudeImageFilterICVF22IF2 in _itkVectorMagnitudeImageFilterPython:
_itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF22IF2_swigregister(itkVectorMagnitudeImageFilterICVF22IF2)

def itkVectorMagnitudeImageFilterICVF22ISS2_New():
    return itkVectorMagnitudeImageFilterICVF22ISS2.New()

class itkVectorMagnitudeImageFilterICVF22ISS2(itkVectorMagnitudeImageFilterICVF22ISS2_Superclass):
    r"""Proxy of C++ itkVectorMagnitudeImageFilterICVF22ISS2 class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorMagnitudeImageFilterICVF22ISS2_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF22ISS2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorMagnitudeImageFilterICVF22ISS2_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF22ISS2_Clone(self)
    InputHasNumericTraitsCheck = _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF22ISS2_InputHasNumericTraitsCheck
    
    __swig_destroy__ = _itkVectorMagnitudeImageFilterPython.delete_itkVectorMagnitudeImageFilterICVF22ISS2

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

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

        """
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF22ISS2_cast(obj)

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

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

          itkVectorMagnitudeImageFilterICVF22ISS2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorMagnitudeImageFilterICVF22ISS2 in _itkVectorMagnitudeImageFilterPython:
_itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF22ISS2_swigregister(itkVectorMagnitudeImageFilterICVF22ISS2)

def itkVectorMagnitudeImageFilterICVF22IUC2_New():
    return itkVectorMagnitudeImageFilterICVF22IUC2.New()

class itkVectorMagnitudeImageFilterICVF22IUC2(itkVectorMagnitudeImageFilterICVF22IUC2_Superclass):
    r"""Proxy of C++ itkVectorMagnitudeImageFilterICVF22IUC2 class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorMagnitudeImageFilterICVF22IUC2_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF22IUC2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorMagnitudeImageFilterICVF22IUC2_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF22IUC2_Clone(self)
    InputHasNumericTraitsCheck = _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF22IUC2_InputHasNumericTraitsCheck
    
    __swig_destroy__ = _itkVectorMagnitudeImageFilterPython.delete_itkVectorMagnitudeImageFilterICVF22IUC2

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

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

        """
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF22IUC2_cast(obj)

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

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

          itkVectorMagnitudeImageFilterICVF22IUC2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorMagnitudeImageFilterICVF22IUC2 in _itkVectorMagnitudeImageFilterPython:
_itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF22IUC2_swigregister(itkVectorMagnitudeImageFilterICVF22IUC2)

def itkVectorMagnitudeImageFilterICVF23IF3_New():
    return itkVectorMagnitudeImageFilterICVF23IF3.New()

class itkVectorMagnitudeImageFilterICVF23IF3(itkVectorMagnitudeImageFilterICVF23IF3_Superclass):
    r"""Proxy of C++ itkVectorMagnitudeImageFilterICVF23IF3 class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorMagnitudeImageFilterICVF23IF3_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF23IF3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorMagnitudeImageFilterICVF23IF3_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF23IF3_Clone(self)
    InputHasNumericTraitsCheck = _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF23IF3_InputHasNumericTraitsCheck
    
    __swig_destroy__ = _itkVectorMagnitudeImageFilterPython.delete_itkVectorMagnitudeImageFilterICVF23IF3

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

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

        """
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF23IF3_cast(obj)

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

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

          itkVectorMagnitudeImageFilterICVF23IF3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorMagnitudeImageFilterICVF23IF3 in _itkVectorMagnitudeImageFilterPython:
_itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF23IF3_swigregister(itkVectorMagnitudeImageFilterICVF23IF3)

def itkVectorMagnitudeImageFilterICVF23ISS3_New():
    return itkVectorMagnitudeImageFilterICVF23ISS3.New()

class itkVectorMagnitudeImageFilterICVF23ISS3(itkVectorMagnitudeImageFilterICVF23ISS3_Superclass):
    r"""Proxy of C++ itkVectorMagnitudeImageFilterICVF23ISS3 class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorMagnitudeImageFilterICVF23ISS3_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF23ISS3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorMagnitudeImageFilterICVF23ISS3_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF23ISS3_Clone(self)
    InputHasNumericTraitsCheck = _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF23ISS3_InputHasNumericTraitsCheck
    
    __swig_destroy__ = _itkVectorMagnitudeImageFilterPython.delete_itkVectorMagnitudeImageFilterICVF23ISS3

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

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

        """
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF23ISS3_cast(obj)

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

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

          itkVectorMagnitudeImageFilterICVF23ISS3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorMagnitudeImageFilterICVF23ISS3 in _itkVectorMagnitudeImageFilterPython:
_itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF23ISS3_swigregister(itkVectorMagnitudeImageFilterICVF23ISS3)

def itkVectorMagnitudeImageFilterICVF23IUC3_New():
    return itkVectorMagnitudeImageFilterICVF23IUC3.New()

class itkVectorMagnitudeImageFilterICVF23IUC3(itkVectorMagnitudeImageFilterICVF23IUC3_Superclass):
    r"""Proxy of C++ itkVectorMagnitudeImageFilterICVF23IUC3 class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorMagnitudeImageFilterICVF23IUC3_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF23IUC3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorMagnitudeImageFilterICVF23IUC3_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF23IUC3_Clone(self)
    InputHasNumericTraitsCheck = _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF23IUC3_InputHasNumericTraitsCheck
    
    __swig_destroy__ = _itkVectorMagnitudeImageFilterPython.delete_itkVectorMagnitudeImageFilterICVF23IUC3

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

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

        """
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF23IUC3_cast(obj)

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

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

          itkVectorMagnitudeImageFilterICVF23IUC3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorMagnitudeImageFilterICVF23IUC3 in _itkVectorMagnitudeImageFilterPython:
_itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF23IUC3_swigregister(itkVectorMagnitudeImageFilterICVF23IUC3)

def itkVectorMagnitudeImageFilterICVF32IF2_New():
    return itkVectorMagnitudeImageFilterICVF32IF2.New()

class itkVectorMagnitudeImageFilterICVF32IF2(itkVectorMagnitudeImageFilterICVF32IF2_Superclass):
    r"""Proxy of C++ itkVectorMagnitudeImageFilterICVF32IF2 class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorMagnitudeImageFilterICVF32IF2_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF32IF2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorMagnitudeImageFilterICVF32IF2_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF32IF2_Clone(self)
    InputHasNumericTraitsCheck = _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF32IF2_InputHasNumericTraitsCheck
    
    __swig_destroy__ = _itkVectorMagnitudeImageFilterPython.delete_itkVectorMagnitudeImageFilterICVF32IF2

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

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

        """
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF32IF2_cast(obj)

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

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

          itkVectorMagnitudeImageFilterICVF32IF2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorMagnitudeImageFilterICVF32IF2 in _itkVectorMagnitudeImageFilterPython:
_itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF32IF2_swigregister(itkVectorMagnitudeImageFilterICVF32IF2)

def itkVectorMagnitudeImageFilterICVF32ISS2_New():
    return itkVectorMagnitudeImageFilterICVF32ISS2.New()

class itkVectorMagnitudeImageFilterICVF32ISS2(itkVectorMagnitudeImageFilterICVF32ISS2_Superclass):
    r"""Proxy of C++ itkVectorMagnitudeImageFilterICVF32ISS2 class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorMagnitudeImageFilterICVF32ISS2_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF32ISS2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorMagnitudeImageFilterICVF32ISS2_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF32ISS2_Clone(self)
    InputHasNumericTraitsCheck = _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF32ISS2_InputHasNumericTraitsCheck
    
    __swig_destroy__ = _itkVectorMagnitudeImageFilterPython.delete_itkVectorMagnitudeImageFilterICVF32ISS2

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

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

        """
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF32ISS2_cast(obj)

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

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

          itkVectorMagnitudeImageFilterICVF32ISS2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorMagnitudeImageFilterICVF32ISS2 in _itkVectorMagnitudeImageFilterPython:
_itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF32ISS2_swigregister(itkVectorMagnitudeImageFilterICVF32ISS2)

def itkVectorMagnitudeImageFilterICVF32IUC2_New():
    return itkVectorMagnitudeImageFilterICVF32IUC2.New()

class itkVectorMagnitudeImageFilterICVF32IUC2(itkVectorMagnitudeImageFilterICVF32IUC2_Superclass):
    r"""Proxy of C++ itkVectorMagnitudeImageFilterICVF32IUC2 class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorMagnitudeImageFilterICVF32IUC2_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF32IUC2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorMagnitudeImageFilterICVF32IUC2_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF32IUC2_Clone(self)
    InputHasNumericTraitsCheck = _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF32IUC2_InputHasNumericTraitsCheck
    
    __swig_destroy__ = _itkVectorMagnitudeImageFilterPython.delete_itkVectorMagnitudeImageFilterICVF32IUC2

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

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

        """
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF32IUC2_cast(obj)

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

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

          itkVectorMagnitudeImageFilterICVF32IUC2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorMagnitudeImageFilterICVF32IUC2 in _itkVectorMagnitudeImageFilterPython:
_itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF32IUC2_swigregister(itkVectorMagnitudeImageFilterICVF32IUC2)

def itkVectorMagnitudeImageFilterICVF33IF3_New():
    return itkVectorMagnitudeImageFilterICVF33IF3.New()

class itkVectorMagnitudeImageFilterICVF33IF3(itkVectorMagnitudeImageFilterICVF33IF3_Superclass):
    r"""Proxy of C++ itkVectorMagnitudeImageFilterICVF33IF3 class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorMagnitudeImageFilterICVF33IF3_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF33IF3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorMagnitudeImageFilterICVF33IF3_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF33IF3_Clone(self)
    InputHasNumericTraitsCheck = _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF33IF3_InputHasNumericTraitsCheck
    
    __swig_destroy__ = _itkVectorMagnitudeImageFilterPython.delete_itkVectorMagnitudeImageFilterICVF33IF3

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

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

        """
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF33IF3_cast(obj)

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

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

          itkVectorMagnitudeImageFilterICVF33IF3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorMagnitudeImageFilterICVF33IF3 in _itkVectorMagnitudeImageFilterPython:
_itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF33IF3_swigregister(itkVectorMagnitudeImageFilterICVF33IF3)

def itkVectorMagnitudeImageFilterICVF33ISS3_New():
    return itkVectorMagnitudeImageFilterICVF33ISS3.New()

class itkVectorMagnitudeImageFilterICVF33ISS3(itkVectorMagnitudeImageFilterICVF33ISS3_Superclass):
    r"""Proxy of C++ itkVectorMagnitudeImageFilterICVF33ISS3 class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorMagnitudeImageFilterICVF33ISS3_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF33ISS3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorMagnitudeImageFilterICVF33ISS3_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF33ISS3_Clone(self)
    InputHasNumericTraitsCheck = _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF33ISS3_InputHasNumericTraitsCheck
    
    __swig_destroy__ = _itkVectorMagnitudeImageFilterPython.delete_itkVectorMagnitudeImageFilterICVF33ISS3

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

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

        """
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF33ISS3_cast(obj)

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

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

          itkVectorMagnitudeImageFilterICVF33ISS3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorMagnitudeImageFilterICVF33ISS3 in _itkVectorMagnitudeImageFilterPython:
_itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF33ISS3_swigregister(itkVectorMagnitudeImageFilterICVF33ISS3)

def itkVectorMagnitudeImageFilterICVF33IUC3_New():
    return itkVectorMagnitudeImageFilterICVF33IUC3.New()

class itkVectorMagnitudeImageFilterICVF33IUC3(itkVectorMagnitudeImageFilterICVF33IUC3_Superclass):
    r"""Proxy of C++ itkVectorMagnitudeImageFilterICVF33IUC3 class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorMagnitudeImageFilterICVF33IUC3_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF33IUC3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorMagnitudeImageFilterICVF33IUC3_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF33IUC3_Clone(self)
    InputHasNumericTraitsCheck = _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF33IUC3_InputHasNumericTraitsCheck
    
    __swig_destroy__ = _itkVectorMagnitudeImageFilterPython.delete_itkVectorMagnitudeImageFilterICVF33IUC3

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

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

        """
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF33IUC3_cast(obj)

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

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

          itkVectorMagnitudeImageFilterICVF33IUC3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorMagnitudeImageFilterICVF33IUC3 in _itkVectorMagnitudeImageFilterPython:
_itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF33IUC3_swigregister(itkVectorMagnitudeImageFilterICVF33IUC3)

def itkVectorMagnitudeImageFilterICVF42IF2_New():
    return itkVectorMagnitudeImageFilterICVF42IF2.New()

class itkVectorMagnitudeImageFilterICVF42IF2(itkVectorMagnitudeImageFilterICVF42IF2_Superclass):
    r"""Proxy of C++ itkVectorMagnitudeImageFilterICVF42IF2 class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorMagnitudeImageFilterICVF42IF2_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF42IF2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorMagnitudeImageFilterICVF42IF2_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF42IF2_Clone(self)
    InputHasNumericTraitsCheck = _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF42IF2_InputHasNumericTraitsCheck
    
    __swig_destroy__ = _itkVectorMagnitudeImageFilterPython.delete_itkVectorMagnitudeImageFilterICVF42IF2

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

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

        """
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF42IF2_cast(obj)

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

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

          itkVectorMagnitudeImageFilterICVF42IF2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorMagnitudeImageFilterICVF42IF2 in _itkVectorMagnitudeImageFilterPython:
_itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF42IF2_swigregister(itkVectorMagnitudeImageFilterICVF42IF2)

def itkVectorMagnitudeImageFilterICVF42ISS2_New():
    return itkVectorMagnitudeImageFilterICVF42ISS2.New()

class itkVectorMagnitudeImageFilterICVF42ISS2(itkVectorMagnitudeImageFilterICVF42ISS2_Superclass):
    r"""Proxy of C++ itkVectorMagnitudeImageFilterICVF42ISS2 class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorMagnitudeImageFilterICVF42ISS2_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF42ISS2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorMagnitudeImageFilterICVF42ISS2_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF42ISS2_Clone(self)
    InputHasNumericTraitsCheck = _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF42ISS2_InputHasNumericTraitsCheck
    
    __swig_destroy__ = _itkVectorMagnitudeImageFilterPython.delete_itkVectorMagnitudeImageFilterICVF42ISS2

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

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

        """
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF42ISS2_cast(obj)

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

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

          itkVectorMagnitudeImageFilterICVF42ISS2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorMagnitudeImageFilterICVF42ISS2 in _itkVectorMagnitudeImageFilterPython:
_itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF42ISS2_swigregister(itkVectorMagnitudeImageFilterICVF42ISS2)

def itkVectorMagnitudeImageFilterICVF42IUC2_New():
    return itkVectorMagnitudeImageFilterICVF42IUC2.New()

class itkVectorMagnitudeImageFilterICVF42IUC2(itkVectorMagnitudeImageFilterICVF42IUC2_Superclass):
    r"""Proxy of C++ itkVectorMagnitudeImageFilterICVF42IUC2 class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorMagnitudeImageFilterICVF42IUC2_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF42IUC2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorMagnitudeImageFilterICVF42IUC2_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF42IUC2_Clone(self)
    InputHasNumericTraitsCheck = _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF42IUC2_InputHasNumericTraitsCheck
    
    __swig_destroy__ = _itkVectorMagnitudeImageFilterPython.delete_itkVectorMagnitudeImageFilterICVF42IUC2

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

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

        """
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF42IUC2_cast(obj)

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

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

          itkVectorMagnitudeImageFilterICVF42IUC2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorMagnitudeImageFilterICVF42IUC2 in _itkVectorMagnitudeImageFilterPython:
_itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF42IUC2_swigregister(itkVectorMagnitudeImageFilterICVF42IUC2)

def itkVectorMagnitudeImageFilterICVF43IF3_New():
    return itkVectorMagnitudeImageFilterICVF43IF3.New()

class itkVectorMagnitudeImageFilterICVF43IF3(itkVectorMagnitudeImageFilterICVF43IF3_Superclass):
    r"""Proxy of C++ itkVectorMagnitudeImageFilterICVF43IF3 class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorMagnitudeImageFilterICVF43IF3_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF43IF3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorMagnitudeImageFilterICVF43IF3_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF43IF3_Clone(self)
    InputHasNumericTraitsCheck = _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF43IF3_InputHasNumericTraitsCheck
    
    __swig_destroy__ = _itkVectorMagnitudeImageFilterPython.delete_itkVectorMagnitudeImageFilterICVF43IF3

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

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

        """
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF43IF3_cast(obj)

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

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

          itkVectorMagnitudeImageFilterICVF43IF3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorMagnitudeImageFilterICVF43IF3 in _itkVectorMagnitudeImageFilterPython:
_itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF43IF3_swigregister(itkVectorMagnitudeImageFilterICVF43IF3)

def itkVectorMagnitudeImageFilterICVF43ISS3_New():
    return itkVectorMagnitudeImageFilterICVF43ISS3.New()

class itkVectorMagnitudeImageFilterICVF43ISS3(itkVectorMagnitudeImageFilterICVF43ISS3_Superclass):
    r"""Proxy of C++ itkVectorMagnitudeImageFilterICVF43ISS3 class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorMagnitudeImageFilterICVF43ISS3_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF43ISS3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorMagnitudeImageFilterICVF43ISS3_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF43ISS3_Clone(self)
    InputHasNumericTraitsCheck = _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF43ISS3_InputHasNumericTraitsCheck
    
    __swig_destroy__ = _itkVectorMagnitudeImageFilterPython.delete_itkVectorMagnitudeImageFilterICVF43ISS3

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

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

        """
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF43ISS3_cast(obj)

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

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

          itkVectorMagnitudeImageFilterICVF43ISS3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorMagnitudeImageFilterICVF43ISS3 in _itkVectorMagnitudeImageFilterPython:
_itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF43ISS3_swigregister(itkVectorMagnitudeImageFilterICVF43ISS3)

def itkVectorMagnitudeImageFilterICVF43IUC3_New():
    return itkVectorMagnitudeImageFilterICVF43IUC3.New()

class itkVectorMagnitudeImageFilterICVF43IUC3(itkVectorMagnitudeImageFilterICVF43IUC3_Superclass):
    r"""Proxy of C++ itkVectorMagnitudeImageFilterICVF43IUC3 class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVectorMagnitudeImageFilterICVF43IUC3_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF43IUC3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorMagnitudeImageFilterICVF43IUC3_Pointer"""
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF43IUC3_Clone(self)
    InputHasNumericTraitsCheck = _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF43IUC3_InputHasNumericTraitsCheck
    
    __swig_destroy__ = _itkVectorMagnitudeImageFilterPython.delete_itkVectorMagnitudeImageFilterICVF43IUC3

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

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

        """
        return _itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF43IUC3_cast(obj)

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

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

          itkVectorMagnitudeImageFilterICVF43IUC3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorMagnitudeImageFilterICVF43IUC3 in _itkVectorMagnitudeImageFilterPython:
_itkVectorMagnitudeImageFilterPython.itkVectorMagnitudeImageFilterICVF43IUC3_swigregister(itkVectorMagnitudeImageFilterICVF43IUC3)

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

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

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


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

    return instance.__internal_call__()

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

    filter_class = itk.ITKImageIntensity.UnaryGeneratorImageFilter
    unary_generator_image_filter.process_object = filter_class
    is_template = isinstance(filter_class, template_class.itkTemplate)
    if is_template:
        filter_object = filter_class.values()[0]
    else:
        filter_object = filter_class

    unary_generator_image_filter.__doc__ = filter_object.__doc__

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

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

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


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

    return instance.__internal_call__()

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

    filter_class = itk.ITKImageIntensity.VectorMagnitudeImageFilter
    vector_magnitude_image_filter.process_object = filter_class
    is_template = isinstance(filter_class, template_class.itkTemplate)
    if is_template:
        filter_object = filter_class.values()[0]
    else:
        filter_object = filter_class

    vector_magnitude_image_filter.__doc__ = filter_object.__doc__



