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


import collections

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

from . import _ITKCommonPython


from . import _ITKCommonPython



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

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


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


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


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


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


if _swig_python_version_info[0:2] >= (3, 3):
    import collections.abc
else:
    import collections

import itk.itkFixedArrayPython
import itk.pyBasePython
import itk.vnl_vector_refPython
import itk.stdcomplexPython
import itk.vnl_vectorPython
import itk.vnl_matrixPython
import itk.itkVectorPython
class vectoritkPointF2(collections.abc.MutableSequence if _swig_python_version_info >= (3, 3) else collections.MutableSequence):
    r"""Proxy of C++ std::vector< itkPointF2 > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _itkPointPython.vectoritkPointF2_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _itkPointPython.vectoritkPointF2___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _itkPointPython.vectoritkPointF2___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::vector< itkPointF2 >::size_type"""
        return _itkPointPython.vectoritkPointF2___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(self, i, j) -> vectoritkPointF2

        Parameters
        ----------
        i: std::vector< itkPointF2 >::difference_type
        j: std::vector< itkPointF2 >::difference_type

        """
        return _itkPointPython.vectoritkPointF2___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< itkPointF2 >::difference_type
        j: std::vector< itkPointF2 >::difference_type

        __setslice__(self, i, j, v)

        Parameters
        ----------
        i: std::vector< itkPointF2 >::difference_type
        j: std::vector< itkPointF2 >::difference_type
        v: std::vector< itkPointF2,std::allocator< itkPointF2 > > const &

        """
        return _itkPointPython.vectoritkPointF2___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< itkPointF2 >::difference_type
        j: std::vector< itkPointF2 >::difference_type

        """
        return _itkPointPython.vectoritkPointF2___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(self, i)

        Parameters
        ----------
        i: std::vector< itkPointF2 >::difference_type

        __delitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _itkPointPython.vectoritkPointF2___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(self, slice) -> vectoritkPointF2

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(self, i) -> itkPointF2

        Parameters
        ----------
        i: std::vector< itkPointF2 >::difference_type

        """
        return _itkPointPython.vectoritkPointF2___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, slice, v)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::vector< itkPointF2,std::allocator< itkPointF2 > > const &

        __setitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(self, i, x)

        Parameters
        ----------
        i: std::vector< itkPointF2 >::difference_type
        x: std::vector< itkPointF2 >::value_type const &

        """
        return _itkPointPython.vectoritkPointF2___setitem__(self, *args)

    def pop(self):
        r"""pop(self) -> itkPointF2"""
        return _itkPointPython.vectoritkPointF2_pop(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::vector< itkPointF2 >::value_type const &

        """
        return _itkPointPython.vectoritkPointF2_append(self, x)

    def empty(self):
        r"""empty(self) -> bool"""
        return _itkPointPython.vectoritkPointF2_empty(self)

    def size(self):
        r"""size(self) -> std::vector< itkPointF2 >::size_type"""
        return _itkPointPython.vectoritkPointF2_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::vector< itkPointF2 > &

        """
        return _itkPointPython.vectoritkPointF2_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::vector< itkPointF2 >::iterator"""
        return _itkPointPython.vectoritkPointF2_begin(self)

    def end(self):
        r"""end(self) -> std::vector< itkPointF2 >::iterator"""
        return _itkPointPython.vectoritkPointF2_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::vector< itkPointF2 >::reverse_iterator"""
        return _itkPointPython.vectoritkPointF2_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::vector< itkPointF2 >::reverse_iterator"""
        return _itkPointPython.vectoritkPointF2_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _itkPointPython.vectoritkPointF2_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::vector< itkPointF2 >::allocator_type"""
        return _itkPointPython.vectoritkPointF2_get_allocator(self)

    def pop_back(self):
        r"""pop_back(self)"""
        return _itkPointPython.vectoritkPointF2_pop_back(self)

    def erase(self, *args):
        r"""
        erase(self, pos) -> std::vector< itkPointF2 >::iterator

        Parameters
        ----------
        pos: std::vector< itkPointF2 >::iterator

        erase(self, first, last) -> std::vector< itkPointF2 >::iterator

        Parameters
        ----------
        first: std::vector< itkPointF2 >::iterator
        last: std::vector< itkPointF2 >::iterator

        """
        return _itkPointPython.vectoritkPointF2_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(self) -> vectoritkPointF2
        __init__(self, other) -> vectoritkPointF2

        Parameters
        ----------
        other: std::vector< itkPointF2 > const &

        __init__(self, size) -> vectoritkPointF2

        Parameters
        ----------
        size: std::vector< itkPointF2 >::size_type

        __init__(self, size, value) -> vectoritkPointF2

        Parameters
        ----------
        size: std::vector< itkPointF2 >::size_type
        value: std::vector< itkPointF2 >::value_type const &

        """
        _itkPointPython.vectoritkPointF2_swiginit(self, _itkPointPython.new_vectoritkPointF2(*args))

    def push_back(self, x):
        r"""
        push_back(self, x)

        Parameters
        ----------
        x: std::vector< itkPointF2 >::value_type const &

        """
        return _itkPointPython.vectoritkPointF2_push_back(self, x)

    def front(self):
        r"""front(self) -> itkPointF2"""
        return _itkPointPython.vectoritkPointF2_front(self)

    def back(self):
        r"""back(self) -> itkPointF2"""
        return _itkPointPython.vectoritkPointF2_back(self)

    def assign(self, n, x):
        r"""
        assign(self, n, x)

        Parameters
        ----------
        n: std::vector< itkPointF2 >::size_type
        x: std::vector< itkPointF2 >::value_type const &

        """
        return _itkPointPython.vectoritkPointF2_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(self, new_size)

        Parameters
        ----------
        new_size: std::vector< itkPointF2 >::size_type

        resize(self, new_size, x)

        Parameters
        ----------
        new_size: std::vector< itkPointF2 >::size_type
        x: std::vector< itkPointF2 >::value_type const &

        """
        return _itkPointPython.vectoritkPointF2_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(self, pos, x) -> std::vector< itkPointF2 >::iterator

        Parameters
        ----------
        pos: std::vector< itkPointF2 >::iterator
        x: std::vector< itkPointF2 >::value_type const &

        insert(self, pos, n, x)

        Parameters
        ----------
        pos: std::vector< itkPointF2 >::iterator
        n: std::vector< itkPointF2 >::size_type
        x: std::vector< itkPointF2 >::value_type const &

        """
        return _itkPointPython.vectoritkPointF2_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(self, n)

        Parameters
        ----------
        n: std::vector< itkPointF2 >::size_type

        """
        return _itkPointPython.vectoritkPointF2_reserve(self, n)

    def capacity(self):
        r"""capacity(self) -> std::vector< itkPointF2 >::size_type"""
        return _itkPointPython.vectoritkPointF2_capacity(self)
    __swig_destroy__ = _itkPointPython.delete_vectoritkPointF2

# Register vectoritkPointF2 in _itkPointPython:
_itkPointPython.vectoritkPointF2_swigregister(vectoritkPointF2)
class vectoritkPointD2(collections.abc.MutableSequence if _swig_python_version_info >= (3, 3) else collections.MutableSequence):
    r"""Proxy of C++ std::vector< itkPointD2 > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _itkPointPython.vectoritkPointD2_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _itkPointPython.vectoritkPointD2___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _itkPointPython.vectoritkPointD2___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::vector< itkPointD2 >::size_type"""
        return _itkPointPython.vectoritkPointD2___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(self, i, j) -> vectoritkPointD2

        Parameters
        ----------
        i: std::vector< itkPointD2 >::difference_type
        j: std::vector< itkPointD2 >::difference_type

        """
        return _itkPointPython.vectoritkPointD2___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< itkPointD2 >::difference_type
        j: std::vector< itkPointD2 >::difference_type

        __setslice__(self, i, j, v)

        Parameters
        ----------
        i: std::vector< itkPointD2 >::difference_type
        j: std::vector< itkPointD2 >::difference_type
        v: std::vector< itkPointD2,std::allocator< itkPointD2 > > const &

        """
        return _itkPointPython.vectoritkPointD2___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< itkPointD2 >::difference_type
        j: std::vector< itkPointD2 >::difference_type

        """
        return _itkPointPython.vectoritkPointD2___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(self, i)

        Parameters
        ----------
        i: std::vector< itkPointD2 >::difference_type

        __delitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _itkPointPython.vectoritkPointD2___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(self, slice) -> vectoritkPointD2

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(self, i) -> itkPointD2

        Parameters
        ----------
        i: std::vector< itkPointD2 >::difference_type

        """
        return _itkPointPython.vectoritkPointD2___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, slice, v)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::vector< itkPointD2,std::allocator< itkPointD2 > > const &

        __setitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(self, i, x)

        Parameters
        ----------
        i: std::vector< itkPointD2 >::difference_type
        x: std::vector< itkPointD2 >::value_type const &

        """
        return _itkPointPython.vectoritkPointD2___setitem__(self, *args)

    def pop(self):
        r"""pop(self) -> itkPointD2"""
        return _itkPointPython.vectoritkPointD2_pop(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::vector< itkPointD2 >::value_type const &

        """
        return _itkPointPython.vectoritkPointD2_append(self, x)

    def empty(self):
        r"""empty(self) -> bool"""
        return _itkPointPython.vectoritkPointD2_empty(self)

    def size(self):
        r"""size(self) -> std::vector< itkPointD2 >::size_type"""
        return _itkPointPython.vectoritkPointD2_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::vector< itkPointD2 > &

        """
        return _itkPointPython.vectoritkPointD2_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::vector< itkPointD2 >::iterator"""
        return _itkPointPython.vectoritkPointD2_begin(self)

    def end(self):
        r"""end(self) -> std::vector< itkPointD2 >::iterator"""
        return _itkPointPython.vectoritkPointD2_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::vector< itkPointD2 >::reverse_iterator"""
        return _itkPointPython.vectoritkPointD2_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::vector< itkPointD2 >::reverse_iterator"""
        return _itkPointPython.vectoritkPointD2_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _itkPointPython.vectoritkPointD2_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::vector< itkPointD2 >::allocator_type"""
        return _itkPointPython.vectoritkPointD2_get_allocator(self)

    def pop_back(self):
        r"""pop_back(self)"""
        return _itkPointPython.vectoritkPointD2_pop_back(self)

    def erase(self, *args):
        r"""
        erase(self, pos) -> std::vector< itkPointD2 >::iterator

        Parameters
        ----------
        pos: std::vector< itkPointD2 >::iterator

        erase(self, first, last) -> std::vector< itkPointD2 >::iterator

        Parameters
        ----------
        first: std::vector< itkPointD2 >::iterator
        last: std::vector< itkPointD2 >::iterator

        """
        return _itkPointPython.vectoritkPointD2_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(self) -> vectoritkPointD2
        __init__(self, other) -> vectoritkPointD2

        Parameters
        ----------
        other: std::vector< itkPointD2 > const &

        __init__(self, size) -> vectoritkPointD2

        Parameters
        ----------
        size: std::vector< itkPointD2 >::size_type

        __init__(self, size, value) -> vectoritkPointD2

        Parameters
        ----------
        size: std::vector< itkPointD2 >::size_type
        value: std::vector< itkPointD2 >::value_type const &

        """
        _itkPointPython.vectoritkPointD2_swiginit(self, _itkPointPython.new_vectoritkPointD2(*args))

    def push_back(self, x):
        r"""
        push_back(self, x)

        Parameters
        ----------
        x: std::vector< itkPointD2 >::value_type const &

        """
        return _itkPointPython.vectoritkPointD2_push_back(self, x)

    def front(self):
        r"""front(self) -> itkPointD2"""
        return _itkPointPython.vectoritkPointD2_front(self)

    def back(self):
        r"""back(self) -> itkPointD2"""
        return _itkPointPython.vectoritkPointD2_back(self)

    def assign(self, n, x):
        r"""
        assign(self, n, x)

        Parameters
        ----------
        n: std::vector< itkPointD2 >::size_type
        x: std::vector< itkPointD2 >::value_type const &

        """
        return _itkPointPython.vectoritkPointD2_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(self, new_size)

        Parameters
        ----------
        new_size: std::vector< itkPointD2 >::size_type

        resize(self, new_size, x)

        Parameters
        ----------
        new_size: std::vector< itkPointD2 >::size_type
        x: std::vector< itkPointD2 >::value_type const &

        """
        return _itkPointPython.vectoritkPointD2_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(self, pos, x) -> std::vector< itkPointD2 >::iterator

        Parameters
        ----------
        pos: std::vector< itkPointD2 >::iterator
        x: std::vector< itkPointD2 >::value_type const &

        insert(self, pos, n, x)

        Parameters
        ----------
        pos: std::vector< itkPointD2 >::iterator
        n: std::vector< itkPointD2 >::size_type
        x: std::vector< itkPointD2 >::value_type const &

        """
        return _itkPointPython.vectoritkPointD2_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(self, n)

        Parameters
        ----------
        n: std::vector< itkPointD2 >::size_type

        """
        return _itkPointPython.vectoritkPointD2_reserve(self, n)

    def capacity(self):
        r"""capacity(self) -> std::vector< itkPointD2 >::size_type"""
        return _itkPointPython.vectoritkPointD2_capacity(self)
    __swig_destroy__ = _itkPointPython.delete_vectoritkPointD2

# Register vectoritkPointD2 in _itkPointPython:
_itkPointPython.vectoritkPointD2_swigregister(vectoritkPointD2)
class vectoritkPointF3(collections.abc.MutableSequence if _swig_python_version_info >= (3, 3) else collections.MutableSequence):
    r"""Proxy of C++ std::vector< itkPointF3 > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _itkPointPython.vectoritkPointF3_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _itkPointPython.vectoritkPointF3___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _itkPointPython.vectoritkPointF3___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::vector< itkPointF3 >::size_type"""
        return _itkPointPython.vectoritkPointF3___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(self, i, j) -> vectoritkPointF3

        Parameters
        ----------
        i: std::vector< itkPointF3 >::difference_type
        j: std::vector< itkPointF3 >::difference_type

        """
        return _itkPointPython.vectoritkPointF3___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< itkPointF3 >::difference_type
        j: std::vector< itkPointF3 >::difference_type

        __setslice__(self, i, j, v)

        Parameters
        ----------
        i: std::vector< itkPointF3 >::difference_type
        j: std::vector< itkPointF3 >::difference_type
        v: std::vector< itkPointF3,std::allocator< itkPointF3 > > const &

        """
        return _itkPointPython.vectoritkPointF3___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< itkPointF3 >::difference_type
        j: std::vector< itkPointF3 >::difference_type

        """
        return _itkPointPython.vectoritkPointF3___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(self, i)

        Parameters
        ----------
        i: std::vector< itkPointF3 >::difference_type

        __delitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _itkPointPython.vectoritkPointF3___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(self, slice) -> vectoritkPointF3

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(self, i) -> itkPointF3

        Parameters
        ----------
        i: std::vector< itkPointF3 >::difference_type

        """
        return _itkPointPython.vectoritkPointF3___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, slice, v)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::vector< itkPointF3,std::allocator< itkPointF3 > > const &

        __setitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(self, i, x)

        Parameters
        ----------
        i: std::vector< itkPointF3 >::difference_type
        x: std::vector< itkPointF3 >::value_type const &

        """
        return _itkPointPython.vectoritkPointF3___setitem__(self, *args)

    def pop(self):
        r"""pop(self) -> itkPointF3"""
        return _itkPointPython.vectoritkPointF3_pop(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::vector< itkPointF3 >::value_type const &

        """
        return _itkPointPython.vectoritkPointF3_append(self, x)

    def empty(self):
        r"""empty(self) -> bool"""
        return _itkPointPython.vectoritkPointF3_empty(self)

    def size(self):
        r"""size(self) -> std::vector< itkPointF3 >::size_type"""
        return _itkPointPython.vectoritkPointF3_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::vector< itkPointF3 > &

        """
        return _itkPointPython.vectoritkPointF3_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::vector< itkPointF3 >::iterator"""
        return _itkPointPython.vectoritkPointF3_begin(self)

    def end(self):
        r"""end(self) -> std::vector< itkPointF3 >::iterator"""
        return _itkPointPython.vectoritkPointF3_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::vector< itkPointF3 >::reverse_iterator"""
        return _itkPointPython.vectoritkPointF3_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::vector< itkPointF3 >::reverse_iterator"""
        return _itkPointPython.vectoritkPointF3_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _itkPointPython.vectoritkPointF3_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::vector< itkPointF3 >::allocator_type"""
        return _itkPointPython.vectoritkPointF3_get_allocator(self)

    def pop_back(self):
        r"""pop_back(self)"""
        return _itkPointPython.vectoritkPointF3_pop_back(self)

    def erase(self, *args):
        r"""
        erase(self, pos) -> std::vector< itkPointF3 >::iterator

        Parameters
        ----------
        pos: std::vector< itkPointF3 >::iterator

        erase(self, first, last) -> std::vector< itkPointF3 >::iterator

        Parameters
        ----------
        first: std::vector< itkPointF3 >::iterator
        last: std::vector< itkPointF3 >::iterator

        """
        return _itkPointPython.vectoritkPointF3_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(self) -> vectoritkPointF3
        __init__(self, other) -> vectoritkPointF3

        Parameters
        ----------
        other: std::vector< itkPointF3 > const &

        __init__(self, size) -> vectoritkPointF3

        Parameters
        ----------
        size: std::vector< itkPointF3 >::size_type

        __init__(self, size, value) -> vectoritkPointF3

        Parameters
        ----------
        size: std::vector< itkPointF3 >::size_type
        value: std::vector< itkPointF3 >::value_type const &

        """
        _itkPointPython.vectoritkPointF3_swiginit(self, _itkPointPython.new_vectoritkPointF3(*args))

    def push_back(self, x):
        r"""
        push_back(self, x)

        Parameters
        ----------
        x: std::vector< itkPointF3 >::value_type const &

        """
        return _itkPointPython.vectoritkPointF3_push_back(self, x)

    def front(self):
        r"""front(self) -> itkPointF3"""
        return _itkPointPython.vectoritkPointF3_front(self)

    def back(self):
        r"""back(self) -> itkPointF3"""
        return _itkPointPython.vectoritkPointF3_back(self)

    def assign(self, n, x):
        r"""
        assign(self, n, x)

        Parameters
        ----------
        n: std::vector< itkPointF3 >::size_type
        x: std::vector< itkPointF3 >::value_type const &

        """
        return _itkPointPython.vectoritkPointF3_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(self, new_size)

        Parameters
        ----------
        new_size: std::vector< itkPointF3 >::size_type

        resize(self, new_size, x)

        Parameters
        ----------
        new_size: std::vector< itkPointF3 >::size_type
        x: std::vector< itkPointF3 >::value_type const &

        """
        return _itkPointPython.vectoritkPointF3_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(self, pos, x) -> std::vector< itkPointF3 >::iterator

        Parameters
        ----------
        pos: std::vector< itkPointF3 >::iterator
        x: std::vector< itkPointF3 >::value_type const &

        insert(self, pos, n, x)

        Parameters
        ----------
        pos: std::vector< itkPointF3 >::iterator
        n: std::vector< itkPointF3 >::size_type
        x: std::vector< itkPointF3 >::value_type const &

        """
        return _itkPointPython.vectoritkPointF3_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(self, n)

        Parameters
        ----------
        n: std::vector< itkPointF3 >::size_type

        """
        return _itkPointPython.vectoritkPointF3_reserve(self, n)

    def capacity(self):
        r"""capacity(self) -> std::vector< itkPointF3 >::size_type"""
        return _itkPointPython.vectoritkPointF3_capacity(self)
    __swig_destroy__ = _itkPointPython.delete_vectoritkPointF3

# Register vectoritkPointF3 in _itkPointPython:
_itkPointPython.vectoritkPointF3_swigregister(vectoritkPointF3)
class vectoritkPointD3(collections.abc.MutableSequence if _swig_python_version_info >= (3, 3) else collections.MutableSequence):
    r"""Proxy of C++ std::vector< itkPointD3 > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _itkPointPython.vectoritkPointD3_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _itkPointPython.vectoritkPointD3___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _itkPointPython.vectoritkPointD3___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::vector< itkPointD3 >::size_type"""
        return _itkPointPython.vectoritkPointD3___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(self, i, j) -> vectoritkPointD3

        Parameters
        ----------
        i: std::vector< itkPointD3 >::difference_type
        j: std::vector< itkPointD3 >::difference_type

        """
        return _itkPointPython.vectoritkPointD3___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< itkPointD3 >::difference_type
        j: std::vector< itkPointD3 >::difference_type

        __setslice__(self, i, j, v)

        Parameters
        ----------
        i: std::vector< itkPointD3 >::difference_type
        j: std::vector< itkPointD3 >::difference_type
        v: std::vector< itkPointD3,std::allocator< itkPointD3 > > const &

        """
        return _itkPointPython.vectoritkPointD3___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< itkPointD3 >::difference_type
        j: std::vector< itkPointD3 >::difference_type

        """
        return _itkPointPython.vectoritkPointD3___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(self, i)

        Parameters
        ----------
        i: std::vector< itkPointD3 >::difference_type

        __delitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _itkPointPython.vectoritkPointD3___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(self, slice) -> vectoritkPointD3

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(self, i) -> itkPointD3

        Parameters
        ----------
        i: std::vector< itkPointD3 >::difference_type

        """
        return _itkPointPython.vectoritkPointD3___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, slice, v)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::vector< itkPointD3,std::allocator< itkPointD3 > > const &

        __setitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(self, i, x)

        Parameters
        ----------
        i: std::vector< itkPointD3 >::difference_type
        x: std::vector< itkPointD3 >::value_type const &

        """
        return _itkPointPython.vectoritkPointD3___setitem__(self, *args)

    def pop(self):
        r"""pop(self) -> itkPointD3"""
        return _itkPointPython.vectoritkPointD3_pop(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::vector< itkPointD3 >::value_type const &

        """
        return _itkPointPython.vectoritkPointD3_append(self, x)

    def empty(self):
        r"""empty(self) -> bool"""
        return _itkPointPython.vectoritkPointD3_empty(self)

    def size(self):
        r"""size(self) -> std::vector< itkPointD3 >::size_type"""
        return _itkPointPython.vectoritkPointD3_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::vector< itkPointD3 > &

        """
        return _itkPointPython.vectoritkPointD3_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::vector< itkPointD3 >::iterator"""
        return _itkPointPython.vectoritkPointD3_begin(self)

    def end(self):
        r"""end(self) -> std::vector< itkPointD3 >::iterator"""
        return _itkPointPython.vectoritkPointD3_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::vector< itkPointD3 >::reverse_iterator"""
        return _itkPointPython.vectoritkPointD3_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::vector< itkPointD3 >::reverse_iterator"""
        return _itkPointPython.vectoritkPointD3_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _itkPointPython.vectoritkPointD3_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::vector< itkPointD3 >::allocator_type"""
        return _itkPointPython.vectoritkPointD3_get_allocator(self)

    def pop_back(self):
        r"""pop_back(self)"""
        return _itkPointPython.vectoritkPointD3_pop_back(self)

    def erase(self, *args):
        r"""
        erase(self, pos) -> std::vector< itkPointD3 >::iterator

        Parameters
        ----------
        pos: std::vector< itkPointD3 >::iterator

        erase(self, first, last) -> std::vector< itkPointD3 >::iterator

        Parameters
        ----------
        first: std::vector< itkPointD3 >::iterator
        last: std::vector< itkPointD3 >::iterator

        """
        return _itkPointPython.vectoritkPointD3_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(self) -> vectoritkPointD3
        __init__(self, other) -> vectoritkPointD3

        Parameters
        ----------
        other: std::vector< itkPointD3 > const &

        __init__(self, size) -> vectoritkPointD3

        Parameters
        ----------
        size: std::vector< itkPointD3 >::size_type

        __init__(self, size, value) -> vectoritkPointD3

        Parameters
        ----------
        size: std::vector< itkPointD3 >::size_type
        value: std::vector< itkPointD3 >::value_type const &

        """
        _itkPointPython.vectoritkPointD3_swiginit(self, _itkPointPython.new_vectoritkPointD3(*args))

    def push_back(self, x):
        r"""
        push_back(self, x)

        Parameters
        ----------
        x: std::vector< itkPointD3 >::value_type const &

        """
        return _itkPointPython.vectoritkPointD3_push_back(self, x)

    def front(self):
        r"""front(self) -> itkPointD3"""
        return _itkPointPython.vectoritkPointD3_front(self)

    def back(self):
        r"""back(self) -> itkPointD3"""
        return _itkPointPython.vectoritkPointD3_back(self)

    def assign(self, n, x):
        r"""
        assign(self, n, x)

        Parameters
        ----------
        n: std::vector< itkPointD3 >::size_type
        x: std::vector< itkPointD3 >::value_type const &

        """
        return _itkPointPython.vectoritkPointD3_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(self, new_size)

        Parameters
        ----------
        new_size: std::vector< itkPointD3 >::size_type

        resize(self, new_size, x)

        Parameters
        ----------
        new_size: std::vector< itkPointD3 >::size_type
        x: std::vector< itkPointD3 >::value_type const &

        """
        return _itkPointPython.vectoritkPointD3_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(self, pos, x) -> std::vector< itkPointD3 >::iterator

        Parameters
        ----------
        pos: std::vector< itkPointD3 >::iterator
        x: std::vector< itkPointD3 >::value_type const &

        insert(self, pos, n, x)

        Parameters
        ----------
        pos: std::vector< itkPointD3 >::iterator
        n: std::vector< itkPointD3 >::size_type
        x: std::vector< itkPointD3 >::value_type const &

        """
        return _itkPointPython.vectoritkPointD3_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(self, n)

        Parameters
        ----------
        n: std::vector< itkPointD3 >::size_type

        """
        return _itkPointPython.vectoritkPointD3_reserve(self, n)

    def capacity(self):
        r"""capacity(self) -> std::vector< itkPointD3 >::size_type"""
        return _itkPointPython.vectoritkPointD3_capacity(self)
    __swig_destroy__ = _itkPointPython.delete_vectoritkPointD3

# Register vectoritkPointD3 in _itkPointPython:
_itkPointPython.vectoritkPointD3_swigregister(vectoritkPointD3)
class vectoritkPointF4(collections.abc.MutableSequence if _swig_python_version_info >= (3, 3) else collections.MutableSequence):
    r"""Proxy of C++ std::vector< itkPointF4 > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _itkPointPython.vectoritkPointF4_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _itkPointPython.vectoritkPointF4___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _itkPointPython.vectoritkPointF4___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::vector< itkPointF4 >::size_type"""
        return _itkPointPython.vectoritkPointF4___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(self, i, j) -> vectoritkPointF4

        Parameters
        ----------
        i: std::vector< itkPointF4 >::difference_type
        j: std::vector< itkPointF4 >::difference_type

        """
        return _itkPointPython.vectoritkPointF4___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< itkPointF4 >::difference_type
        j: std::vector< itkPointF4 >::difference_type

        __setslice__(self, i, j, v)

        Parameters
        ----------
        i: std::vector< itkPointF4 >::difference_type
        j: std::vector< itkPointF4 >::difference_type
        v: std::vector< itkPointF4,std::allocator< itkPointF4 > > const &

        """
        return _itkPointPython.vectoritkPointF4___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< itkPointF4 >::difference_type
        j: std::vector< itkPointF4 >::difference_type

        """
        return _itkPointPython.vectoritkPointF4___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(self, i)

        Parameters
        ----------
        i: std::vector< itkPointF4 >::difference_type

        __delitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _itkPointPython.vectoritkPointF4___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(self, slice) -> vectoritkPointF4

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(self, i) -> itkPointF4

        Parameters
        ----------
        i: std::vector< itkPointF4 >::difference_type

        """
        return _itkPointPython.vectoritkPointF4___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, slice, v)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::vector< itkPointF4,std::allocator< itkPointF4 > > const &

        __setitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(self, i, x)

        Parameters
        ----------
        i: std::vector< itkPointF4 >::difference_type
        x: std::vector< itkPointF4 >::value_type const &

        """
        return _itkPointPython.vectoritkPointF4___setitem__(self, *args)

    def pop(self):
        r"""pop(self) -> itkPointF4"""
        return _itkPointPython.vectoritkPointF4_pop(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::vector< itkPointF4 >::value_type const &

        """
        return _itkPointPython.vectoritkPointF4_append(self, x)

    def empty(self):
        r"""empty(self) -> bool"""
        return _itkPointPython.vectoritkPointF4_empty(self)

    def size(self):
        r"""size(self) -> std::vector< itkPointF4 >::size_type"""
        return _itkPointPython.vectoritkPointF4_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::vector< itkPointF4 > &

        """
        return _itkPointPython.vectoritkPointF4_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::vector< itkPointF4 >::iterator"""
        return _itkPointPython.vectoritkPointF4_begin(self)

    def end(self):
        r"""end(self) -> std::vector< itkPointF4 >::iterator"""
        return _itkPointPython.vectoritkPointF4_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::vector< itkPointF4 >::reverse_iterator"""
        return _itkPointPython.vectoritkPointF4_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::vector< itkPointF4 >::reverse_iterator"""
        return _itkPointPython.vectoritkPointF4_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _itkPointPython.vectoritkPointF4_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::vector< itkPointF4 >::allocator_type"""
        return _itkPointPython.vectoritkPointF4_get_allocator(self)

    def pop_back(self):
        r"""pop_back(self)"""
        return _itkPointPython.vectoritkPointF4_pop_back(self)

    def erase(self, *args):
        r"""
        erase(self, pos) -> std::vector< itkPointF4 >::iterator

        Parameters
        ----------
        pos: std::vector< itkPointF4 >::iterator

        erase(self, first, last) -> std::vector< itkPointF4 >::iterator

        Parameters
        ----------
        first: std::vector< itkPointF4 >::iterator
        last: std::vector< itkPointF4 >::iterator

        """
        return _itkPointPython.vectoritkPointF4_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(self) -> vectoritkPointF4
        __init__(self, other) -> vectoritkPointF4

        Parameters
        ----------
        other: std::vector< itkPointF4 > const &

        __init__(self, size) -> vectoritkPointF4

        Parameters
        ----------
        size: std::vector< itkPointF4 >::size_type

        __init__(self, size, value) -> vectoritkPointF4

        Parameters
        ----------
        size: std::vector< itkPointF4 >::size_type
        value: std::vector< itkPointF4 >::value_type const &

        """
        _itkPointPython.vectoritkPointF4_swiginit(self, _itkPointPython.new_vectoritkPointF4(*args))

    def push_back(self, x):
        r"""
        push_back(self, x)

        Parameters
        ----------
        x: std::vector< itkPointF4 >::value_type const &

        """
        return _itkPointPython.vectoritkPointF4_push_back(self, x)

    def front(self):
        r"""front(self) -> itkPointF4"""
        return _itkPointPython.vectoritkPointF4_front(self)

    def back(self):
        r"""back(self) -> itkPointF4"""
        return _itkPointPython.vectoritkPointF4_back(self)

    def assign(self, n, x):
        r"""
        assign(self, n, x)

        Parameters
        ----------
        n: std::vector< itkPointF4 >::size_type
        x: std::vector< itkPointF4 >::value_type const &

        """
        return _itkPointPython.vectoritkPointF4_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(self, new_size)

        Parameters
        ----------
        new_size: std::vector< itkPointF4 >::size_type

        resize(self, new_size, x)

        Parameters
        ----------
        new_size: std::vector< itkPointF4 >::size_type
        x: std::vector< itkPointF4 >::value_type const &

        """
        return _itkPointPython.vectoritkPointF4_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(self, pos, x) -> std::vector< itkPointF4 >::iterator

        Parameters
        ----------
        pos: std::vector< itkPointF4 >::iterator
        x: std::vector< itkPointF4 >::value_type const &

        insert(self, pos, n, x)

        Parameters
        ----------
        pos: std::vector< itkPointF4 >::iterator
        n: std::vector< itkPointF4 >::size_type
        x: std::vector< itkPointF4 >::value_type const &

        """
        return _itkPointPython.vectoritkPointF4_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(self, n)

        Parameters
        ----------
        n: std::vector< itkPointF4 >::size_type

        """
        return _itkPointPython.vectoritkPointF4_reserve(self, n)

    def capacity(self):
        r"""capacity(self) -> std::vector< itkPointF4 >::size_type"""
        return _itkPointPython.vectoritkPointF4_capacity(self)
    __swig_destroy__ = _itkPointPython.delete_vectoritkPointF4

# Register vectoritkPointF4 in _itkPointPython:
_itkPointPython.vectoritkPointF4_swigregister(vectoritkPointF4)
class vectoritkPointD4(collections.abc.MutableSequence if _swig_python_version_info >= (3, 3) else collections.MutableSequence):
    r"""Proxy of C++ std::vector< itkPointD4 > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _itkPointPython.vectoritkPointD4_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _itkPointPython.vectoritkPointD4___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _itkPointPython.vectoritkPointD4___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::vector< itkPointD4 >::size_type"""
        return _itkPointPython.vectoritkPointD4___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(self, i, j) -> vectoritkPointD4

        Parameters
        ----------
        i: std::vector< itkPointD4 >::difference_type
        j: std::vector< itkPointD4 >::difference_type

        """
        return _itkPointPython.vectoritkPointD4___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< itkPointD4 >::difference_type
        j: std::vector< itkPointD4 >::difference_type

        __setslice__(self, i, j, v)

        Parameters
        ----------
        i: std::vector< itkPointD4 >::difference_type
        j: std::vector< itkPointD4 >::difference_type
        v: std::vector< itkPointD4,std::allocator< itkPointD4 > > const &

        """
        return _itkPointPython.vectoritkPointD4___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< itkPointD4 >::difference_type
        j: std::vector< itkPointD4 >::difference_type

        """
        return _itkPointPython.vectoritkPointD4___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(self, i)

        Parameters
        ----------
        i: std::vector< itkPointD4 >::difference_type

        __delitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _itkPointPython.vectoritkPointD4___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(self, slice) -> vectoritkPointD4

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(self, i) -> itkPointD4

        Parameters
        ----------
        i: std::vector< itkPointD4 >::difference_type

        """
        return _itkPointPython.vectoritkPointD4___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, slice, v)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::vector< itkPointD4,std::allocator< itkPointD4 > > const &

        __setitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(self, i, x)

        Parameters
        ----------
        i: std::vector< itkPointD4 >::difference_type
        x: std::vector< itkPointD4 >::value_type const &

        """
        return _itkPointPython.vectoritkPointD4___setitem__(self, *args)

    def pop(self):
        r"""pop(self) -> itkPointD4"""
        return _itkPointPython.vectoritkPointD4_pop(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::vector< itkPointD4 >::value_type const &

        """
        return _itkPointPython.vectoritkPointD4_append(self, x)

    def empty(self):
        r"""empty(self) -> bool"""
        return _itkPointPython.vectoritkPointD4_empty(self)

    def size(self):
        r"""size(self) -> std::vector< itkPointD4 >::size_type"""
        return _itkPointPython.vectoritkPointD4_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::vector< itkPointD4 > &

        """
        return _itkPointPython.vectoritkPointD4_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::vector< itkPointD4 >::iterator"""
        return _itkPointPython.vectoritkPointD4_begin(self)

    def end(self):
        r"""end(self) -> std::vector< itkPointD4 >::iterator"""
        return _itkPointPython.vectoritkPointD4_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::vector< itkPointD4 >::reverse_iterator"""
        return _itkPointPython.vectoritkPointD4_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::vector< itkPointD4 >::reverse_iterator"""
        return _itkPointPython.vectoritkPointD4_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _itkPointPython.vectoritkPointD4_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::vector< itkPointD4 >::allocator_type"""
        return _itkPointPython.vectoritkPointD4_get_allocator(self)

    def pop_back(self):
        r"""pop_back(self)"""
        return _itkPointPython.vectoritkPointD4_pop_back(self)

    def erase(self, *args):
        r"""
        erase(self, pos) -> std::vector< itkPointD4 >::iterator

        Parameters
        ----------
        pos: std::vector< itkPointD4 >::iterator

        erase(self, first, last) -> std::vector< itkPointD4 >::iterator

        Parameters
        ----------
        first: std::vector< itkPointD4 >::iterator
        last: std::vector< itkPointD4 >::iterator

        """
        return _itkPointPython.vectoritkPointD4_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(self) -> vectoritkPointD4
        __init__(self, other) -> vectoritkPointD4

        Parameters
        ----------
        other: std::vector< itkPointD4 > const &

        __init__(self, size) -> vectoritkPointD4

        Parameters
        ----------
        size: std::vector< itkPointD4 >::size_type

        __init__(self, size, value) -> vectoritkPointD4

        Parameters
        ----------
        size: std::vector< itkPointD4 >::size_type
        value: std::vector< itkPointD4 >::value_type const &

        """
        _itkPointPython.vectoritkPointD4_swiginit(self, _itkPointPython.new_vectoritkPointD4(*args))

    def push_back(self, x):
        r"""
        push_back(self, x)

        Parameters
        ----------
        x: std::vector< itkPointD4 >::value_type const &

        """
        return _itkPointPython.vectoritkPointD4_push_back(self, x)

    def front(self):
        r"""front(self) -> itkPointD4"""
        return _itkPointPython.vectoritkPointD4_front(self)

    def back(self):
        r"""back(self) -> itkPointD4"""
        return _itkPointPython.vectoritkPointD4_back(self)

    def assign(self, n, x):
        r"""
        assign(self, n, x)

        Parameters
        ----------
        n: std::vector< itkPointD4 >::size_type
        x: std::vector< itkPointD4 >::value_type const &

        """
        return _itkPointPython.vectoritkPointD4_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(self, new_size)

        Parameters
        ----------
        new_size: std::vector< itkPointD4 >::size_type

        resize(self, new_size, x)

        Parameters
        ----------
        new_size: std::vector< itkPointD4 >::size_type
        x: std::vector< itkPointD4 >::value_type const &

        """
        return _itkPointPython.vectoritkPointD4_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(self, pos, x) -> std::vector< itkPointD4 >::iterator

        Parameters
        ----------
        pos: std::vector< itkPointD4 >::iterator
        x: std::vector< itkPointD4 >::value_type const &

        insert(self, pos, n, x)

        Parameters
        ----------
        pos: std::vector< itkPointD4 >::iterator
        n: std::vector< itkPointD4 >::size_type
        x: std::vector< itkPointD4 >::value_type const &

        """
        return _itkPointPython.vectoritkPointD4_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(self, n)

        Parameters
        ----------
        n: std::vector< itkPointD4 >::size_type

        """
        return _itkPointPython.vectoritkPointD4_reserve(self, n)

    def capacity(self):
        r"""capacity(self) -> std::vector< itkPointD4 >::size_type"""
        return _itkPointPython.vectoritkPointD4_capacity(self)
    __swig_destroy__ = _itkPointPython.delete_vectoritkPointD4

# Register vectoritkPointD4 in _itkPointPython:
_itkPointPython.vectoritkPointD4_swigregister(vectoritkPointD4)
class vectoritkPointF6(collections.abc.MutableSequence if _swig_python_version_info >= (3, 3) else collections.MutableSequence):
    r"""Proxy of C++ std::vector< itkPointF6 > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _itkPointPython.vectoritkPointF6_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _itkPointPython.vectoritkPointF6___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _itkPointPython.vectoritkPointF6___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::vector< itkPointF6 >::size_type"""
        return _itkPointPython.vectoritkPointF6___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(self, i, j) -> vectoritkPointF6

        Parameters
        ----------
        i: std::vector< itkPointF6 >::difference_type
        j: std::vector< itkPointF6 >::difference_type

        """
        return _itkPointPython.vectoritkPointF6___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< itkPointF6 >::difference_type
        j: std::vector< itkPointF6 >::difference_type

        __setslice__(self, i, j, v)

        Parameters
        ----------
        i: std::vector< itkPointF6 >::difference_type
        j: std::vector< itkPointF6 >::difference_type
        v: std::vector< itkPointF6,std::allocator< itkPointF6 > > const &

        """
        return _itkPointPython.vectoritkPointF6___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< itkPointF6 >::difference_type
        j: std::vector< itkPointF6 >::difference_type

        """
        return _itkPointPython.vectoritkPointF6___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(self, i)

        Parameters
        ----------
        i: std::vector< itkPointF6 >::difference_type

        __delitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _itkPointPython.vectoritkPointF6___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(self, slice) -> vectoritkPointF6

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(self, i) -> itkPointF6

        Parameters
        ----------
        i: std::vector< itkPointF6 >::difference_type

        """
        return _itkPointPython.vectoritkPointF6___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, slice, v)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::vector< itkPointF6,std::allocator< itkPointF6 > > const &

        __setitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(self, i, x)

        Parameters
        ----------
        i: std::vector< itkPointF6 >::difference_type
        x: std::vector< itkPointF6 >::value_type const &

        """
        return _itkPointPython.vectoritkPointF6___setitem__(self, *args)

    def pop(self):
        r"""pop(self) -> itkPointF6"""
        return _itkPointPython.vectoritkPointF6_pop(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::vector< itkPointF6 >::value_type const &

        """
        return _itkPointPython.vectoritkPointF6_append(self, x)

    def empty(self):
        r"""empty(self) -> bool"""
        return _itkPointPython.vectoritkPointF6_empty(self)

    def size(self):
        r"""size(self) -> std::vector< itkPointF6 >::size_type"""
        return _itkPointPython.vectoritkPointF6_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::vector< itkPointF6 > &

        """
        return _itkPointPython.vectoritkPointF6_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::vector< itkPointF6 >::iterator"""
        return _itkPointPython.vectoritkPointF6_begin(self)

    def end(self):
        r"""end(self) -> std::vector< itkPointF6 >::iterator"""
        return _itkPointPython.vectoritkPointF6_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::vector< itkPointF6 >::reverse_iterator"""
        return _itkPointPython.vectoritkPointF6_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::vector< itkPointF6 >::reverse_iterator"""
        return _itkPointPython.vectoritkPointF6_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _itkPointPython.vectoritkPointF6_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::vector< itkPointF6 >::allocator_type"""
        return _itkPointPython.vectoritkPointF6_get_allocator(self)

    def pop_back(self):
        r"""pop_back(self)"""
        return _itkPointPython.vectoritkPointF6_pop_back(self)

    def erase(self, *args):
        r"""
        erase(self, pos) -> std::vector< itkPointF6 >::iterator

        Parameters
        ----------
        pos: std::vector< itkPointF6 >::iterator

        erase(self, first, last) -> std::vector< itkPointF6 >::iterator

        Parameters
        ----------
        first: std::vector< itkPointF6 >::iterator
        last: std::vector< itkPointF6 >::iterator

        """
        return _itkPointPython.vectoritkPointF6_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(self) -> vectoritkPointF6
        __init__(self, other) -> vectoritkPointF6

        Parameters
        ----------
        other: std::vector< itkPointF6 > const &

        __init__(self, size) -> vectoritkPointF6

        Parameters
        ----------
        size: std::vector< itkPointF6 >::size_type

        __init__(self, size, value) -> vectoritkPointF6

        Parameters
        ----------
        size: std::vector< itkPointF6 >::size_type
        value: std::vector< itkPointF6 >::value_type const &

        """
        _itkPointPython.vectoritkPointF6_swiginit(self, _itkPointPython.new_vectoritkPointF6(*args))

    def push_back(self, x):
        r"""
        push_back(self, x)

        Parameters
        ----------
        x: std::vector< itkPointF6 >::value_type const &

        """
        return _itkPointPython.vectoritkPointF6_push_back(self, x)

    def front(self):
        r"""front(self) -> itkPointF6"""
        return _itkPointPython.vectoritkPointF6_front(self)

    def back(self):
        r"""back(self) -> itkPointF6"""
        return _itkPointPython.vectoritkPointF6_back(self)

    def assign(self, n, x):
        r"""
        assign(self, n, x)

        Parameters
        ----------
        n: std::vector< itkPointF6 >::size_type
        x: std::vector< itkPointF6 >::value_type const &

        """
        return _itkPointPython.vectoritkPointF6_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(self, new_size)

        Parameters
        ----------
        new_size: std::vector< itkPointF6 >::size_type

        resize(self, new_size, x)

        Parameters
        ----------
        new_size: std::vector< itkPointF6 >::size_type
        x: std::vector< itkPointF6 >::value_type const &

        """
        return _itkPointPython.vectoritkPointF6_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(self, pos, x) -> std::vector< itkPointF6 >::iterator

        Parameters
        ----------
        pos: std::vector< itkPointF6 >::iterator
        x: std::vector< itkPointF6 >::value_type const &

        insert(self, pos, n, x)

        Parameters
        ----------
        pos: std::vector< itkPointF6 >::iterator
        n: std::vector< itkPointF6 >::size_type
        x: std::vector< itkPointF6 >::value_type const &

        """
        return _itkPointPython.vectoritkPointF6_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(self, n)

        Parameters
        ----------
        n: std::vector< itkPointF6 >::size_type

        """
        return _itkPointPython.vectoritkPointF6_reserve(self, n)

    def capacity(self):
        r"""capacity(self) -> std::vector< itkPointF6 >::size_type"""
        return _itkPointPython.vectoritkPointF6_capacity(self)
    __swig_destroy__ = _itkPointPython.delete_vectoritkPointF6

# Register vectoritkPointF6 in _itkPointPython:
_itkPointPython.vectoritkPointF6_swigregister(vectoritkPointF6)
class vectoritkPointD6(collections.abc.MutableSequence if _swig_python_version_info >= (3, 3) else collections.MutableSequence):
    r"""Proxy of C++ std::vector< itkPointD6 > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _itkPointPython.vectoritkPointD6_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _itkPointPython.vectoritkPointD6___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _itkPointPython.vectoritkPointD6___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::vector< itkPointD6 >::size_type"""
        return _itkPointPython.vectoritkPointD6___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(self, i, j) -> vectoritkPointD6

        Parameters
        ----------
        i: std::vector< itkPointD6 >::difference_type
        j: std::vector< itkPointD6 >::difference_type

        """
        return _itkPointPython.vectoritkPointD6___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< itkPointD6 >::difference_type
        j: std::vector< itkPointD6 >::difference_type

        __setslice__(self, i, j, v)

        Parameters
        ----------
        i: std::vector< itkPointD6 >::difference_type
        j: std::vector< itkPointD6 >::difference_type
        v: std::vector< itkPointD6,std::allocator< itkPointD6 > > const &

        """
        return _itkPointPython.vectoritkPointD6___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< itkPointD6 >::difference_type
        j: std::vector< itkPointD6 >::difference_type

        """
        return _itkPointPython.vectoritkPointD6___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(self, i)

        Parameters
        ----------
        i: std::vector< itkPointD6 >::difference_type

        __delitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _itkPointPython.vectoritkPointD6___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(self, slice) -> vectoritkPointD6

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(self, i) -> itkPointD6

        Parameters
        ----------
        i: std::vector< itkPointD6 >::difference_type

        """
        return _itkPointPython.vectoritkPointD6___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, slice, v)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::vector< itkPointD6,std::allocator< itkPointD6 > > const &

        __setitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(self, i, x)

        Parameters
        ----------
        i: std::vector< itkPointD6 >::difference_type
        x: std::vector< itkPointD6 >::value_type const &

        """
        return _itkPointPython.vectoritkPointD6___setitem__(self, *args)

    def pop(self):
        r"""pop(self) -> itkPointD6"""
        return _itkPointPython.vectoritkPointD6_pop(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::vector< itkPointD6 >::value_type const &

        """
        return _itkPointPython.vectoritkPointD6_append(self, x)

    def empty(self):
        r"""empty(self) -> bool"""
        return _itkPointPython.vectoritkPointD6_empty(self)

    def size(self):
        r"""size(self) -> std::vector< itkPointD6 >::size_type"""
        return _itkPointPython.vectoritkPointD6_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::vector< itkPointD6 > &

        """
        return _itkPointPython.vectoritkPointD6_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::vector< itkPointD6 >::iterator"""
        return _itkPointPython.vectoritkPointD6_begin(self)

    def end(self):
        r"""end(self) -> std::vector< itkPointD6 >::iterator"""
        return _itkPointPython.vectoritkPointD6_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::vector< itkPointD6 >::reverse_iterator"""
        return _itkPointPython.vectoritkPointD6_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::vector< itkPointD6 >::reverse_iterator"""
        return _itkPointPython.vectoritkPointD6_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _itkPointPython.vectoritkPointD6_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::vector< itkPointD6 >::allocator_type"""
        return _itkPointPython.vectoritkPointD6_get_allocator(self)

    def pop_back(self):
        r"""pop_back(self)"""
        return _itkPointPython.vectoritkPointD6_pop_back(self)

    def erase(self, *args):
        r"""
        erase(self, pos) -> std::vector< itkPointD6 >::iterator

        Parameters
        ----------
        pos: std::vector< itkPointD6 >::iterator

        erase(self, first, last) -> std::vector< itkPointD6 >::iterator

        Parameters
        ----------
        first: std::vector< itkPointD6 >::iterator
        last: std::vector< itkPointD6 >::iterator

        """
        return _itkPointPython.vectoritkPointD6_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(self) -> vectoritkPointD6
        __init__(self, other) -> vectoritkPointD6

        Parameters
        ----------
        other: std::vector< itkPointD6 > const &

        __init__(self, size) -> vectoritkPointD6

        Parameters
        ----------
        size: std::vector< itkPointD6 >::size_type

        __init__(self, size, value) -> vectoritkPointD6

        Parameters
        ----------
        size: std::vector< itkPointD6 >::size_type
        value: std::vector< itkPointD6 >::value_type const &

        """
        _itkPointPython.vectoritkPointD6_swiginit(self, _itkPointPython.new_vectoritkPointD6(*args))

    def push_back(self, x):
        r"""
        push_back(self, x)

        Parameters
        ----------
        x: std::vector< itkPointD6 >::value_type const &

        """
        return _itkPointPython.vectoritkPointD6_push_back(self, x)

    def front(self):
        r"""front(self) -> itkPointD6"""
        return _itkPointPython.vectoritkPointD6_front(self)

    def back(self):
        r"""back(self) -> itkPointD6"""
        return _itkPointPython.vectoritkPointD6_back(self)

    def assign(self, n, x):
        r"""
        assign(self, n, x)

        Parameters
        ----------
        n: std::vector< itkPointD6 >::size_type
        x: std::vector< itkPointD6 >::value_type const &

        """
        return _itkPointPython.vectoritkPointD6_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(self, new_size)

        Parameters
        ----------
        new_size: std::vector< itkPointD6 >::size_type

        resize(self, new_size, x)

        Parameters
        ----------
        new_size: std::vector< itkPointD6 >::size_type
        x: std::vector< itkPointD6 >::value_type const &

        """
        return _itkPointPython.vectoritkPointD6_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(self, pos, x) -> std::vector< itkPointD6 >::iterator

        Parameters
        ----------
        pos: std::vector< itkPointD6 >::iterator
        x: std::vector< itkPointD6 >::value_type const &

        insert(self, pos, n, x)

        Parameters
        ----------
        pos: std::vector< itkPointD6 >::iterator
        n: std::vector< itkPointD6 >::size_type
        x: std::vector< itkPointD6 >::value_type const &

        """
        return _itkPointPython.vectoritkPointD6_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(self, n)

        Parameters
        ----------
        n: std::vector< itkPointD6 >::size_type

        """
        return _itkPointPython.vectoritkPointD6_reserve(self, n)

    def capacity(self):
        r"""capacity(self) -> std::vector< itkPointD6 >::size_type"""
        return _itkPointPython.vectoritkPointD6_capacity(self)
    __swig_destroy__ = _itkPointPython.delete_vectoritkPointD6

# Register vectoritkPointD6 in _itkPointPython:
_itkPointPython.vectoritkPointD6_swigregister(vectoritkPointD6)
class itkPointD2(itk.itkFixedArrayPython.itkFixedArrayD2):
    r"""Proxy of C++ itkPointD2 class."""

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

    @staticmethod
    def GetPointDimension():
        r"""GetPointDimension() -> unsigned int"""
        return _itkPointPython.itkPointD2_GetPointDimension()

    def __eq__(self, pt):
        r"""
        __eq__(self, pt) -> bool

        Parameters
        ----------
        pt: itkPointD2 const &

        """
        return _itkPointPython.itkPointD2___eq__(self, pt)

    def __ne__(self, other):
        r"""
        __ne__(self, other) -> bool

        Parameters
        ----------
        other: itkPointD2 const &

        """
        return _itkPointPython.itkPointD2___ne__(self, other)

    def __iadd__(self, vec):
        r"""
        __iadd__(self, vec) -> itkPointD2

        Parameters
        ----------
        vec: itkVectorD2 const &

        """
        return _itkPointPython.itkPointD2___iadd__(self, vec)

    def __isub__(self, vec):
        r"""
        __isub__(self, vec) -> itkPointD2

        Parameters
        ----------
        vec: itkVectorD2 const &

        """
        return _itkPointPython.itkPointD2___isub__(self, vec)

    def __add__(self, vec):
        r"""
        __add__(self, vec) -> itkPointD2

        Parameters
        ----------
        vec: itkVectorD2 const &

        """
        return _itkPointPython.itkPointD2___add__(self, vec)

    def __sub__(self, *args):
        r"""
        __sub__(self, pnt) -> itkVectorD2

        Parameters
        ----------
        pnt: itkPointD2 const &

        __sub__(self, vec) -> itkPointD2

        Parameters
        ----------
        vec: itkVectorD2 const &

        """
        return _itkPointPython.itkPointD2___sub__(self, *args)

    def GetVectorFromOrigin(self):
        r"""GetVectorFromOrigin(self) -> itkVectorD2"""
        return _itkPointPython.itkPointD2_GetVectorFromOrigin(self)

    def GetVnlVector(self, *args):
        r"""
        GetVnlVector(self) -> vnl_vector_refD
        GetVnlVector(self) -> vnl_vectorD
        """
        return _itkPointPython.itkPointD2_GetVnlVector(self, *args)

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

        Parameters
        ----------
        arg0: itkPointD2 const &
        arg1: itkPointD2 const &

        """
        return _itkPointPython.itkPointD2_SetToMidPoint(self, arg0, arg1)

    def SetToBarycentricCombination(self, *args):
        r"""
        SetToBarycentricCombination(self, A, B, alpha)

        Parameters
        ----------
        A: itkPointD2 const &
        B: itkPointD2 const &
        alpha: double

        SetToBarycentricCombination(self, A, B, C, weightForA, weightForB)

        Parameters
        ----------
        A: itkPointD2 const &
        B: itkPointD2 const &
        C: itkPointD2 const &
        weightForA: double
        weightForB: double

        SetToBarycentricCombination(self, P, weights, N)

        Parameters
        ----------
        P: itkPointD2 const *
        weights: double const *
        N: unsigned int

        """
        return _itkPointPython.itkPointD2_SetToBarycentricCombination(self, *args)

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

        Parameters
        ----------
        r: double const *

        __init__(self, v) -> itkPointD2

        Parameters
        ----------
        v: double const &

        __init__(self, stdArray) -> itkPointD2

        Parameters
        ----------
        stdArray: std::array< double,2 > const &

        __init__(self, arg0) -> itkPointD2

        Parameters
        ----------
        arg0: itkPointD2 const &

        """
        _itkPointPython.itkPointD2_swiginit(self, _itkPointPython.new_itkPointD2(*args))
    __swig_destroy__ = _itkPointPython.delete_itkPointD2

    def __getitem__(self, d):
        r"""
        __getitem__(self, d) -> double

        Parameters
        ----------
        d: unsigned long

        """
        return _itkPointPython.itkPointD2___getitem__(self, d)

    def __setitem__(self, d, v):
        r"""
        __setitem__(self, d, v)

        Parameters
        ----------
        d: unsigned long
        v: double

        """
        return _itkPointPython.itkPointD2___setitem__(self, d, v)

    @staticmethod
    def __len__():
        r"""__len__() -> unsigned int"""
        return _itkPointPython.itkPointD2___len__()

    def __repr__(self):
        r"""__repr__(self) -> std::string"""
        return _itkPointPython.itkPointD2___repr__(self)

# Register itkPointD2 in _itkPointPython:
_itkPointPython.itkPointD2_swigregister(itkPointD2)
class itkPointD3(itk.itkFixedArrayPython.itkFixedArrayD3):
    r"""Proxy of C++ itkPointD3 class."""

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

    @staticmethod
    def GetPointDimension():
        r"""GetPointDimension() -> unsigned int"""
        return _itkPointPython.itkPointD3_GetPointDimension()

    def __eq__(self, pt):
        r"""
        __eq__(self, pt) -> bool

        Parameters
        ----------
        pt: itkPointD3 const &

        """
        return _itkPointPython.itkPointD3___eq__(self, pt)

    def __ne__(self, other):
        r"""
        __ne__(self, other) -> bool

        Parameters
        ----------
        other: itkPointD3 const &

        """
        return _itkPointPython.itkPointD3___ne__(self, other)

    def __iadd__(self, vec):
        r"""
        __iadd__(self, vec) -> itkPointD3

        Parameters
        ----------
        vec: itkVectorD3 const &

        """
        return _itkPointPython.itkPointD3___iadd__(self, vec)

    def __isub__(self, vec):
        r"""
        __isub__(self, vec) -> itkPointD3

        Parameters
        ----------
        vec: itkVectorD3 const &

        """
        return _itkPointPython.itkPointD3___isub__(self, vec)

    def __add__(self, vec):
        r"""
        __add__(self, vec) -> itkPointD3

        Parameters
        ----------
        vec: itkVectorD3 const &

        """
        return _itkPointPython.itkPointD3___add__(self, vec)

    def __sub__(self, *args):
        r"""
        __sub__(self, pnt) -> itkVectorD3

        Parameters
        ----------
        pnt: itkPointD3 const &

        __sub__(self, vec) -> itkPointD3

        Parameters
        ----------
        vec: itkVectorD3 const &

        """
        return _itkPointPython.itkPointD3___sub__(self, *args)

    def GetVectorFromOrigin(self):
        r"""GetVectorFromOrigin(self) -> itkVectorD3"""
        return _itkPointPython.itkPointD3_GetVectorFromOrigin(self)

    def GetVnlVector(self, *args):
        r"""
        GetVnlVector(self) -> vnl_vector_refD
        GetVnlVector(self) -> vnl_vectorD
        """
        return _itkPointPython.itkPointD3_GetVnlVector(self, *args)

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

        Parameters
        ----------
        arg0: itkPointD3 const &
        arg1: itkPointD3 const &

        """
        return _itkPointPython.itkPointD3_SetToMidPoint(self, arg0, arg1)

    def SetToBarycentricCombination(self, *args):
        r"""
        SetToBarycentricCombination(self, A, B, alpha)

        Parameters
        ----------
        A: itkPointD3 const &
        B: itkPointD3 const &
        alpha: double

        SetToBarycentricCombination(self, A, B, C, weightForA, weightForB)

        Parameters
        ----------
        A: itkPointD3 const &
        B: itkPointD3 const &
        C: itkPointD3 const &
        weightForA: double
        weightForB: double

        SetToBarycentricCombination(self, P, weights, N)

        Parameters
        ----------
        P: itkPointD3 const *
        weights: double const *
        N: unsigned int

        """
        return _itkPointPython.itkPointD3_SetToBarycentricCombination(self, *args)

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

        Parameters
        ----------
        r: double const *

        __init__(self, v) -> itkPointD3

        Parameters
        ----------
        v: double const &

        __init__(self, stdArray) -> itkPointD3

        Parameters
        ----------
        stdArray: std::array< double,3 > const &

        __init__(self, arg0) -> itkPointD3

        Parameters
        ----------
        arg0: itkPointD3 const &

        """
        _itkPointPython.itkPointD3_swiginit(self, _itkPointPython.new_itkPointD3(*args))
    __swig_destroy__ = _itkPointPython.delete_itkPointD3

    def __getitem__(self, d):
        r"""
        __getitem__(self, d) -> double

        Parameters
        ----------
        d: unsigned long

        """
        return _itkPointPython.itkPointD3___getitem__(self, d)

    def __setitem__(self, d, v):
        r"""
        __setitem__(self, d, v)

        Parameters
        ----------
        d: unsigned long
        v: double

        """
        return _itkPointPython.itkPointD3___setitem__(self, d, v)

    @staticmethod
    def __len__():
        r"""__len__() -> unsigned int"""
        return _itkPointPython.itkPointD3___len__()

    def __repr__(self):
        r"""__repr__(self) -> std::string"""
        return _itkPointPython.itkPointD3___repr__(self)

# Register itkPointD3 in _itkPointPython:
_itkPointPython.itkPointD3_swigregister(itkPointD3)
class itkPointD4(itk.itkFixedArrayPython.itkFixedArrayD4):
    r"""Proxy of C++ itkPointD4 class."""

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

    @staticmethod
    def GetPointDimension():
        r"""GetPointDimension() -> unsigned int"""
        return _itkPointPython.itkPointD4_GetPointDimension()

    def __eq__(self, pt):
        r"""
        __eq__(self, pt) -> bool

        Parameters
        ----------
        pt: itkPointD4 const &

        """
        return _itkPointPython.itkPointD4___eq__(self, pt)

    def __ne__(self, other):
        r"""
        __ne__(self, other) -> bool

        Parameters
        ----------
        other: itkPointD4 const &

        """
        return _itkPointPython.itkPointD4___ne__(self, other)

    def __iadd__(self, vec):
        r"""
        __iadd__(self, vec) -> itkPointD4

        Parameters
        ----------
        vec: itkVectorD4 const &

        """
        return _itkPointPython.itkPointD4___iadd__(self, vec)

    def __isub__(self, vec):
        r"""
        __isub__(self, vec) -> itkPointD4

        Parameters
        ----------
        vec: itkVectorD4 const &

        """
        return _itkPointPython.itkPointD4___isub__(self, vec)

    def __add__(self, vec):
        r"""
        __add__(self, vec) -> itkPointD4

        Parameters
        ----------
        vec: itkVectorD4 const &

        """
        return _itkPointPython.itkPointD4___add__(self, vec)

    def __sub__(self, *args):
        r"""
        __sub__(self, pnt) -> itkVectorD4

        Parameters
        ----------
        pnt: itkPointD4 const &

        __sub__(self, vec) -> itkPointD4

        Parameters
        ----------
        vec: itkVectorD4 const &

        """
        return _itkPointPython.itkPointD4___sub__(self, *args)

    def GetVectorFromOrigin(self):
        r"""GetVectorFromOrigin(self) -> itkVectorD4"""
        return _itkPointPython.itkPointD4_GetVectorFromOrigin(self)

    def GetVnlVector(self, *args):
        r"""
        GetVnlVector(self) -> vnl_vector_refD
        GetVnlVector(self) -> vnl_vectorD
        """
        return _itkPointPython.itkPointD4_GetVnlVector(self, *args)

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

        Parameters
        ----------
        arg0: itkPointD4 const &
        arg1: itkPointD4 const &

        """
        return _itkPointPython.itkPointD4_SetToMidPoint(self, arg0, arg1)

    def SetToBarycentricCombination(self, *args):
        r"""
        SetToBarycentricCombination(self, A, B, alpha)

        Parameters
        ----------
        A: itkPointD4 const &
        B: itkPointD4 const &
        alpha: double

        SetToBarycentricCombination(self, A, B, C, weightForA, weightForB)

        Parameters
        ----------
        A: itkPointD4 const &
        B: itkPointD4 const &
        C: itkPointD4 const &
        weightForA: double
        weightForB: double

        SetToBarycentricCombination(self, P, weights, N)

        Parameters
        ----------
        P: itkPointD4 const *
        weights: double const *
        N: unsigned int

        """
        return _itkPointPython.itkPointD4_SetToBarycentricCombination(self, *args)

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

        Parameters
        ----------
        r: double const *

        __init__(self, v) -> itkPointD4

        Parameters
        ----------
        v: double const &

        __init__(self, stdArray) -> itkPointD4

        Parameters
        ----------
        stdArray: std::array< double,4 > const &

        __init__(self, arg0) -> itkPointD4

        Parameters
        ----------
        arg0: itkPointD4 const &

        """
        _itkPointPython.itkPointD4_swiginit(self, _itkPointPython.new_itkPointD4(*args))
    __swig_destroy__ = _itkPointPython.delete_itkPointD4

    def __getitem__(self, d):
        r"""
        __getitem__(self, d) -> double

        Parameters
        ----------
        d: unsigned long

        """
        return _itkPointPython.itkPointD4___getitem__(self, d)

    def __setitem__(self, d, v):
        r"""
        __setitem__(self, d, v)

        Parameters
        ----------
        d: unsigned long
        v: double

        """
        return _itkPointPython.itkPointD4___setitem__(self, d, v)

    @staticmethod
    def __len__():
        r"""__len__() -> unsigned int"""
        return _itkPointPython.itkPointD4___len__()

    def __repr__(self):
        r"""__repr__(self) -> std::string"""
        return _itkPointPython.itkPointD4___repr__(self)

# Register itkPointD4 in _itkPointPython:
_itkPointPython.itkPointD4_swigregister(itkPointD4)
class itkPointD6(itk.itkFixedArrayPython.itkFixedArrayD6):
    r"""Proxy of C++ itkPointD6 class."""

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

    @staticmethod
    def GetPointDimension():
        r"""GetPointDimension() -> unsigned int"""
        return _itkPointPython.itkPointD6_GetPointDimension()

    def __eq__(self, pt):
        r"""
        __eq__(self, pt) -> bool

        Parameters
        ----------
        pt: itkPointD6 const &

        """
        return _itkPointPython.itkPointD6___eq__(self, pt)

    def __ne__(self, other):
        r"""
        __ne__(self, other) -> bool

        Parameters
        ----------
        other: itkPointD6 const &

        """
        return _itkPointPython.itkPointD6___ne__(self, other)

    def __iadd__(self, vec):
        r"""
        __iadd__(self, vec) -> itkPointD6

        Parameters
        ----------
        vec: itkVectorD6 const &

        """
        return _itkPointPython.itkPointD6___iadd__(self, vec)

    def __isub__(self, vec):
        r"""
        __isub__(self, vec) -> itkPointD6

        Parameters
        ----------
        vec: itkVectorD6 const &

        """
        return _itkPointPython.itkPointD6___isub__(self, vec)

    def __add__(self, vec):
        r"""
        __add__(self, vec) -> itkPointD6

        Parameters
        ----------
        vec: itkVectorD6 const &

        """
        return _itkPointPython.itkPointD6___add__(self, vec)

    def __sub__(self, *args):
        r"""
        __sub__(self, pnt) -> itkVectorD6

        Parameters
        ----------
        pnt: itkPointD6 const &

        __sub__(self, vec) -> itkPointD6

        Parameters
        ----------
        vec: itkVectorD6 const &

        """
        return _itkPointPython.itkPointD6___sub__(self, *args)

    def GetVectorFromOrigin(self):
        r"""GetVectorFromOrigin(self) -> itkVectorD6"""
        return _itkPointPython.itkPointD6_GetVectorFromOrigin(self)

    def GetVnlVector(self, *args):
        r"""
        GetVnlVector(self) -> vnl_vector_refD
        GetVnlVector(self) -> vnl_vectorD
        """
        return _itkPointPython.itkPointD6_GetVnlVector(self, *args)

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

        Parameters
        ----------
        arg0: itkPointD6 const &
        arg1: itkPointD6 const &

        """
        return _itkPointPython.itkPointD6_SetToMidPoint(self, arg0, arg1)

    def SetToBarycentricCombination(self, *args):
        r"""
        SetToBarycentricCombination(self, A, B, alpha)

        Parameters
        ----------
        A: itkPointD6 const &
        B: itkPointD6 const &
        alpha: double

        SetToBarycentricCombination(self, A, B, C, weightForA, weightForB)

        Parameters
        ----------
        A: itkPointD6 const &
        B: itkPointD6 const &
        C: itkPointD6 const &
        weightForA: double
        weightForB: double

        SetToBarycentricCombination(self, P, weights, N)

        Parameters
        ----------
        P: itkPointD6 const *
        weights: double const *
        N: unsigned int

        """
        return _itkPointPython.itkPointD6_SetToBarycentricCombination(self, *args)

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

        Parameters
        ----------
        r: double const *

        __init__(self, v) -> itkPointD6

        Parameters
        ----------
        v: double const &

        __init__(self, stdArray) -> itkPointD6

        Parameters
        ----------
        stdArray: std::array< double,6 > const &

        __init__(self, arg0) -> itkPointD6

        Parameters
        ----------
        arg0: itkPointD6 const &

        """
        _itkPointPython.itkPointD6_swiginit(self, _itkPointPython.new_itkPointD6(*args))
    __swig_destroy__ = _itkPointPython.delete_itkPointD6

    def __getitem__(self, d):
        r"""
        __getitem__(self, d) -> double

        Parameters
        ----------
        d: unsigned long

        """
        return _itkPointPython.itkPointD6___getitem__(self, d)

    def __setitem__(self, d, v):
        r"""
        __setitem__(self, d, v)

        Parameters
        ----------
        d: unsigned long
        v: double

        """
        return _itkPointPython.itkPointD6___setitem__(self, d, v)

    @staticmethod
    def __len__():
        r"""__len__() -> unsigned int"""
        return _itkPointPython.itkPointD6___len__()

    def __repr__(self):
        r"""__repr__(self) -> std::string"""
        return _itkPointPython.itkPointD6___repr__(self)

# Register itkPointD6 in _itkPointPython:
_itkPointPython.itkPointD6_swigregister(itkPointD6)
class itkPointF2(itk.itkFixedArrayPython.itkFixedArrayF2):
    r"""Proxy of C++ itkPointF2 class."""

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

    @staticmethod
    def GetPointDimension():
        r"""GetPointDimension() -> unsigned int"""
        return _itkPointPython.itkPointF2_GetPointDimension()

    def __eq__(self, pt):
        r"""
        __eq__(self, pt) -> bool

        Parameters
        ----------
        pt: itkPointF2 const &

        """
        return _itkPointPython.itkPointF2___eq__(self, pt)

    def __ne__(self, other):
        r"""
        __ne__(self, other) -> bool

        Parameters
        ----------
        other: itkPointF2 const &

        """
        return _itkPointPython.itkPointF2___ne__(self, other)

    def __iadd__(self, vec):
        r"""
        __iadd__(self, vec) -> itkPointF2

        Parameters
        ----------
        vec: itkVectorF2 const &

        """
        return _itkPointPython.itkPointF2___iadd__(self, vec)

    def __isub__(self, vec):
        r"""
        __isub__(self, vec) -> itkPointF2

        Parameters
        ----------
        vec: itkVectorF2 const &

        """
        return _itkPointPython.itkPointF2___isub__(self, vec)

    def __add__(self, vec):
        r"""
        __add__(self, vec) -> itkPointF2

        Parameters
        ----------
        vec: itkVectorF2 const &

        """
        return _itkPointPython.itkPointF2___add__(self, vec)

    def __sub__(self, *args):
        r"""
        __sub__(self, pnt) -> itkVectorF2

        Parameters
        ----------
        pnt: itkPointF2 const &

        __sub__(self, vec) -> itkPointF2

        Parameters
        ----------
        vec: itkVectorF2 const &

        """
        return _itkPointPython.itkPointF2___sub__(self, *args)

    def GetVectorFromOrigin(self):
        r"""GetVectorFromOrigin(self) -> itkVectorF2"""
        return _itkPointPython.itkPointF2_GetVectorFromOrigin(self)

    def GetVnlVector(self, *args):
        r"""
        GetVnlVector(self) -> vnl_vector_refF
        GetVnlVector(self) -> vnl_vectorF
        """
        return _itkPointPython.itkPointF2_GetVnlVector(self, *args)

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

        Parameters
        ----------
        arg0: itkPointF2 const &
        arg1: itkPointF2 const &

        """
        return _itkPointPython.itkPointF2_SetToMidPoint(self, arg0, arg1)

    def SetToBarycentricCombination(self, *args):
        r"""
        SetToBarycentricCombination(self, A, B, alpha)

        Parameters
        ----------
        A: itkPointF2 const &
        B: itkPointF2 const &
        alpha: double

        SetToBarycentricCombination(self, A, B, C, weightForA, weightForB)

        Parameters
        ----------
        A: itkPointF2 const &
        B: itkPointF2 const &
        C: itkPointF2 const &
        weightForA: double
        weightForB: double

        SetToBarycentricCombination(self, P, weights, N)

        Parameters
        ----------
        P: itkPointF2 const *
        weights: double const *
        N: unsigned int

        """
        return _itkPointPython.itkPointF2_SetToBarycentricCombination(self, *args)

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

        Parameters
        ----------
        r: float const *

        __init__(self, v) -> itkPointF2

        Parameters
        ----------
        v: float const &

        __init__(self, stdArray) -> itkPointF2

        Parameters
        ----------
        stdArray: std::array< float,2 > const &

        __init__(self, arg0) -> itkPointF2

        Parameters
        ----------
        arg0: itkPointF2 const &

        """
        _itkPointPython.itkPointF2_swiginit(self, _itkPointPython.new_itkPointF2(*args))
    __swig_destroy__ = _itkPointPython.delete_itkPointF2

    def __getitem__(self, d):
        r"""
        __getitem__(self, d) -> float

        Parameters
        ----------
        d: unsigned long

        """
        return _itkPointPython.itkPointF2___getitem__(self, d)

    def __setitem__(self, d, v):
        r"""
        __setitem__(self, d, v)

        Parameters
        ----------
        d: unsigned long
        v: float

        """
        return _itkPointPython.itkPointF2___setitem__(self, d, v)

    @staticmethod
    def __len__():
        r"""__len__() -> unsigned int"""
        return _itkPointPython.itkPointF2___len__()

    def __repr__(self):
        r"""__repr__(self) -> std::string"""
        return _itkPointPython.itkPointF2___repr__(self)

# Register itkPointF2 in _itkPointPython:
_itkPointPython.itkPointF2_swigregister(itkPointF2)
class itkPointF3(itk.itkFixedArrayPython.itkFixedArrayF3):
    r"""Proxy of C++ itkPointF3 class."""

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

    @staticmethod
    def GetPointDimension():
        r"""GetPointDimension() -> unsigned int"""
        return _itkPointPython.itkPointF3_GetPointDimension()

    def __eq__(self, pt):
        r"""
        __eq__(self, pt) -> bool

        Parameters
        ----------
        pt: itkPointF3 const &

        """
        return _itkPointPython.itkPointF3___eq__(self, pt)

    def __ne__(self, other):
        r"""
        __ne__(self, other) -> bool

        Parameters
        ----------
        other: itkPointF3 const &

        """
        return _itkPointPython.itkPointF3___ne__(self, other)

    def __iadd__(self, vec):
        r"""
        __iadd__(self, vec) -> itkPointF3

        Parameters
        ----------
        vec: itkVectorF3 const &

        """
        return _itkPointPython.itkPointF3___iadd__(self, vec)

    def __isub__(self, vec):
        r"""
        __isub__(self, vec) -> itkPointF3

        Parameters
        ----------
        vec: itkVectorF3 const &

        """
        return _itkPointPython.itkPointF3___isub__(self, vec)

    def __add__(self, vec):
        r"""
        __add__(self, vec) -> itkPointF3

        Parameters
        ----------
        vec: itkVectorF3 const &

        """
        return _itkPointPython.itkPointF3___add__(self, vec)

    def __sub__(self, *args):
        r"""
        __sub__(self, pnt) -> itkVectorF3

        Parameters
        ----------
        pnt: itkPointF3 const &

        __sub__(self, vec) -> itkPointF3

        Parameters
        ----------
        vec: itkVectorF3 const &

        """
        return _itkPointPython.itkPointF3___sub__(self, *args)

    def GetVectorFromOrigin(self):
        r"""GetVectorFromOrigin(self) -> itkVectorF3"""
        return _itkPointPython.itkPointF3_GetVectorFromOrigin(self)

    def GetVnlVector(self, *args):
        r"""
        GetVnlVector(self) -> vnl_vector_refF
        GetVnlVector(self) -> vnl_vectorF
        """
        return _itkPointPython.itkPointF3_GetVnlVector(self, *args)

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

        Parameters
        ----------
        arg0: itkPointF3 const &
        arg1: itkPointF3 const &

        """
        return _itkPointPython.itkPointF3_SetToMidPoint(self, arg0, arg1)

    def SetToBarycentricCombination(self, *args):
        r"""
        SetToBarycentricCombination(self, A, B, alpha)

        Parameters
        ----------
        A: itkPointF3 const &
        B: itkPointF3 const &
        alpha: double

        SetToBarycentricCombination(self, A, B, C, weightForA, weightForB)

        Parameters
        ----------
        A: itkPointF3 const &
        B: itkPointF3 const &
        C: itkPointF3 const &
        weightForA: double
        weightForB: double

        SetToBarycentricCombination(self, P, weights, N)

        Parameters
        ----------
        P: itkPointF3 const *
        weights: double const *
        N: unsigned int

        """
        return _itkPointPython.itkPointF3_SetToBarycentricCombination(self, *args)

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

        Parameters
        ----------
        r: float const *

        __init__(self, v) -> itkPointF3

        Parameters
        ----------
        v: float const &

        __init__(self, stdArray) -> itkPointF3

        Parameters
        ----------
        stdArray: std::array< float,3 > const &

        __init__(self, arg0) -> itkPointF3

        Parameters
        ----------
        arg0: itkPointF3 const &

        """
        _itkPointPython.itkPointF3_swiginit(self, _itkPointPython.new_itkPointF3(*args))
    __swig_destroy__ = _itkPointPython.delete_itkPointF3

    def __getitem__(self, d):
        r"""
        __getitem__(self, d) -> float

        Parameters
        ----------
        d: unsigned long

        """
        return _itkPointPython.itkPointF3___getitem__(self, d)

    def __setitem__(self, d, v):
        r"""
        __setitem__(self, d, v)

        Parameters
        ----------
        d: unsigned long
        v: float

        """
        return _itkPointPython.itkPointF3___setitem__(self, d, v)

    @staticmethod
    def __len__():
        r"""__len__() -> unsigned int"""
        return _itkPointPython.itkPointF3___len__()

    def __repr__(self):
        r"""__repr__(self) -> std::string"""
        return _itkPointPython.itkPointF3___repr__(self)

# Register itkPointF3 in _itkPointPython:
_itkPointPython.itkPointF3_swigregister(itkPointF3)
class itkPointF4(itk.itkFixedArrayPython.itkFixedArrayF4):
    r"""Proxy of C++ itkPointF4 class."""

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

    @staticmethod
    def GetPointDimension():
        r"""GetPointDimension() -> unsigned int"""
        return _itkPointPython.itkPointF4_GetPointDimension()

    def __eq__(self, pt):
        r"""
        __eq__(self, pt) -> bool

        Parameters
        ----------
        pt: itkPointF4 const &

        """
        return _itkPointPython.itkPointF4___eq__(self, pt)

    def __ne__(self, other):
        r"""
        __ne__(self, other) -> bool

        Parameters
        ----------
        other: itkPointF4 const &

        """
        return _itkPointPython.itkPointF4___ne__(self, other)

    def __iadd__(self, vec):
        r"""
        __iadd__(self, vec) -> itkPointF4

        Parameters
        ----------
        vec: itkVectorF4 const &

        """
        return _itkPointPython.itkPointF4___iadd__(self, vec)

    def __isub__(self, vec):
        r"""
        __isub__(self, vec) -> itkPointF4

        Parameters
        ----------
        vec: itkVectorF4 const &

        """
        return _itkPointPython.itkPointF4___isub__(self, vec)

    def __add__(self, vec):
        r"""
        __add__(self, vec) -> itkPointF4

        Parameters
        ----------
        vec: itkVectorF4 const &

        """
        return _itkPointPython.itkPointF4___add__(self, vec)

    def __sub__(self, *args):
        r"""
        __sub__(self, pnt) -> itkVectorF4

        Parameters
        ----------
        pnt: itkPointF4 const &

        __sub__(self, vec) -> itkPointF4

        Parameters
        ----------
        vec: itkVectorF4 const &

        """
        return _itkPointPython.itkPointF4___sub__(self, *args)

    def GetVectorFromOrigin(self):
        r"""GetVectorFromOrigin(self) -> itkVectorF4"""
        return _itkPointPython.itkPointF4_GetVectorFromOrigin(self)

    def GetVnlVector(self, *args):
        r"""
        GetVnlVector(self) -> vnl_vector_refF
        GetVnlVector(self) -> vnl_vectorF
        """
        return _itkPointPython.itkPointF4_GetVnlVector(self, *args)

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

        Parameters
        ----------
        arg0: itkPointF4 const &
        arg1: itkPointF4 const &

        """
        return _itkPointPython.itkPointF4_SetToMidPoint(self, arg0, arg1)

    def SetToBarycentricCombination(self, *args):
        r"""
        SetToBarycentricCombination(self, A, B, alpha)

        Parameters
        ----------
        A: itkPointF4 const &
        B: itkPointF4 const &
        alpha: double

        SetToBarycentricCombination(self, A, B, C, weightForA, weightForB)

        Parameters
        ----------
        A: itkPointF4 const &
        B: itkPointF4 const &
        C: itkPointF4 const &
        weightForA: double
        weightForB: double

        SetToBarycentricCombination(self, P, weights, N)

        Parameters
        ----------
        P: itkPointF4 const *
        weights: double const *
        N: unsigned int

        """
        return _itkPointPython.itkPointF4_SetToBarycentricCombination(self, *args)

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

        Parameters
        ----------
        r: float const *

        __init__(self, v) -> itkPointF4

        Parameters
        ----------
        v: float const &

        __init__(self, stdArray) -> itkPointF4

        Parameters
        ----------
        stdArray: std::array< float,4 > const &

        __init__(self, arg0) -> itkPointF4

        Parameters
        ----------
        arg0: itkPointF4 const &

        """
        _itkPointPython.itkPointF4_swiginit(self, _itkPointPython.new_itkPointF4(*args))
    __swig_destroy__ = _itkPointPython.delete_itkPointF4

    def __getitem__(self, d):
        r"""
        __getitem__(self, d) -> float

        Parameters
        ----------
        d: unsigned long

        """
        return _itkPointPython.itkPointF4___getitem__(self, d)

    def __setitem__(self, d, v):
        r"""
        __setitem__(self, d, v)

        Parameters
        ----------
        d: unsigned long
        v: float

        """
        return _itkPointPython.itkPointF4___setitem__(self, d, v)

    @staticmethod
    def __len__():
        r"""__len__() -> unsigned int"""
        return _itkPointPython.itkPointF4___len__()

    def __repr__(self):
        r"""__repr__(self) -> std::string"""
        return _itkPointPython.itkPointF4___repr__(self)

# Register itkPointF4 in _itkPointPython:
_itkPointPython.itkPointF4_swigregister(itkPointF4)
class itkPointF6(itk.itkFixedArrayPython.itkFixedArrayF6):
    r"""Proxy of C++ itkPointF6 class."""

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

    @staticmethod
    def GetPointDimension():
        r"""GetPointDimension() -> unsigned int"""
        return _itkPointPython.itkPointF6_GetPointDimension()

    def __eq__(self, pt):
        r"""
        __eq__(self, pt) -> bool

        Parameters
        ----------
        pt: itkPointF6 const &

        """
        return _itkPointPython.itkPointF6___eq__(self, pt)

    def __ne__(self, other):
        r"""
        __ne__(self, other) -> bool

        Parameters
        ----------
        other: itkPointF6 const &

        """
        return _itkPointPython.itkPointF6___ne__(self, other)

    def __iadd__(self, vec):
        r"""
        __iadd__(self, vec) -> itkPointF6

        Parameters
        ----------
        vec: itkVectorF6 const &

        """
        return _itkPointPython.itkPointF6___iadd__(self, vec)

    def __isub__(self, vec):
        r"""
        __isub__(self, vec) -> itkPointF6

        Parameters
        ----------
        vec: itkVectorF6 const &

        """
        return _itkPointPython.itkPointF6___isub__(self, vec)

    def __add__(self, vec):
        r"""
        __add__(self, vec) -> itkPointF6

        Parameters
        ----------
        vec: itkVectorF6 const &

        """
        return _itkPointPython.itkPointF6___add__(self, vec)

    def __sub__(self, *args):
        r"""
        __sub__(self, pnt) -> itkVectorF6

        Parameters
        ----------
        pnt: itkPointF6 const &

        __sub__(self, vec) -> itkPointF6

        Parameters
        ----------
        vec: itkVectorF6 const &

        """
        return _itkPointPython.itkPointF6___sub__(self, *args)

    def GetVectorFromOrigin(self):
        r"""GetVectorFromOrigin(self) -> itkVectorF6"""
        return _itkPointPython.itkPointF6_GetVectorFromOrigin(self)

    def GetVnlVector(self, *args):
        r"""
        GetVnlVector(self) -> vnl_vector_refF
        GetVnlVector(self) -> vnl_vectorF
        """
        return _itkPointPython.itkPointF6_GetVnlVector(self, *args)

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

        Parameters
        ----------
        arg0: itkPointF6 const &
        arg1: itkPointF6 const &

        """
        return _itkPointPython.itkPointF6_SetToMidPoint(self, arg0, arg1)

    def SetToBarycentricCombination(self, *args):
        r"""
        SetToBarycentricCombination(self, A, B, alpha)

        Parameters
        ----------
        A: itkPointF6 const &
        B: itkPointF6 const &
        alpha: double

        SetToBarycentricCombination(self, A, B, C, weightForA, weightForB)

        Parameters
        ----------
        A: itkPointF6 const &
        B: itkPointF6 const &
        C: itkPointF6 const &
        weightForA: double
        weightForB: double

        SetToBarycentricCombination(self, P, weights, N)

        Parameters
        ----------
        P: itkPointF6 const *
        weights: double const *
        N: unsigned int

        """
        return _itkPointPython.itkPointF6_SetToBarycentricCombination(self, *args)

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

        Parameters
        ----------
        r: float const *

        __init__(self, v) -> itkPointF6

        Parameters
        ----------
        v: float const &

        __init__(self, stdArray) -> itkPointF6

        Parameters
        ----------
        stdArray: std::array< float,6 > const &

        __init__(self, arg0) -> itkPointF6

        Parameters
        ----------
        arg0: itkPointF6 const &

        """
        _itkPointPython.itkPointF6_swiginit(self, _itkPointPython.new_itkPointF6(*args))
    __swig_destroy__ = _itkPointPython.delete_itkPointF6

    def __getitem__(self, d):
        r"""
        __getitem__(self, d) -> float

        Parameters
        ----------
        d: unsigned long

        """
        return _itkPointPython.itkPointF6___getitem__(self, d)

    def __setitem__(self, d, v):
        r"""
        __setitem__(self, d, v)

        Parameters
        ----------
        d: unsigned long
        v: float

        """
        return _itkPointPython.itkPointF6___setitem__(self, d, v)

    @staticmethod
    def __len__():
        r"""__len__() -> unsigned int"""
        return _itkPointPython.itkPointF6___len__()

    def __repr__(self):
        r"""__repr__(self) -> std::string"""
        return _itkPointPython.itkPointF6___repr__(self)

# Register itkPointF6 in _itkPointPython:
_itkPointPython.itkPointF6_swigregister(itkPointF6)

