python3-openturns 1.5-7build2 / usr / lib / python3 / dist-packages / openturns / geom.py

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




"""
Geometrical classes.
"""


from sys import version_info
if version_info >= (2,6,0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_geom', [dirname(__file__)])
        except ImportError:
            import _geom
            return _geom
        if fp is not None:
            try:
                _mod = imp.load_module('_geom', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _geom = swig_import_helper()
    del swig_import_helper
else:
    import _geom
del version_info
try:
    _swig_property = property
except NameError:
    pass # Python < 2.2 doesn't have 'property'.
def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
    if (name == "thisown"): return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    if (not static):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

def _swig_setattr(self,class_type,name,value):
    return _swig_setattr_nondynamic(self,class_type,name,value,0)

def _swig_getattr(self,class_type,name):
    if (name == "thisown"): return self.this.own()
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError(name)

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

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0


class SwigPyIterator(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _geom.delete_SwigPyIterator
    __del__ = lambda self : None;
    def value(self): return _geom.SwigPyIterator_value(self)
    def incr(self, n=1): return _geom.SwigPyIterator_incr(self, n)
    def decr(self, n=1): return _geom.SwigPyIterator_decr(self, n)
    def distance(self, *args): return _geom.SwigPyIterator_distance(self, *args)
    def equal(self, *args): return _geom.SwigPyIterator_equal(self, *args)
    def copy(self): return _geom.SwigPyIterator_copy(self)
    def next(self): return _geom.SwigPyIterator_next(self)
    def __next__(self): return _geom.SwigPyIterator___next__(self)
    def previous(self): return _geom.SwigPyIterator_previous(self)
    def advance(self, *args): return _geom.SwigPyIterator_advance(self, *args)
    def __eq__(self, *args): return _geom.SwigPyIterator___eq__(self, *args)
    def __ne__(self, *args): return _geom.SwigPyIterator___ne__(self, *args)
    def __iadd__(self, *args): return _geom.SwigPyIterator___iadd__(self, *args)
    def __isub__(self, *args): return _geom.SwigPyIterator___isub__(self, *args)
    def __add__(self, *args): return _geom.SwigPyIterator___add__(self, *args)
    def __sub__(self, *args): return _geom.SwigPyIterator___sub__(self, *args)
    def __iter__(self): return self
SwigPyIterator_swigregister = _geom.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

GCC_VERSION = _geom.GCC_VERSION
class TestFailed:
    """TestFailed is used to raise an uniform exception in tests."""

    __type = "TestFailed"

    def __init__(self, reason=""):
        self.reason = reason

    def type(self):
        return TestFailed.__type

    def what(self):
        return self.reason

    def __str__(self):
        return TestFailed.__type + ": " + self.reason

    def __lshift__(self, ch):
        self.reason += ch
        return self

import openturns.common
import openturns.wrapper
import openturns.typ
import openturns.graph
class DomainImplementationTypedInterfaceObject(openturns.common.InterfaceObject):
    __swig_setmethods__ = {}
    for _s in [openturns.common.InterfaceObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DomainImplementationTypedInterfaceObject, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.InterfaceObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DomainImplementationTypedInterfaceObject, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _geom.new_DomainImplementationTypedInterfaceObject(*args)
        try: self.this.append(this)
        except: self.this = this
    def getImplementation(self, *args):
        """
        Accessor to the underlying implementation.

        Returns
        -------
        impl : Implementation
            The implementation class.
        """
        return _geom.DomainImplementationTypedInterfaceObject_getImplementation(self, *args)

    def setName(self, *args):
        """
        Accessor to the object's name.

        Parameters
        ----------
        name : string
            The name of the object.
        """
        return _geom.DomainImplementationTypedInterfaceObject_setName(self, *args)

    def getName(self):
        """
        Accessor to the object's name.

        Returns
        -------
        name : string
            The name of the object.
        """
        return _geom.DomainImplementationTypedInterfaceObject_getName(self)

    def __eq__(self, *args): return _geom.DomainImplementationTypedInterfaceObject___eq__(self, *args)
    __swig_destroy__ = _geom.delete_DomainImplementationTypedInterfaceObject
    __del__ = lambda self : None;
DomainImplementationTypedInterfaceObject_swigregister = _geom.DomainImplementationTypedInterfaceObject_swigregister
DomainImplementationTypedInterfaceObject_swigregister(DomainImplementationTypedInterfaceObject)

class Domain(DomainImplementationTypedInterfaceObject):
    """
    Domain.

    Available constructors:
        Domain(*lowerBound, upperBound*)

    Parameters
    ----------
    lowerBound, upperBound : float sequences of dimension *dim*
        Define a finite :class:`interval <openturns.Interval>`
        :math:`[lowerBound_0, upperBound_0]\\times \\dots \\times [lowerBound_{dim-1}, upperBound_{dim-1}]`.
        It is allowed to have :math:`lowerBound_i \\geq upperBound_i` for some
        :math:`i`: it simply defines an empty interval.
        By default, an empty interval is created.

    Notes
    -----
    A Domain object can be created through its derived classes:

    - :class:`~openturns.Mesh`

    - :class:`~openturns.RegularGrid`

    - :class:`~openturns.Interval`

    - :class:`~openturns.LevelSet`

    Examples
    --------
    >>> import openturns as ot
    >>> # Create the interval [a, b]
    >>> a = 1
    >>> b = 3
    >>> print(ot.Domain([a], [b]))
    [1, 3]
    >>> print(ot.Domain(ot.Interval(a, b)))
    [1, 3]
    """
    __swig_setmethods__ = {}
    for _s in [DomainImplementationTypedInterfaceObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Domain, name, value)
    __swig_getmethods__ = {}
    for _s in [DomainImplementationTypedInterfaceObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Domain, name)
    __repr__ = _swig_repr
    def getClassName(self):
        """
        Accessor to the object's name.

        Returns
        -------
        class_name : str
            The object class name (`object.__class__.__name__`).
        """
        return _geom.Domain_getClassName(self)

    def isEmpty(self):
        """
        Test whether the domain is empty or not.

        Returns
        -------
        isInside : Bool
            *True* if the interior of the geometric domain is empty.
        """
        return _geom.Domain_isEmpty(self)

    def isNumericallyEmpty(self):
        """
        Check if the domain is numerically empty.

        Returns
        -------
        isInside : Bool
            Flag telling whether the domain is numerically empty, i.e. if its numerical
            volume is inferior or equal to :math:`\\epsilon` (defined in the
            :class:`~openturns.ResourceMap`:
            :math:`\\epsilon` = DomainImplementation-SmallVolume).

        Examples
        --------
        >>> import openturns as ot
        >>> # Get the value of epsilon
        >>> print(ot.ResourceMap_GetAsNumericalScalar('DomainImplementation-SmallVolume'))
        1e-12
        """
        return _geom.Domain_isNumericallyEmpty(self)

    def contains(self, *args):
        """
        Check if the given point is inside of the domain.

        Parameters
        ----------
        point : float sequence
            Point with the same dimension as the current domain's dimension.

        Returns
        -------
        isInside : Bool
            Flag telling whether the given point is inside of the domain.
        """
        return _geom.Domain_contains(self, *args)

    def numericallyContains(self, *args):
        """
        Check if the given point is inside of the discretization of the domain.

        Parameters
        ----------
        point : float sequence
            Point with the same dimension as the current domain's dimension.

        Returns
        -------
        isInside : Bool
            Flag telling whether the point is inside the discretized domain associated
            to the domain. For now, by default, the discretized domain is equal to the
            geometrical domain.
        """
        return _geom.Domain_numericallyContains(self, *args)

    def getNumericalVolume(self):
        """
        Get the volume of the domain.

        Returns
        -------
        volume : float
            Volume of the underlying mesh which is the discretization of the domain.
            For now, by default, it is equal to the geometrical volume.
        """
        return _geom.Domain_getNumericalVolume(self)

    def getVolume(self):
        """
        Get the geometric volume of the domain.

        Returns
        -------
        volume : float
            Geometrical volume of the domain.
        """
        return _geom.Domain_getVolume(self)

    def getDimension(self):
        """
        Get the dimension of the domain.

        Returns
        -------
        dim : int
            Dimension of the domain.
        """
        return _geom.Domain_getDimension(self)

    def __init__(self, *args): 
        this = _geom.new_Domain(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _geom.delete_Domain
    __del__ = lambda self : None;
Domain_swigregister = _geom.Domain_swigregister
Domain_swigregister(Domain)

class Mesh(openturns.typ.DomainImplementation):
    """
    Mesh.

    Available constructors:
        Mesh(*dim=1*)

        Mesh(*vertices, simplices*)

    Parameters
    ----------
    dim : int, :math:`dim \\geq 0`
        The dimension of the vertices. By default, it creates only one
        vertex of dimension :math:`dim` with components equal to 0.
    vertices : 2D float sequence
        Vertices' coordinates in :math:`\\Rset^{dim}`.
    simplices : 2D int sequence
        List of simplices defining the topology of the mesh. The simplex
        :math:`[i_1, \\dots, i_{dim+1}]` relies the vertices of index
        :math:`(i_1, \\dots, i_{dim+1})` in :math:`\\Rset^{dim}`. In dimension 1, a
        simplex is an interval :math:`[i_1, i_2]`; in dimension 2, it is a
        triangle :math:`[i_1, i_2, i_3]`.

    See also
    --------
    RegularGrid

    Examples
    --------
    >>> import openturns as ot
    >>> # Define the vertices of the mesh
    >>> vertices = [[0.0, 0.0], [1.0, 0.0], [1.0, 1.0], [1.5, 1.0]]
    >>> # Define the simplices of the mesh
    >>> simplices = ot.IndicesCollection([[0, 1, 2], [1, 2, 3]])
    >>> # Create the mesh of dimension 2
    >>> mesh2d = ot.Mesh(vertices, simplices)
    """
    __swig_setmethods__ = {}
    for _s in [openturns.typ.DomainImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Mesh, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.typ.DomainImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Mesh, name)
    def getClassName(self):
        """
        Accessor to the object's name.

        Returns
        -------
        class_name : str
            The object class name (`object.__class__.__name__`).
        """
        return _geom.Mesh_getClassName(self)

    def contains(self, *args):
        """
        Check if the given point is inside of the domain.

        Parameters
        ----------
        point : float sequence
            Point with the same dimension as the current domain's dimension.

        Returns
        -------
        isInside : Bool
            Flag telling whether the given point is inside of the domain.
        """
        return _geom.Mesh_contains(self, *args)

    def getDescription(self):
        """
        Get the description of the vertices.

        Returns
        -------
        description : string
            Description of the vertices.

        Examples
        --------
        >>> import openturns as ot
        >>> mesh = ot.Mesh()
        >>> vertices = ot.NumericalSample([[0.0, 0.0], [1.0, 0.0], [1.0, 1.0]])
        >>> vertices.setDescription(['X', 'Y'])
        >>> mesh.setVertices(vertices)
        >>> print(mesh.getDescription())
        [X,Y]
        """
        return _geom.Mesh_getDescription(self)

    def getVerticesNumber(self):
        """
        Get the number of vertices of the mesh.

        Returns
        -------
        number : int
            Number of vertices of the mesh.
        """
        return _geom.Mesh_getVerticesNumber(self)

    def getSimplicesNumber(self):
        """
        Get the number of simplices of the mesh.

        Returns
        -------
        number : int
            Number of simplices of the mesh.
        """
        return _geom.Mesh_getSimplicesNumber(self)

    def getNearestVertexIndex(self, *args):
        """
        Get the index of the nearest vertex of a given point.

        Parameters
        ----------
        point : float sequence
            Point of dimension :math:`dim`, the dimension of the vertices of the mesh.

        Returns
        -------
        index : int
            Index of the simplex the nearest of *point* according to the Euclidean
            norm.

        Examples
        --------
        >>> import openturns as ot
        >>> vertices = [[0.0, 0.0], [1.0, 0.0], [1.0, 1.0]]
        >>> simplices = ot.IndicesCollection([[0, 1, 2]])
        >>> mesh2d = ot.Mesh(vertices, simplices)
        >>> point = [0.9, 0.4]
        >>> print(mesh2d.getNearestVertexIndex(point))
        1
        """
        return _geom.Mesh_getNearestVertexIndex(self, *args)

    def getNearestVertex(self, *args):
        """
        Get the nearest vertex of a given point.

        Parameters
        ----------
        point : float sequence
            Point of dimension :math:`dim`, the dimension of the vertices of the mesh.

        Returns
        -------
        vertex : float sequence
            Coordinates of the nearest vertex of *point*.

        Examples
        --------
        >>> import openturns as ot
        >>> vertices = [[0.0, 0.0], [1.0, 0.0], [1.0, 1.0]]
        >>> simplices = ot.IndicesCollection([[0, 1, 2]])
        >>> mesh2d = ot.Mesh(vertices, simplices)
        >>> point = [0.9, 0.4]
        >>> print(mesh2d.getNearestVertex(point))
        [1,0]
        """
        return _geom.Mesh_getNearestVertex(self, *args)

    def __eq__(self, *args): return _geom.Mesh___eq__(self, *args)
    def isValid(self):
        """
        Check the mesh validity.

        Returns
        -------
        validity : Bool
            Tells if the mesh is valid i.e. if there is non-overlaping simplices,
            no unused vertex, no simplices with duplicate vertices and no coincident
            vertices.
        """
        return _geom.Mesh_isValid(self)

    def checkPointInSimplex(self, *args):
        """
        Check whether the given point is inside a simplex.

        Parameters
        ----------
        point : float sequence
            Point of dimension :math:`dim`, the dimension of the vertices of the mesh.
        index : int
            Integer characterizes one simplex of the mesh.

        Returns
        -------
        isInside : Bool
            Flag telling whether *point* is inside the simplex of index *index*.

        Examples
        --------
        >>> import openturns as ot
        >>> vertices = [[0.0, 0.0], [1.0, 0.0], [1.0, 1.0]]
        >>> simplex = ot.IndicesCollection([[0, 1, 2]])
        >>> mesh2d = ot.Mesh(vertices, simplex)
        >>> # Create a point A inside the simplex
        >>> pointA = [0.6, 0.3]
        >>> print(mesh2d.checkPointInSimplex(pointA, 0))
        True
        >>> # Create a point B outside the simplex
        >>> pointB = [1.1, 0.6]
        >>> print(mesh2d.checkPointInSimplex(pointB, 0))
        False
        """
        return _geom.Mesh_checkPointInSimplex(self, *args)

    def getVertices(self):
        """
        Get the vertices of the mesh.

        Returns
        -------
        vertices : 2D float sequence
            Cordinates in :math:`\\Rset^{dim}` of the vertices,
            where :math:`dim` is the dimension of the vertices of the mesh.

        Examples
        --------
        >>> import openturns as ot
        >>> vertices = [[0.0, 0.0], [1.0, 0.0], [1.0, 1.0]]
        >>> simplices = ot.IndicesCollection([[0, 1, 2]])
        >>> mesh2d = ot.Mesh(vertices, simplices)
        >>> print(mesh2d.getVertices())
        0 : [ 0 0 ]
        1 : [ 1 0 ]
        2 : [ 1 1 ]
        """
        return _geom.Mesh_getVertices(self)

    def setVertices(self, *args):
        """
        Set the vertices of the mesh.

        Parameters
        ----------
        vertices : 2D float sequence
            Cordinates in :math:`\\Rset^{dim}` of the vertices,
            where :math:`dim` is the dimension of the vertices of the mesh.

        Examples
        --------
        >>> import openturns as ot
        >>> mesh = ot.Mesh()
        >>> vertices = [[0.0, 0.0], [1.0, 0.0], [1.0, 1.0]]
        >>> mesh.setVertices(vertices)
        """
        return _geom.Mesh_setVertices(self, *args)

    def getVertex(self, *args):
        """
        Get the vertex of a given index.

        Parameters
        ----------
        index : int
            Index characterizing one vertex of the mesh.

        Returns
        -------
        vertex : float sequence
            Coordinates in :math:`\\Rset^{dim}` of the vertex of index *index*,
            where :math:`dim` is the dimension of the vertices of the mesh.

        Examples
        --------
        >>> import openturns as ot
        >>> vertices = [[0.0, 0.0], [1.0, 0.0], [1.0, 1.0]]
        >>> simplices = ot.IndicesCollection([[0, 1, 2]])
        >>> mesh2d = ot.Mesh(vertices, simplices)
        >>> print(mesh2d.getVertex(1))
        [1,0]
        >>> print(mesh2d.getVertex(0))
        [0,0]
        """
        return _geom.Mesh_getVertex(self, *args)

    def setVertex(self, *args):
        """
        Set a vertex of a given index.

        Parameters
        ----------
        index : int
            Index of the vertex to set.
        vertex : float sequence
            Cordinates in :math:`\\Rset^{dim}` of the vertex of index *index*,
            where :math:`dim` is the dimension of the vertices of the mesh.

        Examples
        --------
        >>> import openturns as ot
        >>> vertices = [[0.0, 0.0], [1.0, 0.0], [1.0, 1.0]]
        >>> simplices = ot.IndicesCollection([[0, 1, 2]])
        >>> mesh = ot.Mesh(vertices, simplices)
        >>> vertex = [0.0, 0.5]
        >>> mesh.setVertex(0, vertex)
        >>> print(mesh.getVertices())
        0 : [ 0   0.5 ]
        1 : [ 1   0   ]
        2 : [ 1   1   ]
        """
        return _geom.Mesh_setVertex(self, *args)

    def getSimplices(self):
        """
        Get the simplices of the mesh.

        Returns
        -------
        indicesCollection : 2D int sequence
            List of indices defining all the simplices. The simplex
            :math:`[i_1, \\dots, i_{n+1}]` relies the vertices of index
            :math:`(i_1, \\dots, i_{n+1})` in :math:`\\Rset^{dim}`. In dimension 1, a
            simplex is an interval :math:`[i_1, i_2]`; in dimension 2, it is a
            triangle :math:`[i_1, i_2, i_3]`.

        Examples
        --------
        >>> import openturns as ot
        >>> vertices = [[0.0, 0.0], [1.0, 0.0], [1.0, 1.0], [1.5, 1.0]]
        >>> simplices = ot.IndicesCollection([[0, 1, 2], [1, 2, 3]])
        >>> mesh2d = ot.Mesh(vertices, simplices)
        >>> print(mesh2d.getSimplices())
        [[0,1,2],[1,2,3]]
        """
        return _geom.Mesh_getSimplices(self)

    def setSimplices(self, *args):
        """
        Set the simplices of the mesh.

        Parameters
        ----------
        indices : 2D int sequence
            List of indices defining all the simplices. The simplex
            :math:`[i_1, \\dots, i_{n+1}]` relies the vertices of index
            :math:`(i_1, \\dots, i_{n+1})` in :math:`\\Rset^{dim}`. In dimension 1, a
            simplex is an interval :math:`[i_1, i_2]`; in dimension 2, it is a
            triangle :math:`[i_1, i_2, i_3]`.

        Examples
        --------
        >>> import openturns as ot
        >>> mesh = ot.Mesh()
        >>> simplices = ot.IndicesCollection([[0, 1, 2], [1, 2, 3]])
        >>> mesh.setSimplices(simplices)
        """
        return _geom.Mesh_setSimplices(self, *args)

    def getSimplex(self, *args):
        """
        Get the simplex of a given index.

        Parameters
        ----------
        index : int
            Index characterizing one simplex of the mesh.

        Returns
        -------
        indices : int sequence
            Indices defining the simplex of index *index*. The simplex
            :math:`[i_1, \\dots, i_{n+1}]` relies the vertices of index
            :math:`(i_1, \\dots, i_{n+1})` in :math:`\\Rset^{dim}`. In dimension 1, a
            simplex is an interval :math:`[i_1, i_2]`; in dimension 2, it is a
            triangle :math:`[i_1, i_2, i_3]`.

        Examples
        --------
        >>> import openturns as ot
        >>> vertices = [[0.0, 0.0], [1.0, 0.0], [1.0, 1.0], [1.5, 1.0]]
        >>> simplices = ot.IndicesCollection([[0, 1, 2], [1, 2, 3]])
        >>> mesh2d = ot.Mesh(vertices, simplices)
        >>> print(mesh2d.getSimplex(0))
        [0,1,2]
        >>> print(mesh2d.getSimplex(1))
        [1,2,3]
        """
        return _geom.Mesh_getSimplex(self, *args)

    def computeSimplexVolume(self, *args):
        """
        Compute the volume of a given simplex.

        Parameters
        ----------
        index : int
            Integer characterizes one simplex of the mesh.

        Returns
        -------
        volume : float
            Volume of the simplex of index *index*.

        Examples
        --------
        >>> import openturns as ot
        >>> vertices = [[0.0, 0.0], [1.0, 0.0], [1.0, 1.0]]
        >>> simplex = ot.IndicesCollection([[0, 1, 2]])
        >>> mesh2d = ot.Mesh(vertices, simplex)
        >>> print(mesh2d.computeSimplexVolume(0))
        0.5
        """
        return _geom.Mesh_computeSimplexVolume(self, *args)

    def isRegular(self):
        """
        Check if the mesh is regular (only for 1D meshes).

        Returns
        -------
        isRegular : Bool
            Tells if the mesh is regular or not.

        Examples
        --------
        >>> import openturns as ot
        >>> vertices = [[0.5], [1.5], [2.4], [3.5]]
        >>> simplices = ot.IndicesCollection([[0, 1], [1, 2], [2, 3]])
        >>> mesh1d = ot.Mesh(vertices, simplices)
        >>> print(mesh1d.isRegular())
        False
        >>> vertices = [[0.5], [1.5], [2.5], [3.5]]
        >>> mesh1d = ot.Mesh(vertices, simplices)
        >>> print(mesh1d.isRegular())
        True
        """
        return _geom.Mesh_isRegular(self)

    def draw(self):
        """
        Draw the mesh.

        Returns
        -------
        graph : :class:`~openturns.Graph`
            If the dimension of the mesh is 1, it draws the corresponding interval,
            using the :meth:`draw1D` method; if the dimension is 2, it draws the
            triangular simplices, using the :meth:`draw2D` method; if the dimension is
            3, it projects the simplices on the plane of the two first components,
            using the :meth:`draw3D` method with its default parameters, superposing
            the simplices.
        """
        return _geom.Mesh_draw(self)

    def draw1D(self):
        """
        Draw the mesh of dimension 1.

        Returns
        -------
        graph : :class:`~openturns.Graph`
            Draws the line linking the vertices of the mesh when the mesh is of
            dimension 1.

        Examples
        --------
        >>> import openturns as ot
        >>> vertices = [[0.5], [1.5], [2.1], [2.7]]
        >>> simplices = ot.IndicesCollection([[0, 1], [1, 2], [2, 3]])
        >>> mesh1d = ot.Mesh(vertices, simplices)
        >>> # Create a graph
        >>> aGraph = mesh1d.draw1D()
        >>> # Draw the mesh
        >>> aGraph.draw('mesh1D')
        """
        return _geom.Mesh_draw1D(self)

    def draw2D(self):
        """
        Draw the mesh of dimension 2.

        Returns
        -------
        graph : :class:`~openturns.Graph`
            Draws the edges of each simplex, when the mesh is of dimension 2.

        Examples
        --------
        >>> import openturns as ot
        >>> vertices = [[0.0, 0.0], [1.0, 0.0], [1.0, 1.0], [1.5, 1.0]]
        >>> simplices = ot.IndicesCollection([[0, 1, 2], [1, 2, 3]])
        >>> mesh2d = ot.Mesh(vertices, simplices)
        >>> # Create a graph
        >>> aGraph = mesh2d.draw2D()
        >>> # Draw the mesh
        >>> aGraph.draw('mesh2D')
        """
        return _geom.Mesh_draw2D(self)

    def draw3D(self, *args):
        """
        Draw the bidimensional projection of the mesh.

        Available usages:
            draw(*drawEdge=True, rotation=ot.IdentityMatrix(3), shading=False, rho=1.0*)

        Parameters
        ----------
        drawEdge : Bool
            Tells if the edge of each simplex has to be drawn.
        rotation : :class:`~openturns.SquareMatrix`
            Operates a rotation on the mesh before its projection of the plane of the
            two first components.
        shading  : Bool
            Enables to give a visual perception of depth and orientation.
        rho : float, :math:`0 \\leq \\rho \\leq 1`
            Contraction factor of the simplices. If :math:`\\rho < 1`, all the
            simplices are contracted and appear deconnected: some holes are created,
            which enables to see inside the mesh. If :math:`\\rho = 1`, the simplices
            keep their initial size and appear connected. If :math:`\\rho = 0`, each
            simplex is reduced to its gravity center.

        Returns
        -------
        graph : :class:`~openturns.Graph`
            Draws the bidimensional projection of the mesh on the :math:`(x,y)` plane.

        Examples
        --------
        >>> import openturns as ot
        >>> from math import cos, sin, pi
        >>> vertices = [[0.0, 0.0, 0.0], [0.0, 0.0, 1.0], [0.0, 1.0, 0.0],
        ...             [0.0, 1.0, 1.0], [1.0, 0.0, 0.0], [1.0, 0.0, 1.0],
        ...             [1.0, 1.0, 0.0], [1.0, 1.0, 1.0]]
        >>> simplices = ot.IndicesCollection([[0, 1, 2, 4], [3, 5, 6, 7],
        ...       [1, 2, 3, 6], [1, 2, 4, 6], [1, 3, 5, 6], [1, 4, 5, 6]])
        >>> mesh3d = ot.Mesh(vertices, simplices)
        >>> rotation = ot.SquareMatrix(3)
        >>> rotation[0, 0] = cos(pi / 3.0)
        >>> rotation[0, 1] = sin(pi / 3.0)
        >>> rotation[1, 0] = -sin(pi / 3.0)
        >>> rotation[1, 1] = cos(pi / 3.0)
        >>> rotation[2, 2] = 1.0
        >>> # Create a graph
        >>> aGraph = mesh3d.draw3D(True, rotation)
        >>> # Draw the mesh
        >>> aGraph.draw('mesh3D')
        """
        return _geom.Mesh_draw3D(self, *args)

    def __repr__(self): return _geom.Mesh___repr__(self)
    def __str__(self, offset=""): return _geom.Mesh___str__(self, offset)
    def ImportFromMSHFile(*args):
        """
        Import mesh from FreeFem 2D mesh files.

        Parameters
        ----------
        MSHFile : string
            A MSH ASCII file.

        Returns
        -------
        mesh : :class:`~openturns.Mesh`
            Mesh defined in the file *MSHFile*.
        """
        return _geom.Mesh_ImportFromMSHFile(*args)

    if _newclass:ImportFromMSHFile = staticmethod(ImportFromMSHFile)
    __swig_getmethods__["ImportFromMSHFile"] = lambda x: ImportFromMSHFile
    def streamToVTKFormat(self):
        """
        Give a VTK representation of the mesh.

        Returns
        -------
        stream : string
            VTK representation of the mesh.
        """
        return _geom.Mesh_streamToVTKFormat(self)

    def exportToVTKFile(self, *args):
        """
        Export the mesh to a VTK file.

        Parameters
        ----------
        myVTKFile.vtk : string
            Name of the created file which contains the mesh and the associated random
            values that can be visualized with the open source software
            `Paraview <http://www.paraview.org/>`_.
        """
        return _geom.Mesh_exportToVTKFile(self, *args)

    def __init__(self, *args): 
        this = _geom.new_Mesh(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _geom.delete_Mesh
    __del__ = lambda self : None;
Mesh_swigregister = _geom.Mesh_swigregister
Mesh_swigregister(Mesh)

def Mesh_ImportFromMSHFile(*args):
  """
    Import mesh from FreeFem 2D mesh files.

    Parameters
    ----------
    MSHFile : string
        A MSH ASCII file.

    Returns
    -------
    mesh : :class:`~openturns.Mesh`
        Mesh defined in the file *MSHFile*.
    """
  return _geom.Mesh_ImportFromMSHFile(*args)

class RegularGrid(Mesh):
    __swig_setmethods__ = {}
    for _s in [Mesh]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RegularGrid, name, value)
    __swig_getmethods__ = {}
    for _s in [Mesh]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, RegularGrid, name)
    def getClassName(self):
        """
        Accessor to the object's name.

        Returns
        -------
        class_name : str
            The object class name (`object.__class__.__name__`).
        """
        return _geom.RegularGrid_getClassName(self)

    def __eq__(self, *args): return _geom.RegularGrid___eq__(self, *args)
    def __ne__(self, *args): return _geom.RegularGrid___ne__(self, *args)
    def getStart(self): return _geom.RegularGrid_getStart(self)
    def getEnd(self): return _geom.RegularGrid_getEnd(self)
    def getStep(self): return _geom.RegularGrid_getStep(self)
    def getN(self): return _geom.RegularGrid_getN(self)
    def getValue(self, *args): return _geom.RegularGrid_getValue(self, *args)
    def getValues(self): return _geom.RegularGrid_getValues(self)
    def follows(self, *args): return _geom.RegularGrid_follows(self, *args)
    def isRegular(self):
        """
        Check if the mesh is regular (only for 1D meshes).

        Returns
        -------
        isRegular : Bool
            Tells if the mesh is regular or not.

        Examples
        --------
        >>> import openturns as ot
        >>> vertices = [[0.5], [1.5], [2.4], [3.5]]
        >>> simplices = ot.IndicesCollection([[0, 1], [1, 2], [2, 3]])
        >>> mesh1d = ot.Mesh(vertices, simplices)
        >>> print(mesh1d.isRegular())
        False
        >>> vertices = [[0.5], [1.5], [2.5], [3.5]]
        >>> mesh1d = ot.Mesh(vertices, simplices)
        >>> print(mesh1d.isRegular())
        True
        """
        return _geom.RegularGrid_isRegular(self)

    def getNearestVertexIndex(self, *args):
        """
        Get the index of the nearest vertex of a given point.

        Parameters
        ----------
        point : float sequence
            Point of dimension :math:`dim`, the dimension of the vertices of the mesh.

        Returns
        -------
        index : int
            Index of the simplex the nearest of *point* according to the Euclidean
            norm.

        Examples
        --------
        >>> import openturns as ot
        >>> vertices = [[0.0, 0.0], [1.0, 0.0], [1.0, 1.0]]
        >>> simplices = ot.IndicesCollection([[0, 1, 2]])
        >>> mesh2d = ot.Mesh(vertices, simplices)
        >>> point = [0.9, 0.4]
        >>> print(mesh2d.getNearestVertexIndex(point))
        1
        """
        return _geom.RegularGrid_getNearestVertexIndex(self, *args)

    def __repr__(self): return _geom.RegularGrid___repr__(self)
    def __str__(self, offset=""): return _geom.RegularGrid___str__(self, offset)
    def __init__(self, *args): 
        this = _geom.new_RegularGrid(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _geom.delete_RegularGrid
    __del__ = lambda self : None;
RegularGrid_swigregister = _geom.RegularGrid_swigregister
RegularGrid_swigregister(RegularGrid)

class MeshFactoryImplementation(openturns.common.PersistentObject):
    __swig_setmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MeshFactoryImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MeshFactoryImplementation, name)
    def getClassName(self):
        """
        Accessor to the object's name.

        Returns
        -------
        class_name : str
            The object class name (`object.__class__.__name__`).
        """
        return _geom.MeshFactoryImplementation_getClassName(self)

    def __repr__(self): return _geom.MeshFactoryImplementation___repr__(self)
    def __str__(self, offset=""): return _geom.MeshFactoryImplementation___str__(self, offset)
    def build(self, *args): return _geom.MeshFactoryImplementation_build(self, *args)
    def __init__(self, *args): 
        this = _geom.new_MeshFactoryImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _geom.delete_MeshFactoryImplementation
    __del__ = lambda self : None;
MeshFactoryImplementation_swigregister = _geom.MeshFactoryImplementation_swigregister
MeshFactoryImplementation_swigregister(MeshFactoryImplementation)

class MeshFactoryImplementationTypedInterfaceObject(openturns.common.InterfaceObject):
    __swig_setmethods__ = {}
    for _s in [openturns.common.InterfaceObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MeshFactoryImplementationTypedInterfaceObject, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.InterfaceObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MeshFactoryImplementationTypedInterfaceObject, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _geom.new_MeshFactoryImplementationTypedInterfaceObject(*args)
        try: self.this.append(this)
        except: self.this = this
    def getImplementation(self, *args):
        """
        Accessor to the underlying implementation.

        Returns
        -------
        impl : Implementation
            The implementation class.
        """
        return _geom.MeshFactoryImplementationTypedInterfaceObject_getImplementation(self, *args)

    def setName(self, *args):
        """
        Accessor to the object's name.

        Parameters
        ----------
        name : string
            The name of the object.
        """
        return _geom.MeshFactoryImplementationTypedInterfaceObject_setName(self, *args)

    def getName(self):
        """
        Accessor to the object's name.

        Returns
        -------
        name : string
            The name of the object.
        """
        return _geom.MeshFactoryImplementationTypedInterfaceObject_getName(self)

    def __eq__(self, *args): return _geom.MeshFactoryImplementationTypedInterfaceObject___eq__(self, *args)
    __swig_destroy__ = _geom.delete_MeshFactoryImplementationTypedInterfaceObject
    __del__ = lambda self : None;
MeshFactoryImplementationTypedInterfaceObject_swigregister = _geom.MeshFactoryImplementationTypedInterfaceObject_swigregister
MeshFactoryImplementationTypedInterfaceObject_swigregister(MeshFactoryImplementationTypedInterfaceObject)

class MeshFactory(MeshFactoryImplementationTypedInterfaceObject):
    __swig_setmethods__ = {}
    for _s in [MeshFactoryImplementationTypedInterfaceObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MeshFactory, name, value)
    __swig_getmethods__ = {}
    for _s in [MeshFactoryImplementationTypedInterfaceObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MeshFactory, name)
    def getClassName(self):
        """
        Accessor to the object's name.

        Returns
        -------
        class_name : str
            The object class name (`object.__class__.__name__`).
        """
        return _geom.MeshFactory_getClassName(self)

    def __repr__(self): return _geom.MeshFactory___repr__(self)
    def __str__(self, offset=""): return _geom.MeshFactory___str__(self, offset)
    def build(self, *args): return _geom.MeshFactory_build(self, *args)
    def __init__(self, *args): 
        this = _geom.new_MeshFactory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _geom.delete_MeshFactory
    __del__ = lambda self : None;
MeshFactory_swigregister = _geom.MeshFactory_swigregister
MeshFactory_swigregister(MeshFactory)

class IntervalMesher(MeshFactoryImplementation):
    __swig_setmethods__ = {}
    for _s in [MeshFactoryImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, IntervalMesher, name, value)
    __swig_getmethods__ = {}
    for _s in [MeshFactoryImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, IntervalMesher, name)
    def getClassName(self):
        """
        Accessor to the object's name.

        Returns
        -------
        class_name : str
            The object class name (`object.__class__.__name__`).
        """
        return _geom.IntervalMesher_getClassName(self)

    def setDiscretization(self, *args): return _geom.IntervalMesher_setDiscretization(self, *args)
    def getDiscretization(self): return _geom.IntervalMesher_getDiscretization(self)
    def __repr__(self): return _geom.IntervalMesher___repr__(self)
    def __str__(self, offset=""): return _geom.IntervalMesher___str__(self, offset)
    def build(self, *args): return _geom.IntervalMesher_build(self, *args)
    def __init__(self, *args): 
        this = _geom.new_IntervalMesher(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _geom.delete_IntervalMesher
    __del__ = lambda self : None;
IntervalMesher_swigregister = _geom.IntervalMesher_swigregister
IntervalMesher_swigregister(IntervalMesher)

# This file is compatible with both classic and new-style classes.