# 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 itkImagePython
import itkFixedArrayPython
import pyBasePython
import itkMatrixPython
import vnl_matrixPython
import vnl_vectorPython
import stdcomplexPython
import itkPointPython
import itkVectorPython
import vnl_vector_refPython
import itkCovariantVectorPython
import vnl_matrix_fixedPython
import itkIndexPython
import itkOffsetPython
import itkSizePython
import ITKCommonBasePython
import itkSymmetricSecondRankTensorPython
import itkRGBAPixelPython
import itkImageRegionPython
import itkRGBPixelPython
import itkQuadEdgeMeshPointPython
import itkGeometricalQuadEdgePython
import itkQuadEdgePython
import itkQuadEdgeCellTraitsInfoPython
import itkQuadEdgeMeshLineCellPython
import itkArrayPython
import itkMapContainerPython

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)

