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

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

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

_swig_new_instance_method = _itkPointSetPython.SWIG_PyInstanceMethod_New
_swig_new_static_method = _itkPointSetPython.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 itkPointPython
import itkVectorPython
import vnl_vectorPython
import stdcomplexPython
import pyBasePython
import vnl_matrixPython
import vnl_vector_refPython
import itkFixedArrayPython
import itkMapContainerPython
import ITKCommonBasePython
import itkMatrixPython
import itkCovariantVectorPython
import vnl_matrix_fixedPython
import itkVectorContainerPython
import itkOffsetPython
import itkSizePython
import itkContinuousIndexPython
import itkIndexPython

def itkPointSetD3DTD33DFD_New():
  return itkPointSetD3DTD33DFD.New()


def itkPointSetD3STD33DFD_New():
  return itkPointSetD3STD33DFD.New()


def itkPointSetD2DTD22DFD_New():
  return itkPointSetD2DTD22DFD.New()


def itkPointSetD2STD22DFD_New():
  return itkPointSetD2STD22DFD.New()


def itkPointSetMD33STMD3333FFMD33_New():
  return itkPointSetMD33STMD3333FFMD33.New()


def itkPointSetMD22STMD2222FFMD22_New():
  return itkPointSetMD22STMD2222FFMD22.New()


def itkPointSetUI3DSMUI33FFUI_New():
  return itkPointSetUI3DSMUI33FFUI.New()


def itkPointSetPD33STD33DD_New():
  return itkPointSetPD33STD33DD.New()


def itkPointSetUI2DSMUI22FFUI_New():
  return itkPointSetUI2DSMUI22FFUI.New()


def itkPointSetPD22STD22DD_New():
  return itkPointSetPD22STD22DD.New()


def itkPointSetD3DTD33DD_New():
  return itkPointSetD3DTD33DD.New()


def itkPointSetD3STD33DD_New():
  return itkPointSetD3STD33DD.New()


def itkPointSetD3STD33_New():
  return itkPointSetD3STD33.New()


def itkPointSetF3DTF33FF_New():
  return itkPointSetF3DTF33FF.New()


def itkPointSetF3STF33FF_New():
  return itkPointSetF3STF33FF.New()


def itkPointSetF3STF33_New():
  return itkPointSetF3STF33.New()


def itkPointSetD2DTD22DD_New():
  return itkPointSetD2DTD22DD.New()


def itkPointSetD2STD22DD_New():
  return itkPointSetD2STD22DD.New()


def itkPointSetD2STD22_New():
  return itkPointSetD2STD22.New()


def itkPointSetF2DTF22FF_New():
  return itkPointSetF2DTF22FF.New()


def itkPointSetF2STF22FF_New():
  return itkPointSetF2STF22FF.New()


def itkPointSetF2STF22_New():
  return itkPointSetF2STF22.New()

class itkPointSetD2DTD22DD(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkPointSetD2DTD22DD 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(_itkPointSetPython.itkPointSetD2DTD22DD___New_orig__)
    Clone = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2DTD22DD_Clone)
    GetMaximumNumberOfRegions = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2DTD22DD_GetMaximumNumberOfRegions)
    PassStructure = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2DTD22DD_PassStructure)
    GetNumberOfPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2DTD22DD_GetNumberOfPoints)
    SetPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2DTD22DD_SetPoints)
    GetPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2DTD22DD_GetPoints)
    SetPoint = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2DTD22DD_SetPoint)
    GetPoint = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2DTD22DD_GetPoint)
    SetPointData = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2DTD22DD_SetPointData)
    GetPointData = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2DTD22DD_GetPointData)
    SetRequestedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2DTD22DD_SetRequestedRegion)
    GetRequestedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2DTD22DD_GetRequestedRegion)
    SetBufferedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2DTD22DD_SetBufferedRegion)
    GetBufferedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2DTD22DD_GetBufferedRegion)
    __swig_destroy__ = _itkPointSetPython.delete_itkPointSetD2DTD22DD
    cast = _swig_new_static_method(_itkPointSetPython.itkPointSetD2DTD22DD_cast)
    GetPointer = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2DTD22DD_GetPointer)

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

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

          itkPointSetD2DTD22DD.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkPointSetD2DTD22DD in _itkPointSetPython:
_itkPointSetPython.itkPointSetD2DTD22DD_swigregister(itkPointSetD2DTD22DD)
class itkPointSetD2DTD22DFD(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkPointSetD2DTD22DFD 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(_itkPointSetPython.itkPointSetD2DTD22DFD___New_orig__)
    Clone = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2DTD22DFD_Clone)
    GetMaximumNumberOfRegions = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2DTD22DFD_GetMaximumNumberOfRegions)
    PassStructure = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2DTD22DFD_PassStructure)
    GetNumberOfPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2DTD22DFD_GetNumberOfPoints)
    SetPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2DTD22DFD_SetPoints)
    GetPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2DTD22DFD_GetPoints)
    SetPoint = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2DTD22DFD_SetPoint)
    GetPoint = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2DTD22DFD_GetPoint)
    SetPointData = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2DTD22DFD_SetPointData)
    GetPointData = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2DTD22DFD_GetPointData)
    SetRequestedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2DTD22DFD_SetRequestedRegion)
    GetRequestedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2DTD22DFD_GetRequestedRegion)
    SetBufferedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2DTD22DFD_SetBufferedRegion)
    GetBufferedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2DTD22DFD_GetBufferedRegion)
    __swig_destroy__ = _itkPointSetPython.delete_itkPointSetD2DTD22DFD
    cast = _swig_new_static_method(_itkPointSetPython.itkPointSetD2DTD22DFD_cast)
    GetPointer = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2DTD22DFD_GetPointer)

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

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

          itkPointSetD2DTD22DFD.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkPointSetD2DTD22DFD in _itkPointSetPython:
