# This file was automatically generated by SWIG (https://www.swig.org).
# Version 4.3.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 __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.itkImageRegionPython
import itk.ITKCommonBasePython
import itk.itkMatrixPython
import itk.itkVectorPython
import itk.vnl_vectorPython
import itk.stdcomplexPython
import itk.pyBasePython
import itk.vnl_matrixPython
import itk.vnl_vector_refPython
import itk.itkFixedArrayPython
import itk.itkCovariantVectorPython
import itk.itkPointPython
import itk.vnl_matrix_fixedPython
import itk.itkIndexPython
import itk.itkOffsetPython
import itk.itkSizePython
import itk.itkInPlaceImageFilterAPython
import itk.itkImageToImageFilterAPython
import itk.itkImageSourcePython
import itk.itkImageSourceCommonPython
import itk.itkImagePython
import itk.itkRGBAPixelPython
import itk.itkRGBPixelPython
import itk.itkSymmetricSecondRankTensorPython
import itk.itkVectorImagePython
import itk.itkVariableLengthVectorPython
import itk.itkPhasedArray3DSpecialCoordinatesImagePython
import itk.itkImageToImageFilterCommonPython
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__



