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

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

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

_swig_new_instance_method = _itkQuadEdgeMeshBasePython.SWIG_PyInstanceMethod_New
_swig_new_static_method = _itkQuadEdgeMeshBasePython.SWIG_PyStaticMethod_New

def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except __builtin__.Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "this":
            set(self, name, value)
        elif name == "thisown":
            self.this.own(value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)


import itkMapContainerPython
import itkPointPython
import vnl_vector_refPython
import stdcomplexPython
import pyBasePython
import vnl_vectorPython
import vnl_matrixPython
import itkVectorPython
import itkFixedArrayPython
import ITKCommonBasePython
import itkQuadEdgeCellTraitsInfoPython
import itkQuadEdgeMeshPointPython
import itkGeometricalQuadEdgePython
import itkQuadEdgePython
import itkImagePython
import itkMatrixPython
import itkCovariantVectorPython
import vnl_matrix_fixedPython
import itkSizePython
import itkIndexPython
import itkOffsetPython
import itkRGBAPixelPython
import itkRGBPixelPython
import itkSymmetricSecondRankTensorPython
import itkImageRegionPython
import itkQuadEdgeMeshLineCellPython
import itkArrayPython

def itkImageToMeshFilterIUC3MD3QEMTD3BBFF_New():
  return itkImageToMeshFilterIUC3MD3QEMTD3BBFF.New()


def itkImageToMeshFilterISS3MD3QEMTD3BBFF_New():
  return itkImageToMeshFilterISS3MD3QEMTD3BBFF.New()


def itkImageToMeshFilterIUC2MD2QEMTD2BBFF_New():
  return itkImageToMeshFilterIUC2MD2QEMTD2BBFF.New()


def itkImageToMeshFilterISS2MD2QEMTD2BBFF_New():
  return itkImageToMeshFilterISS2MD2QEMTD2BBFF.New()


def itkMeshToMeshFilterQEMD3QEMD3_New():
  return itkMeshToMeshFilterQEMD3QEMD3.New()


def itkMeshToMeshFilterQEMD2QEMD2_New():
  return itkMeshToMeshFilterQEMD2QEMD2.New()


def itkMeshSourceMD3QEMTD3BBFF_New():
  return itkMeshSourceMD3QEMTD3BBFF.New()


def itkMeshSourceQEMD3_New():
  return itkMeshSourceQEMD3.New()


def itkMeshSourceMD2QEMTD2BBFF_New():
  return itkMeshSourceMD2QEMTD2BBFF.New()


def itkMeshSourceQEMD2_New():
  return itkMeshSourceQEMD2.New()


def itkQuadEdgeMeshD3_New():
  return itkQuadEdgeMeshD3.New()


def itkQuadEdgeMeshD2_New():
  return itkQuadEdgeMeshD2.New()


def itkBoundingBoxUL3FMCULQEMPF3_New():
  return itkBoundingBoxUL3FMCULQEMPF3.New()


def itkBoundingBoxUL2FMCULQEMPF2_New():
  return itkBoundingBoxUL2FMCULQEMPF2.New()


def itkPointSetD3QEMTD3BBFF_New():
  return itkPointSetD3QEMTD3BBFF.New()


def itkPointSetD2QEMTD2BBFF_New():
  return itkPointSetD2QEMTD2BBFF.New()


def itkMeshD3QEMTD3BBFF_New():
  return itkMeshD3QEMTD3BBFF.New()


def itkMeshD2QEMTD2BBFF_New():
  return itkMeshD2QEMTD2BBFF.New()


def itkMapContainerULCIDQEMCTI3_New():
  return itkMapContainerULCIDQEMCTI3.New()


def itkMapContainerULCIDQEMCTI2_New():
  return itkMapContainerULCIDQEMCTI2.New()

class itkBoundingBoxUL2FMCULQEMPF2(ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkBoundingBoxUL2FMCULQEMPF2 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
    __New_orig__ = _swig_new_static_method(_itkQuadEdgeMeshBasePython.itkBoundingBoxUL2FMCULQEMPF2___New_orig__)
    Clone = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkBoundingBoxUL2FMCULQEMPF2_Clone)
    SetPoints = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkBoundingBoxUL2FMCULQEMPF2_SetPoints)
    GetPoints = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkBoundingBoxUL2FMCULQEMPF2_GetPoints)
    GetCorners = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkBoundingBoxUL2FMCULQEMPF2_GetCorners)
    ComputeBoundingBox = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkBoundingBoxUL2FMCULQEMPF2_ComputeBoundingBox)
    GetBounds = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkBoundingBoxUL2FMCULQEMPF2_GetBounds)
    GetCenter = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkBoundingBoxUL2FMCULQEMPF2_GetCenter)
    GetMinimum = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkBoundingBoxUL2FMCULQEMPF2_GetMinimum)
    SetMinimum = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkBoundingBoxUL2FMCULQEMPF2_SetMinimum)
    GetMaximum = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkBoundingBoxUL2FMCULQEMPF2_GetMaximum)
    SetMaximum = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkBoundingBoxUL2FMCULQEMPF2_SetMaximum)
    ConsiderPoint = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkBoundingBoxUL2FMCULQEMPF2_ConsiderPoint)
    GetDiagonalLength2 = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkBoundingBoxUL2FMCULQEMPF2_GetDiagonalLength2)
    IsInside = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkBoundingBoxUL2FMCULQEMPF2_IsInside)
    DeepCopy = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkBoundingBoxUL2FMCULQEMPF2_DeepCopy)
    __swig_destroy__ = _itkQuadEdgeMeshBasePython.delete_itkBoundingBoxUL2FMCULQEMPF2
    cast = _swig_new_static_method(_itkQuadEdgeMeshBasePython.itkBoundingBoxUL2FMCULQEMPF2_cast)
    GetPointer = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkBoundingBoxUL2FMCULQEMPF2_GetPointer)

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

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

          itkBoundingBoxUL2FMCULQEMPF2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkBoundingBoxUL2FMCULQEMPF2 in _itkQuadEdgeMeshBasePython:
_itkQuadEdgeMeshBasePython.itkBoundingBoxUL2FMCULQEMPF2_swigregister(itkBoundingBoxUL2FMCULQEMPF2)
class itkBoundingBoxUL3FMCULQEMPF3(ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkBoundingBoxUL3FMCULQEMPF3 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
    __New_orig__ = _swig_new_static_method(_itkQuadEdgeMeshBasePython.itkBoundingBoxUL3FMCULQEMPF3___New_orig__)
    Clone = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkBoundingBoxUL3FMCULQEMPF3_Clone)
    SetPoints = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkBoundingBoxUL3FMCULQEMPF3_SetPoints)
    GetPoints = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkBoundingBoxUL3FMCULQEMPF3_GetPoints)
    GetCorners = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkBoundingBoxUL3FMCULQEMPF3_GetCorners)
    ComputeBoundingBox = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkBoundingBoxUL3FMCULQEMPF3_ComputeBoundingBox)
    GetBounds = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkBoundingBoxUL3FMCULQEMPF3_GetBounds)
    GetCenter = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkBoundingBoxUL3FMCULQEMPF3_GetCenter)
    GetMinimum = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkBoundingBoxUL3FMCULQEMPF3_GetMinimum)
    SetMinimum = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkBoundingBoxUL3FMCULQEMPF3_SetMinimum)
    GetMaximum = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkBoundingBoxUL3FMCULQEMPF3_GetMaximum)
    SetMaximum = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkBoundingBoxUL3FMCULQEMPF3_SetMaximum)
    ConsiderPoint = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkBoundingBoxUL3FMCULQEMPF3_ConsiderPoint)
    GetDiagonalLength2 = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkBoundingBoxUL3FMCULQEMPF3_GetDiagonalLength2)
    IsInside = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkBoundingBoxUL3FMCULQEMPF3_IsInside)
    DeepCopy = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkBoundingBoxUL3FMCULQEMPF3_DeepCopy)
    __swig_destroy__ = _itkQuadEdgeMeshBasePython.delete_itkBoundingBoxUL3FMCULQEMPF3
    cast = _swig_new_static_method(_itkQuadEdgeMeshBasePython.itkBoundingBoxUL3FMCULQEMPF3_cast)
    GetPointer = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkBoundingBoxUL3FMCULQEMPF3_GetPointer)

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

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

          itkBoundingBoxUL3FMCULQEMPF3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkBoundingBoxUL3FMCULQEMPF3 in _itkQuadEdgeMeshBasePython:
_itkQuadEdgeMeshBasePython.itkBoundingBoxUL3FMCULQEMPF3_swigregister(itkBoundingBoxUL3FMCULQEMPF3)
class itkMapContainerULCIDQEMCTI2(ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkMapContainerULCIDQEMCTI2 class."""

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

    def __init__(self, *args):
        r"""
        __init__(itkMapContainerULCIDQEMCTI2 self) -> itkMapContainerULCIDQEMCTI2
        __init__(itkMapContainerULCIDQEMCTI2 self, std::less< unsigned long > const & comp) -> itkMapContainerULCIDQEMCTI2
        """
        _itkQuadEdgeMeshBasePython.itkMapContainerULCIDQEMCTI2_swiginit(self, _itkQuadEdgeMeshBasePython.new_itkMapContainerULCIDQEMCTI2(*args))
    __New_orig__ = _swig_new_static_method(_itkQuadEdgeMeshBasePython.itkMapContainerULCIDQEMCTI2___New_orig__)
    Clone = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMapContainerULCIDQEMCTI2_Clone)
    CastToSTLContainer = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMapContainerULCIDQEMCTI2_CastToSTLContainer)
    CastToSTLConstContainer = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMapContainerULCIDQEMCTI2_CastToSTLConstContainer)
    ElementAt = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMapContainerULCIDQEMCTI2_ElementAt)
    CreateElementAt = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMapContainerULCIDQEMCTI2_CreateElementAt)
    GetElement = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMapContainerULCIDQEMCTI2_GetElement)
    SetElement = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMapContainerULCIDQEMCTI2_SetElement)
    InsertElement = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMapContainerULCIDQEMCTI2_InsertElement)
    IndexExists = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMapContainerULCIDQEMCTI2_IndexExists)
    GetElementIfIndexExists = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMapContainerULCIDQEMCTI2_GetElementIfIndexExists)
    CreateIndex = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMapContainerULCIDQEMCTI2_CreateIndex)
    DeleteIndex = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMapContainerULCIDQEMCTI2_DeleteIndex)
    Size = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMapContainerULCIDQEMCTI2_Size)
    Reserve = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMapContainerULCIDQEMCTI2_Reserve)
    Squeeze = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMapContainerULCIDQEMCTI2_Squeeze)
    Initialize = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMapContainerULCIDQEMCTI2_Initialize)
    __swig_destroy__ = _itkQuadEdgeMeshBasePython.delete_itkMapContainerULCIDQEMCTI2
    cast = _swig_new_static_method(_itkQuadEdgeMeshBasePython.itkMapContainerULCIDQEMCTI2_cast)
    GetPointer = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMapContainerULCIDQEMCTI2_GetPointer)

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

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

          itkMapContainerULCIDQEMCTI2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMapContainerULCIDQEMCTI2 in _itkQuadEdgeMeshBasePython:
_itkQuadEdgeMeshBasePython.itkMapContainerULCIDQEMCTI2_swigregister(itkMapContainerULCIDQEMCTI2)
class itkMapContainerULCIDQEMCTI3(ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkMapContainerULCIDQEMCTI3 class."""

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

    def __init__(self, *args):
        r"""
        __init__(itkMapContainerULCIDQEMCTI3 self) -> itkMapContainerULCIDQEMCTI3
        __init__(itkMapContainerULCIDQEMCTI3 self, std::less< unsigned long > const & comp) -> itkMapContainerULCIDQEMCTI3
        """
        _itkQuadEdgeMeshBasePython.itkMapContainerULCIDQEMCTI3_swiginit(self, _itkQuadEdgeMeshBasePython.new_itkMapContainerULCIDQEMCTI3(*args))
    __New_orig__ = _swig_new_static_method(_itkQuadEdgeMeshBasePython.itkMapContainerULCIDQEMCTI3___New_orig__)
    Clone = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMapContainerULCIDQEMCTI3_Clone)
    CastToSTLContainer = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMapContainerULCIDQEMCTI3_CastToSTLContainer)
    CastToSTLConstContainer = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMapContainerULCIDQEMCTI3_CastToSTLConstContainer)
    ElementAt = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMapContainerULCIDQEMCTI3_ElementAt)
    CreateElementAt = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMapContainerULCIDQEMCTI3_CreateElementAt)
    GetElement = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMapContainerULCIDQEMCTI3_GetElement)
    SetElement = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMapContainerULCIDQEMCTI3_SetElement)
    InsertElement = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMapContainerULCIDQEMCTI3_InsertElement)
    IndexExists = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMapContainerULCIDQEMCTI3_IndexExists)
    GetElementIfIndexExists = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMapContainerULCIDQEMCTI3_GetElementIfIndexExists)
    CreateIndex = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMapContainerULCIDQEMCTI3_CreateIndex)
    DeleteIndex = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMapContainerULCIDQEMCTI3_DeleteIndex)
    Size = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMapContainerULCIDQEMCTI3_Size)
    Reserve = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMapContainerULCIDQEMCTI3_Reserve)
    Squeeze = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMapContainerULCIDQEMCTI3_Squeeze)
    Initialize = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMapContainerULCIDQEMCTI3_Initialize)
    __swig_destroy__ = _itkQuadEdgeMeshBasePython.delete_itkMapContainerULCIDQEMCTI3
    cast = _swig_new_static_method(_itkQuadEdgeMeshBasePython.itkMapContainerULCIDQEMCTI3_cast)
    GetPointer = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMapContainerULCIDQEMCTI3_GetPointer)

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

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

          itkMapContainerULCIDQEMCTI3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMapContainerULCIDQEMCTI3 in _itkQuadEdgeMeshBasePython:
_itkQuadEdgeMeshBasePython.itkMapContainerULCIDQEMCTI3_swigregister(itkMapContainerULCIDQEMCTI3)
class itkMeshSourceMD2QEMTD2BBFF(ITKCommonBasePython.itkProcessObject):
    r"""Proxy of C++ itkMeshSourceMD2QEMTD2BBFF 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
    __New_orig__ = _swig_new_static_method(_itkQuadEdgeMeshBasePython.itkMeshSourceMD2QEMTD2BBFF___New_orig__)
    Clone = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshSourceMD2QEMTD2BBFF_Clone)
    GetOutput = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshSourceMD2QEMTD2BBFF_GetOutput)
    SetOutput = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshSourceMD2QEMTD2BBFF_SetOutput)
    GraftOutput = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshSourceMD2QEMTD2BBFF_GraftOutput)
    GraftNthOutput = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshSourceMD2QEMTD2BBFF_GraftNthOutput)
    __swig_destroy__ = _itkQuadEdgeMeshBasePython.delete_itkMeshSourceMD2QEMTD2BBFF
    cast = _swig_new_static_method(_itkQuadEdgeMeshBasePython.itkMeshSourceMD2QEMTD2BBFF_cast)
    GetPointer = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshSourceMD2QEMTD2BBFF_GetPointer)

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

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

          itkMeshSourceMD2QEMTD2BBFF.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMeshSourceMD2QEMTD2BBFF in _itkQuadEdgeMeshBasePython:
_itkQuadEdgeMeshBasePython.itkMeshSourceMD2QEMTD2BBFF_swigregister(itkMeshSourceMD2QEMTD2BBFF)
class itkMeshSourceMD3QEMTD3BBFF(ITKCommonBasePython.itkProcessObject):
    r"""Proxy of C++ itkMeshSourceMD3QEMTD3BBFF 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
    __New_orig__ = _swig_new_static_method(_itkQuadEdgeMeshBasePython.itkMeshSourceMD3QEMTD3BBFF___New_orig__)
    Clone = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshSourceMD3QEMTD3BBFF_Clone)
    GetOutput = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshSourceMD3QEMTD3BBFF_GetOutput)
    SetOutput = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshSourceMD3QEMTD3BBFF_SetOutput)
    GraftOutput = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshSourceMD3QEMTD3BBFF_GraftOutput)
    GraftNthOutput = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshSourceMD3QEMTD3BBFF_GraftNthOutput)
    __swig_destroy__ = _itkQuadEdgeMeshBasePython.delete_itkMeshSourceMD3QEMTD3BBFF
    cast = _swig_new_static_method(_itkQuadEdgeMeshBasePython.itkMeshSourceMD3QEMTD3BBFF_cast)
    GetPointer = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshSourceMD3QEMTD3BBFF_GetPointer)

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

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

          itkMeshSourceMD3QEMTD3BBFF.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMeshSourceMD3QEMTD3BBFF in _itkQuadEdgeMeshBasePython:
_itkQuadEdgeMeshBasePython.itkMeshSourceMD3QEMTD3BBFF_swigregister(itkMeshSourceMD3QEMTD3BBFF)
class itkMeshSourceQEMD2(ITKCommonBasePython.itkProcessObject):
    r"""Proxy of C++ itkMeshSourceQEMD2 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
    __New_orig__ = _swig_new_static_method(_itkQuadEdgeMeshBasePython.itkMeshSourceQEMD2___New_orig__)
    Clone = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshSourceQEMD2_Clone)
    GetOutput = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshSourceQEMD2_GetOutput)
    SetOutput = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshSourceQEMD2_SetOutput)
    GraftOutput = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshSourceQEMD2_GraftOutput)
    GraftNthOutput = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshSourceQEMD2_GraftNthOutput)
    __swig_destroy__ = _itkQuadEdgeMeshBasePython.delete_itkMeshSourceQEMD2
    cast = _swig_new_static_method(_itkQuadEdgeMeshBasePython.itkMeshSourceQEMD2_cast)
    GetPointer = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshSourceQEMD2_GetPointer)

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

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

          itkMeshSourceQEMD2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMeshSourceQEMD2 in _itkQuadEdgeMeshBasePython:
_itkQuadEdgeMeshBasePython.itkMeshSourceQEMD2_swigregister(itkMeshSourceQEMD2)
class itkMeshSourceQEMD3(ITKCommonBasePython.itkProcessObject):
    r"""Proxy of C++ itkMeshSourceQEMD3 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
    __New_orig__ = _swig_new_static_method(_itkQuadEdgeMeshBasePython.itkMeshSourceQEMD3___New_orig__)
    Clone = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshSourceQEMD3_Clone)
    GetOutput = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshSourceQEMD3_GetOutput)
    SetOutput = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshSourceQEMD3_SetOutput)
    GraftOutput = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshSourceQEMD3_GraftOutput)
    GraftNthOutput = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshSourceQEMD3_GraftNthOutput)
    __swig_destroy__ = _itkQuadEdgeMeshBasePython.delete_itkMeshSourceQEMD3
    cast = _swig_new_static_method(_itkQuadEdgeMeshBasePython.itkMeshSourceQEMD3_cast)
    GetPointer = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshSourceQEMD3_GetPointer)

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

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

          itkMeshSourceQEMD3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMeshSourceQEMD3 in _itkQuadEdgeMeshBasePython:
_itkQuadEdgeMeshBasePython.itkMeshSourceQEMD3_swigregister(itkMeshSourceQEMD3)
class itkMeshToMeshFilterQEMD2QEMD2(itkMeshSourceQEMD2):
    r"""Proxy of C++ itkMeshToMeshFilterQEMD2QEMD2 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
    __New_orig__ = _swig_new_static_method(_itkQuadEdgeMeshBasePython.itkMeshToMeshFilterQEMD2QEMD2___New_orig__)
    Clone = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshToMeshFilterQEMD2QEMD2_Clone)
    SetInput = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshToMeshFilterQEMD2QEMD2_SetInput)
    GetInput = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshToMeshFilterQEMD2QEMD2_GetInput)
    __swig_destroy__ = _itkQuadEdgeMeshBasePython.delete_itkMeshToMeshFilterQEMD2QEMD2
    cast = _swig_new_static_method(_itkQuadEdgeMeshBasePython.itkMeshToMeshFilterQEMD2QEMD2_cast)
    GetPointer = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshToMeshFilterQEMD2QEMD2_GetPointer)

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

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

          itkMeshToMeshFilterQEMD2QEMD2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMeshToMeshFilterQEMD2QEMD2 in _itkQuadEdgeMeshBasePython:
_itkQuadEdgeMeshBasePython.itkMeshToMeshFilterQEMD2QEMD2_swigregister(itkMeshToMeshFilterQEMD2QEMD2)
class itkMeshToMeshFilterQEMD3QEMD3(itkMeshSourceQEMD3):
    r"""Proxy of C++ itkMeshToMeshFilterQEMD3QEMD3 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
    __New_orig__ = _swig_new_static_method(_itkQuadEdgeMeshBasePython.itkMeshToMeshFilterQEMD3QEMD3___New_orig__)
    Clone = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshToMeshFilterQEMD3QEMD3_Clone)
    SetInput = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshToMeshFilterQEMD3QEMD3_SetInput)
    GetInput = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshToMeshFilterQEMD3QEMD3_GetInput)
    __swig_destroy__ = _itkQuadEdgeMeshBasePython.delete_itkMeshToMeshFilterQEMD3QEMD3
    cast = _swig_new_static_method(_itkQuadEdgeMeshBasePython.itkMeshToMeshFilterQEMD3QEMD3_cast)
    GetPointer = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshToMeshFilterQEMD3QEMD3_GetPointer)

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

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

          itkMeshToMeshFilterQEMD3QEMD3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMeshToMeshFilterQEMD3QEMD3 in _itkQuadEdgeMeshBasePython:
_itkQuadEdgeMeshBasePython.itkMeshToMeshFilterQEMD3QEMD3_swigregister(itkMeshToMeshFilterQEMD3QEMD3)
class itkPointSetD2QEMTD2BBFF(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkPointSetD2QEMTD2BBFF 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
    __New_orig__ = _swig_new_static_method(_itkQuadEdgeMeshBasePython.itkPointSetD2QEMTD2BBFF___New_orig__)
    Clone = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkPointSetD2QEMTD2BBFF_Clone)
    GetMaximumNumberOfRegions = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkPointSetD2QEMTD2BBFF_GetMaximumNumberOfRegions)
    PassStructure = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkPointSetD2QEMTD2BBFF_PassStructure)
    GetNumberOfPoints = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkPointSetD2QEMTD2BBFF_GetNumberOfPoints)
    SetPoints = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkPointSetD2QEMTD2BBFF_SetPoints)
    GetPoints = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkPointSetD2QEMTD2BBFF_GetPoints)
    SetPoint = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkPointSetD2QEMTD2BBFF_SetPoint)
    GetPoint = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkPointSetD2QEMTD2BBFF_GetPoint)
    SetPointData = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkPointSetD2QEMTD2BBFF_SetPointData)
    GetPointData = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkPointSetD2QEMTD2BBFF_GetPointData)
    SetRequestedRegion = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkPointSetD2QEMTD2BBFF_SetRequestedRegion)
    GetRequestedRegion = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkPointSetD2QEMTD2BBFF_GetRequestedRegion)
    SetBufferedRegion = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkPointSetD2QEMTD2BBFF_SetBufferedRegion)
    GetBufferedRegion = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkPointSetD2QEMTD2BBFF_GetBufferedRegion)
    __swig_destroy__ = _itkQuadEdgeMeshBasePython.delete_itkPointSetD2QEMTD2BBFF
    cast = _swig_new_static_method(_itkQuadEdgeMeshBasePython.itkPointSetD2QEMTD2BBFF_cast)
    GetPointer = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkPointSetD2QEMTD2BBFF_GetPointer)

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

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

          itkPointSetD2QEMTD2BBFF.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkPointSetD2QEMTD2BBFF in _itkQuadEdgeMeshBasePython:
_itkQuadEdgeMeshBasePython.itkPointSetD2QEMTD2BBFF_swigregister(itkPointSetD2QEMTD2BBFF)
class itkPointSetD3QEMTD3BBFF(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkPointSetD3QEMTD3BBFF 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
    __New_orig__ = _swig_new_static_method(_itkQuadEdgeMeshBasePython.itkPointSetD3QEMTD3BBFF___New_orig__)
    Clone = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkPointSetD3QEMTD3BBFF_Clone)
    GetMaximumNumberOfRegions = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkPointSetD3QEMTD3BBFF_GetMaximumNumberOfRegions)
    PassStructure = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkPointSetD3QEMTD3BBFF_PassStructure)
    GetNumberOfPoints = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkPointSetD3QEMTD3BBFF_GetNumberOfPoints)
    SetPoints = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkPointSetD3QEMTD3BBFF_SetPoints)
    GetPoints = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkPointSetD3QEMTD3BBFF_GetPoints)
    SetPoint = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkPointSetD3QEMTD3BBFF_SetPoint)
    GetPoint = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkPointSetD3QEMTD3BBFF_GetPoint)
    SetPointData = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkPointSetD3QEMTD3BBFF_SetPointData)
    GetPointData = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkPointSetD3QEMTD3BBFF_GetPointData)
    SetRequestedRegion = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkPointSetD3QEMTD3BBFF_SetRequestedRegion)
    GetRequestedRegion = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkPointSetD3QEMTD3BBFF_GetRequestedRegion)
    SetBufferedRegion = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkPointSetD3QEMTD3BBFF_SetBufferedRegion)
    GetBufferedRegion = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkPointSetD3QEMTD3BBFF_GetBufferedRegion)
    __swig_destroy__ = _itkQuadEdgeMeshBasePython.delete_itkPointSetD3QEMTD3BBFF
    cast = _swig_new_static_method(_itkQuadEdgeMeshBasePython.itkPointSetD3QEMTD3BBFF_cast)
    GetPointer = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkPointSetD3QEMTD3BBFF_GetPointer)

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

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

          itkPointSetD3QEMTD3BBFF.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkPointSetD3QEMTD3BBFF in _itkQuadEdgeMeshBasePython:
_itkQuadEdgeMeshBasePython.itkPointSetD3QEMTD3BBFF_swigregister(itkPointSetD3QEMTD3BBFF)
class itkImageToMeshFilterISS2MD2QEMTD2BBFF(itkMeshSourceMD2QEMTD2BBFF):
    r"""Proxy of C++ itkImageToMeshFilterISS2MD2QEMTD2BBFF 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
    SetInput = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkImageToMeshFilterISS2MD2QEMTD2BBFF_SetInput)
    GetInput = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkImageToMeshFilterISS2MD2QEMTD2BBFF_GetInput)
    GetOutput = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkImageToMeshFilterISS2MD2QEMTD2BBFF_GetOutput)
    GenerateOutputInformation = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkImageToMeshFilterISS2MD2QEMTD2BBFF_GenerateOutputInformation)
    __swig_destroy__ = _itkQuadEdgeMeshBasePython.delete_itkImageToMeshFilterISS2MD2QEMTD2BBFF
    cast = _swig_new_static_method(_itkQuadEdgeMeshBasePython.itkImageToMeshFilterISS2MD2QEMTD2BBFF_cast)
    GetPointer = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkImageToMeshFilterISS2MD2QEMTD2BBFF_GetPointer)

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

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

          itkImageToMeshFilterISS2MD2QEMTD2BBFF.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToMeshFilterISS2MD2QEMTD2BBFF in _itkQuadEdgeMeshBasePython:
_itkQuadEdgeMeshBasePython.itkImageToMeshFilterISS2MD2QEMTD2BBFF_swigregister(itkImageToMeshFilterISS2MD2QEMTD2BBFF)
class itkImageToMeshFilterISS3MD3QEMTD3BBFF(itkMeshSourceMD3QEMTD3BBFF):
    r"""Proxy of C++ itkImageToMeshFilterISS3MD3QEMTD3BBFF 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
    SetInput = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkImageToMeshFilterISS3MD3QEMTD3BBFF_SetInput)
    GetInput = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkImageToMeshFilterISS3MD3QEMTD3BBFF_GetInput)
    GetOutput = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkImageToMeshFilterISS3MD3QEMTD3BBFF_GetOutput)
    GenerateOutputInformation = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkImageToMeshFilterISS3MD3QEMTD3BBFF_GenerateOutputInformation)
    __swig_destroy__ = _itkQuadEdgeMeshBasePython.delete_itkImageToMeshFilterISS3MD3QEMTD3BBFF
    cast = _swig_new_static_method(_itkQuadEdgeMeshBasePython.itkImageToMeshFilterISS3MD3QEMTD3BBFF_cast)
    GetPointer = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkImageToMeshFilterISS3MD3QEMTD3BBFF_GetPointer)

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

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

          itkImageToMeshFilterISS3MD3QEMTD3BBFF.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToMeshFilterISS3MD3QEMTD3BBFF in _itkQuadEdgeMeshBasePython:
_itkQuadEdgeMeshBasePython.itkImageToMeshFilterISS3MD3QEMTD3BBFF_swigregister(itkImageToMeshFilterISS3MD3QEMTD3BBFF)
class itkImageToMeshFilterIUC2MD2QEMTD2BBFF(itkMeshSourceMD2QEMTD2BBFF):
    r"""Proxy of C++ itkImageToMeshFilterIUC2MD2QEMTD2BBFF 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
    SetInput = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkImageToMeshFilterIUC2MD2QEMTD2BBFF_SetInput)
    GetInput = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkImageToMeshFilterIUC2MD2QEMTD2BBFF_GetInput)
    GetOutput = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkImageToMeshFilterIUC2MD2QEMTD2BBFF_GetOutput)
    GenerateOutputInformation = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkImageToMeshFilterIUC2MD2QEMTD2BBFF_GenerateOutputInformation)
    __swig_destroy__ = _itkQuadEdgeMeshBasePython.delete_itkImageToMeshFilterIUC2MD2QEMTD2BBFF
    cast = _swig_new_static_method(_itkQuadEdgeMeshBasePython.itkImageToMeshFilterIUC2MD2QEMTD2BBFF_cast)
    GetPointer = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkImageToMeshFilterIUC2MD2QEMTD2BBFF_GetPointer)

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

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

          itkImageToMeshFilterIUC2MD2QEMTD2BBFF.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToMeshFilterIUC2MD2QEMTD2BBFF in _itkQuadEdgeMeshBasePython:
_itkQuadEdgeMeshBasePython.itkImageToMeshFilterIUC2MD2QEMTD2BBFF_swigregister(itkImageToMeshFilterIUC2MD2QEMTD2BBFF)
class itkImageToMeshFilterIUC3MD3QEMTD3BBFF(itkMeshSourceMD3QEMTD3BBFF):
    r"""Proxy of C++ itkImageToMeshFilterIUC3MD3QEMTD3BBFF 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
    SetInput = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkImageToMeshFilterIUC3MD3QEMTD3BBFF_SetInput)
    GetInput = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkImageToMeshFilterIUC3MD3QEMTD3BBFF_GetInput)
    GetOutput = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkImageToMeshFilterIUC3MD3QEMTD3BBFF_GetOutput)
    GenerateOutputInformation = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkImageToMeshFilterIUC3MD3QEMTD3BBFF_GenerateOutputInformation)
    __swig_destroy__ = _itkQuadEdgeMeshBasePython.delete_itkImageToMeshFilterIUC3MD3QEMTD3BBFF
    cast = _swig_new_static_method(_itkQuadEdgeMeshBasePython.itkImageToMeshFilterIUC3MD3QEMTD3BBFF_cast)
    GetPointer = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkImageToMeshFilterIUC3MD3QEMTD3BBFF_GetPointer)

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

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

          itkImageToMeshFilterIUC3MD3QEMTD3BBFF.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkImageToMeshFilterIUC3MD3QEMTD3BBFF in _itkQuadEdgeMeshBasePython:
_itkQuadEdgeMeshBasePython.itkImageToMeshFilterIUC3MD3QEMTD3BBFF_swigregister(itkImageToMeshFilterIUC3MD3QEMTD3BBFF)
class itkMeshD2QEMTD2BBFF(itkPointSetD2QEMTD2BBFF):
    r"""Proxy of C++ itkMeshD2QEMTD2BBFF 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
    __New_orig__ = _swig_new_static_method(_itkQuadEdgeMeshBasePython.itkMeshD2QEMTD2BBFF___New_orig__)
    Clone = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshD2QEMTD2BBFF_Clone)
    CellsAllocationMethodUndefined = _itkQuadEdgeMeshBasePython.itkMeshD2QEMTD2BBFF_CellsAllocationMethodUndefined
    
    CellsAllocatedAsStaticArray = _itkQuadEdgeMeshBasePython.itkMeshD2QEMTD2BBFF_CellsAllocatedAsStaticArray
    
    CellsAllocatedAsADynamicArray = _itkQuadEdgeMeshBasePython.itkMeshD2QEMTD2BBFF_CellsAllocatedAsADynamicArray
    
    CellsAllocatedDynamicallyCellByCell = _itkQuadEdgeMeshBasePython.itkMeshD2QEMTD2BBFF_CellsAllocatedDynamicallyCellByCell
    
    GetNumberOfCells = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshD2QEMTD2BBFF_GetNumberOfCells)
    PassStructure = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshD2QEMTD2BBFF_PassStructure)
    GetBoundingBox = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshD2QEMTD2BBFF_GetBoundingBox)
    SetCellLinks = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshD2QEMTD2BBFF_SetCellLinks)
    GetCellLinks = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshD2QEMTD2BBFF_GetCellLinks)
    SetCells = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshD2QEMTD2BBFF_SetCells)
    GetCells = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshD2QEMTD2BBFF_GetCells)
    SetCell = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshD2QEMTD2BBFF_SetCell)
    GetCell = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshD2QEMTD2BBFF_GetCell)
    SetCellData = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshD2QEMTD2BBFF_SetCellData)
    GetCellData = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshD2QEMTD2BBFF_GetCellData)
    SetBoundaryAssignment = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshD2QEMTD2BBFF_SetBoundaryAssignment)
    GetBoundaryAssignment = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshD2QEMTD2BBFF_GetBoundaryAssignment)
    RemoveBoundaryAssignment = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshD2QEMTD2BBFF_RemoveBoundaryAssignment)
    GetNumberOfCellBoundaryFeatures = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshD2QEMTD2BBFF_GetNumberOfCellBoundaryFeatures)
    GetCellBoundaryFeature = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshD2QEMTD2BBFF_GetCellBoundaryFeature)
    GetCellBoundaryFeatureNeighbors = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshD2QEMTD2BBFF_GetCellBoundaryFeatureNeighbors)
    GetCellNeighbors = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshD2QEMTD2BBFF_GetCellNeighbors)
    GetAssignedCellBoundaryIfOneExists = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshD2QEMTD2BBFF_GetAssignedCellBoundaryIfOneExists)
    BuildCellLinks = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshD2QEMTD2BBFF_BuildCellLinks)
    Accept = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshD2QEMTD2BBFF_Accept)
    SetCellsAllocationMethod = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshD2QEMTD2BBFF_SetCellsAllocationMethod)
    GetCellsAllocationMethod = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshD2QEMTD2BBFF_GetCellsAllocationMethod)
    __swig_destroy__ = _itkQuadEdgeMeshBasePython.delete_itkMeshD2QEMTD2BBFF
    cast = _swig_new_static_method(_itkQuadEdgeMeshBasePython.itkMeshD2QEMTD2BBFF_cast)
    GetPointer = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshD2QEMTD2BBFF_GetPointer)

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

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

          itkMeshD2QEMTD2BBFF.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMeshD2QEMTD2BBFF in _itkQuadEdgeMeshBasePython:
_itkQuadEdgeMeshBasePython.itkMeshD2QEMTD2BBFF_swigregister(itkMeshD2QEMTD2BBFF)
class itkMeshD3QEMTD3BBFF(itkPointSetD3QEMTD3BBFF):
    r"""Proxy of C++ itkMeshD3QEMTD3BBFF 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
    __New_orig__ = _swig_new_static_method(_itkQuadEdgeMeshBasePython.itkMeshD3QEMTD3BBFF___New_orig__)
    Clone = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshD3QEMTD3BBFF_Clone)
    CellsAllocationMethodUndefined = _itkQuadEdgeMeshBasePython.itkMeshD3QEMTD3BBFF_CellsAllocationMethodUndefined
    
    CellsAllocatedAsStaticArray = _itkQuadEdgeMeshBasePython.itkMeshD3QEMTD3BBFF_CellsAllocatedAsStaticArray
    
    CellsAllocatedAsADynamicArray = _itkQuadEdgeMeshBasePython.itkMeshD3QEMTD3BBFF_CellsAllocatedAsADynamicArray
    
    CellsAllocatedDynamicallyCellByCell = _itkQuadEdgeMeshBasePython.itkMeshD3QEMTD3BBFF_CellsAllocatedDynamicallyCellByCell
    
    GetNumberOfCells = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshD3QEMTD3BBFF_GetNumberOfCells)
    PassStructure = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshD3QEMTD3BBFF_PassStructure)
    GetBoundingBox = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshD3QEMTD3BBFF_GetBoundingBox)
    SetCellLinks = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshD3QEMTD3BBFF_SetCellLinks)
    GetCellLinks = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshD3QEMTD3BBFF_GetCellLinks)
    SetCells = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshD3QEMTD3BBFF_SetCells)
    GetCells = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshD3QEMTD3BBFF_GetCells)
    SetCell = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshD3QEMTD3BBFF_SetCell)
    GetCell = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshD3QEMTD3BBFF_GetCell)
    SetCellData = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshD3QEMTD3BBFF_SetCellData)
    GetCellData = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshD3QEMTD3BBFF_GetCellData)
    SetBoundaryAssignment = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshD3QEMTD3BBFF_SetBoundaryAssignment)
    GetBoundaryAssignment = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshD3QEMTD3BBFF_GetBoundaryAssignment)
    RemoveBoundaryAssignment = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshD3QEMTD3BBFF_RemoveBoundaryAssignment)
    GetNumberOfCellBoundaryFeatures = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshD3QEMTD3BBFF_GetNumberOfCellBoundaryFeatures)
    GetCellBoundaryFeature = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshD3QEMTD3BBFF_GetCellBoundaryFeature)
    GetCellBoundaryFeatureNeighbors = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshD3QEMTD3BBFF_GetCellBoundaryFeatureNeighbors)
    GetCellNeighbors = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshD3QEMTD3BBFF_GetCellNeighbors)
    GetAssignedCellBoundaryIfOneExists = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshD3QEMTD3BBFF_GetAssignedCellBoundaryIfOneExists)
    BuildCellLinks = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshD3QEMTD3BBFF_BuildCellLinks)
    Accept = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshD3QEMTD3BBFF_Accept)
    SetCellsAllocationMethod = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshD3QEMTD3BBFF_SetCellsAllocationMethod)
    GetCellsAllocationMethod = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshD3QEMTD3BBFF_GetCellsAllocationMethod)
    __swig_destroy__ = _itkQuadEdgeMeshBasePython.delete_itkMeshD3QEMTD3BBFF
    cast = _swig_new_static_method(_itkQuadEdgeMeshBasePython.itkMeshD3QEMTD3BBFF_cast)
    GetPointer = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkMeshD3QEMTD3BBFF_GetPointer)

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

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

          itkMeshD3QEMTD3BBFF.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkMeshD3QEMTD3BBFF in _itkQuadEdgeMeshBasePython:
_itkQuadEdgeMeshBasePython.itkMeshD3QEMTD3BBFF_swigregister(itkMeshD3QEMTD3BBFF)
class itkQuadEdgeMeshD2(itkMeshD2QEMTD2BBFF):
    r"""Proxy of C++ itkQuadEdgeMeshD2 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
    __New_orig__ = _swig_new_static_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD2___New_orig__)
    Clone = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD2_Clone)
    Clear = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD2_Clear)
    GetEdgeCells = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD2_GetEdgeCells)
    SetEdgeCells = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD2_SetEdgeCells)
    SetEdgeCell = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD2_SetEdgeCell)
    SqueezePointsIds = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD2_SqueezePointsIds)
    BuildCellLinks = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD2_BuildCellLinks)
    SetBoundaryAssignment = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD2_SetBoundaryAssignment)
    GetBoundaryAssignment = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD2_GetBoundaryAssignment)
    RemoveBoundaryAssignment = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD2_RemoveBoundaryAssignment)
    GetCellBoundaryFeature = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD2_GetCellBoundaryFeature)
    GetCellBoundaryFeatureNeighbors = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD2_GetCellBoundaryFeatureNeighbors)
    GetCellNeighbors = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD2_GetCellNeighbors)
    GetAssignedCellBoundaryIfOneExists = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD2_GetAssignedCellBoundaryIfOneExists)
    SetCell = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD2_SetCell)
    FindFirstUnusedPointIndex = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD2_FindFirstUnusedPointIndex)
    FindFirstUnusedCellIndex = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD2_FindFirstUnusedCellIndex)
    PushOnContainer = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD2_PushOnContainer)
    AddPoint = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD2_AddPoint)
    AddEdge = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD2_AddEdge)
    AddEdgeWithSecurePointList = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD2_AddEdgeWithSecurePointList)
    AddFace = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD2_AddFace)
    AddFaceWithSecurePointList = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD2_AddFaceWithSecurePointList)
    AddFaceTriangle = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD2_AddFaceTriangle)
    DeletePoint = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD2_DeletePoint)
    DeleteEdge = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD2_DeleteEdge)
    LightWeightDeleteEdge = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD2_LightWeightDeleteEdge)
    DeleteFace = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD2_DeleteFace)
    GetPoint = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD2_GetPoint)
    GetVector = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD2_GetVector)
    GetEdge = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD2_GetEdge)
    FindEdge = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD2_FindEdge)
    FindEdgeCell = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD2_FindEdgeCell)
    ComputeEdgeLength = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD2_ComputeEdgeLength)
    ComputeNumberOfPoints = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD2_ComputeNumberOfPoints)
    ComputeNumberOfFaces = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD2_ComputeNumberOfFaces)
    ComputeNumberOfEdges = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD2_ComputeNumberOfEdges)
    Splice = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD2_Splice)
    ClearFreePointAndCellIndexesLists = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD2_ClearFreePointAndCellIndexesLists)
    GetNumberOfFaces = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD2_GetNumberOfFaces)
    GetNumberOfEdges = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD2_GetNumberOfEdges)
    __swig_destroy__ = _itkQuadEdgeMeshBasePython.delete_itkQuadEdgeMeshD2
    cast = _swig_new_static_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD2_cast)
    GetPointer = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD2_GetPointer)

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

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

          itkQuadEdgeMeshD2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkQuadEdgeMeshD2 in _itkQuadEdgeMeshBasePython:
_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD2_swigregister(itkQuadEdgeMeshD2)
class itkQuadEdgeMeshD3(itkMeshD3QEMTD3BBFF):
    r"""Proxy of C++ itkQuadEdgeMeshD3 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
    __New_orig__ = _swig_new_static_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD3___New_orig__)
    Clone = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD3_Clone)
    Clear = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD3_Clear)
    GetEdgeCells = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD3_GetEdgeCells)
    SetEdgeCells = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD3_SetEdgeCells)
    SetEdgeCell = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD3_SetEdgeCell)
    SqueezePointsIds = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD3_SqueezePointsIds)
    BuildCellLinks = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD3_BuildCellLinks)
    SetBoundaryAssignment = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD3_SetBoundaryAssignment)
    GetBoundaryAssignment = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD3_GetBoundaryAssignment)
    RemoveBoundaryAssignment = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD3_RemoveBoundaryAssignment)
    GetCellBoundaryFeature = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD3_GetCellBoundaryFeature)
    GetCellBoundaryFeatureNeighbors = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD3_GetCellBoundaryFeatureNeighbors)
    GetCellNeighbors = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD3_GetCellNeighbors)
    GetAssignedCellBoundaryIfOneExists = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD3_GetAssignedCellBoundaryIfOneExists)
    SetCell = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD3_SetCell)
    FindFirstUnusedPointIndex = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD3_FindFirstUnusedPointIndex)
    FindFirstUnusedCellIndex = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD3_FindFirstUnusedCellIndex)
    PushOnContainer = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD3_PushOnContainer)
    AddPoint = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD3_AddPoint)
    AddEdge = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD3_AddEdge)
    AddEdgeWithSecurePointList = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD3_AddEdgeWithSecurePointList)
    AddFace = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD3_AddFace)
    AddFaceWithSecurePointList = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD3_AddFaceWithSecurePointList)
    AddFaceTriangle = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD3_AddFaceTriangle)
    DeletePoint = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD3_DeletePoint)
    DeleteEdge = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD3_DeleteEdge)
    LightWeightDeleteEdge = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD3_LightWeightDeleteEdge)
    DeleteFace = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD3_DeleteFace)
    GetPoint = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD3_GetPoint)
    GetVector = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD3_GetVector)
    GetEdge = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD3_GetEdge)
    FindEdge = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD3_FindEdge)
    FindEdgeCell = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD3_FindEdgeCell)
    ComputeEdgeLength = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD3_ComputeEdgeLength)
    ComputeNumberOfPoints = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD3_ComputeNumberOfPoints)
    ComputeNumberOfFaces = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD3_ComputeNumberOfFaces)
    ComputeNumberOfEdges = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD3_ComputeNumberOfEdges)
    Splice = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD3_Splice)
    ClearFreePointAndCellIndexesLists = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD3_ClearFreePointAndCellIndexesLists)
    GetNumberOfFaces = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD3_GetNumberOfFaces)
    GetNumberOfEdges = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD3_GetNumberOfEdges)
    __swig_destroy__ = _itkQuadEdgeMeshBasePython.delete_itkQuadEdgeMeshD3
    cast = _swig_new_static_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD3_cast)
    GetPointer = _swig_new_instance_method(_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD3_GetPointer)

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

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

          itkQuadEdgeMeshD3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkQuadEdgeMeshD3 in _itkQuadEdgeMeshBasePython:
_itkQuadEdgeMeshBasePython.itkQuadEdgeMeshD3_swigregister(itkQuadEdgeMeshD3)

