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

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

def itkVectorRescaleIntensityImageFilterIVF22IVF22_Superclass_New():
    return itkVectorRescaleIntensityImageFilterIVF22IVF22_Superclass.New()

class itkVectorRescaleIntensityImageFilterIVF22IVF22_Superclass(itk.itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF22IVF22):
    r"""Proxy of C++ itkVectorRescaleIntensityImageFilterIVF22IVF22_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__() -> itkVectorRescaleIntensityImageFilterIVF22IVF22_Superclass_Pointer"""
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF22IVF22_Superclass___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorRescaleIntensityImageFilterIVF22IVF22_Superclass_Pointer"""
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF22IVF22_Superclass_Clone(self)

    def GetFunctor(self, *args):
        r"""
        GetFunctor(self) -> itk::Functor::VectorMagnitudeLinearTransform< itk::Vector< float,2 >,itk::Vector< float,2 > >
        GetFunctor(self) -> itk::Functor::VectorMagnitudeLinearTransform< itk::Vector< float,2 >,itk::Vector< float,2 > > const &
        """
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF22IVF22_Superclass_GetFunctor(self, *args)

    def SetFunctor(self, functor):
        r"""
        SetFunctor(self, functor)

        Parameters
        ----------
        functor: itk::Functor::VectorMagnitudeLinearTransform< itk::Vector< float,2 >,itk::Vector< float,2 > > const &

        """
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF22IVF22_Superclass_SetFunctor(self, functor)
    __swig_destroy__ = _itkVectorRescaleIntensityImageFilterPython.delete_itkVectorRescaleIntensityImageFilterIVF22IVF22_Superclass

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

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

        """
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF22IVF22_Superclass_cast(obj)

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

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

          itkVectorRescaleIntensityImageFilterIVF22IVF22_Superclass.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorRescaleIntensityImageFilterIVF22IVF22_Superclass in _itkVectorRescaleIntensityImageFilterPython:
_itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF22IVF22_Superclass_swigregister(itkVectorRescaleIntensityImageFilterIVF22IVF22_Superclass)

def itkVectorRescaleIntensityImageFilterIVF23IVF23_Superclass_New():
    return itkVectorRescaleIntensityImageFilterIVF23IVF23_Superclass.New()

class itkVectorRescaleIntensityImageFilterIVF23IVF23_Superclass(itk.itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF23IVF23):
    r"""Proxy of C++ itkVectorRescaleIntensityImageFilterIVF23IVF23_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__() -> itkVectorRescaleIntensityImageFilterIVF23IVF23_Superclass_Pointer"""
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF23IVF23_Superclass___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorRescaleIntensityImageFilterIVF23IVF23_Superclass_Pointer"""
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF23IVF23_Superclass_Clone(self)

    def GetFunctor(self, *args):
        r"""
        GetFunctor(self) -> itk::Functor::VectorMagnitudeLinearTransform< itk::Vector< float,2 >,itk::Vector< float,2 > >
        GetFunctor(self) -> itk::Functor::VectorMagnitudeLinearTransform< itk::Vector< float,2 >,itk::Vector< float,2 > > const &
        """
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF23IVF23_Superclass_GetFunctor(self, *args)

    def SetFunctor(self, functor):
        r"""
        SetFunctor(self, functor)

        Parameters
        ----------
        functor: itk::Functor::VectorMagnitudeLinearTransform< itk::Vector< float,2 >,itk::Vector< float,2 > > const &

        """
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF23IVF23_Superclass_SetFunctor(self, functor)
    __swig_destroy__ = _itkVectorRescaleIntensityImageFilterPython.delete_itkVectorRescaleIntensityImageFilterIVF23IVF23_Superclass

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

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

        """
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF23IVF23_Superclass_cast(obj)

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

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

          itkVectorRescaleIntensityImageFilterIVF23IVF23_Superclass.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorRescaleIntensityImageFilterIVF23IVF23_Superclass in _itkVectorRescaleIntensityImageFilterPython:
_itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF23IVF23_Superclass_swigregister(itkVectorRescaleIntensityImageFilterIVF23IVF23_Superclass)

