# This file was automatically generated by SWIG (https://www.swig.org).
# Version 4.4.1
#
# Do not make changes to this file unless you know what you are doing - modify
# the SWIG interface file instead.


import collections

from sys import version_info as _version_info
if _version_info < (3, 7, 0):
    raise RuntimeError("Python 3.7 or later required")

from . import _ITKCommonPython


from . import _ITKFastMarchingPython



from sys import version_info as _swig_python_version_info
# Import the low-level C/C++ module
if getattr(globals().get("__spec__"), "parent", None) or __package__ or "." in __name__:
    from . import _ITKFastMarchingBasePython
else:
    import _ITKFastMarchingBasePython

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.ITKCommonBasePython
import itk.itkMatrixPython
import itk.vnl_matrix_fixedPython
import itk.vnl_matrixPython
import itk.stdcomplexPython
import itk.pyBasePython
import itk.vnl_vectorPython
import itk.itkVectorPython
import itk.itkFixedArrayPython
import itk.vnl_vector_refPython
import itk.itkCovariantVectorPython
import itk.itkPointPython
import itk.itkImagePython
import itk.itkSymmetricSecondRankTensorPython
import itk.itkImageRegionPython
import itk.itkIndexPython
import itk.itkSizePython
import itk.itkOffsetPython
import itk.itkRGBPixelPython
import itk.itkRGBAPixelPython
import itk.itkImageToImageFilterAPython
import itk.itkVectorImagePython
import itk.itkVariableLengthVectorPython
import itk.itkImageToImageFilterCommonPython
import itk.itkImageSourcePython
import itk.itkPhasedArray3DSpecialCoordinatesImagePython
import itk.itkImageSourceCommonPython
import itk.itkNodePairPython
import itk.itkLevelSetNodePython
import itk.itkFastMarchingStoppingCriterionBasePython
class itkFastMarchingBaseID2ID2(itk.itkImageToImageFilterAPython.itkImageToImageFilterID2ID2):
    r"""Proxy of C++ itkFastMarchingBaseID2ID2 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

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

        Parameters
        ----------
        _arg: enum itkFastMarchingTraitsEnums::TopologyCheck const

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID2ID2_SetTopologyCheck(self, _arg)

    def GetTopologyCheck(self):
        r"""GetTopologyCheck(self) -> itkFastMarchingTraitsEnums::TopologyCheck const &"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID2ID2_GetTopologyCheck(self)

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

        Parameters
        ----------
        _arg: itkVectorContainerULNPI2D *

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID2ID2_SetTrialPoints(self, _arg)

    def GetModifiableTrialPoints(self):
        r"""GetModifiableTrialPoints(self) -> itkVectorContainerULNPI2D"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID2ID2_GetModifiableTrialPoints(self)

    def GetTrialPoints(self, *args):
        r"""
        GetTrialPoints(self) -> itkVectorContainerULNPI2D
        GetTrialPoints(self) -> itkVectorContainerULNPI2D
        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID2ID2_GetTrialPoints(self, *args)

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

        Parameters
        ----------
        _arg: itkVectorContainerULNPI2D *

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID2ID2_SetAlivePoints(self, _arg)

    def GetModifiableAlivePoints(self):
        r"""GetModifiableAlivePoints(self) -> itkVectorContainerULNPI2D"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID2ID2_GetModifiableAlivePoints(self)

    def GetAlivePoints(self, *args):
        r"""
        GetAlivePoints(self) -> itkVectorContainerULNPI2D
        GetAlivePoints(self) -> itkVectorContainerULNPI2D
        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID2ID2_GetAlivePoints(self, *args)

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

        Parameters
        ----------
        _arg: itkVectorContainerULNPI2D *

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID2ID2_SetProcessedPoints(self, _arg)

    def GetModifiableProcessedPoints(self):
        r"""GetModifiableProcessedPoints(self) -> itkVectorContainerULNPI2D"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID2ID2_GetModifiableProcessedPoints(self)

    def GetProcessedPoints(self, *args):
        r"""
        GetProcessedPoints(self) -> itkVectorContainerULNPI2D
        GetProcessedPoints(self) -> itkVectorContainerULNPI2D
        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID2ID2_GetProcessedPoints(self, *args)

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

        Parameters
        ----------
        _arg: itkVectorContainerULNPI2D *

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID2ID2_SetForbiddenPoints(self, _arg)

    def GetModifiableForbiddenPoints(self):
        r"""GetModifiableForbiddenPoints(self) -> itkVectorContainerULNPI2D"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID2ID2_GetModifiableForbiddenPoints(self)

    def GetForbiddenPoints(self, *args):
        r"""
        GetForbiddenPoints(self) -> itkVectorContainerULNPI2D
        GetForbiddenPoints(self) -> itkVectorContainerULNPI2D
        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID2ID2_GetForbiddenPoints(self, *args)

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

        Parameters
        ----------
        _arg: itkFastMarchingStoppingCriterionBaseID2ID2 *

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID2ID2_SetStoppingCriterion(self, _arg)

    def GetModifiableStoppingCriterion(self):
        r"""GetModifiableStoppingCriterion(self) -> itkFastMarchingStoppingCriterionBaseID2ID2"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID2ID2_GetModifiableStoppingCriterion(self)

    def GetStoppingCriterion(self, *args):
        r"""
        GetStoppingCriterion(self) -> itkFastMarchingStoppingCriterionBaseID2ID2
        GetStoppingCriterion(self) -> itkFastMarchingStoppingCriterionBaseID2ID2
        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID2ID2_GetStoppingCriterion(self, *args)

    def GetSpeedConstant(self):
        r"""GetSpeedConstant(self) -> double"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID2ID2_GetSpeedConstant(self)

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

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

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID2ID2_SetSpeedConstant(self, _arg)

    def GetNormalizationFactor(self):
        r"""GetNormalizationFactor(self) -> double"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID2ID2_GetNormalizationFactor(self)

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

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

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID2ID2_SetNormalizationFactor(self, _arg)

    def GetTargetReachedValue(self):
        r"""GetTargetReachedValue(self) -> double"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID2ID2_GetTargetReachedValue(self)

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

        Parameters
        ----------
        _arg: bool

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID2ID2_SetCollectPoints(self, _arg)

    def GetCollectPoints(self):
        r"""GetCollectPoints(self) -> bool const &"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID2ID2_GetCollectPoints(self)

    def CollectPointsOn(self):
        r"""CollectPointsOn(self)"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID2ID2_CollectPointsOn(self)

    def CollectPointsOff(self):
        r"""CollectPointsOff(self)"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID2ID2_CollectPointsOff(self)
    __swig_destroy__ = _ITKFastMarchingBasePython.delete_itkFastMarchingBaseID2ID2

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

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

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID2ID2_cast(obj)

# Register itkFastMarchingBaseID2ID2 in _ITKFastMarchingBasePython:
_ITKFastMarchingBasePython.itkFastMarchingBaseID2ID2_swigregister(itkFastMarchingBaseID2ID2)
class itkFastMarchingBaseID3ID3(itk.itkImageToImageFilterAPython.itkImageToImageFilterID3ID3):
    r"""Proxy of C++ itkFastMarchingBaseID3ID3 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

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

        Parameters
        ----------
        _arg: enum itkFastMarchingTraitsEnums::TopologyCheck const

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID3ID3_SetTopologyCheck(self, _arg)

    def GetTopologyCheck(self):
        r"""GetTopologyCheck(self) -> itkFastMarchingTraitsEnums::TopologyCheck const &"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID3ID3_GetTopologyCheck(self)

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

        Parameters
        ----------
        _arg: itkVectorContainerULNPI3D *

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID3ID3_SetTrialPoints(self, _arg)

    def GetModifiableTrialPoints(self):
        r"""GetModifiableTrialPoints(self) -> itkVectorContainerULNPI3D"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID3ID3_GetModifiableTrialPoints(self)

    def GetTrialPoints(self, *args):
        r"""
        GetTrialPoints(self) -> itkVectorContainerULNPI3D
        GetTrialPoints(self) -> itkVectorContainerULNPI3D
        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID3ID3_GetTrialPoints(self, *args)

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

        Parameters
        ----------
        _arg: itkVectorContainerULNPI3D *

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID3ID3_SetAlivePoints(self, _arg)

    def GetModifiableAlivePoints(self):
        r"""GetModifiableAlivePoints(self) -> itkVectorContainerULNPI3D"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID3ID3_GetModifiableAlivePoints(self)

    def GetAlivePoints(self, *args):
        r"""
        GetAlivePoints(self) -> itkVectorContainerULNPI3D
        GetAlivePoints(self) -> itkVectorContainerULNPI3D
        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID3ID3_GetAlivePoints(self, *args)

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

        Parameters
        ----------
        _arg: itkVectorContainerULNPI3D *

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID3ID3_SetProcessedPoints(self, _arg)

    def GetModifiableProcessedPoints(self):
        r"""GetModifiableProcessedPoints(self) -> itkVectorContainerULNPI3D"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID3ID3_GetModifiableProcessedPoints(self)

    def GetProcessedPoints(self, *args):
        r"""
        GetProcessedPoints(self) -> itkVectorContainerULNPI3D
        GetProcessedPoints(self) -> itkVectorContainerULNPI3D
        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID3ID3_GetProcessedPoints(self, *args)

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

        Parameters
        ----------
        _arg: itkVectorContainerULNPI3D *

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID3ID3_SetForbiddenPoints(self, _arg)

    def GetModifiableForbiddenPoints(self):
        r"""GetModifiableForbiddenPoints(self) -> itkVectorContainerULNPI3D"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID3ID3_GetModifiableForbiddenPoints(self)

    def GetForbiddenPoints(self, *args):
        r"""
        GetForbiddenPoints(self) -> itkVectorContainerULNPI3D
        GetForbiddenPoints(self) -> itkVectorContainerULNPI3D
        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID3ID3_GetForbiddenPoints(self, *args)

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

        Parameters
        ----------
        _arg: itkFastMarchingStoppingCriterionBaseID3ID3 *

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID3ID3_SetStoppingCriterion(self, _arg)

    def GetModifiableStoppingCriterion(self):
        r"""GetModifiableStoppingCriterion(self) -> itkFastMarchingStoppingCriterionBaseID3ID3"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID3ID3_GetModifiableStoppingCriterion(self)

    def GetStoppingCriterion(self, *args):
        r"""
        GetStoppingCriterion(self) -> itkFastMarchingStoppingCriterionBaseID3ID3
        GetStoppingCriterion(self) -> itkFastMarchingStoppingCriterionBaseID3ID3
        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID3ID3_GetStoppingCriterion(self, *args)

    def GetSpeedConstant(self):
        r"""GetSpeedConstant(self) -> double"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID3ID3_GetSpeedConstant(self)

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

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

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID3ID3_SetSpeedConstant(self, _arg)

    def GetNormalizationFactor(self):
        r"""GetNormalizationFactor(self) -> double"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID3ID3_GetNormalizationFactor(self)

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

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

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID3ID3_SetNormalizationFactor(self, _arg)

    def GetTargetReachedValue(self):
        r"""GetTargetReachedValue(self) -> double"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID3ID3_GetTargetReachedValue(self)

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

        Parameters
        ----------
        _arg: bool

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID3ID3_SetCollectPoints(self, _arg)

    def GetCollectPoints(self):
        r"""GetCollectPoints(self) -> bool const &"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID3ID3_GetCollectPoints(self)

    def CollectPointsOn(self):
        r"""CollectPointsOn(self)"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID3ID3_CollectPointsOn(self)

    def CollectPointsOff(self):
        r"""CollectPointsOff(self)"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID3ID3_CollectPointsOff(self)
    __swig_destroy__ = _ITKFastMarchingBasePython.delete_itkFastMarchingBaseID3ID3

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

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

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID3ID3_cast(obj)

# Register itkFastMarchingBaseID3ID3 in _ITKFastMarchingBasePython:
_ITKFastMarchingBasePython.itkFastMarchingBaseID3ID3_swigregister(itkFastMarchingBaseID3ID3)
class itkFastMarchingBaseID4ID4(itk.itkImageToImageFilterAPython.itkImageToImageFilterID4ID4):
    r"""Proxy of C++ itkFastMarchingBaseID4ID4 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

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

        Parameters
        ----------
        _arg: enum itkFastMarchingTraitsEnums::TopologyCheck const

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID4ID4_SetTopologyCheck(self, _arg)

    def GetTopologyCheck(self):
        r"""GetTopologyCheck(self) -> itkFastMarchingTraitsEnums::TopologyCheck const &"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID4ID4_GetTopologyCheck(self)

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

        Parameters
        ----------
        _arg: itkVectorContainerULNPI4D *

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID4ID4_SetTrialPoints(self, _arg)

    def GetModifiableTrialPoints(self):
        r"""GetModifiableTrialPoints(self) -> itkVectorContainerULNPI4D"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID4ID4_GetModifiableTrialPoints(self)

    def GetTrialPoints(self, *args):
        r"""
        GetTrialPoints(self) -> itkVectorContainerULNPI4D
        GetTrialPoints(self) -> itkVectorContainerULNPI4D
        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID4ID4_GetTrialPoints(self, *args)

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

        Parameters
        ----------
        _arg: itkVectorContainerULNPI4D *

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID4ID4_SetAlivePoints(self, _arg)

    def GetModifiableAlivePoints(self):
        r"""GetModifiableAlivePoints(self) -> itkVectorContainerULNPI4D"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID4ID4_GetModifiableAlivePoints(self)

    def GetAlivePoints(self, *args):
        r"""
        GetAlivePoints(self) -> itkVectorContainerULNPI4D
        GetAlivePoints(self) -> itkVectorContainerULNPI4D
        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID4ID4_GetAlivePoints(self, *args)

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

        Parameters
        ----------
        _arg: itkVectorContainerULNPI4D *

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID4ID4_SetProcessedPoints(self, _arg)

    def GetModifiableProcessedPoints(self):
        r"""GetModifiableProcessedPoints(self) -> itkVectorContainerULNPI4D"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID4ID4_GetModifiableProcessedPoints(self)

    def GetProcessedPoints(self, *args):
        r"""
        GetProcessedPoints(self) -> itkVectorContainerULNPI4D
        GetProcessedPoints(self) -> itkVectorContainerULNPI4D
        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID4ID4_GetProcessedPoints(self, *args)

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

        Parameters
        ----------
        _arg: itkVectorContainerULNPI4D *

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID4ID4_SetForbiddenPoints(self, _arg)

    def GetModifiableForbiddenPoints(self):
        r"""GetModifiableForbiddenPoints(self) -> itkVectorContainerULNPI4D"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID4ID4_GetModifiableForbiddenPoints(self)

    def GetForbiddenPoints(self, *args):
        r"""
        GetForbiddenPoints(self) -> itkVectorContainerULNPI4D
        GetForbiddenPoints(self) -> itkVectorContainerULNPI4D
        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID4ID4_GetForbiddenPoints(self, *args)

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

        Parameters
        ----------
        _arg: itkFastMarchingStoppingCriterionBaseID4ID4 *

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID4ID4_SetStoppingCriterion(self, _arg)

    def GetModifiableStoppingCriterion(self):
        r"""GetModifiableStoppingCriterion(self) -> itkFastMarchingStoppingCriterionBaseID4ID4"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID4ID4_GetModifiableStoppingCriterion(self)

    def GetStoppingCriterion(self, *args):
        r"""
        GetStoppingCriterion(self) -> itkFastMarchingStoppingCriterionBaseID4ID4
        GetStoppingCriterion(self) -> itkFastMarchingStoppingCriterionBaseID4ID4
        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID4ID4_GetStoppingCriterion(self, *args)

    def GetSpeedConstant(self):
        r"""GetSpeedConstant(self) -> double"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID4ID4_GetSpeedConstant(self)

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

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

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID4ID4_SetSpeedConstant(self, _arg)

    def GetNormalizationFactor(self):
        r"""GetNormalizationFactor(self) -> double"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID4ID4_GetNormalizationFactor(self)

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

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

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID4ID4_SetNormalizationFactor(self, _arg)

    def GetTargetReachedValue(self):
        r"""GetTargetReachedValue(self) -> double"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID4ID4_GetTargetReachedValue(self)

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

        Parameters
        ----------
        _arg: bool

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID4ID4_SetCollectPoints(self, _arg)

    def GetCollectPoints(self):
        r"""GetCollectPoints(self) -> bool const &"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID4ID4_GetCollectPoints(self)

    def CollectPointsOn(self):
        r"""CollectPointsOn(self)"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID4ID4_CollectPointsOn(self)

    def CollectPointsOff(self):
        r"""CollectPointsOff(self)"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID4ID4_CollectPointsOff(self)
    __swig_destroy__ = _ITKFastMarchingBasePython.delete_itkFastMarchingBaseID4ID4

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

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

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseID4ID4_cast(obj)