_itkPointSetPython.itkPointSetD2DTD22DFD_swigregister(itkPointSetD2DTD22DFD)
class itkPointSetD2STD22(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkPointSetD2STD22 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(_itkPointSetPython.itkPointSetD2STD22___New_orig__)
    Clone = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2STD22_Clone)
    GetMaximumNumberOfRegions = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2STD22_GetMaximumNumberOfRegions)
    PassStructure = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2STD22_PassStructure)
    GetNumberOfPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2STD22_GetNumberOfPoints)
    SetPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2STD22_SetPoints)
    GetPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2STD22_GetPoints)
    SetPoint = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2STD22_SetPoint)
    GetPoint = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2STD22_GetPoint)
    SetPointData = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2STD22_SetPointData)
    GetPointData = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2STD22_GetPointData)
    SetRequestedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2STD22_SetRequestedRegion)
    GetRequestedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2STD22_GetRequestedRegion)
    SetBufferedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2STD22_SetBufferedRegion)
    GetBufferedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2STD22_GetBufferedRegion)
    __swig_destroy__ = _itkPointSetPython.delete_itkPointSetD2STD22
    cast = _swig_new_static_method(_itkPointSetPython.itkPointSetD2STD22_cast)
    GetPointer = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2STD22_GetPointer)

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

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

          itkPointSetD2STD22.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkPointSetD2STD22 in _itkPointSetPython:
_itkPointSetPython.itkPointSetD2STD22_swigregister(itkPointSetD2STD22)
class itkPointSetD2STD22DD(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkPointSetD2STD22DD 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(_itkPointSetPython.itkPointSetD2STD22DD___New_orig__)
    Clone = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2STD22DD_Clone)
    GetMaximumNumberOfRegions = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2STD22DD_GetMaximumNumberOfRegions)
    PassStructure = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2STD22DD_PassStructure)
    GetNumberOfPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2STD22DD_GetNumberOfPoints)
    SetPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2STD22DD_SetPoints)
    GetPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2STD22DD_GetPoints)
    SetPoint = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2STD22DD_SetPoint)
    GetPoint = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2STD22DD_GetPoint)
    SetPointData = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2STD22DD_SetPointData)
    GetPointData = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2STD22DD_GetPointData)
    SetRequestedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2STD22DD_SetRequestedRegion)
    GetRequestedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2STD22DD_GetRequestedRegion)
    SetBufferedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2STD22DD_SetBufferedRegion)
    GetBufferedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2STD22DD_GetBufferedRegion)
    __swig_destroy__ = _itkPointSetPython.delete_itkPointSetD2STD22DD
    cast = _swig_new_static_method(_itkPointSetPython.itkPointSetD2STD22DD_cast)
    GetPointer = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2STD22DD_GetPointer)

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

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

          itkPointSetD2STD22DD.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkPointSetD2STD22DD in _itkPointSetPython:
_itkPointSetPython.itkPointSetD2STD22DD_swigregister(itkPointSetD2STD22DD)
class itkPointSetD2STD22DFD(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkPointSetD2STD22DFD 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(_itkPointSetPython.itkPointSetD2STD22DFD___New_orig__)
    Clone = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2STD22DFD_Clone)
    GetMaximumNumberOfRegions = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2STD22DFD_GetMaximumNumberOfRegions)
    PassStructure = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2STD22DFD_PassStructure)
    GetNumberOfPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2STD22DFD_GetNumberOfPoints)
    SetPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2STD22DFD_SetPoints)
    GetPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2STD22DFD_GetPoints)
    SetPoint = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2STD22DFD_SetPoint)
    GetPoint = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2STD22DFD_GetPoint)
    SetPointData = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2STD22DFD_SetPointData)
    GetPointData = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2STD22DFD_GetPointData)
    SetRequestedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2STD22DFD_SetRequestedRegion)
    GetRequestedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2STD22DFD_GetRequestedRegion)
    SetBufferedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2STD22DFD_SetBufferedRegion)
    GetBufferedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2STD22DFD_GetBufferedRegion)
    __swig_destroy__ = _itkPointSetPython.delete_itkPointSetD2STD22DFD
    cast = _swig_new_static_method(_itkPointSetPython.itkPointSetD2STD22DFD_cast)
    GetPointer = _swig_new_instance_method(_itkPointSetPython.itkPointSetD2STD22DFD_GetPointer)

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

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

          itkPointSetD2STD22DFD.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkPointSetD2STD22DFD in _itkPointSetPython:
_itkPointSetPython.itkPointSetD2STD22DFD_swigregister(itkPointSetD2STD22DFD)
class itkPointSetD3DTD33DD(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkPointSetD3DTD33DD 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(_itkPointSetPython.itkPointSetD3DTD33DD___New_orig__)
    Clone = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3DTD33DD_Clone)
    GetMaximumNumberOfRegions = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3DTD33DD_GetMaximumNumberOfRegions)
    PassStructure = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3DTD33DD_PassStructure)
    GetNumberOfPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3DTD33DD_GetNumberOfPoints)
    SetPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3DTD33DD_SetPoints)
    GetPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3DTD33DD_GetPoints)
    SetPoint = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3DTD33DD_SetPoint)
    GetPoint = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3DTD33DD_GetPoint)
    SetPointData = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3DTD33DD_SetPointData)
    GetPointData = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3DTD33DD_GetPointData)
    SetRequestedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3DTD33DD_SetRequestedRegion)
    GetRequestedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3DTD33DD_GetRequestedRegion)
    SetBufferedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3DTD33DD_SetBufferedRegion)
    GetBufferedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3DTD33DD_GetBufferedRegion)
    __swig_destroy__ = _itkPointSetPython.delete_itkPointSetD3DTD33DD
    cast = _swig_new_static_method(_itkPointSetPython.itkPointSetD3DTD33DD_cast)
    GetPointer = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3DTD33DD_GetPointer)

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

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

          itkPointSetD3DTD33DD.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkPointSetD3DTD33DD in _itkPointSetPython:
_itkPointSetPython.itkPointSetD3DTD33DD_swigregister(itkPointSetD3DTD33DD)
class itkPointSetD3DTD33DFD(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkPointSetD3DTD33DFD 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(_itkPointSetPython.itkPointSetD3DTD33DFD___New_orig__)
    Clone = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3DTD33DFD_Clone)
    GetMaximumNumberOfRegions = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3DTD33DFD_GetMaximumNumberOfRegions)
    PassStructure = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3DTD33DFD_PassStructure)
    GetNumberOfPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3DTD33DFD_GetNumberOfPoints)
    SetPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3DTD33DFD_SetPoints)
    GetPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3DTD33DFD_GetPoints)
    SetPoint = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3DTD33DFD_SetPoint)
    GetPoint = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3DTD33DFD_GetPoint)
    SetPointData = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3DTD33DFD_SetPointData)
    GetPointData = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3DTD33DFD_GetPointData)
    SetRequestedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3DTD33DFD_SetRequestedRegion)
    GetRequestedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3DTD33DFD_GetRequestedRegion)
    SetBufferedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3DTD33DFD_SetBufferedRegion)
    GetBufferedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3DTD33DFD_GetBufferedRegion)
    __swig_destroy__ = _itkPointSetPython.delete_itkPointSetD3DTD33DFD
    cast = _swig_new_static_method(_itkPointSetPython.itkPointSetD3DTD33DFD_cast)
    GetPointer = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3DTD33DFD_GetPointer)

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

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

          itkPointSetD3DTD33DFD.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkPointSetD3DTD33DFD in _itkPointSetPython:
_itkPointSetPython.itkPointSetD3DTD33DFD_swigregister(itkPointSetD3DTD33DFD)
class itkPointSetD3STD33(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkPointSetD3STD33 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(_itkPointSetPython.itkPointSetD3STD33___New_orig__)
    Clone = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3STD33_Clone)
    GetMaximumNumberOfRegions = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3STD33_GetMaximumNumberOfRegions)
    PassStructure = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3STD33_PassStructure)
    GetNumberOfPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3STD33_GetNumberOfPoints)
    SetPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3STD33_SetPoints)
    GetPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3STD33_GetPoints)
    SetPoint = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3STD33_SetPoint)
    GetPoint = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3STD33_GetPoint)
    SetPointData = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3STD33_SetPointData)
    GetPointData = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3STD33_GetPointData)
    SetRequestedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3STD33_SetRequestedRegion)
    GetRequestedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3STD33_GetRequestedRegion)
    SetBufferedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3STD33_SetBufferedRegion)
    GetBufferedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3STD33_GetBufferedRegion)
    __swig_destroy__ = _itkPointSetPython.delete_itkPointSetD3STD33
    cast = _swig_new_static_method(_itkPointSetPython.itkPointSetD3STD33_cast)
    GetPointer = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3STD33_GetPointer)

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

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

          itkPointSetD3STD33.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkPointSetD3STD33 in _itkPointSetPython:
_itkPointSetPython.itkPointSetD3STD33_swigregister(itkPointSetD3STD33)
class itkPointSetD3STD33DD(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkPointSetD3STD33DD 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(_itkPointSetPython.itkPointSetD3STD33DD___New_orig__)
    Clone = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3STD33DD_Clone)
    GetMaximumNumberOfRegions = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3STD33DD_GetMaximumNumberOfRegions)
    PassStructure = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3STD33DD_PassStructure)
    GetNumberOfPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3STD33DD_GetNumberOfPoints)
    SetPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3STD33DD_SetPoints)
    GetPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3STD33DD_GetPoints)
    SetPoint = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3STD33DD_SetPoint)
    GetPoint = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3STD33DD_GetPoint)
    SetPointData = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3STD33DD_SetPointData)
    GetPointData = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3STD33DD_GetPointData)
    SetRequestedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3STD33DD_SetRequestedRegion)
    GetRequestedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3STD33DD_GetRequestedRegion)
    SetBufferedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3STD33DD_SetBufferedRegion)
    GetBufferedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3STD33DD_GetBufferedRegion)
    __swig_destroy__ = _itkPointSetPython.delete_itkPointSetD3STD33DD
    cast = _swig_new_static_method(_itkPointSetPython.itkPointSetD3STD33DD_cast)
    GetPointer = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3STD33DD_GetPointer)

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

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

          itkPointSetD3STD33DD.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkPointSetD3STD33DD in _itkPointSetPython:
_itkPointSetPython.itkPointSetD3STD33DD_swigregister(itkPointSetD3STD33DD)
class itkPointSetD3STD33DFD(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkPointSetD3STD33DFD 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(_itkPointSetPython.itkPointSetD3STD33DFD___New_orig__)
    Clone = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3STD33DFD_Clone)
    GetMaximumNumberOfRegions = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3STD33DFD_GetMaximumNumberOfRegions)
    PassStructure = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3STD33DFD_PassStructure)
    GetNumberOfPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3STD33DFD_GetNumberOfPoints)
    SetPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3STD33DFD_SetPoints)
    GetPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3STD33DFD_GetPoints)
    SetPoint = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3STD33DFD_SetPoint)
    GetPoint = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3STD33DFD_GetPoint)
    SetPointData = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3STD33DFD_SetPointData)
    GetPointData = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3STD33DFD_GetPointData)
    SetRequestedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3STD33DFD_SetRequestedRegion)
    GetRequestedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3STD33DFD_GetRequestedRegion)
    SetBufferedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3STD33DFD_SetBufferedRegion)
    GetBufferedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3STD33DFD_GetBufferedRegion)
    __swig_destroy__ = _itkPointSetPython.delete_itkPointSetD3STD33DFD
    cast = _swig_new_static_method(_itkPointSetPython.itkPointSetD3STD33DFD_cast)
    GetPointer = _swig_new_instance_method(_itkPointSetPython.itkPointSetD3STD33DFD_GetPointer)

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

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

          itkPointSetD3STD33DFD.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkPointSetD3STD33DFD in _itkPointSetPython:
_itkPointSetPython.itkPointSetD3STD33DFD_swigregister(itkPointSetD3STD33DFD)
class itkPointSetF2DTF22FF(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkPointSetF2DTF22FF 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(_itkPointSetPython.itkPointSetF2DTF22FF___New_orig__)
    Clone = _swig_new_instance_method(_itkPointSetPython.itkPointSetF2DTF22FF_Clone)
    GetMaximumNumberOfRegions = _swig_new_instance_method(_itkPointSetPython.itkPointSetF2DTF22FF_GetMaximumNumberOfRegions)
    PassStructure = _swig_new_instance_method(_itkPointSetPython.itkPointSetF2DTF22FF_PassStructure)
    GetNumberOfPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetF2DTF22FF_GetNumberOfPoints)
    SetPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetF2DTF22FF_SetPoints)
    GetPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetF2DTF22FF_GetPoints)
    SetPoint = _swig_new_instance_method(_itkPointSetPython.itkPointSetF2DTF22FF_SetPoint)
    GetPoint = _swig_new_instance_method(_itkPointSetPython.itkPointSetF2DTF22FF_GetPoint)
    SetPointData = _swig_new_instance_method(_itkPointSetPython.itkPointSetF2DTF22FF_SetPointData)
    GetPointData = _swig_new_instance_method(_itkPointSetPython.itkPointSetF2DTF22FF_GetPointData)
    SetRequestedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetF2DTF22FF_SetRequestedRegion)
    GetRequestedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetF2DTF22FF_GetRequestedRegion)
    SetBufferedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetF2DTF22FF_SetBufferedRegion)
    GetBufferedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetF2DTF22FF_GetBufferedRegion)
    __swig_destroy__ = _itkPointSetPython.delete_itkPointSetF2DTF22FF
    cast = _swig_new_static_method(_itkPointSetPython.itkPointSetF2DTF22FF_cast)
    GetPointer = _swig_new_instance_method(_itkPointSetPython.itkPointSetF2DTF22FF_GetPointer)

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

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

          itkPointSetF2DTF22FF.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkPointSetF2DTF22FF in _itkPointSetPython:
_itkPointSetPython.itkPointSetF2DTF22FF_swigregister(itkPointSetF2DTF22FF)
class itkPointSetF2STF22(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkPointSetF2STF22 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(_itkPointSetPython.itkPointSetF2STF22___New_orig__)
    Clone = _swig_new_instance_method(_itkPointSetPython.itkPointSetF2STF22_Clone)
    GetMaximumNumberOfRegions = _swig_new_instance_method(_itkPointSetPython.itkPointSetF2STF22_GetMaximumNumberOfRegions)
    PassStructure = _swig_new_instance_method(_itkPointSetPython.itkPointSetF2STF22_PassStructure)
    GetNumberOfPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetF2STF22_GetNumberOfPoints)
    SetPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetF2STF22_SetPoints)
    GetPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetF2STF22_GetPoints)
    SetPoint = _swig_new_instance_method(_itkPointSetPython.itkPointSetF2STF22_SetPoint)
    GetPoint = _swig_new_instance_method(_itkPointSetPython.itkPointSetF2STF22_GetPoint)
    SetPointData = _swig_new_instance_method(_itkPointSetPython.itkPointSetF2STF22_SetPointData)
    GetPointData = _swig_new_instance_method(_itkPointSetPython.itkPointSetF2STF22_GetPointData)
    SetRequestedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetF2STF22_SetRequestedRegion)
    GetRequestedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetF2STF22_GetRequestedRegion)
    SetBufferedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetF2STF22_SetBufferedRegion)
    GetBufferedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetF2STF22_GetBufferedRegion)
    __swig_destroy__ = _itkPointSetPython.delete_itkPointSetF2STF22
    cast = _swig_new_static_method(_itkPointSetPython.itkPointSetF2STF22_cast)
    GetPointer = _swig_new_instance_method(_itkPointSetPython.itkPointSetF2STF22_GetPointer)

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

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

          itkPointSetF2STF22.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkPointSetF2STF22 in _itkPointSetPython:
_itkPointSetPython.itkPointSetF2STF22_swigregister(itkPointSetF2STF22)
class itkPointSetF2STF22FF(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkPointSetF2STF22FF 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(_itkPointSetPython.itkPointSetF2STF22FF___New_orig__)
    Clone = _swig_new_instance_method(_itkPointSetPython.itkPointSetF2STF22FF_Clone)
    GetMaximumNumberOfRegions = _swig_new_instance_method(_itkPointSetPython.itkPointSetF2STF22FF_GetMaximumNumberOfRegions)
    PassStructure = _swig_new_instance_method(_itkPointSetPython.itkPointSetF2STF22FF_PassStructure)
    GetNumberOfPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetF2STF22FF_GetNumberOfPoints)
    SetPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetF2STF22FF_SetPoints)
    GetPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetF2STF22FF_GetPoints)
    SetPoint = _swig_new_instance_method(_itkPointSetPython.itkPointSetF2STF22FF_SetPoint)
    GetPoint = _swig_new_instance_method(_itkPointSetPython.itkPointSetF2STF22FF_GetPoint)
    SetPointData = _swig_new_instance_method(_itkPointSetPython.itkPointSetF2STF22FF_SetPointData)
    GetPointData = _swig_new_instance_method(_itkPointSetPython.itkPointSetF2STF22FF_GetPointData)
    SetRequestedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetF2STF22FF_SetRequestedRegion)
    GetRequestedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetF2STF22FF_GetRequestedRegion)
    SetBufferedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetF2STF22FF_SetBufferedRegion)
    GetBufferedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetF2STF22FF_GetBufferedRegion)
    __swig_destroy__ = _itkPointSetPython.delete_itkPointSetF2STF22FF
    cast = _swig_new_static_method(_itkPointSetPython.itkPointSetF2STF22FF_cast)
    GetPointer = _swig_new_instance_method(_itkPointSetPython.itkPointSetF2STF22FF_GetPointer)

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

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

          itkPointSetF2STF22FF.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkPointSetF2STF22FF in _itkPointSetPython:
_itkPointSetPython.itkPointSetF2STF22FF_swigregister(itkPointSetF2STF22FF)
class itkPointSetF3DTF33FF(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkPointSetF3DTF33FF 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(_itkPointSetPython.itkPointSetF3DTF33FF___New_orig__)
    Clone = _swig_new_instance_method(_itkPointSetPython.itkPointSetF3DTF33FF_Clone)
    GetMaximumNumberOfRegions = _swig_new_instance_method(_itkPointSetPython.itkPointSetF3DTF33FF_GetMaximumNumberOfRegions)
    PassStructure = _swig_new_instance_method(_itkPointSetPython.itkPointSetF3DTF33FF_PassStructure)
    GetNumberOfPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetF3DTF33FF_GetNumberOfPoints)
    SetPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetF3DTF33FF_SetPoints)
    GetPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetF3DTF33FF_GetPoints)
    SetPoint = _swig_new_instance_method(_itkPointSetPython.itkPointSetF3DTF33FF_SetPoint)
    GetPoint = _swig_new_instance_method(_itkPointSetPython.itkPointSetF3DTF33FF_GetPoint)
    SetPointData = _swig_new_instance_method(_itkPointSetPython.itkPointSetF3DTF33FF_SetPointData)
    GetPointData = _swig_new_instance_method(_itkPointSetPython.itkPointSetF3DTF33FF_GetPointData)
    SetRequestedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetF3DTF33FF_SetRequestedRegion)
    GetRequestedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetF3DTF33FF_GetRequestedRegion)
    SetBufferedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetF3DTF33FF_SetBufferedRegion)
    GetBufferedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetF3DTF33FF_GetBufferedRegion)
    __swig_destroy__ = _itkPointSetPython.delete_itkPointSetF3DTF33FF
    cast = _swig_new_static_method(_itkPointSetPython.itkPointSetF3DTF33FF_cast)
    GetPointer = _swig_new_instance_method(_itkPointSetPython.itkPointSetF3DTF33FF_GetPointer)

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

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

          itkPointSetF3DTF33FF.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkPointSetF3DTF33FF in _itkPointSetPython:
_itkPointSetPython.itkPointSetF3DTF33FF_swigregister(itkPointSetF3DTF33FF)
class itkPointSetF3STF33(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkPointSetF3STF33 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(_itkPointSetPython.itkPointSetF3STF33___New_orig__)
    Clone = _swig_new_instance_method(_itkPointSetPython.itkPointSetF3STF33_Clone)
    GetMaximumNumberOfRegions = _swig_new_instance_method(_itkPointSetPython.itkPointSetF3STF33_GetMaximumNumberOfRegions)
    PassStructure = _swig_new_instance_method(_itkPointSetPython.itkPointSetF3STF33_PassStructure)
    GetNumberOfPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetF3STF33_GetNumberOfPoints)
    SetPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetF3STF33_SetPoints)
    GetPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetF3STF33_GetPoints)
    SetPoint = _swig_new_instance_method(_itkPointSetPython.itkPointSetF3STF33_SetPoint)
    GetPoint = _swig_new_instance_method(_itkPointSetPython.itkPointSetF3STF33_GetPoint)
    SetPointData = _swig_new_instance_method(_itkPointSetPython.itkPointSetF3STF33_SetPointData)
    GetPointData = _swig_new_instance_method(_itkPointSetPython.itkPointSetF3STF33_GetPointData)
    SetRequestedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetF3STF33_SetRequestedRegion)
    GetRequestedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetF3STF33_GetRequestedRegion)
    SetBufferedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetF3STF33_SetBufferedRegion)
    GetBufferedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetF3STF33_GetBufferedRegion)
    __swig_destroy__ = _itkPointSetPython.delete_itkPointSetF3STF33
    cast = _swig_new_static_method(_itkPointSetPython.itkPointSetF3STF33_cast)
    GetPointer = _swig_new_instance_method(_itkPointSetPython.itkPointSetF3STF33_GetPointer)

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

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

          itkPointSetF3STF33.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkPointSetF3STF33 in _itkPointSetPython:
_itkPointSetPython.itkPointSetF3STF33_swigregister(itkPointSetF3STF33)
class itkPointSetF3STF33FF(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkPointSetF3STF33FF 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(_itkPointSetPython.itkPointSetF3STF33FF___New_orig__)
    Clone = _swig_new_instance_method(_itkPointSetPython.itkPointSetF3STF33FF_Clone)
    GetMaximumNumberOfRegions = _swig_new_instance_method(_itkPointSetPython.itkPointSetF3STF33FF_GetMaximumNumberOfRegions)
    PassStructure = _swig_new_instance_method(_itkPointSetPython.itkPointSetF3STF33FF_PassStructure)
    GetNumberOfPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetF3STF33FF_GetNumberOfPoints)
    SetPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetF3STF33FF_SetPoints)
    GetPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetF3STF33FF_GetPoints)
    SetPoint = _swig_new_instance_method(_itkPointSetPython.itkPointSetF3STF33FF_SetPoint)
    GetPoint = _swig_new_instance_method(_itkPointSetPython.itkPointSetF3STF33FF_GetPoint)
    SetPointData = _swig_new_instance_method(_itkPointSetPython.itkPointSetF3STF33FF_SetPointData)
    GetPointData = _swig_new_instance_method(_itkPointSetPython.itkPointSetF3STF33FF_GetPointData)
    SetRequestedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetF3STF33FF_SetRequestedRegion)
    GetRequestedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetF3STF33FF_GetRequestedRegion)
    SetBufferedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetF3STF33FF_SetBufferedRegion)
    GetBufferedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetF3STF33FF_GetBufferedRegion)
    __swig_destroy__ = _itkPointSetPython.delete_itkPointSetF3STF33FF
    cast = _swig_new_static_method(_itkPointSetPython.itkPointSetF3STF33FF_cast)
    GetPointer = _swig_new_instance_method(_itkPointSetPython.itkPointSetF3STF33FF_GetPointer)

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

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

          itkPointSetF3STF33FF.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkPointSetF3STF33FF in _itkPointSetPython:
_itkPointSetPython.itkPointSetF3STF33FF_swigregister(itkPointSetF3STF33FF)
class itkPointSetMD22STMD2222FFMD22(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkPointSetMD22STMD2222FFMD22 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(_itkPointSetPython.itkPointSetMD22STMD2222FFMD22___New_orig__)
    Clone = _swig_new_instance_method(_itkPointSetPython.itkPointSetMD22STMD2222FFMD22_Clone)
    GetMaximumNumberOfRegions = _swig_new_instance_method(_itkPointSetPython.itkPointSetMD22STMD2222FFMD22_GetMaximumNumberOfRegions)
    PassStructure = _swig_new_instance_method(_itkPointSetPython.itkPointSetMD22STMD2222FFMD22_PassStructure)
    GetNumberOfPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetMD22STMD2222FFMD22_GetNumberOfPoints)
    SetPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetMD22STMD2222FFMD22_SetPoints)
    GetPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetMD22STMD2222FFMD22_GetPoints)
    SetPoint = _swig_new_instance_method(_itkPointSetPython.itkPointSetMD22STMD2222FFMD22_SetPoint)
    GetPoint = _swig_new_instance_method(_itkPointSetPython.itkPointSetMD22STMD2222FFMD22_GetPoint)
    SetPointData = _swig_new_instance_method(_itkPointSetPython.itkPointSetMD22STMD2222FFMD22_SetPointData)
    GetPointData = _swig_new_instance_method(_itkPointSetPython.itkPointSetMD22STMD2222FFMD22_GetPointData)
    SetRequestedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetMD22STMD2222FFMD22_SetRequestedRegion)
    GetRequestedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetMD22STMD2222FFMD22_GetRequestedRegion)
    SetBufferedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetMD22STMD2222FFMD22_SetBufferedRegion)
    GetBufferedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetMD22STMD2222FFMD22_GetBufferedRegion)
    __swig_destroy__ = _itkPointSetPython.delete_itkPointSetMD22STMD2222FFMD22
    cast = _swig_new_static_method(_itkPointSetPython.itkPointSetMD22STMD2222FFMD22_cast)
    GetPointer = _swig_new_instance_method(_itkPointSetPython.itkPointSetMD22STMD2222FFMD22_GetPointer)

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

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

          itkPointSetMD22STMD2222FFMD22.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkPointSetMD22STMD2222FFMD22 in _itkPointSetPython:
_itkPointSetPython.itkPointSetMD22STMD2222FFMD22_swigregister(itkPointSetMD22STMD2222FFMD22)
class itkPointSetMD33STMD3333FFMD33(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkPointSetMD33STMD3333FFMD33 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(_itkPointSetPython.itkPointSetMD33STMD3333FFMD33___New_orig__)
    Clone = _swig_new_instance_method(_itkPointSetPython.itkPointSetMD33STMD3333FFMD33_Clone)
    GetMaximumNumberOfRegions = _swig_new_instance_method(_itkPointSetPython.itkPointSetMD33STMD3333FFMD33_GetMaximumNumberOfRegions)
    PassStructure = _swig_new_instance_method(_itkPointSetPython.itkPointSetMD33STMD3333FFMD33_PassStructure)
    GetNumberOfPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetMD33STMD3333FFMD33_GetNumberOfPoints)
    SetPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetMD33STMD3333FFMD33_SetPoints)
    GetPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetMD33STMD3333FFMD33_GetPoints)
    SetPoint = _swig_new_instance_method(_itkPointSetPython.itkPointSetMD33STMD3333FFMD33_SetPoint)
    GetPoint = _swig_new_instance_method(_itkPointSetPython.itkPointSetMD33STMD3333FFMD33_GetPoint)
    SetPointData = _swig_new_instance_method(_itkPointSetPython.itkPointSetMD33STMD3333FFMD33_SetPointData)
    GetPointData = _swig_new_instance_method(_itkPointSetPython.itkPointSetMD33STMD3333FFMD33_GetPointData)
    SetRequestedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetMD33STMD3333FFMD33_SetRequestedRegion)
    GetRequestedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetMD33STMD3333FFMD33_GetRequestedRegion)
    SetBufferedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetMD33STMD3333FFMD33_SetBufferedRegion)
    GetBufferedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetMD33STMD3333FFMD33_GetBufferedRegion)
    __swig_destroy__ = _itkPointSetPython.delete_itkPointSetMD33STMD3333FFMD33
    cast = _swig_new_static_method(_itkPointSetPython.itkPointSetMD33STMD3333FFMD33_cast)
    GetPointer = _swig_new_instance_method(_itkPointSetPython.itkPointSetMD33STMD3333FFMD33_GetPointer)

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

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

          itkPointSetMD33STMD3333FFMD33.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkPointSetMD33STMD3333FFMD33 in _itkPointSetPython:
_itkPointSetPython.itkPointSetMD33STMD3333FFMD33_swigregister(itkPointSetMD33STMD3333FFMD33)
class itkPointSetPD22STD22DD(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkPointSetPD22STD22DD 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(_itkPointSetPython.itkPointSetPD22STD22DD___New_orig__)
    Clone = _swig_new_instance_method(_itkPointSetPython.itkPointSetPD22STD22DD_Clone)
    GetMaximumNumberOfRegions = _swig_new_instance_method(_itkPointSetPython.itkPointSetPD22STD22DD_GetMaximumNumberOfRegions)
    PassStructure = _swig_new_instance_method(_itkPointSetPython.itkPointSetPD22STD22DD_PassStructure)
    GetNumberOfPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetPD22STD22DD_GetNumberOfPoints)
    SetPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetPD22STD22DD_SetPoints)
    GetPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetPD22STD22DD_GetPoints)
    SetPoint = _swig_new_instance_method(_itkPointSetPython.itkPointSetPD22STD22DD_SetPoint)
    GetPoint = _swig_new_instance_method(_itkPointSetPython.itkPointSetPD22STD22DD_GetPoint)
    SetPointData = _swig_new_instance_method(_itkPointSetPython.itkPointSetPD22STD22DD_SetPointData)
    GetPointData = _swig_new_instance_method(_itkPointSetPython.itkPointSetPD22STD22DD_GetPointData)
    SetRequestedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetPD22STD22DD_SetRequestedRegion)
    GetRequestedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetPD22STD22DD_GetRequestedRegion)
    SetBufferedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetPD22STD22DD_SetBufferedRegion)
    GetBufferedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetPD22STD22DD_GetBufferedRegion)
    __swig_destroy__ = _itkPointSetPython.delete_itkPointSetPD22STD22DD
    cast = _swig_new_static_method(_itkPointSetPython.itkPointSetPD22STD22DD_cast)
    GetPointer = _swig_new_instance_method(_itkPointSetPython.itkPointSetPD22STD22DD_GetPointer)

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

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

          itkPointSetPD22STD22DD.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkPointSetPD22STD22DD in _itkPointSetPython:
_itkPointSetPython.itkPointSetPD22STD22DD_swigregister(itkPointSetPD22STD22DD)
class itkPointSetPD33STD33DD(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkPointSetPD33STD33DD 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(_itkPointSetPython.itkPointSetPD33STD33DD___New_orig__)
    Clone = _swig_new_instance_method(_itkPointSetPython.itkPointSetPD33STD33DD_Clone)
    GetMaximumNumberOfRegions = _swig_new_instance_method(_itkPointSetPython.itkPointSetPD33STD33DD_GetMaximumNumberOfRegions)
    PassStructure = _swig_new_instance_method(_itkPointSetPython.itkPointSetPD33STD33DD_PassStructure)
    GetNumberOfPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetPD33STD33DD_GetNumberOfPoints)
    SetPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetPD33STD33DD_SetPoints)
    GetPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetPD33STD33DD_GetPoints)
    SetPoint = _swig_new_instance_method(_itkPointSetPython.itkPointSetPD33STD33DD_SetPoint)
    GetPoint = _swig_new_instance_method(_itkPointSetPython.itkPointSetPD33STD33DD_GetPoint)
    SetPointData = _swig_new_instance_method(_itkPointSetPython.itkPointSetPD33STD33DD_SetPointData)
    GetPointData = _swig_new_instance_method(_itkPointSetPython.itkPointSetPD33STD33DD_GetPointData)
    SetRequestedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetPD33STD33DD_SetRequestedRegion)
    GetRequestedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetPD33STD33DD_GetRequestedRegion)
    SetBufferedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetPD33STD33DD_SetBufferedRegion)
    GetBufferedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetPD33STD33DD_GetBufferedRegion)
    __swig_destroy__ = _itkPointSetPython.delete_itkPointSetPD33STD33DD
    cast = _swig_new_static_method(_itkPointSetPython.itkPointSetPD33STD33DD_cast)
    GetPointer = _swig_new_instance_method(_itkPointSetPython.itkPointSetPD33STD33DD_GetPointer)

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

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

          itkPointSetPD33STD33DD.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkPointSetPD33STD33DD in _itkPointSetPython:
_itkPointSetPython.itkPointSetPD33STD33DD_swigregister(itkPointSetPD33STD33DD)
class itkPointSetUI2DSMUI22FFUI(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkPointSetUI2DSMUI22FFUI 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(_itkPointSetPython.itkPointSetUI2DSMUI22FFUI___New_orig__)
    Clone = _swig_new_instance_method(_itkPointSetPython.itkPointSetUI2DSMUI22FFUI_Clone)
    GetMaximumNumberOfRegions = _swig_new_instance_method(_itkPointSetPython.itkPointSetUI2DSMUI22FFUI_GetMaximumNumberOfRegions)
    PassStructure = _swig_new_instance_method(_itkPointSetPython.itkPointSetUI2DSMUI22FFUI_PassStructure)
    GetNumberOfPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetUI2DSMUI22FFUI_GetNumberOfPoints)
    SetPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetUI2DSMUI22FFUI_SetPoints)
    GetPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetUI2DSMUI22FFUI_GetPoints)
    SetPoint = _swig_new_instance_method(_itkPointSetPython.itkPointSetUI2DSMUI22FFUI_SetPoint)
    GetPoint = _swig_new_instance_method(_itkPointSetPython.itkPointSetUI2DSMUI22FFUI_GetPoint)
    SetPointData = _swig_new_instance_method(_itkPointSetPython.itkPointSetUI2DSMUI22FFUI_SetPointData)
    GetPointData = _swig_new_instance_method(_itkPointSetPython.itkPointSetUI2DSMUI22FFUI_GetPointData)
    SetRequestedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetUI2DSMUI22FFUI_SetRequestedRegion)
    GetRequestedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetUI2DSMUI22FFUI_GetRequestedRegion)
    SetBufferedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetUI2DSMUI22FFUI_SetBufferedRegion)
    GetBufferedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetUI2DSMUI22FFUI_GetBufferedRegion)
    __swig_destroy__ = _itkPointSetPython.delete_itkPointSetUI2DSMUI22FFUI
    cast = _swig_new_static_method(_itkPointSetPython.itkPointSetUI2DSMUI22FFUI_cast)
    GetPointer = _swig_new_instance_method(_itkPointSetPython.itkPointSetUI2DSMUI22FFUI_GetPointer)

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

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

          itkPointSetUI2DSMUI22FFUI.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkPointSetUI2DSMUI22FFUI in _itkPointSetPython:
_itkPointSetPython.itkPointSetUI2DSMUI22FFUI_swigregister(itkPointSetUI2DSMUI22FFUI)
class itkPointSetUI3DSMUI33FFUI(ITKCommonBasePython.itkDataObject):
    r"""Proxy of C++ itkPointSetUI3DSMUI33FFUI 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(_itkPointSetPython.itkPointSetUI3DSMUI33FFUI___New_orig__)
    Clone = _swig_new_instance_method(_itkPointSetPython.itkPointSetUI3DSMUI33FFUI_Clone)
    GetMaximumNumberOfRegions = _swig_new_instance_method(_itkPointSetPython.itkPointSetUI3DSMUI33FFUI_GetMaximumNumberOfRegions)
    PassStructure = _swig_new_instance_method(_itkPointSetPython.itkPointSetUI3DSMUI33FFUI_PassStructure)
    GetNumberOfPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetUI3DSMUI33FFUI_GetNumberOfPoints)
    SetPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetUI3DSMUI33FFUI_SetPoints)
    GetPoints = _swig_new_instance_method(_itkPointSetPython.itkPointSetUI3DSMUI33FFUI_GetPoints)
    SetPoint = _swig_new_instance_method(_itkPointSetPython.itkPointSetUI3DSMUI33FFUI_SetPoint)
    GetPoint = _swig_new_instance_method(_itkPointSetPython.itkPointSetUI3DSMUI33FFUI_GetPoint)
    SetPointData = _swig_new_instance_method(_itkPointSetPython.itkPointSetUI3DSMUI33FFUI_SetPointData)
    GetPointData = _swig_new_instance_method(_itkPointSetPython.itkPointSetUI3DSMUI33FFUI_GetPointData)
    SetRequestedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetUI3DSMUI33FFUI_SetRequestedRegion)
    GetRequestedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetUI3DSMUI33FFUI_GetRequestedRegion)
    SetBufferedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetUI3DSMUI33FFUI_SetBufferedRegion)
    GetBufferedRegion = _swig_new_instance_method(_itkPointSetPython.itkPointSetUI3DSMUI33FFUI_GetBufferedRegion)
    __swig_destroy__ = _itkPointSetPython.delete_itkPointSetUI3DSMUI33FFUI
    cast = _swig_new_static_method(_itkPointSetPython.itkPointSetUI3DSMUI33FFUI_cast)
    GetPointer = _swig_new_instance_method(_itkPointSetPython.itkPointSetUI3DSMUI33FFUI_GetPointer)

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

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

          itkPointSetUI3DSMUI33FFUI.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkPointSetUI3DSMUI33FFUI in _itkPointSetPython:
_itkPointSetPython.itkPointSetUI3DSMUI33FFUI_swigregister(itkPointSetUI3DSMUI33FFUI)

