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

from sys import version_info as _swig_python_version_info
# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _itkSamplePython
else:
    import _itkSamplePython

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

_swig_new_instance_method = _itkSamplePython.SWIG_PyInstanceMethod_New
_swig_new_static_method = _itkSamplePython.SWIG_PyStaticMethod_New

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__)


import itkArrayPython
import vnl_vectorPython
import vnl_matrixPython
import stdcomplexPython
import pyBasePython
import itkFixedArrayPython
import itkVectorPython
import vnl_vector_refPython
import ITKCommonBasePython

def itkSampleAD_New():
  return itkSampleAD.New()


def itkSampleAF_New():
  return itkSampleAF.New()


def itkSampleVF3_New():
  return itkSampleVF3.New()


def itkSampleVF2_New():
  return itkSampleVF2.New()


def itkSampleFASC3_New():
  return itkSampleFASC3.New()


def itkSampleFASS3_New():
  return itkSampleFASS3.New()


def itkSampleFASL3_New():
  return itkSampleFASL3.New()


def itkSampleFAUC3_New():
  return itkSampleFAUC3.New()


def itkSampleFAUS3_New():
  return itkSampleFAUS3.New()


def itkSampleFAUL3_New():
  return itkSampleFAUL3.New()


def itkSampleFAF3_New():
  return itkSampleFAF3.New()


def itkSampleFAD3_New():
  return itkSampleFAD3.New()


def itkSampleFASC2_New():
  return itkSampleFASC2.New()


def itkSampleFASS2_New():
  return itkSampleFASS2.New()


def itkSampleFASL2_New():
  return itkSampleFASL2.New()


def itkSampleFAUC2_New():
  return itkSampleFAUC2.New()


def itkSampleFAUS2_New():
  return itkSampleFAUS2.New()


def itkSampleFAUL2_New():
  return itkSampleFAUL2.New()


def itkSampleFAF2_New():
  return itkSampleFAF2.New()


def itkSampleFAD2_New():
  return itkSampleFAD2.New()


def itkSampleFASC1_New():
  return itkSampleFASC1.New()


def itkSampleFASS1_New():
  return itkSampleFASS1.New()


def itkSampleFASL1_New():
  return itkSampleFASL1.New()


def itkSampleFAUC1_New():
  return itkSampleFAUC1.New()


def itkSampleFAUS1_New():
  return itkSampleFAUS1.New()


def itkSampleFAUL1_New():
  return itkSampleFAUL1.New()


def itkSampleFAF1_New():
  return itkSampleFAF1.New()


def itkSampleFAD1_New():
  return itkSampleFAD1.New()

class itkSampleAD(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkSampleAD 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 - class is abstract")
    __repr__ = _swig_repr
    Size = _swig_new_instance_method(_itkSamplePython.itkSampleAD_Size)
    GetMeasurementVector = _swig_new_instance_method(_itkSamplePython.itkSampleAD_GetMeasurementVector)
    GetFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleAD_GetFrequency)
    GetTotalFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleAD_GetTotalFrequency)
    SetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleAD_SetMeasurementVectorSize)
    GetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleAD_GetMeasurementVectorSize)
    __swig_destroy__ = _itkSamplePython.delete_itkSampleAD
    cast = _swig_new_static_method(_itkSamplePython.itkSampleAD_cast)
    GetPointer = _swig_new_instance_method(_itkSamplePython.itkSampleAD_GetPointer)

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

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

          itkSampleAD.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkSampleAD.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkSampleAD.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkSampleAD in _itkSamplePython:
_itkSamplePython.itkSampleAD_swigregister(itkSampleAD)
class itkSampleAF(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkSampleAF 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 - class is abstract")
    __repr__ = _swig_repr
    Size = _swig_new_instance_method(_itkSamplePython.itkSampleAF_Size)
    GetMeasurementVector = _swig_new_instance_method(_itkSamplePython.itkSampleAF_GetMeasurementVector)
    GetFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleAF_GetFrequency)
    GetTotalFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleAF_GetTotalFrequency)
    SetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleAF_SetMeasurementVectorSize)
    GetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleAF_GetMeasurementVectorSize)
    __swig_destroy__ = _itkSamplePython.delete_itkSampleAF
    cast = _swig_new_static_method(_itkSamplePython.itkSampleAF_cast)
    GetPointer = _swig_new_instance_method(_itkSamplePython.itkSampleAF_GetPointer)

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

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

          itkSampleAF.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkSampleAF.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkSampleAF.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkSampleAF in _itkSamplePython:
_itkSamplePython.itkSampleAF_swigregister(itkSampleAF)
class itkSampleFAD1(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkSampleFAD1 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 - class is abstract")
    __repr__ = _swig_repr
    Size = _swig_new_instance_method(_itkSamplePython.itkSampleFAD1_Size)
    GetMeasurementVector = _swig_new_instance_method(_itkSamplePython.itkSampleFAD1_GetMeasurementVector)
    GetFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleFAD1_GetFrequency)
    GetTotalFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleFAD1_GetTotalFrequency)
    SetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleFAD1_SetMeasurementVectorSize)
    GetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleFAD1_GetMeasurementVectorSize)
    __swig_destroy__ = _itkSamplePython.delete_itkSampleFAD1
    cast = _swig_new_static_method(_itkSamplePython.itkSampleFAD1_cast)
    GetPointer = _swig_new_instance_method(_itkSamplePython.itkSampleFAD1_GetPointer)

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

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

          itkSampleFAD1.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkSampleFAD1.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkSampleFAD1.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkSampleFAD1 in _itkSamplePython:
_itkSamplePython.itkSampleFAD1_swigregister(itkSampleFAD1)
class itkSampleFAD2(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkSampleFAD2 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 - class is abstract")
    __repr__ = _swig_repr
    Size = _swig_new_instance_method(_itkSamplePython.itkSampleFAD2_Size)
    GetMeasurementVector = _swig_new_instance_method(_itkSamplePython.itkSampleFAD2_GetMeasurementVector)
    GetFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleFAD2_GetFrequency)
    GetTotalFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleFAD2_GetTotalFrequency)
    SetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleFAD2_SetMeasurementVectorSize)
    GetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleFAD2_GetMeasurementVectorSize)
    __swig_destroy__ = _itkSamplePython.delete_itkSampleFAD2
    cast = _swig_new_static_method(_itkSamplePython.itkSampleFAD2_cast)
    GetPointer = _swig_new_instance_method(_itkSamplePython.itkSampleFAD2_GetPointer)

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

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

          itkSampleFAD2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkSampleFAD2.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkSampleFAD2.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkSampleFAD2 in _itkSamplePython:
_itkSamplePython.itkSampleFAD2_swigregister(itkSampleFAD2)
class itkSampleFAD3(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkSampleFAD3 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 - class is abstract")
    __repr__ = _swig_repr
    Size = _swig_new_instance_method(_itkSamplePython.itkSampleFAD3_Size)
    GetMeasurementVector = _swig_new_instance_method(_itkSamplePython.itkSampleFAD3_GetMeasurementVector)
    GetFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleFAD3_GetFrequency)
    GetTotalFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleFAD3_GetTotalFrequency)
    SetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleFAD3_SetMeasurementVectorSize)
    GetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleFAD3_GetMeasurementVectorSize)
    __swig_destroy__ = _itkSamplePython.delete_itkSampleFAD3
    cast = _swig_new_static_method(_itkSamplePython.itkSampleFAD3_cast)
    GetPointer = _swig_new_instance_method(_itkSamplePython.itkSampleFAD3_GetPointer)

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

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

          itkSampleFAD3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkSampleFAD3.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkSampleFAD3.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkSampleFAD3 in _itkSamplePython:
_itkSamplePython.itkSampleFAD3_swigregister(itkSampleFAD3)
class itkSampleFAF1(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkSampleFAF1 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 - class is abstract")
    __repr__ = _swig_repr
    Size = _swig_new_instance_method(_itkSamplePython.itkSampleFAF1_Size)
    GetMeasurementVector = _swig_new_instance_method(_itkSamplePython.itkSampleFAF1_GetMeasurementVector)
    GetFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleFAF1_GetFrequency)
    GetTotalFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleFAF1_GetTotalFrequency)
    SetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleFAF1_SetMeasurementVectorSize)
    GetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleFAF1_GetMeasurementVectorSize)
    __swig_destroy__ = _itkSamplePython.delete_itkSampleFAF1
    cast = _swig_new_static_method(_itkSamplePython.itkSampleFAF1_cast)
    GetPointer = _swig_new_instance_method(_itkSamplePython.itkSampleFAF1_GetPointer)

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

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

          itkSampleFAF1.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkSampleFAF1.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkSampleFAF1.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkSampleFAF1 in _itkSamplePython:
_itkSamplePython.itkSampleFAF1_swigregister(itkSampleFAF1)
class itkSampleFAF2(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkSampleFAF2 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 - class is abstract")
    __repr__ = _swig_repr
    Size = _swig_new_instance_method(_itkSamplePython.itkSampleFAF2_Size)
    GetMeasurementVector = _swig_new_instance_method(_itkSamplePython.itkSampleFAF2_GetMeasurementVector)
    GetFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleFAF2_GetFrequency)
    GetTotalFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleFAF2_GetTotalFrequency)
    SetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleFAF2_SetMeasurementVectorSize)
    GetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleFAF2_GetMeasurementVectorSize)
    __swig_destroy__ = _itkSamplePython.delete_itkSampleFAF2
    cast = _swig_new_static_method(_itkSamplePython.itkSampleFAF2_cast)
    GetPointer = _swig_new_instance_method(_itkSamplePython.itkSampleFAF2_GetPointer)

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

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

          itkSampleFAF2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkSampleFAF2.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkSampleFAF2.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkSampleFAF2 in _itkSamplePython:
_itkSamplePython.itkSampleFAF2_swigregister(itkSampleFAF2)
class itkSampleFAF3(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkSampleFAF3 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 - class is abstract")
    __repr__ = _swig_repr
    Size = _swig_new_instance_method(_itkSamplePython.itkSampleFAF3_Size)
    GetMeasurementVector = _swig_new_instance_method(_itkSamplePython.itkSampleFAF3_GetMeasurementVector)
    GetFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleFAF3_GetFrequency)
    GetTotalFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleFAF3_GetTotalFrequency)
    SetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleFAF3_SetMeasurementVectorSize)
    GetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleFAF3_GetMeasurementVectorSize)
    __swig_destroy__ = _itkSamplePython.delete_itkSampleFAF3
    cast = _swig_new_static_method(_itkSamplePython.itkSampleFAF3_cast)
    GetPointer = _swig_new_instance_method(_itkSamplePython.itkSampleFAF3_GetPointer)

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

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

          itkSampleFAF3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkSampleFAF3.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkSampleFAF3.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkSampleFAF3 in _itkSamplePython:
_itkSamplePython.itkSampleFAF3_swigregister(itkSampleFAF3)
class itkSampleFASC1(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkSampleFASC1 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 - class is abstract")
    __repr__ = _swig_repr
    Size = _swig_new_instance_method(_itkSamplePython.itkSampleFASC1_Size)
    GetMeasurementVector = _swig_new_instance_method(_itkSamplePython.itkSampleFASC1_GetMeasurementVector)
    GetFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleFASC1_GetFrequency)
    GetTotalFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleFASC1_GetTotalFrequency)
    SetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleFASC1_SetMeasurementVectorSize)
    GetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleFASC1_GetMeasurementVectorSize)
    __swig_destroy__ = _itkSamplePython.delete_itkSampleFASC1
    cast = _swig_new_static_method(_itkSamplePython.itkSampleFASC1_cast)
    GetPointer = _swig_new_instance_method(_itkSamplePython.itkSampleFASC1_GetPointer)

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

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

          itkSampleFASC1.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkSampleFASC1.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkSampleFASC1.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkSampleFASC1 in _itkSamplePython:
_itkSamplePython.itkSampleFASC1_swigregister(itkSampleFASC1)
class itkSampleFASC2(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkSampleFASC2 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 - class is abstract")
    __repr__ = _swig_repr
    Size = _swig_new_instance_method(_itkSamplePython.itkSampleFASC2_Size)
    GetMeasurementVector = _swig_new_instance_method(_itkSamplePython.itkSampleFASC2_GetMeasurementVector)
    GetFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleFASC2_GetFrequency)
    GetTotalFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleFASC2_GetTotalFrequency)
    SetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleFASC2_SetMeasurementVectorSize)
    GetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleFASC2_GetMeasurementVectorSize)
    __swig_destroy__ = _itkSamplePython.delete_itkSampleFASC2
    cast = _swig_new_static_method(_itkSamplePython.itkSampleFASC2_cast)
    GetPointer = _swig_new_instance_method(_itkSamplePython.itkSampleFASC2_GetPointer)

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

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

          itkSampleFASC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkSampleFASC2.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkSampleFASC2.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkSampleFASC2 in _itkSamplePython:
_itkSamplePython.itkSampleFASC2_swigregister(itkSampleFASC2)
class itkSampleFASC3(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkSampleFASC3 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 - class is abstract")
    __repr__ = _swig_repr
    Size = _swig_new_instance_method(_itkSamplePython.itkSampleFASC3_Size)
    GetMeasurementVector = _swig_new_instance_method(_itkSamplePython.itkSampleFASC3_GetMeasurementVector)
    GetFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleFASC3_GetFrequency)
    GetTotalFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleFASC3_GetTotalFrequency)
    SetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleFASC3_SetMeasurementVectorSize)
    GetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleFASC3_GetMeasurementVectorSize)
    __swig_destroy__ = _itkSamplePython.delete_itkSampleFASC3
    cast = _swig_new_static_method(_itkSamplePython.itkSampleFASC3_cast)
    GetPointer = _swig_new_instance_method(_itkSamplePython.itkSampleFASC3_GetPointer)

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

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

          itkSampleFASC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkSampleFASC3.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkSampleFASC3.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkSampleFASC3 in _itkSamplePython:
_itkSamplePython.itkSampleFASC3_swigregister(itkSampleFASC3)
class itkSampleFASL1(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkSampleFASL1 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 - class is abstract")
    __repr__ = _swig_repr
    Size = _swig_new_instance_method(_itkSamplePython.itkSampleFASL1_Size)
    GetMeasurementVector = _swig_new_instance_method(_itkSamplePython.itkSampleFASL1_GetMeasurementVector)
    GetFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleFASL1_GetFrequency)
    GetTotalFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleFASL1_GetTotalFrequency)
    SetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleFASL1_SetMeasurementVectorSize)
    GetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleFASL1_GetMeasurementVectorSize)
    __swig_destroy__ = _itkSamplePython.delete_itkSampleFASL1
    cast = _swig_new_static_method(_itkSamplePython.itkSampleFASL1_cast)
    GetPointer = _swig_new_instance_method(_itkSamplePython.itkSampleFASL1_GetPointer)

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

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

          itkSampleFASL1.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkSampleFASL1.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkSampleFASL1.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkSampleFASL1 in _itkSamplePython:
_itkSamplePython.itkSampleFASL1_swigregister(itkSampleFASL1)
class itkSampleFASL2(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkSampleFASL2 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 - class is abstract")
    __repr__ = _swig_repr
    Size = _swig_new_instance_method(_itkSamplePython.itkSampleFASL2_Size)
    GetMeasurementVector = _swig_new_instance_method(_itkSamplePython.itkSampleFASL2_GetMeasurementVector)
    GetFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleFASL2_GetFrequency)
    GetTotalFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleFASL2_GetTotalFrequency)
    SetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleFASL2_SetMeasurementVectorSize)
    GetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleFASL2_GetMeasurementVectorSize)
    __swig_destroy__ = _itkSamplePython.delete_itkSampleFASL2
    cast = _swig_new_static_method(_itkSamplePython.itkSampleFASL2_cast)
    GetPointer = _swig_new_instance_method(_itkSamplePython.itkSampleFASL2_GetPointer)

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

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

          itkSampleFASL2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkSampleFASL2.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkSampleFASL2.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkSampleFASL2 in _itkSamplePython:
_itkSamplePython.itkSampleFASL2_swigregister(itkSampleFASL2)
class itkSampleFASL3(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkSampleFASL3 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 - class is abstract")
    __repr__ = _swig_repr
    Size = _swig_new_instance_method(_itkSamplePython.itkSampleFASL3_Size)
    GetMeasurementVector = _swig_new_instance_method(_itkSamplePython.itkSampleFASL3_GetMeasurementVector)
    GetFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleFASL3_GetFrequency)
    GetTotalFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleFASL3_GetTotalFrequency)
    SetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleFASL3_SetMeasurementVectorSize)
    GetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleFASL3_GetMeasurementVectorSize)
    __swig_destroy__ = _itkSamplePython.delete_itkSampleFASL3
    cast = _swig_new_static_method(_itkSamplePython.itkSampleFASL3_cast)
    GetPointer = _swig_new_instance_method(_itkSamplePython.itkSampleFASL3_GetPointer)

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

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

          itkSampleFASL3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkSampleFASL3.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkSampleFASL3.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkSampleFASL3 in _itkSamplePython:
_itkSamplePython.itkSampleFASL3_swigregister(itkSampleFASL3)
class itkSampleFASS1(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkSampleFASS1 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 - class is abstract")
    __repr__ = _swig_repr
    Size = _swig_new_instance_method(_itkSamplePython.itkSampleFASS1_Size)
    GetMeasurementVector = _swig_new_instance_method(_itkSamplePython.itkSampleFASS1_GetMeasurementVector)
    GetFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleFASS1_GetFrequency)
    GetTotalFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleFASS1_GetTotalFrequency)
    SetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleFASS1_SetMeasurementVectorSize)
    GetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleFASS1_GetMeasurementVectorSize)
    __swig_destroy__ = _itkSamplePython.delete_itkSampleFASS1
    cast = _swig_new_static_method(_itkSamplePython.itkSampleFASS1_cast)
    GetPointer = _swig_new_instance_method(_itkSamplePython.itkSampleFASS1_GetPointer)

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

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

          itkSampleFASS1.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkSampleFASS1.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkSampleFASS1.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkSampleFASS1 in _itkSamplePython:
_itkSamplePython.itkSampleFASS1_swigregister(itkSampleFASS1)
class itkSampleFASS2(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkSampleFASS2 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 - class is abstract")
    __repr__ = _swig_repr
    Size = _swig_new_instance_method(_itkSamplePython.itkSampleFASS2_Size)
    GetMeasurementVector = _swig_new_instance_method(_itkSamplePython.itkSampleFASS2_GetMeasurementVector)
    GetFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleFASS2_GetFrequency)
    GetTotalFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleFASS2_GetTotalFrequency)
    SetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleFASS2_SetMeasurementVectorSize)
    GetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleFASS2_GetMeasurementVectorSize)
    __swig_destroy__ = _itkSamplePython.delete_itkSampleFASS2
    cast = _swig_new_static_method(_itkSamplePython.itkSampleFASS2_cast)
    GetPointer = _swig_new_instance_method(_itkSamplePython.itkSampleFASS2_GetPointer)

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

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

          itkSampleFASS2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkSampleFASS2.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkSampleFASS2.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkSampleFASS2 in _itkSamplePython:
_itkSamplePython.itkSampleFASS2_swigregister(itkSampleFASS2)
class itkSampleFASS3(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkSampleFASS3 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 - class is abstract")
    __repr__ = _swig_repr
    Size = _swig_new_instance_method(_itkSamplePython.itkSampleFASS3_Size)
    GetMeasurementVector = _swig_new_instance_method(_itkSamplePython.itkSampleFASS3_GetMeasurementVector)
    GetFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleFASS3_GetFrequency)
    GetTotalFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleFASS3_GetTotalFrequency)
    SetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleFASS3_SetMeasurementVectorSize)
    GetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleFASS3_GetMeasurementVectorSize)
    __swig_destroy__ = _itkSamplePython.delete_itkSampleFASS3
    cast = _swig_new_static_method(_itkSamplePython.itkSampleFASS3_cast)
    GetPointer = _swig_new_instance_method(_itkSamplePython.itkSampleFASS3_GetPointer)

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

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

          itkSampleFASS3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkSampleFASS3.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkSampleFASS3.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkSampleFASS3 in _itkSamplePython:
_itkSamplePython.itkSampleFASS3_swigregister(itkSampleFASS3)
class itkSampleFAUC1(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkSampleFAUC1 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 - class is abstract")
    __repr__ = _swig_repr
    Size = _swig_new_instance_method(_itkSamplePython.itkSampleFAUC1_Size)
    GetMeasurementVector = _swig_new_instance_method(_itkSamplePython.itkSampleFAUC1_GetMeasurementVector)
    GetFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleFAUC1_GetFrequency)
    GetTotalFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleFAUC1_GetTotalFrequency)
    SetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleFAUC1_SetMeasurementVectorSize)
    GetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleFAUC1_GetMeasurementVectorSize)
    __swig_destroy__ = _itkSamplePython.delete_itkSampleFAUC1
    cast = _swig_new_static_method(_itkSamplePython.itkSampleFAUC1_cast)
    GetPointer = _swig_new_instance_method(_itkSamplePython.itkSampleFAUC1_GetPointer)

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

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

          itkSampleFAUC1.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkSampleFAUC1.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkSampleFAUC1.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkSampleFAUC1 in _itkSamplePython:
_itkSamplePython.itkSampleFAUC1_swigregister(itkSampleFAUC1)
class itkSampleFAUC2(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkSampleFAUC2 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 - class is abstract")
    __repr__ = _swig_repr
    Size = _swig_new_instance_method(_itkSamplePython.itkSampleFAUC2_Size)
    GetMeasurementVector = _swig_new_instance_method(_itkSamplePython.itkSampleFAUC2_GetMeasurementVector)
    GetFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleFAUC2_GetFrequency)
    GetTotalFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleFAUC2_GetTotalFrequency)
    SetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleFAUC2_SetMeasurementVectorSize)
    GetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleFAUC2_GetMeasurementVectorSize)
    __swig_destroy__ = _itkSamplePython.delete_itkSampleFAUC2
    cast = _swig_new_static_method(_itkSamplePython.itkSampleFAUC2_cast)
    GetPointer = _swig_new_instance_method(_itkSamplePython.itkSampleFAUC2_GetPointer)

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

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

          itkSampleFAUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkSampleFAUC2.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkSampleFAUC2.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkSampleFAUC2 in _itkSamplePython:
_itkSamplePython.itkSampleFAUC2_swigregister(itkSampleFAUC2)
class itkSampleFAUC3(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkSampleFAUC3 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 - class is abstract")
    __repr__ = _swig_repr
    Size = _swig_new_instance_method(_itkSamplePython.itkSampleFAUC3_Size)
    GetMeasurementVector = _swig_new_instance_method(_itkSamplePython.itkSampleFAUC3_GetMeasurementVector)
    GetFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleFAUC3_GetFrequency)
    GetTotalFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleFAUC3_GetTotalFrequency)
    SetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleFAUC3_SetMeasurementVectorSize)
    GetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleFAUC3_GetMeasurementVectorSize)
    __swig_destroy__ = _itkSamplePython.delete_itkSampleFAUC3
    cast = _swig_new_static_method(_itkSamplePython.itkSampleFAUC3_cast)
    GetPointer = _swig_new_instance_method(_itkSamplePython.itkSampleFAUC3_GetPointer)

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

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

          itkSampleFAUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkSampleFAUC3.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkSampleFAUC3.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkSampleFAUC3 in _itkSamplePython:
_itkSamplePython.itkSampleFAUC3_swigregister(itkSampleFAUC3)
class itkSampleFAUL1(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkSampleFAUL1 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 - class is abstract")
    __repr__ = _swig_repr
    Size = _swig_new_instance_method(_itkSamplePython.itkSampleFAUL1_Size)
    GetMeasurementVector = _swig_new_instance_method(_itkSamplePython.itkSampleFAUL1_GetMeasurementVector)
    GetFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleFAUL1_GetFrequency)
    GetTotalFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleFAUL1_GetTotalFrequency)
    SetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleFAUL1_SetMeasurementVectorSize)
    GetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleFAUL1_GetMeasurementVectorSize)
    __swig_destroy__ = _itkSamplePython.delete_itkSampleFAUL1
    cast = _swig_new_static_method(_itkSamplePython.itkSampleFAUL1_cast)
    GetPointer = _swig_new_instance_method(_itkSamplePython.itkSampleFAUL1_GetPointer)

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

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

          itkSampleFAUL1.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkSampleFAUL1.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkSampleFAUL1.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkSampleFAUL1 in _itkSamplePython:
_itkSamplePython.itkSampleFAUL1_swigregister(itkSampleFAUL1)
class itkSampleFAUL2(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkSampleFAUL2 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 - class is abstract")
    __repr__ = _swig_repr
    Size = _swig_new_instance_method(_itkSamplePython.itkSampleFAUL2_Size)
    GetMeasurementVector = _swig_new_instance_method(_itkSamplePython.itkSampleFAUL2_GetMeasurementVector)
    GetFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleFAUL2_GetFrequency)
    GetTotalFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleFAUL2_GetTotalFrequency)
    SetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleFAUL2_SetMeasurementVectorSize)
    GetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleFAUL2_GetMeasurementVectorSize)
    __swig_destroy__ = _itkSamplePython.delete_itkSampleFAUL2
    cast = _swig_new_static_method(_itkSamplePython.itkSampleFAUL2_cast)
    GetPointer = _swig_new_instance_method(_itkSamplePython.itkSampleFAUL2_GetPointer)

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

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

          itkSampleFAUL2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkSampleFAUL2.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkSampleFAUL2.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkSampleFAUL2 in _itkSamplePython:
_itkSamplePython.itkSampleFAUL2_swigregister(itkSampleFAUL2)
class itkSampleFAUL3(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkSampleFAUL3 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 - class is abstract")
    __repr__ = _swig_repr
    Size = _swig_new_instance_method(_itkSamplePython.itkSampleFAUL3_Size)
    GetMeasurementVector = _swig_new_instance_method(_itkSamplePython.itkSampleFAUL3_GetMeasurementVector)
    GetFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleFAUL3_GetFrequency)
    GetTotalFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleFAUL3_GetTotalFrequency)
    SetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleFAUL3_SetMeasurementVectorSize)
    GetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleFAUL3_GetMeasurementVectorSize)
    __swig_destroy__ = _itkSamplePython.delete_itkSampleFAUL3
    cast = _swig_new_static_method(_itkSamplePython.itkSampleFAUL3_cast)
    GetPointer = _swig_new_instance_method(_itkSamplePython.itkSampleFAUL3_GetPointer)

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

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

          itkSampleFAUL3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkSampleFAUL3.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkSampleFAUL3.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkSampleFAUL3 in _itkSamplePython:
_itkSamplePython.itkSampleFAUL3_swigregister(itkSampleFAUL3)
class itkSampleFAUS1(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkSampleFAUS1 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 - class is abstract")
    __repr__ = _swig_repr
    Size = _swig_new_instance_method(_itkSamplePython.itkSampleFAUS1_Size)
    GetMeasurementVector = _swig_new_instance_method(_itkSamplePython.itkSampleFAUS1_GetMeasurementVector)
    GetFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleFAUS1_GetFrequency)
    GetTotalFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleFAUS1_GetTotalFrequency)
    SetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleFAUS1_SetMeasurementVectorSize)
    GetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleFAUS1_GetMeasurementVectorSize)
    __swig_destroy__ = _itkSamplePython.delete_itkSampleFAUS1
    cast = _swig_new_static_method(_itkSamplePython.itkSampleFAUS1_cast)
    GetPointer = _swig_new_instance_method(_itkSamplePython.itkSampleFAUS1_GetPointer)

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

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

          itkSampleFAUS1.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkSampleFAUS1.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkSampleFAUS1.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkSampleFAUS1 in _itkSamplePython:
_itkSamplePython.itkSampleFAUS1_swigregister(itkSampleFAUS1)
class itkSampleFAUS2(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkSampleFAUS2 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 - class is abstract")
    __repr__ = _swig_repr
    Size = _swig_new_instance_method(_itkSamplePython.itkSampleFAUS2_Size)
    GetMeasurementVector = _swig_new_instance_method(_itkSamplePython.itkSampleFAUS2_GetMeasurementVector)
    GetFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleFAUS2_GetFrequency)
    GetTotalFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleFAUS2_GetTotalFrequency)
    SetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleFAUS2_SetMeasurementVectorSize)
    GetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleFAUS2_GetMeasurementVectorSize)
    __swig_destroy__ = _itkSamplePython.delete_itkSampleFAUS2
    cast = _swig_new_static_method(_itkSamplePython.itkSampleFAUS2_cast)
    GetPointer = _swig_new_instance_method(_itkSamplePython.itkSampleFAUS2_GetPointer)

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

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

          itkSampleFAUS2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkSampleFAUS2.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkSampleFAUS2.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkSampleFAUS2 in _itkSamplePython:
_itkSamplePython.itkSampleFAUS2_swigregister(itkSampleFAUS2)
class itkSampleFAUS3(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkSampleFAUS3 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 - class is abstract")
    __repr__ = _swig_repr
    Size = _swig_new_instance_method(_itkSamplePython.itkSampleFAUS3_Size)
    GetMeasurementVector = _swig_new_instance_method(_itkSamplePython.itkSampleFAUS3_GetMeasurementVector)
    GetFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleFAUS3_GetFrequency)
    GetTotalFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleFAUS3_GetTotalFrequency)
    SetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleFAUS3_SetMeasurementVectorSize)
    GetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleFAUS3_GetMeasurementVectorSize)
    __swig_destroy__ = _itkSamplePython.delete_itkSampleFAUS3
    cast = _swig_new_static_method(_itkSamplePython.itkSampleFAUS3_cast)
    GetPointer = _swig_new_instance_method(_itkSamplePython.itkSampleFAUS3_GetPointer)

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

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

          itkSampleFAUS3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkSampleFAUS3.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkSampleFAUS3.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkSampleFAUS3 in _itkSamplePython:
_itkSamplePython.itkSampleFAUS3_swigregister(itkSampleFAUS3)
class itkSampleVF2(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkSampleVF2 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 - class is abstract")
    __repr__ = _swig_repr
    Size = _swig_new_instance_method(_itkSamplePython.itkSampleVF2_Size)
    GetMeasurementVector = _swig_new_instance_method(_itkSamplePython.itkSampleVF2_GetMeasurementVector)
    GetFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleVF2_GetFrequency)
    GetTotalFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleVF2_GetTotalFrequency)
    SetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleVF2_SetMeasurementVectorSize)
    GetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleVF2_GetMeasurementVectorSize)
    __swig_destroy__ = _itkSamplePython.delete_itkSampleVF2
    cast = _swig_new_static_method(_itkSamplePython.itkSampleVF2_cast)
    GetPointer = _swig_new_instance_method(_itkSamplePython.itkSampleVF2_GetPointer)

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

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

          itkSampleVF2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkSampleVF2.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkSampleVF2.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkSampleVF2 in _itkSamplePython:
_itkSamplePython.itkSampleVF2_swigregister(itkSampleVF2)
class itkSampleVF3(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkSampleVF3 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 - class is abstract")
    __repr__ = _swig_repr
    Size = _swig_new_instance_method(_itkSamplePython.itkSampleVF3_Size)
    GetMeasurementVector = _swig_new_instance_method(_itkSamplePython.itkSampleVF3_GetMeasurementVector)
    GetFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleVF3_GetFrequency)
    GetTotalFrequency = _swig_new_instance_method(_itkSamplePython.itkSampleVF3_GetTotalFrequency)
    SetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleVF3_SetMeasurementVectorSize)
    GetMeasurementVectorSize = _swig_new_instance_method(_itkSamplePython.itkSampleVF3_GetMeasurementVectorSize)
    __swig_destroy__ = _itkSamplePython.delete_itkSampleVF3
    cast = _swig_new_static_method(_itkSamplePython.itkSampleVF3_cast)
    GetPointer = _swig_new_instance_method(_itkSamplePython.itkSampleVF3_GetPointer)

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

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

          itkSampleVF3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkSampleVF3.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkSampleVF3.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkSampleVF3 in _itkSamplePython:
_itkSamplePython.itkSampleVF3_swigregister(itkSampleVF3)