# Register itkFastMarchingBaseID4ID4 in _ITKFastMarchingBasePython:
_ITKFastMarchingBasePython.itkFastMarchingBaseID4ID4_swigregister(itkFastMarchingBaseID4ID4)
class itkFastMarchingBaseIF2IF2(itk.itkImageToImageFilterAPython.itkImageToImageFilterIF2IF2):
    r"""Proxy of C++ itkFastMarchingBaseIF2IF2 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

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

        Parameters
        ----------
        _arg: enum itkFastMarchingTraitsEnums::TopologyCheck const

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF2IF2_SetTopologyCheck(self, _arg)

    def GetTopologyCheck(self):
        r"""GetTopologyCheck(self) -> itkFastMarchingTraitsEnums::TopologyCheck const &"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF2IF2_GetTopologyCheck(self)

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

        Parameters
        ----------
        _arg: itkVectorContainerULNPI2F *

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF2IF2_SetTrialPoints(self, _arg)

    def GetModifiableTrialPoints(self):
        r"""GetModifiableTrialPoints(self) -> itkVectorContainerULNPI2F"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF2IF2_GetModifiableTrialPoints(self)

    def GetTrialPoints(self, *args):
        r"""
        GetTrialPoints(self) -> itkVectorContainerULNPI2F
        GetTrialPoints(self) -> itkVectorContainerULNPI2F
        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF2IF2_GetTrialPoints(self, *args)

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

        Parameters
        ----------
        _arg: itkVectorContainerULNPI2F *

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF2IF2_SetAlivePoints(self, _arg)

    def GetModifiableAlivePoints(self):
        r"""GetModifiableAlivePoints(self) -> itkVectorContainerULNPI2F"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF2IF2_GetModifiableAlivePoints(self)

    def GetAlivePoints(self, *args):
        r"""
        GetAlivePoints(self) -> itkVectorContainerULNPI2F
        GetAlivePoints(self) -> itkVectorContainerULNPI2F
        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF2IF2_GetAlivePoints(self, *args)

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

        Parameters
        ----------
        _arg: itkVectorContainerULNPI2F *

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF2IF2_SetProcessedPoints(self, _arg)

    def GetModifiableProcessedPoints(self):
        r"""GetModifiableProcessedPoints(self) -> itkVectorContainerULNPI2F"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF2IF2_GetModifiableProcessedPoints(self)

    def GetProcessedPoints(self, *args):
        r"""
        GetProcessedPoints(self) -> itkVectorContainerULNPI2F
        GetProcessedPoints(self) -> itkVectorContainerULNPI2F
        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF2IF2_GetProcessedPoints(self, *args)

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

        Parameters
        ----------
        _arg: itkVectorContainerULNPI2F *

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF2IF2_SetForbiddenPoints(self, _arg)

    def GetModifiableForbiddenPoints(self):
        r"""GetModifiableForbiddenPoints(self) -> itkVectorContainerULNPI2F"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF2IF2_GetModifiableForbiddenPoints(self)

    def GetForbiddenPoints(self, *args):
        r"""
        GetForbiddenPoints(self) -> itkVectorContainerULNPI2F
        GetForbiddenPoints(self) -> itkVectorContainerULNPI2F
        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF2IF2_GetForbiddenPoints(self, *args)

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

        Parameters
        ----------
        _arg: itkFastMarchingStoppingCriterionBaseIF2IF2 *

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF2IF2_SetStoppingCriterion(self, _arg)

    def GetModifiableStoppingCriterion(self):
        r"""GetModifiableStoppingCriterion(self) -> itkFastMarchingStoppingCriterionBaseIF2IF2"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF2IF2_GetModifiableStoppingCriterion(self)

    def GetStoppingCriterion(self, *args):
        r"""
        GetStoppingCriterion(self) -> itkFastMarchingStoppingCriterionBaseIF2IF2
        GetStoppingCriterion(self) -> itkFastMarchingStoppingCriterionBaseIF2IF2
        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF2IF2_GetStoppingCriterion(self, *args)

    def GetSpeedConstant(self):
        r"""GetSpeedConstant(self) -> double"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF2IF2_GetSpeedConstant(self)

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

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

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF2IF2_SetSpeedConstant(self, _arg)

    def GetNormalizationFactor(self):
        r"""GetNormalizationFactor(self) -> double"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF2IF2_GetNormalizationFactor(self)

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

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

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF2IF2_SetNormalizationFactor(self, _arg)

    def GetTargetReachedValue(self):
        r"""GetTargetReachedValue(self) -> float"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF2IF2_GetTargetReachedValue(self)

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

        Parameters
        ----------
        _arg: bool

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF2IF2_SetCollectPoints(self, _arg)

    def GetCollectPoints(self):
        r"""GetCollectPoints(self) -> bool const &"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF2IF2_GetCollectPoints(self)

    def CollectPointsOn(self):
        r"""CollectPointsOn(self)"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF2IF2_CollectPointsOn(self)

    def CollectPointsOff(self):
        r"""CollectPointsOff(self)"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF2IF2_CollectPointsOff(self)
    __swig_destroy__ = _ITKFastMarchingBasePython.delete_itkFastMarchingBaseIF2IF2

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

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

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF2IF2_cast(obj)

# Register itkFastMarchingBaseIF2IF2 in _ITKFastMarchingBasePython:
_ITKFastMarchingBasePython.itkFastMarchingBaseIF2IF2_swigregister(itkFastMarchingBaseIF2IF2)
class itkFastMarchingBaseIF3IF3(itk.itkImageToImageFilterAPython.itkImageToImageFilterIF3IF3):
    r"""Proxy of C++ itkFastMarchingBaseIF3IF3 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

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

        Parameters
        ----------
        _arg: enum itkFastMarchingTraitsEnums::TopologyCheck const

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF3IF3_SetTopologyCheck(self, _arg)

    def GetTopologyCheck(self):
        r"""GetTopologyCheck(self) -> itkFastMarchingTraitsEnums::TopologyCheck const &"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF3IF3_GetTopologyCheck(self)

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

        Parameters
        ----------
        _arg: itkVectorContainerULNPI3F *

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF3IF3_SetTrialPoints(self, _arg)

    def GetModifiableTrialPoints(self):
        r"""GetModifiableTrialPoints(self) -> itkVectorContainerULNPI3F"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF3IF3_GetModifiableTrialPoints(self)

    def GetTrialPoints(self, *args):
        r"""
        GetTrialPoints(self) -> itkVectorContainerULNPI3F
        GetTrialPoints(self) -> itkVectorContainerULNPI3F
        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF3IF3_GetTrialPoints(self, *args)

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

        Parameters
        ----------
        _arg: itkVectorContainerULNPI3F *

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF3IF3_SetAlivePoints(self, _arg)

    def GetModifiableAlivePoints(self):
        r"""GetModifiableAlivePoints(self) -> itkVectorContainerULNPI3F"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF3IF3_GetModifiableAlivePoints(self)

    def GetAlivePoints(self, *args):
        r"""
        GetAlivePoints(self) -> itkVectorContainerULNPI3F
        GetAlivePoints(self) -> itkVectorContainerULNPI3F
        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF3IF3_GetAlivePoints(self, *args)

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

        Parameters
        ----------
        _arg: itkVectorContainerULNPI3F *

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF3IF3_SetProcessedPoints(self, _arg)

    def GetModifiableProcessedPoints(self):
        r"""GetModifiableProcessedPoints(self) -> itkVectorContainerULNPI3F"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF3IF3_GetModifiableProcessedPoints(self)

    def GetProcessedPoints(self, *args):
        r"""
        GetProcessedPoints(self) -> itkVectorContainerULNPI3F
        GetProcessedPoints(self) -> itkVectorContainerULNPI3F
        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF3IF3_GetProcessedPoints(self, *args)

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

        Parameters
        ----------
        _arg: itkVectorContainerULNPI3F *

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF3IF3_SetForbiddenPoints(self, _arg)

    def GetModifiableForbiddenPoints(self):
        r"""GetModifiableForbiddenPoints(self) -> itkVectorContainerULNPI3F"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF3IF3_GetModifiableForbiddenPoints(self)

    def GetForbiddenPoints(self, *args):
        r"""
        GetForbiddenPoints(self) -> itkVectorContainerULNPI3F
        GetForbiddenPoints(self) -> itkVectorContainerULNPI3F
        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF3IF3_GetForbiddenPoints(self, *args)

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

        Parameters
        ----------
        _arg: itkFastMarchingStoppingCriterionBaseIF3IF3 *

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF3IF3_SetStoppingCriterion(self, _arg)

    def GetModifiableStoppingCriterion(self):
        r"""GetModifiableStoppingCriterion(self) -> itkFastMarchingStoppingCriterionBaseIF3IF3"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF3IF3_GetModifiableStoppingCriterion(self)

    def GetStoppingCriterion(self, *args):
        r"""
        GetStoppingCriterion(self) -> itkFastMarchingStoppingCriterionBaseIF3IF3
        GetStoppingCriterion(self) -> itkFastMarchingStoppingCriterionBaseIF3IF3
        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF3IF3_GetStoppingCriterion(self, *args)

    def GetSpeedConstant(self):
        r"""GetSpeedConstant(self) -> double"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF3IF3_GetSpeedConstant(self)

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

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

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF3IF3_SetSpeedConstant(self, _arg)

    def GetNormalizationFactor(self):
        r"""GetNormalizationFactor(self) -> double"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF3IF3_GetNormalizationFactor(self)

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

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

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF3IF3_SetNormalizationFactor(self, _arg)

    def GetTargetReachedValue(self):
        r"""GetTargetReachedValue(self) -> float"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF3IF3_GetTargetReachedValue(self)

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

        Parameters
        ----------
        _arg: bool

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF3IF3_SetCollectPoints(self, _arg)

    def GetCollectPoints(self):
        r"""GetCollectPoints(self) -> bool const &"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF3IF3_GetCollectPoints(self)

    def CollectPointsOn(self):
        r"""CollectPointsOn(self)"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF3IF3_CollectPointsOn(self)

    def CollectPointsOff(self):
        r"""CollectPointsOff(self)"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF3IF3_CollectPointsOff(self)
    __swig_destroy__ = _ITKFastMarchingBasePython.delete_itkFastMarchingBaseIF3IF3

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

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

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF3IF3_cast(obj)

# Register itkFastMarchingBaseIF3IF3 in _ITKFastMarchingBasePython:
_ITKFastMarchingBasePython.itkFastMarchingBaseIF3IF3_swigregister(itkFastMarchingBaseIF3IF3)
class itkFastMarchingBaseIF4IF4(itk.itkImageToImageFilterAPython.itkImageToImageFilterIF4IF4):
    r"""Proxy of C++ itkFastMarchingBaseIF4IF4 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

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

        Parameters
        ----------
        _arg: enum itkFastMarchingTraitsEnums::TopologyCheck const

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF4IF4_SetTopologyCheck(self, _arg)

    def GetTopologyCheck(self):
        r"""GetTopologyCheck(self) -> itkFastMarchingTraitsEnums::TopologyCheck const &"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF4IF4_GetTopologyCheck(self)

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

        Parameters
        ----------
        _arg: itkVectorContainerULNPI4F *

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF4IF4_SetTrialPoints(self, _arg)

    def GetModifiableTrialPoints(self):
        r"""GetModifiableTrialPoints(self) -> itkVectorContainerULNPI4F"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF4IF4_GetModifiableTrialPoints(self)

    def GetTrialPoints(self, *args):
        r"""
        GetTrialPoints(self) -> itkVectorContainerULNPI4F
        GetTrialPoints(self) -> itkVectorContainerULNPI4F
        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF4IF4_GetTrialPoints(self, *args)

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

        Parameters
        ----------
        _arg: itkVectorContainerULNPI4F *

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF4IF4_SetAlivePoints(self, _arg)

    def GetModifiableAlivePoints(self):
        r"""GetModifiableAlivePoints(self) -> itkVectorContainerULNPI4F"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF4IF4_GetModifiableAlivePoints(self)

    def GetAlivePoints(self, *args):
        r"""
        GetAlivePoints(self) -> itkVectorContainerULNPI4F
        GetAlivePoints(self) -> itkVectorContainerULNPI4F
        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF4IF4_GetAlivePoints(self, *args)

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

        Parameters
        ----------
        _arg: itkVectorContainerULNPI4F *

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF4IF4_SetProcessedPoints(self, _arg)

    def GetModifiableProcessedPoints(self):
        r"""GetModifiableProcessedPoints(self) -> itkVectorContainerULNPI4F"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF4IF4_GetModifiableProcessedPoints(self)

    def GetProcessedPoints(self, *args):
        r"""
        GetProcessedPoints(self) -> itkVectorContainerULNPI4F
        GetProcessedPoints(self) -> itkVectorContainerULNPI4F
        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF4IF4_GetProcessedPoints(self, *args)

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

        Parameters
        ----------
        _arg: itkVectorContainerULNPI4F *

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF4IF4_SetForbiddenPoints(self, _arg)

    def GetModifiableForbiddenPoints(self):
        r"""GetModifiableForbiddenPoints(self) -> itkVectorContainerULNPI4F"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF4IF4_GetModifiableForbiddenPoints(self)

    def GetForbiddenPoints(self, *args):
        r"""
        GetForbiddenPoints(self) -> itkVectorContainerULNPI4F
        GetForbiddenPoints(self) -> itkVectorContainerULNPI4F
        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF4IF4_GetForbiddenPoints(self, *args)

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

        Parameters
        ----------
        _arg: itkFastMarchingStoppingCriterionBaseIF4IF4 *

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF4IF4_SetStoppingCriterion(self, _arg)

    def GetModifiableStoppingCriterion(self):
        r"""GetModifiableStoppingCriterion(self) -> itkFastMarchingStoppingCriterionBaseIF4IF4"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF4IF4_GetModifiableStoppingCriterion(self)

    def GetStoppingCriterion(self, *args):
        r"""
        GetStoppingCriterion(self) -> itkFastMarchingStoppingCriterionBaseIF4IF4
        GetStoppingCriterion(self) -> itkFastMarchingStoppingCriterionBaseIF4IF4
        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF4IF4_GetStoppingCriterion(self, *args)

    def GetSpeedConstant(self):
        r"""GetSpeedConstant(self) -> double"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF4IF4_GetSpeedConstant(self)

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

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

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF4IF4_SetSpeedConstant(self, _arg)

    def GetNormalizationFactor(self):
        r"""GetNormalizationFactor(self) -> double"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF4IF4_GetNormalizationFactor(self)

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

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

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF4IF4_SetNormalizationFactor(self, _arg)

    def GetTargetReachedValue(self):
        r"""GetTargetReachedValue(self) -> float"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF4IF4_GetTargetReachedValue(self)

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

        Parameters
        ----------
        _arg: bool

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF4IF4_SetCollectPoints(self, _arg)

    def GetCollectPoints(self):
        r"""GetCollectPoints(self) -> bool const &"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF4IF4_GetCollectPoints(self)

    def CollectPointsOn(self):
        r"""CollectPointsOn(self)"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF4IF4_CollectPointsOn(self)

    def CollectPointsOff(self):
        r"""CollectPointsOff(self)"""
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF4IF4_CollectPointsOff(self)
    __swig_destroy__ = _ITKFastMarchingBasePython.delete_itkFastMarchingBaseIF4IF4

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

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

        """
        return _ITKFastMarchingBasePython.itkFastMarchingBaseIF4IF4_cast(obj)