def itkVectorRescaleIntensityImageFilterIVF32IVF32_Superclass_New():
    return itkVectorRescaleIntensityImageFilterIVF32IVF32_Superclass.New()

class itkVectorRescaleIntensityImageFilterIVF32IVF32_Superclass(itk.itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF32IVF32):
    r"""Proxy of C++ itkVectorRescaleIntensityImageFilterIVF32IVF32_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__() -> itkVectorRescaleIntensityImageFilterIVF32IVF32_Superclass_Pointer"""
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF32IVF32_Superclass___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorRescaleIntensityImageFilterIVF32IVF32_Superclass_Pointer"""
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF32IVF32_Superclass_Clone(self)

    def GetFunctor(self, *args):
        r"""
        GetFunctor(self) -> itk::Functor::VectorMagnitudeLinearTransform< itk::Vector< float >,itk::Vector< float > >
        GetFunctor(self) -> itk::Functor::VectorMagnitudeLinearTransform< itk::Vector< float >,itk::Vector< float > > const &
        """
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF32IVF32_Superclass_GetFunctor(self, *args)

    def SetFunctor(self, functor):
        r"""
        SetFunctor(self, functor)

        Parameters
        ----------
        functor: itk::Functor::VectorMagnitudeLinearTransform< itk::Vector< float >,itk::Vector< float > > const &

        """
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF32IVF32_Superclass_SetFunctor(self, functor)
    __swig_destroy__ = _itkVectorRescaleIntensityImageFilterPython.delete_itkVectorRescaleIntensityImageFilterIVF32IVF32_Superclass

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

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

        """
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF32IVF32_Superclass_cast(obj)

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

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

          itkVectorRescaleIntensityImageFilterIVF32IVF32_Superclass.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorRescaleIntensityImageFilterIVF32IVF32_Superclass in _itkVectorRescaleIntensityImageFilterPython:
_itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF32IVF32_Superclass_swigregister(itkVectorRescaleIntensityImageFilterIVF32IVF32_Superclass)

def itkVectorRescaleIntensityImageFilterIVF33IVF33_Superclass_New():
    return itkVectorRescaleIntensityImageFilterIVF33IVF33_Superclass.New()

class itkVectorRescaleIntensityImageFilterIVF33IVF33_Superclass(itk.itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF33IVF33):
    r"""Proxy of C++ itkVectorRescaleIntensityImageFilterIVF33IVF33_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__() -> itkVectorRescaleIntensityImageFilterIVF33IVF33_Superclass_Pointer"""
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF33IVF33_Superclass___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorRescaleIntensityImageFilterIVF33IVF33_Superclass_Pointer"""
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF33IVF33_Superclass_Clone(self)

    def GetFunctor(self, *args):
        r"""
        GetFunctor(self) -> itk::Functor::VectorMagnitudeLinearTransform< itk::Vector< float >,itk::Vector< float > >
        GetFunctor(self) -> itk::Functor::VectorMagnitudeLinearTransform< itk::Vector< float >,itk::Vector< float > > const &
        """
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF33IVF33_Superclass_GetFunctor(self, *args)

    def SetFunctor(self, functor):
        r"""
        SetFunctor(self, functor)

        Parameters
        ----------
        functor: itk::Functor::VectorMagnitudeLinearTransform< itk::Vector< float >,itk::Vector< float > > const &

        """
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF33IVF33_Superclass_SetFunctor(self, functor)
    __swig_destroy__ = _itkVectorRescaleIntensityImageFilterPython.delete_itkVectorRescaleIntensityImageFilterIVF33IVF33_Superclass

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

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

        """
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF33IVF33_Superclass_cast(obj)

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

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

          itkVectorRescaleIntensityImageFilterIVF33IVF33_Superclass.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorRescaleIntensityImageFilterIVF33IVF33_Superclass in _itkVectorRescaleIntensityImageFilterPython:
_itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF33IVF33_Superclass_swigregister(itkVectorRescaleIntensityImageFilterIVF33IVF33_Superclass)