# Register itkFastMarchingBaseIF4IF4 in _ITKFastMarchingBasePython:
_ITKFastMarchingBasePython.itkFastMarchingBaseIF4IF4_swigregister(itkFastMarchingBaseIF4IF4)
class itkFastMarchingTraitsEnums(object):
    r"""Proxy of C++ itkFastMarchingTraitsEnums class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    TopologyCheck_Nothing = _ITKFastMarchingBasePython.itkFastMarchingTraitsEnums_TopologyCheck_Nothing
    
    TopologyCheck_NoHandles = _ITKFastMarchingBasePython.itkFastMarchingTraitsEnums_TopologyCheck_NoHandles
    
    TopologyCheck_Strict = _ITKFastMarchingBasePython.itkFastMarchingTraitsEnums_TopologyCheck_Strict
    

    def __init__(self, *args):
        r"""
        __init__(self) -> itkFastMarchingTraitsEnums
        __init__(self, arg0) -> itkFastMarchingTraitsEnums

        Parameters
        ----------
        arg0: itkFastMarchingTraitsEnums const &

        """
        _ITKFastMarchingBasePython.itkFastMarchingTraitsEnums_swiginit(self, _ITKFastMarchingBasePython.new_itkFastMarchingTraitsEnums(*args))
    __swig_destroy__ = _ITKFastMarchingBasePython.delete_itkFastMarchingTraitsEnums

# Register itkFastMarchingTraitsEnums in _ITKFastMarchingBasePython:
_ITKFastMarchingBasePython.itkFastMarchingTraitsEnums_swigregister(itkFastMarchingTraitsEnums)

def itkVectorContainerUILSND2_New():
    return itkVectorContainerUILSND2.New()

class itkVectorContainerUILSND2(itk.ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkVectorContainerUILSND2 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__() -> itkVectorContainerUILSND2_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSND2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerUILSND2_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSND2_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkLevelSetNodeD2,std::allocator< itkLevelSetNodeD2 > > &"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSND2_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkLevelSetNodeD2,std::allocator< itkLevelSetNodeD2 > > const &"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSND2_CastToSTLConstContainer(self)

    def ElementAt(self, *args):
        r"""
        ElementAt(self, arg0) -> itkLevelSetNodeD2

        Parameters
        ----------
        arg0: unsigned int

        ElementAt(self, arg0) -> itkLevelSetNodeD2

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSND2_ElementAt(self, *args)

    def CreateElementAt(self, arg0):
        r"""
        CreateElementAt(self, arg0) -> itkLevelSetNodeD2

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSND2_CreateElementAt(self, arg0)

    def GetElement(self, arg0):
        r"""
        GetElement(self, arg0) -> itkLevelSetNodeD2

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSND2_GetElement(self, arg0)

    def SetElement(self, arg0, arg1):
        r"""
        SetElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeD2

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSND2_SetElement(self, arg0, arg1)

    def InsertElement(self, arg0, arg1):
        r"""
        InsertElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeD2

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSND2_InsertElement(self, arg0, arg1)

    def IndexExists(self, arg0):
        r"""
        IndexExists(self, arg0) -> bool

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSND2_IndexExists(self, arg0)

    def GetElementIfIndexExists(self, arg0, arg1):
        r"""
        GetElementIfIndexExists(self, arg0, arg1) -> bool

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeD2 *

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSND2_GetElementIfIndexExists(self, arg0, arg1)

    def CreateIndex(self, arg0):
        r"""
        CreateIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSND2_CreateIndex(self, arg0)

    def DeleteIndex(self, arg0):
        r"""
        DeleteIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSND2_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned int"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSND2_Size(self)

    def Reserve(self, arg0):
        r"""
        Reserve(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSND2_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSND2_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSND2_Initialize(self)
    __swig_destroy__ = _ITKFastMarchingBasePython.delete_itkVectorContainerUILSND2

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

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

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSND2_cast(obj)

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

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

          itkVectorContainerUILSND2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerUILSND2 in _ITKFastMarchingBasePython:
_ITKFastMarchingBasePython.itkVectorContainerUILSND2_swigregister(itkVectorContainerUILSND2)

def itkVectorContainerUILSND3_New():
    return itkVectorContainerUILSND3.New()

class itkVectorContainerUILSND3(itk.ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkVectorContainerUILSND3 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__() -> itkVectorContainerUILSND3_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSND3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerUILSND3_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSND3_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkLevelSetNodeD3,std::allocator< itkLevelSetNodeD3 > > &"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSND3_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkLevelSetNodeD3,std::allocator< itkLevelSetNodeD3 > > const &"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSND3_CastToSTLConstContainer(self)

    def ElementAt(self, *args):
        r"""
        ElementAt(self, arg0) -> itkLevelSetNodeD3

        Parameters
        ----------
        arg0: unsigned int

        ElementAt(self, arg0) -> itkLevelSetNodeD3

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSND3_ElementAt(self, *args)

    def CreateElementAt(self, arg0):
        r"""
        CreateElementAt(self, arg0) -> itkLevelSetNodeD3

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSND3_CreateElementAt(self, arg0)

    def GetElement(self, arg0):
        r"""
        GetElement(self, arg0) -> itkLevelSetNodeD3

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSND3_GetElement(self, arg0)

    def SetElement(self, arg0, arg1):
        r"""
        SetElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeD3

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSND3_SetElement(self, arg0, arg1)

    def InsertElement(self, arg0, arg1):
        r"""
        InsertElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeD3

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSND3_InsertElement(self, arg0, arg1)

    def IndexExists(self, arg0):
        r"""
        IndexExists(self, arg0) -> bool

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSND3_IndexExists(self, arg0)

    def GetElementIfIndexExists(self, arg0, arg1):
        r"""
        GetElementIfIndexExists(self, arg0, arg1) -> bool

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeD3 *

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSND3_GetElementIfIndexExists(self, arg0, arg1)

    def CreateIndex(self, arg0):
        r"""
        CreateIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSND3_CreateIndex(self, arg0)

    def DeleteIndex(self, arg0):
        r"""
        DeleteIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSND3_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned int"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSND3_Size(self)

    def Reserve(self, arg0):
        r"""
        Reserve(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSND3_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSND3_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSND3_Initialize(self)
    __swig_destroy__ = _ITKFastMarchingBasePython.delete_itkVectorContainerUILSND3

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

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

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSND3_cast(obj)

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

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

          itkVectorContainerUILSND3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerUILSND3 in _ITKFastMarchingBasePython:
_ITKFastMarchingBasePython.itkVectorContainerUILSND3_swigregister(itkVectorContainerUILSND3)

def itkVectorContainerUILSND4_New():
    return itkVectorContainerUILSND4.New()

class itkVectorContainerUILSND4(itk.ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkVectorContainerUILSND4 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__() -> itkVectorContainerUILSND4_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSND4___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerUILSND4_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSND4_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkLevelSetNodeD4,std::allocator< itkLevelSetNodeD4 > > &"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSND4_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkLevelSetNodeD4,std::allocator< itkLevelSetNodeD4 > > const &"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSND4_CastToSTLConstContainer(self)

    def ElementAt(self, *args):
        r"""
        ElementAt(self, arg0) -> itkLevelSetNodeD4

        Parameters
        ----------
        arg0: unsigned int

        ElementAt(self, arg0) -> itkLevelSetNodeD4

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSND4_ElementAt(self, *args)

    def CreateElementAt(self, arg0):
        r"""
        CreateElementAt(self, arg0) -> itkLevelSetNodeD4

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSND4_CreateElementAt(self, arg0)

    def GetElement(self, arg0):
        r"""
        GetElement(self, arg0) -> itkLevelSetNodeD4

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSND4_GetElement(self, arg0)

    def SetElement(self, arg0, arg1):
        r"""
        SetElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeD4

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSND4_SetElement(self, arg0, arg1)

    def InsertElement(self, arg0, arg1):
        r"""
        InsertElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeD4

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSND4_InsertElement(self, arg0, arg1)

    def IndexExists(self, arg0):
        r"""
        IndexExists(self, arg0) -> bool

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSND4_IndexExists(self, arg0)

    def GetElementIfIndexExists(self, arg0, arg1):
        r"""
        GetElementIfIndexExists(self, arg0, arg1) -> bool

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeD4 *

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSND4_GetElementIfIndexExists(self, arg0, arg1)

    def CreateIndex(self, arg0):
        r"""
        CreateIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSND4_CreateIndex(self, arg0)

    def DeleteIndex(self, arg0):
        r"""
        DeleteIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSND4_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned int"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSND4_Size(self)

    def Reserve(self, arg0):
        r"""
        Reserve(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSND4_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSND4_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSND4_Initialize(self)
    __swig_destroy__ = _ITKFastMarchingBasePython.delete_itkVectorContainerUILSND4

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

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

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSND4_cast(obj)

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

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

          itkVectorContainerUILSND4.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerUILSND4 in _ITKFastMarchingBasePython:
_ITKFastMarchingBasePython.itkVectorContainerUILSND4_swigregister(itkVectorContainerUILSND4)

def itkVectorContainerUILSNF2_New():
    return itkVectorContainerUILSNF2.New()

class itkVectorContainerUILSNF2(itk.ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkVectorContainerUILSNF2 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__() -> itkVectorContainerUILSNF2_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNF2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerUILSNF2_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNF2_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkLevelSetNodeF2,std::allocator< itkLevelSetNodeF2 > > &"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNF2_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkLevelSetNodeF2,std::allocator< itkLevelSetNodeF2 > > const &"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNF2_CastToSTLConstContainer(self)

    def ElementAt(self, *args):
        r"""
        ElementAt(self, arg0) -> itkLevelSetNodeF2

        Parameters
        ----------
        arg0: unsigned int

        ElementAt(self, arg0) -> itkLevelSetNodeF2

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNF2_ElementAt(self, *args)

    def CreateElementAt(self, arg0):
        r"""
        CreateElementAt(self, arg0) -> itkLevelSetNodeF2

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNF2_CreateElementAt(self, arg0)

    def GetElement(self, arg0):
        r"""
        GetElement(self, arg0) -> itkLevelSetNodeF2

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNF2_GetElement(self, arg0)

    def SetElement(self, arg0, arg1):
        r"""
        SetElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeF2

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNF2_SetElement(self, arg0, arg1)

    def InsertElement(self, arg0, arg1):
        r"""
        InsertElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeF2

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNF2_InsertElement(self, arg0, arg1)

    def IndexExists(self, arg0):
        r"""
        IndexExists(self, arg0) -> bool

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNF2_IndexExists(self, arg0)

    def GetElementIfIndexExists(self, arg0, arg1):
        r"""
        GetElementIfIndexExists(self, arg0, arg1) -> bool

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeF2 *

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNF2_GetElementIfIndexExists(self, arg0, arg1)

    def CreateIndex(self, arg0):
        r"""
        CreateIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNF2_CreateIndex(self, arg0)

    def DeleteIndex(self, arg0):
        r"""
        DeleteIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNF2_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned int"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNF2_Size(self)

    def Reserve(self, arg0):
        r"""
        Reserve(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNF2_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNF2_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNF2_Initialize(self)
    __swig_destroy__ = _ITKFastMarchingBasePython.delete_itkVectorContainerUILSNF2

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

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

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNF2_cast(obj)

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

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

          itkVectorContainerUILSNF2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerUILSNF2 in _ITKFastMarchingBasePython:
_ITKFastMarchingBasePython.itkVectorContainerUILSNF2_swigregister(itkVectorContainerUILSNF2)

def itkVectorContainerUILSNF3_New():
    return itkVectorContainerUILSNF3.New()

class itkVectorContainerUILSNF3(itk.ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkVectorContainerUILSNF3 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__() -> itkVectorContainerUILSNF3_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNF3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerUILSNF3_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNF3_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkLevelSetNodeF3,std::allocator< itkLevelSetNodeF3 > > &"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNF3_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkLevelSetNodeF3,std::allocator< itkLevelSetNodeF3 > > const &"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNF3_CastToSTLConstContainer(self)

    def ElementAt(self, *args):
        r"""
        ElementAt(self, arg0) -> itkLevelSetNodeF3

        Parameters
        ----------
        arg0: unsigned int

        ElementAt(self, arg0) -> itkLevelSetNodeF3

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNF3_ElementAt(self, *args)

    def CreateElementAt(self, arg0):
        r"""
        CreateElementAt(self, arg0) -> itkLevelSetNodeF3

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNF3_CreateElementAt(self, arg0)

    def GetElement(self, arg0):
        r"""
        GetElement(self, arg0) -> itkLevelSetNodeF3

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNF3_GetElement(self, arg0)

    def SetElement(self, arg0, arg1):
        r"""
        SetElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeF3

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNF3_SetElement(self, arg0, arg1)

    def InsertElement(self, arg0, arg1):
        r"""
        InsertElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeF3

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNF3_InsertElement(self, arg0, arg1)

    def IndexExists(self, arg0):
        r"""
        IndexExists(self, arg0) -> bool

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNF3_IndexExists(self, arg0)

    def GetElementIfIndexExists(self, arg0, arg1):
        r"""
        GetElementIfIndexExists(self, arg0, arg1) -> bool

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeF3 *

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNF3_GetElementIfIndexExists(self, arg0, arg1)

    def CreateIndex(self, arg0):
        r"""
        CreateIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNF3_CreateIndex(self, arg0)

    def DeleteIndex(self, arg0):
        r"""
        DeleteIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNF3_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned int"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNF3_Size(self)

    def Reserve(self, arg0):
        r"""
        Reserve(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNF3_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNF3_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNF3_Initialize(self)
    __swig_destroy__ = _ITKFastMarchingBasePython.delete_itkVectorContainerUILSNF3

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

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

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNF3_cast(obj)

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

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

          itkVectorContainerUILSNF3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerUILSNF3 in _ITKFastMarchingBasePython:
_ITKFastMarchingBasePython.itkVectorContainerUILSNF3_swigregister(itkVectorContainerUILSNF3)

def itkVectorContainerUILSNF4_New():
    return itkVectorContainerUILSNF4.New()

class itkVectorContainerUILSNF4(itk.ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkVectorContainerUILSNF4 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__() -> itkVectorContainerUILSNF4_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNF4___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerUILSNF4_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNF4_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkLevelSetNodeF4,std::allocator< itkLevelSetNodeF4 > > &"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNF4_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkLevelSetNodeF4,std::allocator< itkLevelSetNodeF4 > > const &"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNF4_CastToSTLConstContainer(self)

    def ElementAt(self, *args):
        r"""
        ElementAt(self, arg0) -> itkLevelSetNodeF4

        Parameters
        ----------
        arg0: unsigned int

        ElementAt(self, arg0) -> itkLevelSetNodeF4

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNF4_ElementAt(self, *args)

    def CreateElementAt(self, arg0):
        r"""
        CreateElementAt(self, arg0) -> itkLevelSetNodeF4

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNF4_CreateElementAt(self, arg0)

    def GetElement(self, arg0):
        r"""
        GetElement(self, arg0) -> itkLevelSetNodeF4

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNF4_GetElement(self, arg0)

    def SetElement(self, arg0, arg1):
        r"""
        SetElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeF4

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNF4_SetElement(self, arg0, arg1)

    def InsertElement(self, arg0, arg1):
        r"""
        InsertElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeF4

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNF4_InsertElement(self, arg0, arg1)

    def IndexExists(self, arg0):
        r"""
        IndexExists(self, arg0) -> bool

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNF4_IndexExists(self, arg0)

    def GetElementIfIndexExists(self, arg0, arg1):
        r"""
        GetElementIfIndexExists(self, arg0, arg1) -> bool

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeF4 *

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNF4_GetElementIfIndexExists(self, arg0, arg1)

    def CreateIndex(self, arg0):
        r"""
        CreateIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNF4_CreateIndex(self, arg0)

    def DeleteIndex(self, arg0):
        r"""
        DeleteIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNF4_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned int"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNF4_Size(self)

    def Reserve(self, arg0):
        r"""
        Reserve(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNF4_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNF4_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNF4_Initialize(self)
    __swig_destroy__ = _ITKFastMarchingBasePython.delete_itkVectorContainerUILSNF4

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

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

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNF4_cast(obj)

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

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

          itkVectorContainerUILSNF4.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerUILSNF4 in _ITKFastMarchingBasePython:
_ITKFastMarchingBasePython.itkVectorContainerUILSNF4_swigregister(itkVectorContainerUILSNF4)

def itkVectorContainerUILSNSC2_New():
    return itkVectorContainerUILSNSC2.New()

class itkVectorContainerUILSNSC2(itk.ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkVectorContainerUILSNSC2 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__() -> itkVectorContainerUILSNSC2_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSC2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerUILSNSC2_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSC2_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkLevelSetNodeSC2,std::allocator< itkLevelSetNodeSC2 > > &"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSC2_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkLevelSetNodeSC2,std::allocator< itkLevelSetNodeSC2 > > const &"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSC2_CastToSTLConstContainer(self)

    def ElementAt(self, *args):
        r"""
        ElementAt(self, arg0) -> itkLevelSetNodeSC2

        Parameters
        ----------
        arg0: unsigned int

        ElementAt(self, arg0) -> itkLevelSetNodeSC2

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSC2_ElementAt(self, *args)

    def CreateElementAt(self, arg0):
        r"""
        CreateElementAt(self, arg0) -> itkLevelSetNodeSC2

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSC2_CreateElementAt(self, arg0)

    def GetElement(self, arg0):
        r"""
        GetElement(self, arg0) -> itkLevelSetNodeSC2

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSC2_GetElement(self, arg0)

    def SetElement(self, arg0, arg1):
        r"""
        SetElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeSC2

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSC2_SetElement(self, arg0, arg1)

    def InsertElement(self, arg0, arg1):
        r"""
        InsertElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeSC2

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSC2_InsertElement(self, arg0, arg1)

    def IndexExists(self, arg0):
        r"""
        IndexExists(self, arg0) -> bool

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSC2_IndexExists(self, arg0)

    def GetElementIfIndexExists(self, arg0, arg1):
        r"""
        GetElementIfIndexExists(self, arg0, arg1) -> bool

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeSC2 *

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSC2_GetElementIfIndexExists(self, arg0, arg1)

    def CreateIndex(self, arg0):
        r"""
        CreateIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSC2_CreateIndex(self, arg0)

    def DeleteIndex(self, arg0):
        r"""
        DeleteIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSC2_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned int"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSC2_Size(self)

    def Reserve(self, arg0):
        r"""
        Reserve(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSC2_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSC2_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSC2_Initialize(self)
    __swig_destroy__ = _ITKFastMarchingBasePython.delete_itkVectorContainerUILSNSC2

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

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

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSC2_cast(obj)

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

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

          itkVectorContainerUILSNSC2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerUILSNSC2 in _ITKFastMarchingBasePython:
_ITKFastMarchingBasePython.itkVectorContainerUILSNSC2_swigregister(itkVectorContainerUILSNSC2)

def itkVectorContainerUILSNSC3_New():
    return itkVectorContainerUILSNSC3.New()

class itkVectorContainerUILSNSC3(itk.ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkVectorContainerUILSNSC3 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__() -> itkVectorContainerUILSNSC3_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSC3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerUILSNSC3_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSC3_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkLevelSetNodeSC3,std::allocator< itkLevelSetNodeSC3 > > &"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSC3_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkLevelSetNodeSC3,std::allocator< itkLevelSetNodeSC3 > > const &"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSC3_CastToSTLConstContainer(self)

    def ElementAt(self, *args):
        r"""
        ElementAt(self, arg0) -> itkLevelSetNodeSC3

        Parameters
        ----------
        arg0: unsigned int

        ElementAt(self, arg0) -> itkLevelSetNodeSC3

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSC3_ElementAt(self, *args)

    def CreateElementAt(self, arg0):
        r"""
        CreateElementAt(self, arg0) -> itkLevelSetNodeSC3

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSC3_CreateElementAt(self, arg0)

    def GetElement(self, arg0):
        r"""
        GetElement(self, arg0) -> itkLevelSetNodeSC3

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSC3_GetElement(self, arg0)

    def SetElement(self, arg0, arg1):
        r"""
        SetElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeSC3

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSC3_SetElement(self, arg0, arg1)

    def InsertElement(self, arg0, arg1):
        r"""
        InsertElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeSC3

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSC3_InsertElement(self, arg0, arg1)

    def IndexExists(self, arg0):
        r"""
        IndexExists(self, arg0) -> bool

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSC3_IndexExists(self, arg0)

    def GetElementIfIndexExists(self, arg0, arg1):
        r"""
        GetElementIfIndexExists(self, arg0, arg1) -> bool

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeSC3 *

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSC3_GetElementIfIndexExists(self, arg0, arg1)

    def CreateIndex(self, arg0):
        r"""
        CreateIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSC3_CreateIndex(self, arg0)

    def DeleteIndex(self, arg0):
        r"""
        DeleteIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSC3_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned int"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSC3_Size(self)

    def Reserve(self, arg0):
        r"""
        Reserve(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSC3_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSC3_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSC3_Initialize(self)
    __swig_destroy__ = _ITKFastMarchingBasePython.delete_itkVectorContainerUILSNSC3

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

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

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSC3_cast(obj)

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

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

          itkVectorContainerUILSNSC3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerUILSNSC3 in _ITKFastMarchingBasePython:
_ITKFastMarchingBasePython.itkVectorContainerUILSNSC3_swigregister(itkVectorContainerUILSNSC3)

def itkVectorContainerUILSNSC4_New():
    return itkVectorContainerUILSNSC4.New()

class itkVectorContainerUILSNSC4(itk.ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkVectorContainerUILSNSC4 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__() -> itkVectorContainerUILSNSC4_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSC4___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerUILSNSC4_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSC4_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkLevelSetNodeSC4,std::allocator< itkLevelSetNodeSC4 > > &"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSC4_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkLevelSetNodeSC4,std::allocator< itkLevelSetNodeSC4 > > const &"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSC4_CastToSTLConstContainer(self)

    def ElementAt(self, *args):
        r"""
        ElementAt(self, arg0) -> itkLevelSetNodeSC4

        Parameters
        ----------
        arg0: unsigned int

        ElementAt(self, arg0) -> itkLevelSetNodeSC4

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSC4_ElementAt(self, *args)

    def CreateElementAt(self, arg0):
        r"""
        CreateElementAt(self, arg0) -> itkLevelSetNodeSC4

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSC4_CreateElementAt(self, arg0)

    def GetElement(self, arg0):
        r"""
        GetElement(self, arg0) -> itkLevelSetNodeSC4

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSC4_GetElement(self, arg0)

    def SetElement(self, arg0, arg1):
        r"""
        SetElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeSC4

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSC4_SetElement(self, arg0, arg1)

    def InsertElement(self, arg0, arg1):
        r"""
        InsertElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeSC4

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSC4_InsertElement(self, arg0, arg1)

    def IndexExists(self, arg0):
        r"""
        IndexExists(self, arg0) -> bool

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSC4_IndexExists(self, arg0)

    def GetElementIfIndexExists(self, arg0, arg1):
        r"""
        GetElementIfIndexExists(self, arg0, arg1) -> bool

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeSC4 *

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSC4_GetElementIfIndexExists(self, arg0, arg1)

    def CreateIndex(self, arg0):
        r"""
        CreateIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSC4_CreateIndex(self, arg0)

    def DeleteIndex(self, arg0):
        r"""
        DeleteIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSC4_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned int"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSC4_Size(self)

    def Reserve(self, arg0):
        r"""
        Reserve(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSC4_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSC4_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSC4_Initialize(self)
    __swig_destroy__ = _ITKFastMarchingBasePython.delete_itkVectorContainerUILSNSC4

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

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

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSC4_cast(obj)

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

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

          itkVectorContainerUILSNSC4.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerUILSNSC4 in _ITKFastMarchingBasePython:
_ITKFastMarchingBasePython.itkVectorContainerUILSNSC4_swigregister(itkVectorContainerUILSNSC4)

def itkVectorContainerUILSNSS2_New():
    return itkVectorContainerUILSNSS2.New()

class itkVectorContainerUILSNSS2(itk.ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkVectorContainerUILSNSS2 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__() -> itkVectorContainerUILSNSS2_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSS2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerUILSNSS2_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSS2_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkLevelSetNodeSS2,std::allocator< itkLevelSetNodeSS2 > > &"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSS2_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkLevelSetNodeSS2,std::allocator< itkLevelSetNodeSS2 > > const &"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSS2_CastToSTLConstContainer(self)

    def ElementAt(self, *args):
        r"""
        ElementAt(self, arg0) -> itkLevelSetNodeSS2

        Parameters
        ----------
        arg0: unsigned int

        ElementAt(self, arg0) -> itkLevelSetNodeSS2

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSS2_ElementAt(self, *args)

    def CreateElementAt(self, arg0):
        r"""
        CreateElementAt(self, arg0) -> itkLevelSetNodeSS2

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSS2_CreateElementAt(self, arg0)

    def GetElement(self, arg0):
        r"""
        GetElement(self, arg0) -> itkLevelSetNodeSS2

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSS2_GetElement(self, arg0)

    def SetElement(self, arg0, arg1):
        r"""
        SetElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeSS2

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSS2_SetElement(self, arg0, arg1)

    def InsertElement(self, arg0, arg1):
        r"""
        InsertElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeSS2

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSS2_InsertElement(self, arg0, arg1)

    def IndexExists(self, arg0):
        r"""
        IndexExists(self, arg0) -> bool

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSS2_IndexExists(self, arg0)

    def GetElementIfIndexExists(self, arg0, arg1):
        r"""
        GetElementIfIndexExists(self, arg0, arg1) -> bool

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeSS2 *

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSS2_GetElementIfIndexExists(self, arg0, arg1)

    def CreateIndex(self, arg0):
        r"""
        CreateIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSS2_CreateIndex(self, arg0)

    def DeleteIndex(self, arg0):
        r"""
        DeleteIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSS2_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned int"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSS2_Size(self)

    def Reserve(self, arg0):
        r"""
        Reserve(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSS2_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSS2_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSS2_Initialize(self)
    __swig_destroy__ = _ITKFastMarchingBasePython.delete_itkVectorContainerUILSNSS2

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

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

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSS2_cast(obj)

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

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

          itkVectorContainerUILSNSS2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerUILSNSS2 in _ITKFastMarchingBasePython:
_ITKFastMarchingBasePython.itkVectorContainerUILSNSS2_swigregister(itkVectorContainerUILSNSS2)

def itkVectorContainerUILSNSS3_New():
    return itkVectorContainerUILSNSS3.New()

class itkVectorContainerUILSNSS3(itk.ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkVectorContainerUILSNSS3 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__() -> itkVectorContainerUILSNSS3_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSS3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerUILSNSS3_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSS3_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkLevelSetNodeSS3,std::allocator< itkLevelSetNodeSS3 > > &"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSS3_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkLevelSetNodeSS3,std::allocator< itkLevelSetNodeSS3 > > const &"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSS3_CastToSTLConstContainer(self)

    def ElementAt(self, *args):
        r"""
        ElementAt(self, arg0) -> itkLevelSetNodeSS3

        Parameters
        ----------
        arg0: unsigned int

        ElementAt(self, arg0) -> itkLevelSetNodeSS3

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSS3_ElementAt(self, *args)

    def CreateElementAt(self, arg0):
        r"""
        CreateElementAt(self, arg0) -> itkLevelSetNodeSS3

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSS3_CreateElementAt(self, arg0)

    def GetElement(self, arg0):
        r"""
        GetElement(self, arg0) -> itkLevelSetNodeSS3

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSS3_GetElement(self, arg0)

    def SetElement(self, arg0, arg1):
        r"""
        SetElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeSS3

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSS3_SetElement(self, arg0, arg1)

    def InsertElement(self, arg0, arg1):
        r"""
        InsertElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeSS3

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSS3_InsertElement(self, arg0, arg1)

    def IndexExists(self, arg0):
        r"""
        IndexExists(self, arg0) -> bool

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSS3_IndexExists(self, arg0)

    def GetElementIfIndexExists(self, arg0, arg1):
        r"""
        GetElementIfIndexExists(self, arg0, arg1) -> bool

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeSS3 *

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSS3_GetElementIfIndexExists(self, arg0, arg1)

    def CreateIndex(self, arg0):
        r"""
        CreateIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSS3_CreateIndex(self, arg0)

    def DeleteIndex(self, arg0):
        r"""
        DeleteIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSS3_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned int"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSS3_Size(self)

    def Reserve(self, arg0):
        r"""
        Reserve(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSS3_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSS3_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSS3_Initialize(self)
    __swig_destroy__ = _ITKFastMarchingBasePython.delete_itkVectorContainerUILSNSS3

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

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

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSS3_cast(obj)

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

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

          itkVectorContainerUILSNSS3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerUILSNSS3 in _ITKFastMarchingBasePython:
_ITKFastMarchingBasePython.itkVectorContainerUILSNSS3_swigregister(itkVectorContainerUILSNSS3)

def itkVectorContainerUILSNSS4_New():
    return itkVectorContainerUILSNSS4.New()

class itkVectorContainerUILSNSS4(itk.ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkVectorContainerUILSNSS4 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__() -> itkVectorContainerUILSNSS4_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSS4___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerUILSNSS4_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSS4_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkLevelSetNodeSS4,std::allocator< itkLevelSetNodeSS4 > > &"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSS4_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkLevelSetNodeSS4,std::allocator< itkLevelSetNodeSS4 > > const &"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSS4_CastToSTLConstContainer(self)

    def ElementAt(self, *args):
        r"""
        ElementAt(self, arg0) -> itkLevelSetNodeSS4

        Parameters
        ----------
        arg0: unsigned int

        ElementAt(self, arg0) -> itkLevelSetNodeSS4

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSS4_ElementAt(self, *args)

    def CreateElementAt(self, arg0):
        r"""
        CreateElementAt(self, arg0) -> itkLevelSetNodeSS4

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSS4_CreateElementAt(self, arg0)

    def GetElement(self, arg0):
        r"""
        GetElement(self, arg0) -> itkLevelSetNodeSS4

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSS4_GetElement(self, arg0)

    def SetElement(self, arg0, arg1):
        r"""
        SetElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeSS4

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSS4_SetElement(self, arg0, arg1)

    def InsertElement(self, arg0, arg1):
        r"""
        InsertElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeSS4

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSS4_InsertElement(self, arg0, arg1)

    def IndexExists(self, arg0):
        r"""
        IndexExists(self, arg0) -> bool

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSS4_IndexExists(self, arg0)

    def GetElementIfIndexExists(self, arg0, arg1):
        r"""
        GetElementIfIndexExists(self, arg0, arg1) -> bool

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeSS4 *

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSS4_GetElementIfIndexExists(self, arg0, arg1)

    def CreateIndex(self, arg0):
        r"""
        CreateIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSS4_CreateIndex(self, arg0)

    def DeleteIndex(self, arg0):
        r"""
        DeleteIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSS4_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned int"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSS4_Size(self)

    def Reserve(self, arg0):
        r"""
        Reserve(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSS4_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSS4_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSS4_Initialize(self)
    __swig_destroy__ = _ITKFastMarchingBasePython.delete_itkVectorContainerUILSNSS4

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

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

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNSS4_cast(obj)

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

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

          itkVectorContainerUILSNSS4.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerUILSNSS4 in _ITKFastMarchingBasePython:
_ITKFastMarchingBasePython.itkVectorContainerUILSNSS4_swigregister(itkVectorContainerUILSNSS4)

def itkVectorContainerUILSNUC2_New():
    return itkVectorContainerUILSNUC2.New()

class itkVectorContainerUILSNUC2(itk.ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkVectorContainerUILSNUC2 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__() -> itkVectorContainerUILSNUC2_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUC2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerUILSNUC2_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUC2_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkLevelSetNodeUC2,std::allocator< itkLevelSetNodeUC2 > > &"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUC2_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkLevelSetNodeUC2,std::allocator< itkLevelSetNodeUC2 > > const &"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUC2_CastToSTLConstContainer(self)

    def ElementAt(self, *args):
        r"""
        ElementAt(self, arg0) -> itkLevelSetNodeUC2

        Parameters
        ----------
        arg0: unsigned int

        ElementAt(self, arg0) -> itkLevelSetNodeUC2

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUC2_ElementAt(self, *args)

    def CreateElementAt(self, arg0):
        r"""
        CreateElementAt(self, arg0) -> itkLevelSetNodeUC2

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUC2_CreateElementAt(self, arg0)

    def GetElement(self, arg0):
        r"""
        GetElement(self, arg0) -> itkLevelSetNodeUC2

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUC2_GetElement(self, arg0)

    def SetElement(self, arg0, arg1):
        r"""
        SetElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeUC2

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUC2_SetElement(self, arg0, arg1)

    def InsertElement(self, arg0, arg1):
        r"""
        InsertElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeUC2

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUC2_InsertElement(self, arg0, arg1)

    def IndexExists(self, arg0):
        r"""
        IndexExists(self, arg0) -> bool

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUC2_IndexExists(self, arg0)

    def GetElementIfIndexExists(self, arg0, arg1):
        r"""
        GetElementIfIndexExists(self, arg0, arg1) -> bool

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeUC2 *

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUC2_GetElementIfIndexExists(self, arg0, arg1)

    def CreateIndex(self, arg0):
        r"""
        CreateIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUC2_CreateIndex(self, arg0)

    def DeleteIndex(self, arg0):
        r"""
        DeleteIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUC2_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned int"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUC2_Size(self)

    def Reserve(self, arg0):
        r"""
        Reserve(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUC2_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUC2_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUC2_Initialize(self)
    __swig_destroy__ = _ITKFastMarchingBasePython.delete_itkVectorContainerUILSNUC2

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

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

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUC2_cast(obj)

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

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

          itkVectorContainerUILSNUC2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerUILSNUC2 in _ITKFastMarchingBasePython:
_ITKFastMarchingBasePython.itkVectorContainerUILSNUC2_swigregister(itkVectorContainerUILSNUC2)

def itkVectorContainerUILSNUC3_New():
    return itkVectorContainerUILSNUC3.New()

class itkVectorContainerUILSNUC3(itk.ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkVectorContainerUILSNUC3 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__() -> itkVectorContainerUILSNUC3_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUC3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerUILSNUC3_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUC3_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkLevelSetNodeUC3,std::allocator< itkLevelSetNodeUC3 > > &"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUC3_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkLevelSetNodeUC3,std::allocator< itkLevelSetNodeUC3 > > const &"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUC3_CastToSTLConstContainer(self)

    def ElementAt(self, *args):
        r"""
        ElementAt(self, arg0) -> itkLevelSetNodeUC3

        Parameters
        ----------
        arg0: unsigned int

        ElementAt(self, arg0) -> itkLevelSetNodeUC3

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUC3_ElementAt(self, *args)

    def CreateElementAt(self, arg0):
        r"""
        CreateElementAt(self, arg0) -> itkLevelSetNodeUC3

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUC3_CreateElementAt(self, arg0)

    def GetElement(self, arg0):
        r"""
        GetElement(self, arg0) -> itkLevelSetNodeUC3

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUC3_GetElement(self, arg0)

    def SetElement(self, arg0, arg1):
        r"""
        SetElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeUC3

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUC3_SetElement(self, arg0, arg1)

    def InsertElement(self, arg0, arg1):
        r"""
        InsertElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeUC3

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUC3_InsertElement(self, arg0, arg1)

    def IndexExists(self, arg0):
        r"""
        IndexExists(self, arg0) -> bool

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUC3_IndexExists(self, arg0)

    def GetElementIfIndexExists(self, arg0, arg1):
        r"""
        GetElementIfIndexExists(self, arg0, arg1) -> bool

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeUC3 *

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUC3_GetElementIfIndexExists(self, arg0, arg1)

    def CreateIndex(self, arg0):
        r"""
        CreateIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUC3_CreateIndex(self, arg0)

    def DeleteIndex(self, arg0):
        r"""
        DeleteIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUC3_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned int"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUC3_Size(self)

    def Reserve(self, arg0):
        r"""
        Reserve(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUC3_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUC3_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUC3_Initialize(self)
    __swig_destroy__ = _ITKFastMarchingBasePython.delete_itkVectorContainerUILSNUC3

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

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

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUC3_cast(obj)

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

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

          itkVectorContainerUILSNUC3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerUILSNUC3 in _ITKFastMarchingBasePython:
_ITKFastMarchingBasePython.itkVectorContainerUILSNUC3_swigregister(itkVectorContainerUILSNUC3)

def itkVectorContainerUILSNUC4_New():
    return itkVectorContainerUILSNUC4.New()

class itkVectorContainerUILSNUC4(itk.ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkVectorContainerUILSNUC4 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__() -> itkVectorContainerUILSNUC4_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUC4___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerUILSNUC4_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUC4_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkLevelSetNodeUC4,std::allocator< itkLevelSetNodeUC4 > > &"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUC4_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkLevelSetNodeUC4,std::allocator< itkLevelSetNodeUC4 > > const &"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUC4_CastToSTLConstContainer(self)

    def ElementAt(self, *args):
        r"""
        ElementAt(self, arg0) -> itkLevelSetNodeUC4

        Parameters
        ----------
        arg0: unsigned int

        ElementAt(self, arg0) -> itkLevelSetNodeUC4

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUC4_ElementAt(self, *args)

    def CreateElementAt(self, arg0):
        r"""
        CreateElementAt(self, arg0) -> itkLevelSetNodeUC4

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUC4_CreateElementAt(self, arg0)

    def GetElement(self, arg0):
        r"""
        GetElement(self, arg0) -> itkLevelSetNodeUC4

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUC4_GetElement(self, arg0)

    def SetElement(self, arg0, arg1):
        r"""
        SetElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeUC4

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUC4_SetElement(self, arg0, arg1)

    def InsertElement(self, arg0, arg1):
        r"""
        InsertElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeUC4

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUC4_InsertElement(self, arg0, arg1)

    def IndexExists(self, arg0):
        r"""
        IndexExists(self, arg0) -> bool

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUC4_IndexExists(self, arg0)

    def GetElementIfIndexExists(self, arg0, arg1):
        r"""
        GetElementIfIndexExists(self, arg0, arg1) -> bool

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeUC4 *

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUC4_GetElementIfIndexExists(self, arg0, arg1)

    def CreateIndex(self, arg0):
        r"""
        CreateIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUC4_CreateIndex(self, arg0)

    def DeleteIndex(self, arg0):
        r"""
        DeleteIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUC4_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned int"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUC4_Size(self)

    def Reserve(self, arg0):
        r"""
        Reserve(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUC4_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUC4_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUC4_Initialize(self)
    __swig_destroy__ = _ITKFastMarchingBasePython.delete_itkVectorContainerUILSNUC4

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

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

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUC4_cast(obj)

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

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

          itkVectorContainerUILSNUC4.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerUILSNUC4 in _ITKFastMarchingBasePython:
_ITKFastMarchingBasePython.itkVectorContainerUILSNUC4_swigregister(itkVectorContainerUILSNUC4)

def itkVectorContainerUILSNULL2_New():
    return itkVectorContainerUILSNULL2.New()

class itkVectorContainerUILSNULL2(itk.ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkVectorContainerUILSNULL2 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__() -> itkVectorContainerUILSNULL2_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNULL2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerUILSNULL2_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNULL2_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkLevelSetNodeULL2,std::allocator< itkLevelSetNodeULL2 > > &"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNULL2_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkLevelSetNodeULL2,std::allocator< itkLevelSetNodeULL2 > > const &"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNULL2_CastToSTLConstContainer(self)

    def ElementAt(self, *args):
        r"""
        ElementAt(self, arg0) -> itkLevelSetNodeULL2

        Parameters
        ----------
        arg0: unsigned int

        ElementAt(self, arg0) -> itkLevelSetNodeULL2

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNULL2_ElementAt(self, *args)

    def CreateElementAt(self, arg0):
        r"""
        CreateElementAt(self, arg0) -> itkLevelSetNodeULL2

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNULL2_CreateElementAt(self, arg0)

    def GetElement(self, arg0):
        r"""
        GetElement(self, arg0) -> itkLevelSetNodeULL2

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNULL2_GetElement(self, arg0)

    def SetElement(self, arg0, arg1):
        r"""
        SetElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeULL2

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNULL2_SetElement(self, arg0, arg1)

    def InsertElement(self, arg0, arg1):
        r"""
        InsertElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeULL2

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNULL2_InsertElement(self, arg0, arg1)

    def IndexExists(self, arg0):
        r"""
        IndexExists(self, arg0) -> bool

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNULL2_IndexExists(self, arg0)

    def GetElementIfIndexExists(self, arg0, arg1):
        r"""
        GetElementIfIndexExists(self, arg0, arg1) -> bool

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeULL2 *

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNULL2_GetElementIfIndexExists(self, arg0, arg1)

    def CreateIndex(self, arg0):
        r"""
        CreateIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNULL2_CreateIndex(self, arg0)

    def DeleteIndex(self, arg0):
        r"""
        DeleteIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNULL2_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned int"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNULL2_Size(self)

    def Reserve(self, arg0):
        r"""
        Reserve(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNULL2_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNULL2_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNULL2_Initialize(self)
    __swig_destroy__ = _ITKFastMarchingBasePython.delete_itkVectorContainerUILSNULL2

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

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

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNULL2_cast(obj)

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

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

          itkVectorContainerUILSNULL2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerUILSNULL2 in _ITKFastMarchingBasePython:
_ITKFastMarchingBasePython.itkVectorContainerUILSNULL2_swigregister(itkVectorContainerUILSNULL2)

def itkVectorContainerUILSNULL3_New():
    return itkVectorContainerUILSNULL3.New()

class itkVectorContainerUILSNULL3(itk.ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkVectorContainerUILSNULL3 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__() -> itkVectorContainerUILSNULL3_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNULL3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerUILSNULL3_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNULL3_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkLevelSetNodeULL3,std::allocator< itkLevelSetNodeULL3 > > &"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNULL3_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkLevelSetNodeULL3,std::allocator< itkLevelSetNodeULL3 > > const &"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNULL3_CastToSTLConstContainer(self)

    def ElementAt(self, *args):
        r"""
        ElementAt(self, arg0) -> itkLevelSetNodeULL3

        Parameters
        ----------
        arg0: unsigned int

        ElementAt(self, arg0) -> itkLevelSetNodeULL3

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNULL3_ElementAt(self, *args)

    def CreateElementAt(self, arg0):
        r"""
        CreateElementAt(self, arg0) -> itkLevelSetNodeULL3

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNULL3_CreateElementAt(self, arg0)

    def GetElement(self, arg0):
        r"""
        GetElement(self, arg0) -> itkLevelSetNodeULL3

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNULL3_GetElement(self, arg0)

    def SetElement(self, arg0, arg1):
        r"""
        SetElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeULL3

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNULL3_SetElement(self, arg0, arg1)

    def InsertElement(self, arg0, arg1):
        r"""
        InsertElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeULL3

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNULL3_InsertElement(self, arg0, arg1)

    def IndexExists(self, arg0):
        r"""
        IndexExists(self, arg0) -> bool

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNULL3_IndexExists(self, arg0)

    def GetElementIfIndexExists(self, arg0, arg1):
        r"""
        GetElementIfIndexExists(self, arg0, arg1) -> bool

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeULL3 *

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNULL3_GetElementIfIndexExists(self, arg0, arg1)

    def CreateIndex(self, arg0):
        r"""
        CreateIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNULL3_CreateIndex(self, arg0)

    def DeleteIndex(self, arg0):
        r"""
        DeleteIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNULL3_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned int"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNULL3_Size(self)

    def Reserve(self, arg0):
        r"""
        Reserve(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNULL3_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNULL3_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNULL3_Initialize(self)
    __swig_destroy__ = _ITKFastMarchingBasePython.delete_itkVectorContainerUILSNULL3

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

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

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNULL3_cast(obj)

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

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

          itkVectorContainerUILSNULL3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerUILSNULL3 in _ITKFastMarchingBasePython:
_ITKFastMarchingBasePython.itkVectorContainerUILSNULL3_swigregister(itkVectorContainerUILSNULL3)

def itkVectorContainerUILSNULL4_New():
    return itkVectorContainerUILSNULL4.New()

class itkVectorContainerUILSNULL4(itk.ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkVectorContainerUILSNULL4 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__() -> itkVectorContainerUILSNULL4_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNULL4___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerUILSNULL4_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNULL4_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkLevelSetNodeULL4,std::allocator< itkLevelSetNodeULL4 > > &"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNULL4_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkLevelSetNodeULL4,std::allocator< itkLevelSetNodeULL4 > > const &"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNULL4_CastToSTLConstContainer(self)

    def ElementAt(self, *args):
        r"""
        ElementAt(self, arg0) -> itkLevelSetNodeULL4

        Parameters
        ----------
        arg0: unsigned int

        ElementAt(self, arg0) -> itkLevelSetNodeULL4

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNULL4_ElementAt(self, *args)

    def CreateElementAt(self, arg0):
        r"""
        CreateElementAt(self, arg0) -> itkLevelSetNodeULL4

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNULL4_CreateElementAt(self, arg0)

    def GetElement(self, arg0):
        r"""
        GetElement(self, arg0) -> itkLevelSetNodeULL4

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNULL4_GetElement(self, arg0)

    def SetElement(self, arg0, arg1):
        r"""
        SetElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeULL4

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNULL4_SetElement(self, arg0, arg1)

    def InsertElement(self, arg0, arg1):
        r"""
        InsertElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeULL4

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNULL4_InsertElement(self, arg0, arg1)

    def IndexExists(self, arg0):
        r"""
        IndexExists(self, arg0) -> bool

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNULL4_IndexExists(self, arg0)

    def GetElementIfIndexExists(self, arg0, arg1):
        r"""
        GetElementIfIndexExists(self, arg0, arg1) -> bool

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeULL4 *

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNULL4_GetElementIfIndexExists(self, arg0, arg1)

    def CreateIndex(self, arg0):
        r"""
        CreateIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNULL4_CreateIndex(self, arg0)

    def DeleteIndex(self, arg0):
        r"""
        DeleteIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNULL4_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned int"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNULL4_Size(self)

    def Reserve(self, arg0):
        r"""
        Reserve(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNULL4_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNULL4_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNULL4_Initialize(self)
    __swig_destroy__ = _ITKFastMarchingBasePython.delete_itkVectorContainerUILSNULL4

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

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

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNULL4_cast(obj)

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

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

          itkVectorContainerUILSNULL4.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerUILSNULL4 in _ITKFastMarchingBasePython:
_ITKFastMarchingBasePython.itkVectorContainerUILSNULL4_swigregister(itkVectorContainerUILSNULL4)

def itkVectorContainerUILSNUS2_New():
    return itkVectorContainerUILSNUS2.New()

class itkVectorContainerUILSNUS2(itk.ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkVectorContainerUILSNUS2 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__() -> itkVectorContainerUILSNUS2_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUS2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerUILSNUS2_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUS2_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkLevelSetNodeUS2,std::allocator< itkLevelSetNodeUS2 > > &"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUS2_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkLevelSetNodeUS2,std::allocator< itkLevelSetNodeUS2 > > const &"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUS2_CastToSTLConstContainer(self)

    def ElementAt(self, *args):
        r"""
        ElementAt(self, arg0) -> itkLevelSetNodeUS2

        Parameters
        ----------
        arg0: unsigned int

        ElementAt(self, arg0) -> itkLevelSetNodeUS2

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUS2_ElementAt(self, *args)

    def CreateElementAt(self, arg0):
        r"""
        CreateElementAt(self, arg0) -> itkLevelSetNodeUS2

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUS2_CreateElementAt(self, arg0)

    def GetElement(self, arg0):
        r"""
        GetElement(self, arg0) -> itkLevelSetNodeUS2

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUS2_GetElement(self, arg0)

    def SetElement(self, arg0, arg1):
        r"""
        SetElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeUS2

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUS2_SetElement(self, arg0, arg1)

    def InsertElement(self, arg0, arg1):
        r"""
        InsertElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeUS2

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUS2_InsertElement(self, arg0, arg1)

    def IndexExists(self, arg0):
        r"""
        IndexExists(self, arg0) -> bool

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUS2_IndexExists(self, arg0)

    def GetElementIfIndexExists(self, arg0, arg1):
        r"""
        GetElementIfIndexExists(self, arg0, arg1) -> bool

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeUS2 *

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUS2_GetElementIfIndexExists(self, arg0, arg1)

    def CreateIndex(self, arg0):
        r"""
        CreateIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUS2_CreateIndex(self, arg0)

    def DeleteIndex(self, arg0):
        r"""
        DeleteIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUS2_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned int"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUS2_Size(self)

    def Reserve(self, arg0):
        r"""
        Reserve(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUS2_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUS2_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUS2_Initialize(self)
    __swig_destroy__ = _ITKFastMarchingBasePython.delete_itkVectorContainerUILSNUS2

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

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

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUS2_cast(obj)

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

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

          itkVectorContainerUILSNUS2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerUILSNUS2 in _ITKFastMarchingBasePython:
_ITKFastMarchingBasePython.itkVectorContainerUILSNUS2_swigregister(itkVectorContainerUILSNUS2)

def itkVectorContainerUILSNUS3_New():
    return itkVectorContainerUILSNUS3.New()

class itkVectorContainerUILSNUS3(itk.ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkVectorContainerUILSNUS3 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__() -> itkVectorContainerUILSNUS3_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUS3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerUILSNUS3_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUS3_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkLevelSetNodeUS3,std::allocator< itkLevelSetNodeUS3 > > &"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUS3_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkLevelSetNodeUS3,std::allocator< itkLevelSetNodeUS3 > > const &"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUS3_CastToSTLConstContainer(self)

    def ElementAt(self, *args):
        r"""
        ElementAt(self, arg0) -> itkLevelSetNodeUS3

        Parameters
        ----------
        arg0: unsigned int

        ElementAt(self, arg0) -> itkLevelSetNodeUS3

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUS3_ElementAt(self, *args)

    def CreateElementAt(self, arg0):
        r"""
        CreateElementAt(self, arg0) -> itkLevelSetNodeUS3

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUS3_CreateElementAt(self, arg0)

    def GetElement(self, arg0):
        r"""
        GetElement(self, arg0) -> itkLevelSetNodeUS3

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUS3_GetElement(self, arg0)

    def SetElement(self, arg0, arg1):
        r"""
        SetElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeUS3

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUS3_SetElement(self, arg0, arg1)

    def InsertElement(self, arg0, arg1):
        r"""
        InsertElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeUS3

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUS3_InsertElement(self, arg0, arg1)

    def IndexExists(self, arg0):
        r"""
        IndexExists(self, arg0) -> bool

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUS3_IndexExists(self, arg0)

    def GetElementIfIndexExists(self, arg0, arg1):
        r"""
        GetElementIfIndexExists(self, arg0, arg1) -> bool

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeUS3 *

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUS3_GetElementIfIndexExists(self, arg0, arg1)

    def CreateIndex(self, arg0):
        r"""
        CreateIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUS3_CreateIndex(self, arg0)

    def DeleteIndex(self, arg0):
        r"""
        DeleteIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUS3_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned int"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUS3_Size(self)

    def Reserve(self, arg0):
        r"""
        Reserve(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUS3_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUS3_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUS3_Initialize(self)
    __swig_destroy__ = _ITKFastMarchingBasePython.delete_itkVectorContainerUILSNUS3

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

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

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUS3_cast(obj)

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

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

          itkVectorContainerUILSNUS3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerUILSNUS3 in _ITKFastMarchingBasePython:
_ITKFastMarchingBasePython.itkVectorContainerUILSNUS3_swigregister(itkVectorContainerUILSNUS3)

def itkVectorContainerUILSNUS4_New():
    return itkVectorContainerUILSNUS4.New()

class itkVectorContainerUILSNUS4(itk.ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkVectorContainerUILSNUS4 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__() -> itkVectorContainerUILSNUS4_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUS4___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerUILSNUS4_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUS4_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkLevelSetNodeUS4,std::allocator< itkLevelSetNodeUS4 > > &"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUS4_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkLevelSetNodeUS4,std::allocator< itkLevelSetNodeUS4 > > const &"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUS4_CastToSTLConstContainer(self)

    def ElementAt(self, *args):
        r"""
        ElementAt(self, arg0) -> itkLevelSetNodeUS4

        Parameters
        ----------
        arg0: unsigned int

        ElementAt(self, arg0) -> itkLevelSetNodeUS4

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUS4_ElementAt(self, *args)

    def CreateElementAt(self, arg0):
        r"""
        CreateElementAt(self, arg0) -> itkLevelSetNodeUS4

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUS4_CreateElementAt(self, arg0)

    def GetElement(self, arg0):
        r"""
        GetElement(self, arg0) -> itkLevelSetNodeUS4

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUS4_GetElement(self, arg0)

    def SetElement(self, arg0, arg1):
        r"""
        SetElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeUS4

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUS4_SetElement(self, arg0, arg1)

    def InsertElement(self, arg0, arg1):
        r"""
        InsertElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeUS4

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUS4_InsertElement(self, arg0, arg1)

    def IndexExists(self, arg0):
        r"""
        IndexExists(self, arg0) -> bool

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUS4_IndexExists(self, arg0)

    def GetElementIfIndexExists(self, arg0, arg1):
        r"""
        GetElementIfIndexExists(self, arg0, arg1) -> bool

        Parameters
        ----------
        arg0: unsigned int
        arg1: itkLevelSetNodeUS4 *

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUS4_GetElementIfIndexExists(self, arg0, arg1)

    def CreateIndex(self, arg0):
        r"""
        CreateIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUS4_CreateIndex(self, arg0)

    def DeleteIndex(self, arg0):
        r"""
        DeleteIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUS4_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned int"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUS4_Size(self)

    def Reserve(self, arg0):
        r"""
        Reserve(self, arg0)

        Parameters
        ----------
        arg0: unsigned int

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUS4_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUS4_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUS4_Initialize(self)
    __swig_destroy__ = _ITKFastMarchingBasePython.delete_itkVectorContainerUILSNUS4

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

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

        """
        return _ITKFastMarchingBasePython.itkVectorContainerUILSNUS4_cast(obj)

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

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

          itkVectorContainerUILSNUS4.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerUILSNUS4 in _ITKFastMarchingBasePython:
_ITKFastMarchingBasePython.itkVectorContainerUILSNUS4_swigregister(itkVectorContainerUILSNUS4)

def itkVectorContainerULNPI2D_New():
    return itkVectorContainerULNPI2D.New()

class itkVectorContainerULNPI2D(itk.ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkVectorContainerULNPI2D 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__() -> itkVectorContainerULNPI2D_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2D___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerULNPI2D_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2D_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkNodePairI2D,std::allocator< itkNodePairI2D > > &"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2D_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkNodePairI2D,std::allocator< itkNodePairI2D > > const &"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2D_CastToSTLConstContainer(self)

    def ElementAt(self, *args):
        r"""
        ElementAt(self, arg0) -> itkNodePairI2D

        Parameters
        ----------
        arg0: unsigned long

        ElementAt(self, arg0) -> itkNodePairI2D

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2D_ElementAt(self, *args)

    def CreateElementAt(self, arg0):
        r"""
        CreateElementAt(self, arg0) -> itkNodePairI2D

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2D_CreateElementAt(self, arg0)

    def GetElement(self, arg0):
        r"""
        GetElement(self, arg0) -> itkNodePairI2D

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2D_GetElement(self, arg0)

    def SetElement(self, arg0, arg1):
        r"""
        SetElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI2D

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2D_SetElement(self, arg0, arg1)

    def InsertElement(self, arg0, arg1):
        r"""
        InsertElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI2D

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2D_InsertElement(self, arg0, arg1)

    def IndexExists(self, arg0):
        r"""
        IndexExists(self, arg0) -> bool

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2D_IndexExists(self, arg0)

    def GetElementIfIndexExists(self, arg0, arg1):
        r"""
        GetElementIfIndexExists(self, arg0, arg1) -> bool

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI2D *

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2D_GetElementIfIndexExists(self, arg0, arg1)

    def CreateIndex(self, arg0):
        r"""
        CreateIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2D_CreateIndex(self, arg0)

    def DeleteIndex(self, arg0):
        r"""
        DeleteIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2D_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned long"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2D_Size(self)

    def Reserve(self, arg0):
        r"""
        Reserve(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2D_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2D_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2D_Initialize(self)
    __swig_destroy__ = _ITKFastMarchingBasePython.delete_itkVectorContainerULNPI2D

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

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

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2D_cast(obj)

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

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

          itkVectorContainerULNPI2D.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerULNPI2D in _ITKFastMarchingBasePython:
_ITKFastMarchingBasePython.itkVectorContainerULNPI2D_swigregister(itkVectorContainerULNPI2D)

def itkVectorContainerULNPI2F_New():
    return itkVectorContainerULNPI2F.New()

class itkVectorContainerULNPI2F(itk.ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkVectorContainerULNPI2F 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__() -> itkVectorContainerULNPI2F_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2F___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerULNPI2F_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2F_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkNodePairI2F,std::allocator< itkNodePairI2F > > &"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2F_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkNodePairI2F,std::allocator< itkNodePairI2F > > const &"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2F_CastToSTLConstContainer(self)

    def ElementAt(self, *args):
        r"""
        ElementAt(self, arg0) -> itkNodePairI2F

        Parameters
        ----------
        arg0: unsigned long

        ElementAt(self, arg0) -> itkNodePairI2F

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2F_ElementAt(self, *args)

    def CreateElementAt(self, arg0):
        r"""
        CreateElementAt(self, arg0) -> itkNodePairI2F

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2F_CreateElementAt(self, arg0)

    def GetElement(self, arg0):
        r"""
        GetElement(self, arg0) -> itkNodePairI2F

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2F_GetElement(self, arg0)

    def SetElement(self, arg0, arg1):
        r"""
        SetElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI2F

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2F_SetElement(self, arg0, arg1)

    def InsertElement(self, arg0, arg1):
        r"""
        InsertElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI2F

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2F_InsertElement(self, arg0, arg1)

    def IndexExists(self, arg0):
        r"""
        IndexExists(self, arg0) -> bool

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2F_IndexExists(self, arg0)

    def GetElementIfIndexExists(self, arg0, arg1):
        r"""
        GetElementIfIndexExists(self, arg0, arg1) -> bool

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI2F *

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2F_GetElementIfIndexExists(self, arg0, arg1)

    def CreateIndex(self, arg0):
        r"""
        CreateIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2F_CreateIndex(self, arg0)

    def DeleteIndex(self, arg0):
        r"""
        DeleteIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2F_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned long"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2F_Size(self)

    def Reserve(self, arg0):
        r"""
        Reserve(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2F_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2F_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2F_Initialize(self)
    __swig_destroy__ = _ITKFastMarchingBasePython.delete_itkVectorContainerULNPI2F

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

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

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2F_cast(obj)

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

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

          itkVectorContainerULNPI2F.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerULNPI2F in _ITKFastMarchingBasePython:
_ITKFastMarchingBasePython.itkVectorContainerULNPI2F_swigregister(itkVectorContainerULNPI2F)

def itkVectorContainerULNPI2SC_New():
    return itkVectorContainerULNPI2SC.New()

class itkVectorContainerULNPI2SC(itk.ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkVectorContainerULNPI2SC 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__() -> itkVectorContainerULNPI2SC_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2SC___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerULNPI2SC_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2SC_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkNodePairI2SC,std::allocator< itkNodePairI2SC > > &"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2SC_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkNodePairI2SC,std::allocator< itkNodePairI2SC > > const &"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2SC_CastToSTLConstContainer(self)

    def ElementAt(self, *args):
        r"""
        ElementAt(self, arg0) -> itkNodePairI2SC

        Parameters
        ----------
        arg0: unsigned long

        ElementAt(self, arg0) -> itkNodePairI2SC

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2SC_ElementAt(self, *args)

    def CreateElementAt(self, arg0):
        r"""
        CreateElementAt(self, arg0) -> itkNodePairI2SC

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2SC_CreateElementAt(self, arg0)

    def GetElement(self, arg0):
        r"""
        GetElement(self, arg0) -> itkNodePairI2SC

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2SC_GetElement(self, arg0)

    def SetElement(self, arg0, arg1):
        r"""
        SetElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI2SC

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2SC_SetElement(self, arg0, arg1)

    def InsertElement(self, arg0, arg1):
        r"""
        InsertElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI2SC

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2SC_InsertElement(self, arg0, arg1)

    def IndexExists(self, arg0):
        r"""
        IndexExists(self, arg0) -> bool

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2SC_IndexExists(self, arg0)

    def GetElementIfIndexExists(self, arg0, arg1):
        r"""
        GetElementIfIndexExists(self, arg0, arg1) -> bool

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI2SC *

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2SC_GetElementIfIndexExists(self, arg0, arg1)

    def CreateIndex(self, arg0):
        r"""
        CreateIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2SC_CreateIndex(self, arg0)

    def DeleteIndex(self, arg0):
        r"""
        DeleteIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2SC_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned long"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2SC_Size(self)

    def Reserve(self, arg0):
        r"""
        Reserve(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2SC_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2SC_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2SC_Initialize(self)
    __swig_destroy__ = _ITKFastMarchingBasePython.delete_itkVectorContainerULNPI2SC

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

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

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2SC_cast(obj)

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

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

          itkVectorContainerULNPI2SC.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerULNPI2SC in _ITKFastMarchingBasePython:
_ITKFastMarchingBasePython.itkVectorContainerULNPI2SC_swigregister(itkVectorContainerULNPI2SC)

def itkVectorContainerULNPI2SS_New():
    return itkVectorContainerULNPI2SS.New()

class itkVectorContainerULNPI2SS(itk.ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkVectorContainerULNPI2SS 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__() -> itkVectorContainerULNPI2SS_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2SS___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerULNPI2SS_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2SS_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkNodePairI2SS,std::allocator< itkNodePairI2SS > > &"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2SS_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkNodePairI2SS,std::allocator< itkNodePairI2SS > > const &"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2SS_CastToSTLConstContainer(self)

    def ElementAt(self, *args):
        r"""
        ElementAt(self, arg0) -> itkNodePairI2SS

        Parameters
        ----------
        arg0: unsigned long

        ElementAt(self, arg0) -> itkNodePairI2SS

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2SS_ElementAt(self, *args)

    def CreateElementAt(self, arg0):
        r"""
        CreateElementAt(self, arg0) -> itkNodePairI2SS

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2SS_CreateElementAt(self, arg0)

    def GetElement(self, arg0):
        r"""
        GetElement(self, arg0) -> itkNodePairI2SS

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2SS_GetElement(self, arg0)

    def SetElement(self, arg0, arg1):
        r"""
        SetElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI2SS

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2SS_SetElement(self, arg0, arg1)

    def InsertElement(self, arg0, arg1):
        r"""
        InsertElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI2SS

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2SS_InsertElement(self, arg0, arg1)

    def IndexExists(self, arg0):
        r"""
        IndexExists(self, arg0) -> bool

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2SS_IndexExists(self, arg0)

    def GetElementIfIndexExists(self, arg0, arg1):
        r"""
        GetElementIfIndexExists(self, arg0, arg1) -> bool

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI2SS *

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2SS_GetElementIfIndexExists(self, arg0, arg1)

    def CreateIndex(self, arg0):
        r"""
        CreateIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2SS_CreateIndex(self, arg0)

    def DeleteIndex(self, arg0):
        r"""
        DeleteIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2SS_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned long"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2SS_Size(self)

    def Reserve(self, arg0):
        r"""
        Reserve(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2SS_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2SS_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2SS_Initialize(self)
    __swig_destroy__ = _ITKFastMarchingBasePython.delete_itkVectorContainerULNPI2SS

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

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

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2SS_cast(obj)

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

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

          itkVectorContainerULNPI2SS.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerULNPI2SS in _ITKFastMarchingBasePython:
_ITKFastMarchingBasePython.itkVectorContainerULNPI2SS_swigregister(itkVectorContainerULNPI2SS)

def itkVectorContainerULNPI2UC_New():
    return itkVectorContainerULNPI2UC.New()

class itkVectorContainerULNPI2UC(itk.ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkVectorContainerULNPI2UC 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__() -> itkVectorContainerULNPI2UC_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2UC___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerULNPI2UC_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2UC_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkNodePairI2UC,std::allocator< itkNodePairI2UC > > &"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2UC_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkNodePairI2UC,std::allocator< itkNodePairI2UC > > const &"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2UC_CastToSTLConstContainer(self)

    def ElementAt(self, *args):
        r"""
        ElementAt(self, arg0) -> itkNodePairI2UC

        Parameters
        ----------
        arg0: unsigned long

        ElementAt(self, arg0) -> itkNodePairI2UC

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2UC_ElementAt(self, *args)

    def CreateElementAt(self, arg0):
        r"""
        CreateElementAt(self, arg0) -> itkNodePairI2UC

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2UC_CreateElementAt(self, arg0)

    def GetElement(self, arg0):
        r"""
        GetElement(self, arg0) -> itkNodePairI2UC

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2UC_GetElement(self, arg0)

    def SetElement(self, arg0, arg1):
        r"""
        SetElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI2UC

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2UC_SetElement(self, arg0, arg1)

    def InsertElement(self, arg0, arg1):
        r"""
        InsertElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI2UC

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2UC_InsertElement(self, arg0, arg1)

    def IndexExists(self, arg0):
        r"""
        IndexExists(self, arg0) -> bool

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2UC_IndexExists(self, arg0)

    def GetElementIfIndexExists(self, arg0, arg1):
        r"""
        GetElementIfIndexExists(self, arg0, arg1) -> bool

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI2UC *

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2UC_GetElementIfIndexExists(self, arg0, arg1)

    def CreateIndex(self, arg0):
        r"""
        CreateIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2UC_CreateIndex(self, arg0)

    def DeleteIndex(self, arg0):
        r"""
        DeleteIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2UC_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned long"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2UC_Size(self)

    def Reserve(self, arg0):
        r"""
        Reserve(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2UC_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2UC_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2UC_Initialize(self)
    __swig_destroy__ = _ITKFastMarchingBasePython.delete_itkVectorContainerULNPI2UC

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

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

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2UC_cast(obj)

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

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

          itkVectorContainerULNPI2UC.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerULNPI2UC in _ITKFastMarchingBasePython:
_ITKFastMarchingBasePython.itkVectorContainerULNPI2UC_swigregister(itkVectorContainerULNPI2UC)

def itkVectorContainerULNPI2ULL_New():
    return itkVectorContainerULNPI2ULL.New()

class itkVectorContainerULNPI2ULL(itk.ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkVectorContainerULNPI2ULL 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__() -> itkVectorContainerULNPI2ULL_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2ULL___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerULNPI2ULL_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2ULL_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkNodePairI2ULL,std::allocator< itkNodePairI2ULL > > &"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2ULL_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkNodePairI2ULL,std::allocator< itkNodePairI2ULL > > const &"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2ULL_CastToSTLConstContainer(self)

    def ElementAt(self, *args):
        r"""
        ElementAt(self, arg0) -> itkNodePairI2ULL

        Parameters
        ----------
        arg0: unsigned long

        ElementAt(self, arg0) -> itkNodePairI2ULL

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2ULL_ElementAt(self, *args)

    def CreateElementAt(self, arg0):
        r"""
        CreateElementAt(self, arg0) -> itkNodePairI2ULL

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2ULL_CreateElementAt(self, arg0)

    def GetElement(self, arg0):
        r"""
        GetElement(self, arg0) -> itkNodePairI2ULL

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2ULL_GetElement(self, arg0)

    def SetElement(self, arg0, arg1):
        r"""
        SetElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI2ULL

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2ULL_SetElement(self, arg0, arg1)

    def InsertElement(self, arg0, arg1):
        r"""
        InsertElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI2ULL

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2ULL_InsertElement(self, arg0, arg1)

    def IndexExists(self, arg0):
        r"""
        IndexExists(self, arg0) -> bool

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2ULL_IndexExists(self, arg0)

    def GetElementIfIndexExists(self, arg0, arg1):
        r"""
        GetElementIfIndexExists(self, arg0, arg1) -> bool

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI2ULL *

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2ULL_GetElementIfIndexExists(self, arg0, arg1)

    def CreateIndex(self, arg0):
        r"""
        CreateIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2ULL_CreateIndex(self, arg0)

    def DeleteIndex(self, arg0):
        r"""
        DeleteIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2ULL_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned long"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2ULL_Size(self)

    def Reserve(self, arg0):
        r"""
        Reserve(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2ULL_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2ULL_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2ULL_Initialize(self)
    __swig_destroy__ = _ITKFastMarchingBasePython.delete_itkVectorContainerULNPI2ULL

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

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

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2ULL_cast(obj)

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

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

          itkVectorContainerULNPI2ULL.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerULNPI2ULL in _ITKFastMarchingBasePython:
_ITKFastMarchingBasePython.itkVectorContainerULNPI2ULL_swigregister(itkVectorContainerULNPI2ULL)

def itkVectorContainerULNPI2US_New():
    return itkVectorContainerULNPI2US.New()

class itkVectorContainerULNPI2US(itk.ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkVectorContainerULNPI2US 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__() -> itkVectorContainerULNPI2US_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2US___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerULNPI2US_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2US_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkNodePairI2US,std::allocator< itkNodePairI2US > > &"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2US_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkNodePairI2US,std::allocator< itkNodePairI2US > > const &"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2US_CastToSTLConstContainer(self)

    def ElementAt(self, *args):
        r"""
        ElementAt(self, arg0) -> itkNodePairI2US

        Parameters
        ----------
        arg0: unsigned long

        ElementAt(self, arg0) -> itkNodePairI2US

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2US_ElementAt(self, *args)

    def CreateElementAt(self, arg0):
        r"""
        CreateElementAt(self, arg0) -> itkNodePairI2US

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2US_CreateElementAt(self, arg0)

    def GetElement(self, arg0):
        r"""
        GetElement(self, arg0) -> itkNodePairI2US

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2US_GetElement(self, arg0)

    def SetElement(self, arg0, arg1):
        r"""
        SetElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI2US

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2US_SetElement(self, arg0, arg1)

    def InsertElement(self, arg0, arg1):
        r"""
        InsertElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI2US

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2US_InsertElement(self, arg0, arg1)

    def IndexExists(self, arg0):
        r"""
        IndexExists(self, arg0) -> bool

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2US_IndexExists(self, arg0)

    def GetElementIfIndexExists(self, arg0, arg1):
        r"""
        GetElementIfIndexExists(self, arg0, arg1) -> bool

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI2US *

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2US_GetElementIfIndexExists(self, arg0, arg1)

    def CreateIndex(self, arg0):
        r"""
        CreateIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2US_CreateIndex(self, arg0)

    def DeleteIndex(self, arg0):
        r"""
        DeleteIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2US_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned long"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2US_Size(self)

    def Reserve(self, arg0):
        r"""
        Reserve(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2US_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2US_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2US_Initialize(self)
    __swig_destroy__ = _ITKFastMarchingBasePython.delete_itkVectorContainerULNPI2US

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

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

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI2US_cast(obj)

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

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

          itkVectorContainerULNPI2US.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerULNPI2US in _ITKFastMarchingBasePython:
_ITKFastMarchingBasePython.itkVectorContainerULNPI2US_swigregister(itkVectorContainerULNPI2US)

def itkVectorContainerULNPI3D_New():
    return itkVectorContainerULNPI3D.New()

class itkVectorContainerULNPI3D(itk.ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkVectorContainerULNPI3D 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__() -> itkVectorContainerULNPI3D_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3D___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerULNPI3D_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3D_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkNodePairI3D,std::allocator< itkNodePairI3D > > &"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3D_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkNodePairI3D,std::allocator< itkNodePairI3D > > const &"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3D_CastToSTLConstContainer(self)

    def ElementAt(self, *args):
        r"""
        ElementAt(self, arg0) -> itkNodePairI3D

        Parameters
        ----------
        arg0: unsigned long

        ElementAt(self, arg0) -> itkNodePairI3D

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3D_ElementAt(self, *args)

    def CreateElementAt(self, arg0):
        r"""
        CreateElementAt(self, arg0) -> itkNodePairI3D

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3D_CreateElementAt(self, arg0)

    def GetElement(self, arg0):
        r"""
        GetElement(self, arg0) -> itkNodePairI3D

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3D_GetElement(self, arg0)

    def SetElement(self, arg0, arg1):
        r"""
        SetElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI3D

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3D_SetElement(self, arg0, arg1)

    def InsertElement(self, arg0, arg1):
        r"""
        InsertElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI3D

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3D_InsertElement(self, arg0, arg1)

    def IndexExists(self, arg0):
        r"""
        IndexExists(self, arg0) -> bool

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3D_IndexExists(self, arg0)

    def GetElementIfIndexExists(self, arg0, arg1):
        r"""
        GetElementIfIndexExists(self, arg0, arg1) -> bool

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI3D *

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3D_GetElementIfIndexExists(self, arg0, arg1)

    def CreateIndex(self, arg0):
        r"""
        CreateIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3D_CreateIndex(self, arg0)

    def DeleteIndex(self, arg0):
        r"""
        DeleteIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3D_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned long"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3D_Size(self)

    def Reserve(self, arg0):
        r"""
        Reserve(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3D_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3D_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3D_Initialize(self)
    __swig_destroy__ = _ITKFastMarchingBasePython.delete_itkVectorContainerULNPI3D

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

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

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3D_cast(obj)

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

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

          itkVectorContainerULNPI3D.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerULNPI3D in _ITKFastMarchingBasePython:
_ITKFastMarchingBasePython.itkVectorContainerULNPI3D_swigregister(itkVectorContainerULNPI3D)

def itkVectorContainerULNPI3F_New():
    return itkVectorContainerULNPI3F.New()

class itkVectorContainerULNPI3F(itk.ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkVectorContainerULNPI3F 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__() -> itkVectorContainerULNPI3F_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3F___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerULNPI3F_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3F_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkNodePairI3F,std::allocator< itkNodePairI3F > > &"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3F_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkNodePairI3F,std::allocator< itkNodePairI3F > > const &"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3F_CastToSTLConstContainer(self)

    def ElementAt(self, *args):
        r"""
        ElementAt(self, arg0) -> itkNodePairI3F

        Parameters
        ----------
        arg0: unsigned long

        ElementAt(self, arg0) -> itkNodePairI3F

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3F_ElementAt(self, *args)

    def CreateElementAt(self, arg0):
        r"""
        CreateElementAt(self, arg0) -> itkNodePairI3F

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3F_CreateElementAt(self, arg0)

    def GetElement(self, arg0):
        r"""
        GetElement(self, arg0) -> itkNodePairI3F

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3F_GetElement(self, arg0)

    def SetElement(self, arg0, arg1):
        r"""
        SetElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI3F

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3F_SetElement(self, arg0, arg1)

    def InsertElement(self, arg0, arg1):
        r"""
        InsertElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI3F

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3F_InsertElement(self, arg0, arg1)

    def IndexExists(self, arg0):
        r"""
        IndexExists(self, arg0) -> bool

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3F_IndexExists(self, arg0)

    def GetElementIfIndexExists(self, arg0, arg1):
        r"""
        GetElementIfIndexExists(self, arg0, arg1) -> bool

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI3F *

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3F_GetElementIfIndexExists(self, arg0, arg1)

    def CreateIndex(self, arg0):
        r"""
        CreateIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3F_CreateIndex(self, arg0)

    def DeleteIndex(self, arg0):
        r"""
        DeleteIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3F_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned long"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3F_Size(self)

    def Reserve(self, arg0):
        r"""
        Reserve(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3F_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3F_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3F_Initialize(self)
    __swig_destroy__ = _ITKFastMarchingBasePython.delete_itkVectorContainerULNPI3F

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

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

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3F_cast(obj)

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

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

          itkVectorContainerULNPI3F.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerULNPI3F in _ITKFastMarchingBasePython:
_ITKFastMarchingBasePython.itkVectorContainerULNPI3F_swigregister(itkVectorContainerULNPI3F)

def itkVectorContainerULNPI3SC_New():
    return itkVectorContainerULNPI3SC.New()

class itkVectorContainerULNPI3SC(itk.ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkVectorContainerULNPI3SC 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__() -> itkVectorContainerULNPI3SC_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3SC___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerULNPI3SC_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3SC_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkNodePairI3SC,std::allocator< itkNodePairI3SC > > &"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3SC_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkNodePairI3SC,std::allocator< itkNodePairI3SC > > const &"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3SC_CastToSTLConstContainer(self)

    def ElementAt(self, *args):
        r"""
        ElementAt(self, arg0) -> itkNodePairI3SC

        Parameters
        ----------
        arg0: unsigned long

        ElementAt(self, arg0) -> itkNodePairI3SC

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3SC_ElementAt(self, *args)

    def CreateElementAt(self, arg0):
        r"""
        CreateElementAt(self, arg0) -> itkNodePairI3SC

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3SC_CreateElementAt(self, arg0)

    def GetElement(self, arg0):
        r"""
        GetElement(self, arg0) -> itkNodePairI3SC

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3SC_GetElement(self, arg0)

    def SetElement(self, arg0, arg1):
        r"""
        SetElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI3SC

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3SC_SetElement(self, arg0, arg1)

    def InsertElement(self, arg0, arg1):
        r"""
        InsertElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI3SC

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3SC_InsertElement(self, arg0, arg1)

    def IndexExists(self, arg0):
        r"""
        IndexExists(self, arg0) -> bool

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3SC_IndexExists(self, arg0)

    def GetElementIfIndexExists(self, arg0, arg1):
        r"""
        GetElementIfIndexExists(self, arg0, arg1) -> bool

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI3SC *

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3SC_GetElementIfIndexExists(self, arg0, arg1)

    def CreateIndex(self, arg0):
        r"""
        CreateIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3SC_CreateIndex(self, arg0)

    def DeleteIndex(self, arg0):
        r"""
        DeleteIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3SC_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned long"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3SC_Size(self)

    def Reserve(self, arg0):
        r"""
        Reserve(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3SC_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3SC_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3SC_Initialize(self)
    __swig_destroy__ = _ITKFastMarchingBasePython.delete_itkVectorContainerULNPI3SC

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

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

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3SC_cast(obj)

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

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

          itkVectorContainerULNPI3SC.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerULNPI3SC in _ITKFastMarchingBasePython:
_ITKFastMarchingBasePython.itkVectorContainerULNPI3SC_swigregister(itkVectorContainerULNPI3SC)

def itkVectorContainerULNPI3SS_New():
    return itkVectorContainerULNPI3SS.New()

class itkVectorContainerULNPI3SS(itk.ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkVectorContainerULNPI3SS 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__() -> itkVectorContainerULNPI3SS_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3SS___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerULNPI3SS_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3SS_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkNodePairI3SS,std::allocator< itkNodePairI3SS > > &"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3SS_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkNodePairI3SS,std::allocator< itkNodePairI3SS > > const &"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3SS_CastToSTLConstContainer(self)

    def ElementAt(self, *args):
        r"""
        ElementAt(self, arg0) -> itkNodePairI3SS

        Parameters
        ----------
        arg0: unsigned long

        ElementAt(self, arg0) -> itkNodePairI3SS

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3SS_ElementAt(self, *args)

    def CreateElementAt(self, arg0):
        r"""
        CreateElementAt(self, arg0) -> itkNodePairI3SS

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3SS_CreateElementAt(self, arg0)

    def GetElement(self, arg0):
        r"""
        GetElement(self, arg0) -> itkNodePairI3SS

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3SS_GetElement(self, arg0)

    def SetElement(self, arg0, arg1):
        r"""
        SetElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI3SS

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3SS_SetElement(self, arg0, arg1)

    def InsertElement(self, arg0, arg1):
        r"""
        InsertElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI3SS

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3SS_InsertElement(self, arg0, arg1)

    def IndexExists(self, arg0):
        r"""
        IndexExists(self, arg0) -> bool

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3SS_IndexExists(self, arg0)

    def GetElementIfIndexExists(self, arg0, arg1):
        r"""
        GetElementIfIndexExists(self, arg0, arg1) -> bool

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI3SS *

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3SS_GetElementIfIndexExists(self, arg0, arg1)

    def CreateIndex(self, arg0):
        r"""
        CreateIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3SS_CreateIndex(self, arg0)

    def DeleteIndex(self, arg0):
        r"""
        DeleteIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3SS_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned long"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3SS_Size(self)

    def Reserve(self, arg0):
        r"""
        Reserve(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3SS_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3SS_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3SS_Initialize(self)
    __swig_destroy__ = _ITKFastMarchingBasePython.delete_itkVectorContainerULNPI3SS

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

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

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3SS_cast(obj)

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

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

          itkVectorContainerULNPI3SS.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerULNPI3SS in _ITKFastMarchingBasePython:
_ITKFastMarchingBasePython.itkVectorContainerULNPI3SS_swigregister(itkVectorContainerULNPI3SS)

def itkVectorContainerULNPI3UC_New():
    return itkVectorContainerULNPI3UC.New()

class itkVectorContainerULNPI3UC(itk.ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkVectorContainerULNPI3UC 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__() -> itkVectorContainerULNPI3UC_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3UC___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerULNPI3UC_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3UC_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkNodePairI3UC,std::allocator< itkNodePairI3UC > > &"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3UC_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkNodePairI3UC,std::allocator< itkNodePairI3UC > > const &"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3UC_CastToSTLConstContainer(self)

    def ElementAt(self, *args):
        r"""
        ElementAt(self, arg0) -> itkNodePairI3UC

        Parameters
        ----------
        arg0: unsigned long

        ElementAt(self, arg0) -> itkNodePairI3UC

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3UC_ElementAt(self, *args)

    def CreateElementAt(self, arg0):
        r"""
        CreateElementAt(self, arg0) -> itkNodePairI3UC

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3UC_CreateElementAt(self, arg0)

    def GetElement(self, arg0):
        r"""
        GetElement(self, arg0) -> itkNodePairI3UC

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3UC_GetElement(self, arg0)

    def SetElement(self, arg0, arg1):
        r"""
        SetElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI3UC

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3UC_SetElement(self, arg0, arg1)

    def InsertElement(self, arg0, arg1):
        r"""
        InsertElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI3UC

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3UC_InsertElement(self, arg0, arg1)

    def IndexExists(self, arg0):
        r"""
        IndexExists(self, arg0) -> bool

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3UC_IndexExists(self, arg0)

    def GetElementIfIndexExists(self, arg0, arg1):
        r"""
        GetElementIfIndexExists(self, arg0, arg1) -> bool

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI3UC *

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3UC_GetElementIfIndexExists(self, arg0, arg1)

    def CreateIndex(self, arg0):
        r"""
        CreateIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3UC_CreateIndex(self, arg0)

    def DeleteIndex(self, arg0):
        r"""
        DeleteIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3UC_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned long"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3UC_Size(self)

    def Reserve(self, arg0):
        r"""
        Reserve(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3UC_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3UC_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3UC_Initialize(self)
    __swig_destroy__ = _ITKFastMarchingBasePython.delete_itkVectorContainerULNPI3UC

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

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

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3UC_cast(obj)

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

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

          itkVectorContainerULNPI3UC.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerULNPI3UC in _ITKFastMarchingBasePython:
_ITKFastMarchingBasePython.itkVectorContainerULNPI3UC_swigregister(itkVectorContainerULNPI3UC)

def itkVectorContainerULNPI3ULL_New():
    return itkVectorContainerULNPI3ULL.New()

class itkVectorContainerULNPI3ULL(itk.ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkVectorContainerULNPI3ULL 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__() -> itkVectorContainerULNPI3ULL_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3ULL___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerULNPI3ULL_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3ULL_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkNodePairI3ULL,std::allocator< itkNodePairI3ULL > > &"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3ULL_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkNodePairI3ULL,std::allocator< itkNodePairI3ULL > > const &"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3ULL_CastToSTLConstContainer(self)

    def ElementAt(self, *args):
        r"""
        ElementAt(self, arg0) -> itkNodePairI3ULL

        Parameters
        ----------
        arg0: unsigned long

        ElementAt(self, arg0) -> itkNodePairI3ULL

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3ULL_ElementAt(self, *args)

    def CreateElementAt(self, arg0):
        r"""
        CreateElementAt(self, arg0) -> itkNodePairI3ULL

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3ULL_CreateElementAt(self, arg0)

    def GetElement(self, arg0):
        r"""
        GetElement(self, arg0) -> itkNodePairI3ULL

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3ULL_GetElement(self, arg0)

    def SetElement(self, arg0, arg1):
        r"""
        SetElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI3ULL

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3ULL_SetElement(self, arg0, arg1)

    def InsertElement(self, arg0, arg1):
        r"""
        InsertElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI3ULL

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3ULL_InsertElement(self, arg0, arg1)

    def IndexExists(self, arg0):
        r"""
        IndexExists(self, arg0) -> bool

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3ULL_IndexExists(self, arg0)

    def GetElementIfIndexExists(self, arg0, arg1):
        r"""
        GetElementIfIndexExists(self, arg0, arg1) -> bool

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI3ULL *

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3ULL_GetElementIfIndexExists(self, arg0, arg1)

    def CreateIndex(self, arg0):
        r"""
        CreateIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3ULL_CreateIndex(self, arg0)

    def DeleteIndex(self, arg0):
        r"""
        DeleteIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3ULL_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned long"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3ULL_Size(self)

    def Reserve(self, arg0):
        r"""
        Reserve(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3ULL_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3ULL_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3ULL_Initialize(self)
    __swig_destroy__ = _ITKFastMarchingBasePython.delete_itkVectorContainerULNPI3ULL

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

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

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3ULL_cast(obj)

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

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

          itkVectorContainerULNPI3ULL.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerULNPI3ULL in _ITKFastMarchingBasePython:
_ITKFastMarchingBasePython.itkVectorContainerULNPI3ULL_swigregister(itkVectorContainerULNPI3ULL)

def itkVectorContainerULNPI3US_New():
    return itkVectorContainerULNPI3US.New()

class itkVectorContainerULNPI3US(itk.ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkVectorContainerULNPI3US 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__() -> itkVectorContainerULNPI3US_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3US___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerULNPI3US_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3US_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkNodePairI3US,std::allocator< itkNodePairI3US > > &"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3US_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkNodePairI3US,std::allocator< itkNodePairI3US > > const &"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3US_CastToSTLConstContainer(self)

    def ElementAt(self, *args):
        r"""
        ElementAt(self, arg0) -> itkNodePairI3US

        Parameters
        ----------
        arg0: unsigned long

        ElementAt(self, arg0) -> itkNodePairI3US

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3US_ElementAt(self, *args)

    def CreateElementAt(self, arg0):
        r"""
        CreateElementAt(self, arg0) -> itkNodePairI3US

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3US_CreateElementAt(self, arg0)

    def GetElement(self, arg0):
        r"""
        GetElement(self, arg0) -> itkNodePairI3US

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3US_GetElement(self, arg0)

    def SetElement(self, arg0, arg1):
        r"""
        SetElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI3US

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3US_SetElement(self, arg0, arg1)

    def InsertElement(self, arg0, arg1):
        r"""
        InsertElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI3US

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3US_InsertElement(self, arg0, arg1)

    def IndexExists(self, arg0):
        r"""
        IndexExists(self, arg0) -> bool

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3US_IndexExists(self, arg0)

    def GetElementIfIndexExists(self, arg0, arg1):
        r"""
        GetElementIfIndexExists(self, arg0, arg1) -> bool

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI3US *

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3US_GetElementIfIndexExists(self, arg0, arg1)

    def CreateIndex(self, arg0):
        r"""
        CreateIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3US_CreateIndex(self, arg0)

    def DeleteIndex(self, arg0):
        r"""
        DeleteIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3US_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned long"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3US_Size(self)

    def Reserve(self, arg0):
        r"""
        Reserve(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3US_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3US_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3US_Initialize(self)
    __swig_destroy__ = _ITKFastMarchingBasePython.delete_itkVectorContainerULNPI3US

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

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

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI3US_cast(obj)

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

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

          itkVectorContainerULNPI3US.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerULNPI3US in _ITKFastMarchingBasePython:
_ITKFastMarchingBasePython.itkVectorContainerULNPI3US_swigregister(itkVectorContainerULNPI3US)

def itkVectorContainerULNPI4D_New():
    return itkVectorContainerULNPI4D.New()

class itkVectorContainerULNPI4D(itk.ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkVectorContainerULNPI4D 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__() -> itkVectorContainerULNPI4D_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4D___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerULNPI4D_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4D_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkNodePairI4D,std::allocator< itkNodePairI4D > > &"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4D_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkNodePairI4D,std::allocator< itkNodePairI4D > > const &"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4D_CastToSTLConstContainer(self)

    def ElementAt(self, *args):
        r"""
        ElementAt(self, arg0) -> itkNodePairI4D

        Parameters
        ----------
        arg0: unsigned long

        ElementAt(self, arg0) -> itkNodePairI4D

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4D_ElementAt(self, *args)

    def CreateElementAt(self, arg0):
        r"""
        CreateElementAt(self, arg0) -> itkNodePairI4D

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4D_CreateElementAt(self, arg0)

    def GetElement(self, arg0):
        r"""
        GetElement(self, arg0) -> itkNodePairI4D

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4D_GetElement(self, arg0)

    def SetElement(self, arg0, arg1):
        r"""
        SetElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI4D

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4D_SetElement(self, arg0, arg1)

    def InsertElement(self, arg0, arg1):
        r"""
        InsertElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI4D

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4D_InsertElement(self, arg0, arg1)

    def IndexExists(self, arg0):
        r"""
        IndexExists(self, arg0) -> bool

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4D_IndexExists(self, arg0)

    def GetElementIfIndexExists(self, arg0, arg1):
        r"""
        GetElementIfIndexExists(self, arg0, arg1) -> bool

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI4D *

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4D_GetElementIfIndexExists(self, arg0, arg1)

    def CreateIndex(self, arg0):
        r"""
        CreateIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4D_CreateIndex(self, arg0)

    def DeleteIndex(self, arg0):
        r"""
        DeleteIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4D_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned long"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4D_Size(self)

    def Reserve(self, arg0):
        r"""
        Reserve(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4D_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4D_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4D_Initialize(self)
    __swig_destroy__ = _ITKFastMarchingBasePython.delete_itkVectorContainerULNPI4D

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

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

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4D_cast(obj)

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

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

          itkVectorContainerULNPI4D.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerULNPI4D in _ITKFastMarchingBasePython:
_ITKFastMarchingBasePython.itkVectorContainerULNPI4D_swigregister(itkVectorContainerULNPI4D)

def itkVectorContainerULNPI4F_New():
    return itkVectorContainerULNPI4F.New()

class itkVectorContainerULNPI4F(itk.ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkVectorContainerULNPI4F 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__() -> itkVectorContainerULNPI4F_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4F___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerULNPI4F_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4F_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkNodePairI4F,std::allocator< itkNodePairI4F > > &"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4F_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkNodePairI4F,std::allocator< itkNodePairI4F > > const &"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4F_CastToSTLConstContainer(self)

    def ElementAt(self, *args):
        r"""
        ElementAt(self, arg0) -> itkNodePairI4F

        Parameters
        ----------
        arg0: unsigned long

        ElementAt(self, arg0) -> itkNodePairI4F

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4F_ElementAt(self, *args)

    def CreateElementAt(self, arg0):
        r"""
        CreateElementAt(self, arg0) -> itkNodePairI4F

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4F_CreateElementAt(self, arg0)

    def GetElement(self, arg0):
        r"""
        GetElement(self, arg0) -> itkNodePairI4F

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4F_GetElement(self, arg0)

    def SetElement(self, arg0, arg1):
        r"""
        SetElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI4F

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4F_SetElement(self, arg0, arg1)

    def InsertElement(self, arg0, arg1):
        r"""
        InsertElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI4F

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4F_InsertElement(self, arg0, arg1)

    def IndexExists(self, arg0):
        r"""
        IndexExists(self, arg0) -> bool

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4F_IndexExists(self, arg0)

    def GetElementIfIndexExists(self, arg0, arg1):
        r"""
        GetElementIfIndexExists(self, arg0, arg1) -> bool

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI4F *

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4F_GetElementIfIndexExists(self, arg0, arg1)

    def CreateIndex(self, arg0):
        r"""
        CreateIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4F_CreateIndex(self, arg0)

    def DeleteIndex(self, arg0):
        r"""
        DeleteIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4F_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned long"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4F_Size(self)

    def Reserve(self, arg0):
        r"""
        Reserve(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4F_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4F_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4F_Initialize(self)
    __swig_destroy__ = _ITKFastMarchingBasePython.delete_itkVectorContainerULNPI4F

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

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

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4F_cast(obj)

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

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

          itkVectorContainerULNPI4F.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerULNPI4F in _ITKFastMarchingBasePython:
_ITKFastMarchingBasePython.itkVectorContainerULNPI4F_swigregister(itkVectorContainerULNPI4F)

def itkVectorContainerULNPI4SC_New():
    return itkVectorContainerULNPI4SC.New()

class itkVectorContainerULNPI4SC(itk.ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkVectorContainerULNPI4SC 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__() -> itkVectorContainerULNPI4SC_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4SC___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerULNPI4SC_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4SC_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkNodePairI4SC,std::allocator< itkNodePairI4SC > > &"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4SC_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkNodePairI4SC,std::allocator< itkNodePairI4SC > > const &"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4SC_CastToSTLConstContainer(self)

    def ElementAt(self, *args):
        r"""
        ElementAt(self, arg0) -> itkNodePairI4SC

        Parameters
        ----------
        arg0: unsigned long

        ElementAt(self, arg0) -> itkNodePairI4SC

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4SC_ElementAt(self, *args)

    def CreateElementAt(self, arg0):
        r"""
        CreateElementAt(self, arg0) -> itkNodePairI4SC

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4SC_CreateElementAt(self, arg0)

    def GetElement(self, arg0):
        r"""
        GetElement(self, arg0) -> itkNodePairI4SC

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4SC_GetElement(self, arg0)

    def SetElement(self, arg0, arg1):
        r"""
        SetElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI4SC

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4SC_SetElement(self, arg0, arg1)

    def InsertElement(self, arg0, arg1):
        r"""
        InsertElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI4SC

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4SC_InsertElement(self, arg0, arg1)

    def IndexExists(self, arg0):
        r"""
        IndexExists(self, arg0) -> bool

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4SC_IndexExists(self, arg0)

    def GetElementIfIndexExists(self, arg0, arg1):
        r"""
        GetElementIfIndexExists(self, arg0, arg1) -> bool

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI4SC *

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4SC_GetElementIfIndexExists(self, arg0, arg1)

    def CreateIndex(self, arg0):
        r"""
        CreateIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4SC_CreateIndex(self, arg0)

    def DeleteIndex(self, arg0):
        r"""
        DeleteIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4SC_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned long"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4SC_Size(self)

    def Reserve(self, arg0):
        r"""
        Reserve(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4SC_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4SC_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4SC_Initialize(self)
    __swig_destroy__ = _ITKFastMarchingBasePython.delete_itkVectorContainerULNPI4SC

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

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

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4SC_cast(obj)

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

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

          itkVectorContainerULNPI4SC.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerULNPI4SC in _ITKFastMarchingBasePython:
_ITKFastMarchingBasePython.itkVectorContainerULNPI4SC_swigregister(itkVectorContainerULNPI4SC)

def itkVectorContainerULNPI4SS_New():
    return itkVectorContainerULNPI4SS.New()

class itkVectorContainerULNPI4SS(itk.ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkVectorContainerULNPI4SS 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__() -> itkVectorContainerULNPI4SS_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4SS___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerULNPI4SS_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4SS_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkNodePairI4SS,std::allocator< itkNodePairI4SS > > &"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4SS_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkNodePairI4SS,std::allocator< itkNodePairI4SS > > const &"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4SS_CastToSTLConstContainer(self)

    def ElementAt(self, *args):
        r"""
        ElementAt(self, arg0) -> itkNodePairI4SS

        Parameters
        ----------
        arg0: unsigned long

        ElementAt(self, arg0) -> itkNodePairI4SS

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4SS_ElementAt(self, *args)

    def CreateElementAt(self, arg0):
        r"""
        CreateElementAt(self, arg0) -> itkNodePairI4SS

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4SS_CreateElementAt(self, arg0)

    def GetElement(self, arg0):
        r"""
        GetElement(self, arg0) -> itkNodePairI4SS

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4SS_GetElement(self, arg0)

    def SetElement(self, arg0, arg1):
        r"""
        SetElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI4SS

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4SS_SetElement(self, arg0, arg1)

    def InsertElement(self, arg0, arg1):
        r"""
        InsertElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI4SS

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4SS_InsertElement(self, arg0, arg1)

    def IndexExists(self, arg0):
        r"""
        IndexExists(self, arg0) -> bool

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4SS_IndexExists(self, arg0)

    def GetElementIfIndexExists(self, arg0, arg1):
        r"""
        GetElementIfIndexExists(self, arg0, arg1) -> bool

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI4SS *

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4SS_GetElementIfIndexExists(self, arg0, arg1)

    def CreateIndex(self, arg0):
        r"""
        CreateIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4SS_CreateIndex(self, arg0)

    def DeleteIndex(self, arg0):
        r"""
        DeleteIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4SS_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned long"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4SS_Size(self)

    def Reserve(self, arg0):
        r"""
        Reserve(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4SS_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4SS_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4SS_Initialize(self)
    __swig_destroy__ = _ITKFastMarchingBasePython.delete_itkVectorContainerULNPI4SS

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

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

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4SS_cast(obj)

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

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

          itkVectorContainerULNPI4SS.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerULNPI4SS in _ITKFastMarchingBasePython:
_ITKFastMarchingBasePython.itkVectorContainerULNPI4SS_swigregister(itkVectorContainerULNPI4SS)

def itkVectorContainerULNPI4UC_New():
    return itkVectorContainerULNPI4UC.New()

class itkVectorContainerULNPI4UC(itk.ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkVectorContainerULNPI4UC 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__() -> itkVectorContainerULNPI4UC_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4UC___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerULNPI4UC_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4UC_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkNodePairI4UC,std::allocator< itkNodePairI4UC > > &"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4UC_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkNodePairI4UC,std::allocator< itkNodePairI4UC > > const &"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4UC_CastToSTLConstContainer(self)

    def ElementAt(self, *args):
        r"""
        ElementAt(self, arg0) -> itkNodePairI4UC

        Parameters
        ----------
        arg0: unsigned long

        ElementAt(self, arg0) -> itkNodePairI4UC

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4UC_ElementAt(self, *args)

    def CreateElementAt(self, arg0):
        r"""
        CreateElementAt(self, arg0) -> itkNodePairI4UC

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4UC_CreateElementAt(self, arg0)

    def GetElement(self, arg0):
        r"""
        GetElement(self, arg0) -> itkNodePairI4UC

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4UC_GetElement(self, arg0)

    def SetElement(self, arg0, arg1):
        r"""
        SetElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI4UC

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4UC_SetElement(self, arg0, arg1)

    def InsertElement(self, arg0, arg1):
        r"""
        InsertElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI4UC

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4UC_InsertElement(self, arg0, arg1)

    def IndexExists(self, arg0):
        r"""
        IndexExists(self, arg0) -> bool

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4UC_IndexExists(self, arg0)

    def GetElementIfIndexExists(self, arg0, arg1):
        r"""
        GetElementIfIndexExists(self, arg0, arg1) -> bool

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI4UC *

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4UC_GetElementIfIndexExists(self, arg0, arg1)

    def CreateIndex(self, arg0):
        r"""
        CreateIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4UC_CreateIndex(self, arg0)

    def DeleteIndex(self, arg0):
        r"""
        DeleteIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4UC_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned long"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4UC_Size(self)

    def Reserve(self, arg0):
        r"""
        Reserve(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4UC_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4UC_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4UC_Initialize(self)
    __swig_destroy__ = _ITKFastMarchingBasePython.delete_itkVectorContainerULNPI4UC

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

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

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4UC_cast(obj)

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

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

          itkVectorContainerULNPI4UC.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerULNPI4UC in _ITKFastMarchingBasePython:
_ITKFastMarchingBasePython.itkVectorContainerULNPI4UC_swigregister(itkVectorContainerULNPI4UC)

def itkVectorContainerULNPI4ULL_New():
    return itkVectorContainerULNPI4ULL.New()

class itkVectorContainerULNPI4ULL(itk.ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkVectorContainerULNPI4ULL 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__() -> itkVectorContainerULNPI4ULL_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4ULL___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerULNPI4ULL_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4ULL_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkNodePairI4ULL,std::allocator< itkNodePairI4ULL > > &"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4ULL_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkNodePairI4ULL,std::allocator< itkNodePairI4ULL > > const &"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4ULL_CastToSTLConstContainer(self)

    def ElementAt(self, *args):
        r"""
        ElementAt(self, arg0) -> itkNodePairI4ULL

        Parameters
        ----------
        arg0: unsigned long

        ElementAt(self, arg0) -> itkNodePairI4ULL

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4ULL_ElementAt(self, *args)

    def CreateElementAt(self, arg0):
        r"""
        CreateElementAt(self, arg0) -> itkNodePairI4ULL

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4ULL_CreateElementAt(self, arg0)

    def GetElement(self, arg0):
        r"""
        GetElement(self, arg0) -> itkNodePairI4ULL

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4ULL_GetElement(self, arg0)

    def SetElement(self, arg0, arg1):
        r"""
        SetElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI4ULL

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4ULL_SetElement(self, arg0, arg1)

    def InsertElement(self, arg0, arg1):
        r"""
        InsertElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI4ULL

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4ULL_InsertElement(self, arg0, arg1)

    def IndexExists(self, arg0):
        r"""
        IndexExists(self, arg0) -> bool

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4ULL_IndexExists(self, arg0)

    def GetElementIfIndexExists(self, arg0, arg1):
        r"""
        GetElementIfIndexExists(self, arg0, arg1) -> bool

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI4ULL *

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4ULL_GetElementIfIndexExists(self, arg0, arg1)

    def CreateIndex(self, arg0):
        r"""
        CreateIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4ULL_CreateIndex(self, arg0)

    def DeleteIndex(self, arg0):
        r"""
        DeleteIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4ULL_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned long"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4ULL_Size(self)

    def Reserve(self, arg0):
        r"""
        Reserve(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4ULL_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4ULL_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4ULL_Initialize(self)
    __swig_destroy__ = _ITKFastMarchingBasePython.delete_itkVectorContainerULNPI4ULL

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

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

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4ULL_cast(obj)

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

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

          itkVectorContainerULNPI4ULL.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerULNPI4ULL in _ITKFastMarchingBasePython:
_ITKFastMarchingBasePython.itkVectorContainerULNPI4ULL_swigregister(itkVectorContainerULNPI4ULL)

def itkVectorContainerULNPI4US_New():
    return itkVectorContainerULNPI4US.New()

class itkVectorContainerULNPI4US(itk.ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkVectorContainerULNPI4US 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__() -> itkVectorContainerULNPI4US_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4US___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVectorContainerULNPI4US_Pointer"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4US_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::vector< itkNodePairI4US,std::allocator< itkNodePairI4US > > &"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4US_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::vector< itkNodePairI4US,std::allocator< itkNodePairI4US > > const &"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4US_CastToSTLConstContainer(self)

    def ElementAt(self, *args):
        r"""
        ElementAt(self, arg0) -> itkNodePairI4US

        Parameters
        ----------
        arg0: unsigned long

        ElementAt(self, arg0) -> itkNodePairI4US

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4US_ElementAt(self, *args)

    def CreateElementAt(self, arg0):
        r"""
        CreateElementAt(self, arg0) -> itkNodePairI4US

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4US_CreateElementAt(self, arg0)

    def GetElement(self, arg0):
        r"""
        GetElement(self, arg0) -> itkNodePairI4US

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4US_GetElement(self, arg0)

    def SetElement(self, arg0, arg1):
        r"""
        SetElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI4US

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4US_SetElement(self, arg0, arg1)

    def InsertElement(self, arg0, arg1):
        r"""
        InsertElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI4US

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4US_InsertElement(self, arg0, arg1)

    def IndexExists(self, arg0):
        r"""
        IndexExists(self, arg0) -> bool

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4US_IndexExists(self, arg0)

    def GetElementIfIndexExists(self, arg0, arg1):
        r"""
        GetElementIfIndexExists(self, arg0, arg1) -> bool

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkNodePairI4US *

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4US_GetElementIfIndexExists(self, arg0, arg1)

    def CreateIndex(self, arg0):
        r"""
        CreateIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4US_CreateIndex(self, arg0)

    def DeleteIndex(self, arg0):
        r"""
        DeleteIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4US_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned long"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4US_Size(self)

    def Reserve(self, arg0):
        r"""
        Reserve(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4US_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4US_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4US_Initialize(self)
    __swig_destroy__ = _ITKFastMarchingBasePython.delete_itkVectorContainerULNPI4US

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

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

        """
        return _ITKFastMarchingBasePython.itkVectorContainerULNPI4US_cast(obj)

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

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

          itkVectorContainerULNPI4US.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkVectorContainerULNPI4US in _ITKFastMarchingBasePython:
_ITKFastMarchingBasePython.itkVectorContainerULNPI4US_swigregister(itkVectorContainerULNPI4US)