def itkVectorRescaleIntensityImageFilterIVF42IVF42_Superclass_New():
    return itkVectorRescaleIntensityImageFilterIVF42IVF42_Superclass.New()

class itkVectorRescaleIntensityImageFilterIVF42IVF42_Superclass(itk.itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF42IVF42):
    r"""Proxy of C++ itkVectorRescaleIntensityImageFilterIVF42IVF42_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__() -> itkVectorRescaleIntensityImageFilterIVF42IVF42_Superclass_Pointer"""
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF42IVF42_Superclass___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorRescaleIntensityImageFilterIVF42IVF42_Superclass_Pointer"""
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF42IVF42_Superclass_Clone(self)

    def GetFunctor(self, *args):
        r"""
        GetFunctor(self) -> itk::Functor::VectorMagnitudeLinearTransform< itk::Vector< float,4 >,itk::Vector< float,4 > >
        GetFunctor(self) -> itk::Functor::VectorMagnitudeLinearTransform< itk::Vector< float,4 >,itk::Vector< float,4 > > const &
        """
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF42IVF42_Superclass_GetFunctor(self, *args)

    def SetFunctor(self, functor):
        r"""
        SetFunctor(self, functor)

        Parameters
        ----------
        functor: itk::Functor::VectorMagnitudeLinearTransform< itk::Vector< float,4 >,itk::Vector< float,4 > > const &

        """
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF42IVF42_Superclass_SetFunctor(self, functor)
    __swig_destroy__ = _itkVectorRescaleIntensityImageFilterPython.delete_itkVectorRescaleIntensityImageFilterIVF42IVF42_Superclass

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

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

        """
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF42IVF42_Superclass_cast(obj)

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

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

          itkVectorRescaleIntensityImageFilterIVF42IVF42_Superclass.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorRescaleIntensityImageFilterIVF42IVF42_Superclass in _itkVectorRescaleIntensityImageFilterPython:
_itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF42IVF42_Superclass_swigregister(itkVectorRescaleIntensityImageFilterIVF42IVF42_Superclass)

def itkVectorRescaleIntensityImageFilterIVF43IVF43_Superclass_New():
    return itkVectorRescaleIntensityImageFilterIVF43IVF43_Superclass.New()

class itkVectorRescaleIntensityImageFilterIVF43IVF43_Superclass(itk.itkInPlaceImageFilterAPython.itkInPlaceImageFilterIVF43IVF43):
    r"""Proxy of C++ itkVectorRescaleIntensityImageFilterIVF43IVF43_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__() -> itkVectorRescaleIntensityImageFilterIVF43IVF43_Superclass_Pointer"""
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF43IVF43_Superclass___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorRescaleIntensityImageFilterIVF43IVF43_Superclass_Pointer"""
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF43IVF43_Superclass_Clone(self)

    def GetFunctor(self, *args):
        r"""
        GetFunctor(self) -> itk::Functor::VectorMagnitudeLinearTransform< itk::Vector< float,4 >,itk::Vector< float,4 > >
        GetFunctor(self) -> itk::Functor::VectorMagnitudeLinearTransform< itk::Vector< float,4 >,itk::Vector< float,4 > > const &
        """
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF43IVF43_Superclass_GetFunctor(self, *args)

    def SetFunctor(self, functor):
        r"""
        SetFunctor(self, functor)

        Parameters
        ----------
        functor: itk::Functor::VectorMagnitudeLinearTransform< itk::Vector< float,4 >,itk::Vector< float,4 > > const &

        """
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF43IVF43_Superclass_SetFunctor(self, functor)
    __swig_destroy__ = _itkVectorRescaleIntensityImageFilterPython.delete_itkVectorRescaleIntensityImageFilterIVF43IVF43_Superclass

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

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

        """
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF43IVF43_Superclass_cast(obj)

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

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

          itkVectorRescaleIntensityImageFilterIVF43IVF43_Superclass.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorRescaleIntensityImageFilterIVF43IVF43_Superclass in _itkVectorRescaleIntensityImageFilterPython:
_itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF43IVF43_Superclass_swigregister(itkVectorRescaleIntensityImageFilterIVF43IVF43_Superclass)

def itkVectorRescaleIntensityImageFilterIVF22IVF22_New():
    return itkVectorRescaleIntensityImageFilterIVF22IVF22.New()

class itkVectorRescaleIntensityImageFilterIVF22IVF22(itkVectorRescaleIntensityImageFilterIVF22IVF22_Superclass):
    r"""Proxy of C++ itkVectorRescaleIntensityImageFilterIVF22IVF22 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__() -> itkVectorRescaleIntensityImageFilterIVF22IVF22_Pointer"""
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF22IVF22___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorRescaleIntensityImageFilterIVF22IVF22_Pointer"""
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF22IVF22_Clone(self)

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

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

        """
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF22IVF22_SetOutputMaximumMagnitude(self, _arg)

    def GetOutputMaximumMagnitude(self):
        r"""GetOutputMaximumMagnitude(self) -> double const &"""
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF22IVF22_GetOutputMaximumMagnitude(self)

    def GetScale(self):
        r"""GetScale(self) -> double const &"""
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF22IVF22_GetScale(self)

    def GetShift(self):
        r"""GetShift(self) -> double const &"""
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF22IVF22_GetShift(self)

    def GetInputMaximumMagnitude(self):
        r"""GetInputMaximumMagnitude(self) -> double const &"""
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF22IVF22_GetInputMaximumMagnitude(self)

    def BeforeThreadedGenerateData(self):
        r"""BeforeThreadedGenerateData(self)"""
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF22IVF22_BeforeThreadedGenerateData(self)

    def PrintSelf(self, os, indent):
        r"""
        PrintSelf(self, os, indent)

        Parameters
        ----------
        os: std::basic_ostream< char,std::char_traits< char > > &
        indent: itkIndent

        """
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF22IVF22_PrintSelf(self, os, indent)
    InputHasNumericTraitsCheck = _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF22IVF22_InputHasNumericTraitsCheck
    
    OutputHasNumericTraitsCheck = _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF22IVF22_OutputHasNumericTraitsCheck
    
    __swig_destroy__ = _itkVectorRescaleIntensityImageFilterPython.delete_itkVectorRescaleIntensityImageFilterIVF22IVF22

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

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

        """
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF22IVF22_cast(obj)

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

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

          itkVectorRescaleIntensityImageFilterIVF22IVF22.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorRescaleIntensityImageFilterIVF22IVF22 in _itkVectorRescaleIntensityImageFilterPython:
_itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF22IVF22_swigregister(itkVectorRescaleIntensityImageFilterIVF22IVF22)

def itkVectorRescaleIntensityImageFilterIVF23IVF23_New():
    return itkVectorRescaleIntensityImageFilterIVF23IVF23.New()

class itkVectorRescaleIntensityImageFilterIVF23IVF23(itkVectorRescaleIntensityImageFilterIVF23IVF23_Superclass):
    r"""Proxy of C++ itkVectorRescaleIntensityImageFilterIVF23IVF23 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__() -> itkVectorRescaleIntensityImageFilterIVF23IVF23_Pointer"""
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF23IVF23___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorRescaleIntensityImageFilterIVF23IVF23_Pointer"""
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF23IVF23_Clone(self)

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

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

        """
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF23IVF23_SetOutputMaximumMagnitude(self, _arg)

    def GetOutputMaximumMagnitude(self):
        r"""GetOutputMaximumMagnitude(self) -> double const &"""
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF23IVF23_GetOutputMaximumMagnitude(self)

    def GetScale(self):
        r"""GetScale(self) -> double const &"""
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF23IVF23_GetScale(self)

    def GetShift(self):
        r"""GetShift(self) -> double const &"""
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF23IVF23_GetShift(self)

    def GetInputMaximumMagnitude(self):
        r"""GetInputMaximumMagnitude(self) -> double const &"""
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF23IVF23_GetInputMaximumMagnitude(self)

    def BeforeThreadedGenerateData(self):
        r"""BeforeThreadedGenerateData(self)"""
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF23IVF23_BeforeThreadedGenerateData(self)

    def PrintSelf(self, os, indent):
        r"""
        PrintSelf(self, os, indent)

        Parameters
        ----------
        os: std::basic_ostream< char,std::char_traits< char > > &
        indent: itkIndent

        """
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF23IVF23_PrintSelf(self, os, indent)
    InputHasNumericTraitsCheck = _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF23IVF23_InputHasNumericTraitsCheck
    
    OutputHasNumericTraitsCheck = _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF23IVF23_OutputHasNumericTraitsCheck
    
    __swig_destroy__ = _itkVectorRescaleIntensityImageFilterPython.delete_itkVectorRescaleIntensityImageFilterIVF23IVF23

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

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

        """
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF23IVF23_cast(obj)

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

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

          itkVectorRescaleIntensityImageFilterIVF23IVF23.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorRescaleIntensityImageFilterIVF23IVF23 in _itkVectorRescaleIntensityImageFilterPython:
_itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF23IVF23_swigregister(itkVectorRescaleIntensityImageFilterIVF23IVF23)

def itkVectorRescaleIntensityImageFilterIVF32IVF32_New():
    return itkVectorRescaleIntensityImageFilterIVF32IVF32.New()

class itkVectorRescaleIntensityImageFilterIVF32IVF32(itkVectorRescaleIntensityImageFilterIVF32IVF32_Superclass):
    r"""Proxy of C++ itkVectorRescaleIntensityImageFilterIVF32IVF32 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__() -> itkVectorRescaleIntensityImageFilterIVF32IVF32_Pointer"""
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF32IVF32___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorRescaleIntensityImageFilterIVF32IVF32_Pointer"""
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF32IVF32_Clone(self)

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

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

        """
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF32IVF32_SetOutputMaximumMagnitude(self, _arg)

    def GetOutputMaximumMagnitude(self):
        r"""GetOutputMaximumMagnitude(self) -> double const &"""
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF32IVF32_GetOutputMaximumMagnitude(self)

    def GetScale(self):
        r"""GetScale(self) -> double const &"""
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF32IVF32_GetScale(self)

    def GetShift(self):
        r"""GetShift(self) -> double const &"""
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF32IVF32_GetShift(self)

    def GetInputMaximumMagnitude(self):
        r"""GetInputMaximumMagnitude(self) -> double const &"""
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF32IVF32_GetInputMaximumMagnitude(self)

    def BeforeThreadedGenerateData(self):
        r"""BeforeThreadedGenerateData(self)"""
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF32IVF32_BeforeThreadedGenerateData(self)

    def PrintSelf(self, os, indent):
        r"""
        PrintSelf(self, os, indent)

        Parameters
        ----------
        os: std::basic_ostream< char,std::char_traits< char > > &
        indent: itkIndent

        """
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF32IVF32_PrintSelf(self, os, indent)
    InputHasNumericTraitsCheck = _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF32IVF32_InputHasNumericTraitsCheck
    
    OutputHasNumericTraitsCheck = _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF32IVF32_OutputHasNumericTraitsCheck
    
    __swig_destroy__ = _itkVectorRescaleIntensityImageFilterPython.delete_itkVectorRescaleIntensityImageFilterIVF32IVF32

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

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

        """
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF32IVF32_cast(obj)

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

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

          itkVectorRescaleIntensityImageFilterIVF32IVF32.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorRescaleIntensityImageFilterIVF32IVF32 in _itkVectorRescaleIntensityImageFilterPython:
_itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF32IVF32_swigregister(itkVectorRescaleIntensityImageFilterIVF32IVF32)

def itkVectorRescaleIntensityImageFilterIVF33IVF33_New():
    return itkVectorRescaleIntensityImageFilterIVF33IVF33.New()

class itkVectorRescaleIntensityImageFilterIVF33IVF33(itkVectorRescaleIntensityImageFilterIVF33IVF33_Superclass):
    r"""Proxy of C++ itkVectorRescaleIntensityImageFilterIVF33IVF33 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__() -> itkVectorRescaleIntensityImageFilterIVF33IVF33_Pointer"""
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF33IVF33___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorRescaleIntensityImageFilterIVF33IVF33_Pointer"""
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF33IVF33_Clone(self)

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

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

        """
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF33IVF33_SetOutputMaximumMagnitude(self, _arg)

    def GetOutputMaximumMagnitude(self):
        r"""GetOutputMaximumMagnitude(self) -> double const &"""
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF33IVF33_GetOutputMaximumMagnitude(self)

    def GetScale(self):
        r"""GetScale(self) -> double const &"""
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF33IVF33_GetScale(self)

    def GetShift(self):
        r"""GetShift(self) -> double const &"""
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF33IVF33_GetShift(self)

    def GetInputMaximumMagnitude(self):
        r"""GetInputMaximumMagnitude(self) -> double const &"""
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF33IVF33_GetInputMaximumMagnitude(self)

    def BeforeThreadedGenerateData(self):
        r"""BeforeThreadedGenerateData(self)"""
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF33IVF33_BeforeThreadedGenerateData(self)

    def PrintSelf(self, os, indent):
        r"""
        PrintSelf(self, os, indent)

        Parameters
        ----------
        os: std::basic_ostream< char,std::char_traits< char > > &
        indent: itkIndent

        """
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF33IVF33_PrintSelf(self, os, indent)
    InputHasNumericTraitsCheck = _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF33IVF33_InputHasNumericTraitsCheck
    
    OutputHasNumericTraitsCheck = _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF33IVF33_OutputHasNumericTraitsCheck
    
    __swig_destroy__ = _itkVectorRescaleIntensityImageFilterPython.delete_itkVectorRescaleIntensityImageFilterIVF33IVF33

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

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

        """
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF33IVF33_cast(obj)

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

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

          itkVectorRescaleIntensityImageFilterIVF33IVF33.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorRescaleIntensityImageFilterIVF33IVF33 in _itkVectorRescaleIntensityImageFilterPython:
_itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF33IVF33_swigregister(itkVectorRescaleIntensityImageFilterIVF33IVF33)

def itkVectorRescaleIntensityImageFilterIVF42IVF42_New():
    return itkVectorRescaleIntensityImageFilterIVF42IVF42.New()

class itkVectorRescaleIntensityImageFilterIVF42IVF42(itkVectorRescaleIntensityImageFilterIVF42IVF42_Superclass):
    r"""Proxy of C++ itkVectorRescaleIntensityImageFilterIVF42IVF42 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__() -> itkVectorRescaleIntensityImageFilterIVF42IVF42_Pointer"""
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF42IVF42___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorRescaleIntensityImageFilterIVF42IVF42_Pointer"""
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF42IVF42_Clone(self)

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

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

        """
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF42IVF42_SetOutputMaximumMagnitude(self, _arg)

    def GetOutputMaximumMagnitude(self):
        r"""GetOutputMaximumMagnitude(self) -> double const &"""
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF42IVF42_GetOutputMaximumMagnitude(self)

    def GetScale(self):
        r"""GetScale(self) -> double const &"""
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF42IVF42_GetScale(self)

    def GetShift(self):
        r"""GetShift(self) -> double const &"""
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF42IVF42_GetShift(self)

    def GetInputMaximumMagnitude(self):
        r"""GetInputMaximumMagnitude(self) -> double const &"""
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF42IVF42_GetInputMaximumMagnitude(self)

    def BeforeThreadedGenerateData(self):
        r"""BeforeThreadedGenerateData(self)"""
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF42IVF42_BeforeThreadedGenerateData(self)

    def PrintSelf(self, os, indent):
        r"""
        PrintSelf(self, os, indent)

        Parameters
        ----------
        os: std::basic_ostream< char,std::char_traits< char > > &
        indent: itkIndent

        """
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF42IVF42_PrintSelf(self, os, indent)
    InputHasNumericTraitsCheck = _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF42IVF42_InputHasNumericTraitsCheck
    
    OutputHasNumericTraitsCheck = _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF42IVF42_OutputHasNumericTraitsCheck
    
    __swig_destroy__ = _itkVectorRescaleIntensityImageFilterPython.delete_itkVectorRescaleIntensityImageFilterIVF42IVF42

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

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

        """
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF42IVF42_cast(obj)

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

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

          itkVectorRescaleIntensityImageFilterIVF42IVF42.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorRescaleIntensityImageFilterIVF42IVF42 in _itkVectorRescaleIntensityImageFilterPython:
_itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF42IVF42_swigregister(itkVectorRescaleIntensityImageFilterIVF42IVF42)

def itkVectorRescaleIntensityImageFilterIVF43IVF43_New():
    return itkVectorRescaleIntensityImageFilterIVF43IVF43.New()

class itkVectorRescaleIntensityImageFilterIVF43IVF43(itkVectorRescaleIntensityImageFilterIVF43IVF43_Superclass):
    r"""Proxy of C++ itkVectorRescaleIntensityImageFilterIVF43IVF43 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__() -> itkVectorRescaleIntensityImageFilterIVF43IVF43_Pointer"""
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF43IVF43___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorRescaleIntensityImageFilterIVF43IVF43_Pointer"""
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF43IVF43_Clone(self)

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

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

        """
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF43IVF43_SetOutputMaximumMagnitude(self, _arg)

    def GetOutputMaximumMagnitude(self):
        r"""GetOutputMaximumMagnitude(self) -> double const &"""
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF43IVF43_GetOutputMaximumMagnitude(self)

    def GetScale(self):
        r"""GetScale(self) -> double const &"""
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF43IVF43_GetScale(self)

    def GetShift(self):
        r"""GetShift(self) -> double const &"""
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF43IVF43_GetShift(self)

    def GetInputMaximumMagnitude(self):
        r"""GetInputMaximumMagnitude(self) -> double const &"""
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF43IVF43_GetInputMaximumMagnitude(self)

    def BeforeThreadedGenerateData(self):
        r"""BeforeThreadedGenerateData(self)"""
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF43IVF43_BeforeThreadedGenerateData(self)

    def PrintSelf(self, os, indent):
        r"""
        PrintSelf(self, os, indent)

        Parameters
        ----------
        os: std::basic_ostream< char,std::char_traits< char > > &
        indent: itkIndent

        """
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF43IVF43_PrintSelf(self, os, indent)
    InputHasNumericTraitsCheck = _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF43IVF43_InputHasNumericTraitsCheck
    
    OutputHasNumericTraitsCheck = _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF43IVF43_OutputHasNumericTraitsCheck
    
    __swig_destroy__ = _itkVectorRescaleIntensityImageFilterPython.delete_itkVectorRescaleIntensityImageFilterIVF43IVF43

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

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

        """
        return _itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF43IVF43_cast(obj)

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

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

          itkVectorRescaleIntensityImageFilterIVF43IVF43.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorRescaleIntensityImageFilterIVF43IVF43 in _itkVectorRescaleIntensityImageFilterPython:
_itkVectorRescaleIntensityImageFilterPython.itkVectorRescaleIntensityImageFilterIVF43IVF43_swigregister(itkVectorRescaleIntensityImageFilterIVF43IVF43)

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_rescale_intensity_image_filter(*args: itkt.ImageLike,  output_maximum_magnitude: float=..., functor=...,**kwargs)-> itkt.ImageSourceReturn:
    """Functional interface for VectorRescaleIntensityImageFilter"""
    import itk

    kwarg_typehints = { 'output_maximum_magnitude':output_maximum_magnitude,'functor':functor }
    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.VectorRescaleIntensityImageFilter.New(*args, **kwargs)

    return instance.__internal_call__()

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

    filter_class = itk.ITKImageIntensity.VectorRescaleIntensityImageFilter
    vector_rescale_intensity_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_rescale_intensity_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 unary_functor_image_filter(*args: itkt.ImageLike,  functor=...,**kwargs)-> itkt.ImageSourceReturn:
    """Functional interface for UnaryFunctorImageFilter"""
    import itk

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

    return instance.__internal_call__()

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

    filter_class = itk.ITKImageIntensity.UnaryFunctorImageFilter
    unary_functor_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_functor_image_filter.__doc__ = filter_object.__doc__



