otmeshing 0.2.dev0__p39-abi3-win_amd64.whl

otmeshing/__init__.py

@@ -0,0 +1,19 @@
+"""
+    otmeshing --- An OpenTURNS module
+    ==================================
+
+    Contents
+    --------
+      'otmeshing' is a module for OpenTURNS
+
+"""
+
+# flake8: noqa
+
+# ensures swig type tables order & dll load
+import openturns as _ot
+
+from .otmeshing import *
+
+__version__ = '0.2dev0'
+

otmeshing/otmeshing.py

@@ -0,0 +1,1270 @@
+# This file was automatically generated by SWIG (https://www.swig.org).
+# Version 4.4.1
+#
+# Do not make changes to this file unless you know what you are doing - modify
+# the SWIG interface file instead.
+
+"""otmeshing module"""
+
+from sys import version_info as _swig_python_version_info
+# Import the low-level C/C++ module
+if getattr(globals().get("__spec__"), "parent", None) or __package__ or "." in __name__:
+    from . import _otmeshing
+else:
+    import _otmeshing
+
+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__)
+
+
+import openturns.base
+import openturns.common
+import openturns.typ
+import openturns.statistics
+import openturns.graph
+import openturns.func
+import openturns.geom
+import openturns.iterative_statistics
+import openturns.func2
+import openturns.diff
+import openturns.optim
+import openturns.experiment
+import openturns.solver
+import openturns.algo
+import openturns.uncertainty
+import openturns.model_copula
+import openturns.randomvector
+import openturns.dist_bundle1
+import openturns.dist_bundle2
+import openturns.weightedexperiment
+import openturns.classification
+import openturns.orthogonalbasis
+import openturns.metamodel
+import openturns.model_process
+import openturns.dist_bundle3
+import openturns.transformation
+import openturns.analytical
+import openturns.simulation
+import openturns.stattests
+class CloudMesher(openturns.common.PersistentObject):
+    r"""
+    Mesher from a set of points.
+
+    Triangulates a set of points.
+
+    This can also be seen as the volumetric mesh (full cells) of the convex hull.
+
+    Parameters
+    ----------
+    triangulationMethod : int
+        Triangulation method to use, either:
+
+        - CloudMesher.BASIC (default)
+        - CloudMesher.DELAUNAY triangulation with the empty ball property (slower)
+
+    Examples
+    --------
+    Triangulate a set of points:
+
+    >>> import openturns as ot
+    >>> import otmeshing
+    >>> points = ot.JointDistribution([ot.Uniform()] * 2).getSample(15)
+    >>> mesher = otmeshing.CloudMesher(otmeshing.CloudMesher.DELAUNAY)
+    >>> triangulation = mesher.build(points)
+    """
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+
+    def getClassName(self):
+        r"""
+        Accessor to the object's name.
+
+        Returns
+        -------
+        class_name : str
+            The object class name (`object.__class__.__name__`).
+        """
+        return _otmeshing.CloudMesher_getClassName(self)
+    BASIC = _otmeshing.CloudMesher_BASIC
+    DELAUNAY = _otmeshing.CloudMesher_DELAUNAY
+
+    def build(self, points):
+        r"""
+        Triangulate a set of points.
+
+        Parameters
+        ----------
+        points : :class:`~openturns.Sample`
+            A set of points.
+
+        Returns
+        -------
+        mesh : :class:`~openturns.Mesh`
+            The mesh built.
+        """
+        return _otmeshing.CloudMesher_build(self, points)
+
+    def __repr__(self):
+        return _otmeshing.CloudMesher___repr__(self)
+
+    def __init__(self, *args):
+        _otmeshing.CloudMesher_swiginit(self, _otmeshing.new_CloudMesher(*args))
+    __swig_destroy__ = _otmeshing.delete_CloudMesher
+
+# Register CloudMesher in _otmeshing:
+_otmeshing.CloudMesher_swigregister(CloudMesher)
+class ConvexHullMesher(openturns.common.PersistentObject):
+    r"""
+    Meshing of the convex hull of a set of points.
+
+    Yields a surface mesh of the convex hull (of intrinsic dimension d-1).
+
+    Examples
+    --------
+    >>> import openturns as ot
+    >>> import otmeshing
+    >>> points = ot.Normal(2).getSample(100)
+    >>> mesher = otmeshing.ConvexHullMesher()
+    >>> hull = mesher.build(points)
+    """
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+
+    def getClassName(self):
+        r"""
+        Accessor to the object's name.
+
+        Returns
+        -------
+        class_name : str
+            The object class name (`object.__class__.__name__`).
+        """
+        return _otmeshing.ConvexHullMesher_getClassName(self)
+
+    def build(self, points):
+        r"""
+        Buld the convex hull a set of points.
+
+        Parameters
+        ----------
+        points : :class:`~openturns.Sample`
+            A set of points.
+
+        Returns
+        -------
+        mesh : :class:`~openturns.Mesh`
+            The convex hull.
+        """
+        return _otmeshing.ConvexHullMesher_build(self, points)
+
+    def __repr__(self):
+        return _otmeshing.ConvexHullMesher___repr__(self)
+
+    def __init__(self, *args):
+        _otmeshing.ConvexHullMesher_swiginit(self, _otmeshing.new_ConvexHullMesher(*args))
+    __swig_destroy__ = _otmeshing.delete_ConvexHullMesher
+
+# Register ConvexHullMesher in _otmeshing:
+_otmeshing.ConvexHullMesher_swigregister(ConvexHullMesher)
+class ConvexDecompositionMesher(openturns.common.PersistentObject):
+    r"""
+    Build a convex decomposition.
+
+    Notes
+    -----
+    The following keys in :class:`openturns.ResourceMap` can be configured:
+
+    - *ConvexDecompositionMesher-Threshold*: concavity threshold for CoACD
+      decomposition (default=0.05).
+
+    """
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+
+    def getClassName(self):
+        r"""
+        Accessor to the object's name.
+
+        Returns
+        -------
+        class_name : str
+            The object class name (`object.__class__.__name__`).
+        """
+        return _otmeshing.ConvexDecompositionMesher_getClassName(self)
+
+    def build(self, mesh):
+        r"""
+        Build a convex decomposition.
+
+        Parameters
+        ----------
+        mesh : :class:`~openturns.Mesh`
+            A mesh.
+
+        Returns
+        -------
+        decomposition : sequence of :class:`~openturns.Mesh`
+            A sequence of non-convex polyhedra.
+        """
+        return _otmeshing.ConvexDecompositionMesher_build(self, mesh)
+
+    def __repr__(self):
+        return _otmeshing.ConvexDecompositionMesher___repr__(self)
+
+    @staticmethod
+    def IsConvex(mesh):
+        r"""
+        Test whether a mesh is convex.
+
+        We test the volume of the mesh versus the volume of its convex hull.
+
+        Parameters
+        ----------
+        mesh : :py:class:`openturns.Mesh`
+            A mesh.
+
+        Returns
+        -------
+        isConvex : bool
+            Whether the mesh is convex.
+
+        """
+        return _otmeshing.ConvexDecompositionMesher_IsConvex(mesh)
+
+    def setUseSimplicesDecomposition(self, useSimplicesDecomposition):
+        r"""
+        Simplicial decomposition flag accessor.
+
+        Parameters
+        ----------
+        useSimplicesDecomposition : bool
+            Whether to decompose the mesh by its simplices.
+
+        """
+        return _otmeshing.ConvexDecompositionMesher_setUseSimplicesDecomposition(self, useSimplicesDecomposition)
+
+    def getUseSimplicesDecomposition(self):
+        r"""
+        Simplicial decomposition flag accessor.
+
+        Returns
+        -------
+        useSimplicesDecomposition : bool
+            Whether to decompose the mesh by its simplices.
+
+        """
+        return _otmeshing.ConvexDecompositionMesher_getUseSimplicesDecomposition(self)
+
+    @staticmethod
+    def HasFeature(feature):
+        r"""
+        Test available features.
+
+        Parameters
+        ----------
+        feature : str
+            A feature (for example coacd).
+
+        Returns
+        -------
+        hasFeature : bool
+            Whether the feature is enabled.
+
+        """
+        return _otmeshing.ConvexDecompositionMesher_HasFeature(feature)
+
+    def __init__(self, *args):
+        _otmeshing.ConvexDecompositionMesher_swiginit(self, _otmeshing.new_ConvexDecompositionMesher(*args))
+    __swig_destroy__ = _otmeshing.delete_ConvexDecompositionMesher
+
+# Register ConvexDecompositionMesher in _otmeshing:
+_otmeshing.ConvexDecompositionMesher_swigregister(ConvexDecompositionMesher)
+class _MeshCollection(object):
+    r"""
+    Collection.
+
+    Examples
+    --------
+    >>> import openturns as ot
+
+    - Collection of **real values**:
+
+    >>> ot.ScalarCollection(2)
+    [0,0]
+    >>> ot.ScalarCollection(2, 3.25)
+    [3.25,3.25]
+    >>> vector = ot.ScalarCollection([2.0, 1.5, 2.6])
+    >>> vector
+    [2,1.5,2.6]
+    >>> vector[1] = 4.2
+    >>> vector
+    [2,4.2,2.6]
+    >>> vector.add(3.8)
+    >>> vector
+    [2,4.2,2.6,3.8]
+
+    - Collection of **complex values**:
+
+    >>> ot.ComplexCollection(2)
+    [(0,0),(0,0)]
+    >>> ot.ComplexCollection(2, 3+4j)
+    [(3,4),(3,4)]
+    >>> vector = ot.ComplexCollection([2+3j, 1-4j, 3.0])
+    >>> vector
+    [(2,3),(1,-4),(3,0)]
+    >>> vector[1] = 4+3j
+    >>> vector
+    [(2,3),(4,3),(3,0)]
+    >>> vector.add(5+1j)
+    >>> vector
+    [(2,3),(4,3),(3,0),(5,1)]
+
+    - Collection of **booleans**:
+
+    >>> ot.BoolCollection(3)
+    [0,0,0]
+    >>> ot.BoolCollection(3, 1)
+    [1,1,1]
+    >>> vector = ot.BoolCollection([0, 1, 0])
+    >>> vector
+    [0,1,0]
+    >>> vector[1] = 0
+    >>> vector
+    [0,0,0]
+    >>> vector.add(1)
+    >>> vector
+    [0,0,0,1]
+
+    - Collection of **distributions**:
+
+    >>> print(ot.DistributionCollection(2))
+    [Uniform(a = -1, b = 1),Uniform(a = -1, b = 1)]
+    >>> print(ot.DistributionCollection(2, ot.Gamma(2.75, 1.0)))
+    [Gamma(k = 2.75, lambda = 1, gamma = 0),Gamma(k = 2.75, lambda = 1, gamma = 0)]
+    >>> vector = ot.DistributionCollection([ot.Normal(), ot.Uniform()])
+    >>> print(vector)
+    [Normal(mu = 0, sigma = 1),Uniform(a = -1, b = 1)]
+    >>> vector[1] = ot.Uniform(-0.5, 1)
+    >>> print(vector)
+    [Normal(mu = 0, sigma = 1),Uniform(a = -0.5, b = 1)]
+    >>> vector.add(ot.Gamma(2.75, 1.0))
+    >>> print(vector)
+    [Normal(mu = 0, sigma = 1),Uniform(a = -0.5, b = 1),Gamma(k = 2.75, lambda = 1, gamma = 0)]
+    """
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __swig_destroy__ = _otmeshing.delete__MeshCollection
+
+    def clear(self):
+        r"""
+        Reset the collection to zero dimension.
+
+        Examples
+        --------
+        >>> import openturns as ot
+        >>> x = ot.Point(2)
+        >>> x.clear()
+        >>> x
+        class=Point name=Unnamed dimension=0 values=[]
+        """
+        return _otmeshing._MeshCollection_clear(self)
+
+    def __len__(self):
+        return _otmeshing._MeshCollection___len__(self)
+
+    def __eq__(self, rhs):
+        return _otmeshing._MeshCollection___eq__(self, rhs)
+
+    def __contains__(self, val):
+        return _otmeshing._MeshCollection___contains__(self, val)
+
+    def select(self, marginalIndices):
+        r"""
+        Selection from indices.
+
+        Parameters
+        ----------
+        indices : sequence of int
+            Indices to select
+
+        Returns
+        -------
+        coll : sequence
+            Sub-collection of values at the selection indices.
+        """
+        return _otmeshing._MeshCollection_select(self, marginalIndices)
+
+    def __getitem__(self, i):
+        return _otmeshing._MeshCollection___getitem__(self, i)
+
+    def __setitem__(self, i, val):
+        return _otmeshing._MeshCollection___setitem__(self, i, val)
+
+    def __delitem__(self, i):
+        return _otmeshing._MeshCollection___delitem__(self, i)
+
+    def at(self, *args):
+        r"""
+        Access to an element of the collection.
+
+        Parameters
+        ----------
+        index : positive int
+            Position of the element to access.
+
+        Returns
+        -------
+        element : type depends on the type of the collection
+            Element of the collection at the position *index*.
+        """
+        return _otmeshing._MeshCollection_at(self, *args)
+
+    def add(self, *args):
+        r"""
+        Append a component (in-place).
+
+        Parameters
+        ----------
+        value : type depends on the type of the collection.
+            The component to append.
+
+        Examples
+        --------
+        >>> import openturns as ot
+        >>> x = ot.Point(2)
+        >>> x.add(1.)
+        >>> print(x)
+        [0,0,1]
+        """
+        return _otmeshing._MeshCollection_add(self, *args)
+
+    def getSize(self):
+        r"""
+        Get the collection's dimension (or size).
+
+        Returns
+        -------
+        n : int
+            The number of components in the collection.
+        """
+        return _otmeshing._MeshCollection_getSize(self)
+
+    def resize(self, newSize):
+        r"""
+        Change the size of the collection.
+
+        Parameters
+        ----------
+        newSize : positive int
+            New size of the collection.
+
+        Notes
+        -----
+        If the new size is smaller than the older one, the last elements are thrown
+        away, else the new elements are set to the default value of the element type.
+
+        Examples
+        --------
+        >>> import openturns as ot
+        >>> x = ot.Point(2, 4)
+        >>> print(x)
+        [4,4]
+        >>> x.resize(1)
+        >>> print(x)
+        [4]
+        >>> x.resize(4)
+        >>> print(x)
+        [4,0,0,0]
+        """
+        return _otmeshing._MeshCollection_resize(self, newSize)
+
+    def isEmpty(self):
+        r"""
+        Tell if the collection is empty.
+
+        Returns
+        -------
+        isEmpty : bool
+            *True* if there is no element in the collection.
+
+        Examples
+        --------
+        >>> import openturns as ot
+        >>> x = ot.Point(2)
+        >>> x.isEmpty()
+        False
+        >>> x.clear()
+        >>> x.isEmpty()
+        True
+        """
+        return _otmeshing._MeshCollection_isEmpty(self)
+
+    def find(self, val):
+        return _otmeshing._MeshCollection_find(self, val)
+
+    def __repr__(self):
+        return _otmeshing._MeshCollection___repr__(self)
+
+    def __str__(self, *args):
+        return _otmeshing._MeshCollection___str__(self, *args)
+
+    def index(self, value):
+        r"""
+        Find the index of a given value.
+
+        Parameters
+        ----------
+        val : collection value type
+            The value to find
+
+        Returns
+        -------
+        index : int
+            The index of the first occurrence of the value.
+            Throws when the value is not found.
+        """
+        return _otmeshing._MeshCollection_index(self, value)
+
+    def __init__(self, *args):
+        _otmeshing._MeshCollection_swiginit(self, _otmeshing.new__MeshCollection(*args))
+
+# Register _MeshCollection in _otmeshing:
+_otmeshing._MeshCollection_swigregister(_MeshCollection)
+class Cylinder(openturns.common.PersistentObject):
+    r"""
+    Generalized cylinder.
+
+    Parameters
+    ----------
+    base : :py:class:`openturns.Mesh`
+        Cylinder base
+    extension : :py:class:`openturns.Interval`
+        Extension range 
+    injection : sequence of int
+        Dimension indices of the extension
+    discretization : int
+        Discretization number along dimensions of the extension
+
+    Examples
+    --------
+    Create a cylinder with an octogonal base, extended in the z-axis over [0, 5]:
+
+    >>> import otmeshing
+    >>> import openturns as ot
+    >>> import math
+    >>> polyline = []
+    >>> n = 8
+    >>> for i in range(n):
+    ...     theta = i * 2.0 * math.pi / n
+    ...     polyline.append([math.cos(theta), math.sin(theta)])
+    >>> base = otmeshing.PolygonMesher().build(polyline)
+    >>> extension = ot.Interval([0.0], [5.0])  # z-range
+    >>> injection = [2]  # extension in the z-axis
+    >>> M = 4  # number of cells in the z-axis
+    >>> cylinder = otmeshing.Cylinder(base, extension, injection, M)
+    """
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+
+    def getClassName(self):
+        r"""
+        Accessor to the object's name.
+
+        Returns
+        -------
+        class_name : str
+            The object class name (`object.__class__.__name__`).
+        """
+        return _otmeshing.Cylinder_getClassName(self)
+
+    def __init__(self, *args):
+        _otmeshing.Cylinder_swiginit(self, _otmeshing.new_Cylinder(*args))
+
+    def __repr__(self):
+        return _otmeshing.Cylinder___repr__(self)
+
+    def __str__(self, *args):
+        return _otmeshing.Cylinder___str__(self, *args)
+
+    def getBase(self):
+        r"""
+        Base accessor.
+
+        Returns
+        -------
+        base : :py:class:`openturns.Mesh`
+            Cylinder base
+        """
+        return _otmeshing.Cylinder_getBase(self)
+
+    def getExtension(self):
+        r"""
+        Extension accessor.
+
+        Returns
+        -------
+        extension : :py:class:`openturns.Interval`
+            Extension range
+        """
+        return _otmeshing.Cylinder_getExtension(self)
+
+    def getInjection(self):
+        r"""
+        Injection accessor.
+
+        Returns
+        -------
+        injection : :py:class:`openturns.Indices`
+            Dimension indices of the extension
+        """
+        return _otmeshing.Cylinder_getInjection(self)
+
+    def getDiscretization(self):
+        r"""
+        Discretization accessor.
+
+        Returns
+        -------
+        discretization : int
+            Discretization number along dimensions of the extension
+        """
+        return _otmeshing.Cylinder_getDiscretization(self)
+
+    def getVertices(self):
+        r"""
+        Vertices accessor.
+
+        Returns
+        -------
+        vertices : :py:class:`openturns.Sample`
+            Cylinder vertices.
+        """
+        return _otmeshing.Cylinder_getVertices(self)
+
+    def getBoundingBox(self):
+        r"""
+        Bounding box accessor.
+
+        Returns
+        -------
+        bbox : :py:class:`openturns.Interval`
+            Cylinder bounding box.
+        """
+        return _otmeshing.Cylinder_getBoundingBox(self)
+
+    def getVolume(self):
+        r"""
+        Volume accessor.
+
+        Returns
+        -------
+        volume : float
+            Cylinder volume.
+        """
+        return _otmeshing.Cylinder_getVolume(self)
+
+    def isConvex(self):
+        r"""
+        Convex property accessor.
+
+        Returns
+        -------
+        isConvex : bool
+            Convex property.
+        """
+        return _otmeshing.Cylinder_isConvex(self)
+
+    def getDimension(self):
+        r"""
+        Dimension accessor.
+
+        Returns
+        -------
+        dimension : int
+            Dimension
+        """
+        return _otmeshing.Cylinder_getDimension(self)
+
+    def computeMesh(self):
+        r"""
+        Build the mesh.
+
+        Returns
+        -------
+        mesh : :py:class:`openturns.Mesh`
+            Mesh of the cylinder
+        """
+        return _otmeshing.Cylinder_computeMesh(self)
+    __swig_destroy__ = _otmeshing.delete_Cylinder
+
+# Register Cylinder in _otmeshing:
+_otmeshing.Cylinder_swigregister(Cylinder)
+class FunctionGraphMesher(openturns.common.PersistentObject):
+    r"""
+    Function meshing algorithm.
+
+    Examples
+    --------
+    >>> import openturns as ot
+    >>> import otmeshing
+    >>> bbox = ot.Interval([-8] * 2, [8] * 2)
+    >>> inputDiscretization = [10] * 2
+    >>> mesher = otmeshing.FunctionGraphMesher(bbox, inputDiscretization)
+    >>> f = ot.SymbolicFunction(['x', 'y'], ['cos(x) * sin(y)'])
+    >>> zIndex = 2  # z axis index
+    >>> zMin, zMax = 0.01, 0.3  # clip f in [0.01, 0.3]
+    >>> mesh = mesher.build(f, zIndex, zMin, zMax)
+    """
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+
+    def getClassName(self):
+        r"""
+        Accessor to the object's name.
+
+        Returns
+        -------
+        class_name : str
+            The object class name (`object.__class__.__name__`).
+        """
+        return _otmeshing.FunctionGraphMesher_getClassName(self)
+
+    def __init__(self, *args):
+        _otmeshing.FunctionGraphMesher_swiginit(self, _otmeshing.new_FunctionGraphMesher(*args))
+
+    def __repr__(self):
+        return _otmeshing.FunctionGraphMesher___repr__(self)
+
+    def __str__(self, *args):
+        return _otmeshing.FunctionGraphMesher___str__(self, *args)
+
+    def build(self, function, outputIndex, minOutput, maxOutput, outputDiscretization=1, subGraph=True):
+        r"""
+        Generate a mesh from function discretization.
+
+        Parameters
+        ----------
+        function : :py:class:`openturns.Function`
+            Surface function, of output dimension 1
+        outputIndex : int
+            Index of the output variable
+        minOutput : float
+            Minimum output value
+        maxOutput : float
+            Maximum output value
+        outputDiscretization : int, optional
+            Number of discretizations along the output axis (default=1)
+        subGraph : bool, optional
+            Whether to mesh below or above the surface (default=True: below)
+
+        Returns
+        -------
+        mesh : :py:class:`openturns.Mesh`
+            The mesh generated.
+        """
+        return _otmeshing.FunctionGraphMesher_build(self, function, outputIndex, minOutput, maxOutput, outputDiscretization, subGraph)
+    __swig_destroy__ = _otmeshing.delete_FunctionGraphMesher
+
+# Register FunctionGraphMesher in _otmeshing:
+_otmeshing.FunctionGraphMesher_swigregister(FunctionGraphMesher)
+class IntersectionMesher(openturns.common.PersistentObject):
+    r"""
+    Intersection meshing algorithm.
+
+    Examples
+    --------
+    Triangulate a parallelogram:
+
+    >>> import otmeshing
+    >>> import openturns as ot
+    >>> mesher = otmeshing.IntersectionMesher()
+    >>> dim = 2
+    >>> mesh1 = ot.IntervalMesher([1] * dim).build(ot.Interval([0.0] * dim, [3.0] * dim))
+    >>> mesh2 = ot.IntervalMesher([1] * dim).build(ot.Interval([1.0] * dim, [4.0] * dim))
+    >>> intersection = mesher.build([mesh1, mesh2])  # doctest: +SKIP
+
+    """
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+
+    def getClassName(self):
+        r"""
+        Accessor to the object's name.
+
+        Returns
+        -------
+        class_name : str
+            The object class name (`object.__class__.__name__`).
+        """
+        return _otmeshing.IntersectionMesher_getClassName(self)
+
+    def __init__(self):
+        _otmeshing.IntersectionMesher_swiginit(self, _otmeshing.new_IntersectionMesher())
+
+    def __repr__(self):
+        return _otmeshing.IntersectionMesher___repr__(self)
+
+    def __str__(self, *args):
+        return _otmeshing.IntersectionMesher___str__(self, *args)
+
+    def build(self, coll):
+        r"""
+        Generate the mesh of the intersection.
+
+        Parameters
+        ----------
+        coll : sequence of :py:class:`openturns.Mesh`
+            Input meshes.
+
+        Returns
+        -------
+        mesh : :py:class:`openturns.Mesh`
+            The mesh of the intersection.
+        """
+        return _otmeshing.IntersectionMesher_build(self, coll)
+
+    def buildWithConvexParts(self, mesh, convexPieces):
+        r"""
+        Generate the mesh of the intersection of a mesh with pre-decomposed convex pieces.
+
+        Parameters
+        ----------
+        mesh : :py:class:`openturns.Mesh`
+            The first mesh, to be internally decomposed into convex parts.
+        convexPieces : sequence of :py:class:`openturns.Sample`
+            Pre-decomposed convex vertex sets for the second operand, e.g. from :meth:`buildCylinderConvex`.
+
+        Returns
+        -------
+        mesh : :py:class:`openturns.Mesh`
+            The mesh of the intersection.
+        """
+        return _otmeshing.IntersectionMesher_buildWithConvexParts(self, mesh, convexPieces)
+
+    def buildConvex(self, coll):
+        r"""
+        Generate the mesh of the intersection of convexes.
+
+        Parameters
+        ----------
+        coll : sequence of :py:class:`openturns.Mesh`
+            Input convex meshes.
+
+        Returns
+        -------
+        mesh : :py:class:`openturns.Mesh`
+            The mesh of the intersection.
+        """
+        return _otmeshing.IntersectionMesher_buildConvex(self, coll)
+
+    def buildConvexSample(self, coll):
+        r"""
+        Generate the vertices of the intersection of convexes.
+
+        Parameters
+        ----------
+        coll : sequence of :py:class:`openturns.Sample`
+            Input convex vertices.
+
+        Returns
+        -------
+        vertices : :py:class:`openturns.Sample`
+            The vertices of the intersection.
+        """
+        return _otmeshing.IntersectionMesher_buildConvexSample(self, coll)
+
+    def buildCylinder(self, coll):
+        r"""
+        Generate the mesh of the intersection of cylinders.
+
+        Parameters
+        ----------
+        coll : sequence of :class:`~otmeshing.Cylinder`
+            Input cylinders.
+
+        Returns
+        -------
+        mesh : :py:class:`openturns.Mesh`
+            The mesh of the intersection.
+        """
+        return _otmeshing.IntersectionMesher_buildCylinder(self, coll)
+
+    def buildCylinderConvex(self, coll):
+        r"""
+        Generate the convex decomposition of the intersection of cylinders.
+
+        Parameters
+        ----------
+        coll : sequence of :class:`~otmeshing.Cylinder`
+            Input cylinders.
+
+        Returns
+        -------
+        pieces : sequence of :py:class:`openturns.Sample`
+            Convex vertex sets representing the intersection, suitable for use with :meth:`build`.
+        """
+        return _otmeshing.IntersectionMesher_buildCylinderConvex(self, coll)
+
+    def setRecompress(self, recompress):
+        r"""
+        Recompression flag accessor.
+
+        Parameters
+        ----------
+        recompress : bool
+            Whether to eliminate duplicate vertices.
+
+        """
+        return _otmeshing.IntersectionMesher_setRecompress(self, recompress)
+
+    def getRecompress(self):
+        r"""
+        Recompression flag accessor.
+
+        Returns
+        -------
+        recompress : bool
+            Whether to eliminate duplicate vertices.
+
+        """
+        return _otmeshing.IntersectionMesher_getRecompress(self)
+
+    def setUseSimplicesDecomposition(self, useSimplicesDecomposition):
+        r"""
+        Simplicial decomposition flag accessor.
+
+        Parameters
+        ----------
+        useSimplicesDecomposition : bool
+            Whether to decompose the mesh by its simplices.
+
+        """
+        return _otmeshing.IntersectionMesher_setUseSimplicesDecomposition(self, useSimplicesDecomposition)
+
+    def getUseSimplicesDecomposition(self):
+        r"""
+        Simplicial decomposition flag accessor.
+
+        Returns
+        -------
+        useSimplicesDecomposition : bool
+            Whether to decompose the mesh by its simplices.
+
+        """
+        return _otmeshing.IntersectionMesher_getUseSimplicesDecomposition(self)
+    __swig_destroy__ = _otmeshing.delete_IntersectionMesher
+
+# Register IntersectionMesher in _otmeshing:
+_otmeshing.IntersectionMesher_swigregister(IntersectionMesher)
+class MeshDomain2(openturns.algo.MeshDomain):
+    r"""
+    Adaptor to convert a Mesh to a Domain, with signed distance.
+
+    Parameters
+    ----------
+    mesh : :class:`~openturns.Mesh`
+        Underlying mesh.
+
+    Examples
+    --------
+    Compute the distance from a point to a domain defined from
+    the mesh of the unit square
+
+    >>> import otmeshing
+    >>> import openturns as ot
+    >>> dim = 2
+    >>> mesh = ot.IntervalMesher([1] * dim).build(ot.Interval(dim))
+    >>> domain = otmeshing.MeshDomain2(mesh)
+    >>> p = [5.0] * dim
+    >>> distance = domain.computeDistance(p)
+
+    """
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def getClassName(self):
+        r"""
+        Accessor to the object's name.
+
+        Returns
+        -------
+        class_name : str
+            The object class name (`object.__class__.__name__`).
+        """
+        return _otmeshing.MeshDomain2_getClassName(self)
+
+    def __init__(self, *args):
+        _otmeshing.MeshDomain2_swiginit(self, _otmeshing.new_MeshDomain2(*args))
+
+    def computeDistance(self, *args):
+        r"""
+        Compute the Euclidean distance of a given point to the domain.
+
+        Parameters
+        ----------
+        point or sample : sequence of float or 2-d sequence of float
+            Point or Sample with the same dimension as the current domain's dimension.
+
+        Returns
+        -------
+        distance : float or Sample
+            Euclidean distance of the point to the domain.
+        """
+        return _otmeshing.MeshDomain2_computeDistance(self, *args)
+    __swig_destroy__ = _otmeshing.delete_MeshDomain2
+
+# Register MeshDomain2 in _otmeshing:
+_otmeshing.MeshDomain2_swigregister(MeshDomain2)
+class PolygonMesher(openturns.common.PersistentObject):
+    r"""
+    2-d Polygon meshing algorithm.
+
+    Examples
+    --------
+    Triangulate a parallelogram:
+
+    >>> import otmeshing
+    >>> mesher = otmeshing.PolygonMesher()
+    >>> polyline = [[0, 0], [3, 0], [4, 2], [1, 2]]
+    >>> triangulation = mesher.build(polyline)
+    """
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+
+    def getClassName(self):
+        r"""
+        Accessor to the object's name.
+
+        Returns
+        -------
+        class_name : str
+            The object class name (`object.__class__.__name__`).
+        """
+        return _otmeshing.PolygonMesher_getClassName(self)
+
+    def __init__(self):
+        _otmeshing.PolygonMesher_swiginit(self, _otmeshing.new_PolygonMesher())
+
+    def __repr__(self):
+        return _otmeshing.PolygonMesher___repr__(self)
+
+    def __str__(self, *args):
+        return _otmeshing.PolygonMesher___str__(self, *args)
+
+    def build(self, points):
+        r"""
+        Generate a mesh from polygon coordinates.
+
+        Parameters
+        ----------
+        polyline : :py:class:`openturns.Sample`
+            An ordered set of vertices defining a 2-d polygon, possibly non-convex.
+            The polygon must be simple (with no redundant vertex).
+            The vertices can be of dimension greater than 2,
+            but the polygon itsef should be within a single plane.
+
+        Returns
+        -------
+        mesh : :py:class:`openturns.Mesh`
+            The triangulation generated.
+        """
+        return _otmeshing.PolygonMesher_build(self, points)
+    __swig_destroy__ = _otmeshing.delete_PolygonMesher
+
+# Register PolygonMesher in _otmeshing:
+_otmeshing.PolygonMesher_swigregister(PolygonMesher)
+class UnionMesher(openturns.common.PersistentObject):
+    r"""
+    Union of disjoint meshes.
+
+    Examples
+    --------
+    >>> import openturns as ot
+    >>> import otmeshing
+    >>> mesher = otmeshing.UnionMesher()
+    >>> dim = 2
+    >>> mesh1 = ot.IntervalMesher([1] * dim).build(ot.Interval(dim))
+    >>> mesh2 = ot.IntervalMesher([1] * dim).build(ot.Interval([2.0] * dim, [3.0] * dim))
+    >>> union = mesher.build([mesh1, mesh2])
+    """
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+
+    def getClassName(self):
+        r"""
+        Accessor to the object's name.
+
+        Returns
+        -------
+        class_name : str
+            The object class name (`object.__class__.__name__`).
+        """
+        return _otmeshing.UnionMesher_getClassName(self)
+
+    def __init__(self):
+        _otmeshing.UnionMesher_swiginit(self, _otmeshing.new_UnionMesher())
+
+    def __repr__(self):
+        return _otmeshing.UnionMesher___repr__(self)
+
+    def __str__(self, *args):
+        return _otmeshing.UnionMesher___str__(self, *args)
+
+    def build(self, coll):
+        r"""
+        Generate a mesh from the union of disjoint meshes.
+
+        Parameters
+        ----------
+        coll : sequence of :py:class:`openturns.Mesh`
+            Non-overlapping meshes.
+
+        Returns
+        -------
+        mesh : :py:class:`openturns.Mesh`
+            The mesh of the union.
+        """
+        return _otmeshing.UnionMesher_build(self, coll)
+
+    @staticmethod
+    def CompressMesh(mesh):
+        r"""
+        Deduplicate mesh vertices.
+
+        A k-D tree radius search is used to filter out duplicate vertices.
+
+        Parameters
+        ----------
+        mesh : :py:class:`openturns.Mesh`
+            A mesh.
+
+        Returns
+        -------
+        compressedMesh : :py:class:`openturns.Mesh`
+            The crompressed mesh.
+
+        """
+        return _otmeshing.UnionMesher_CompressMesh(mesh)
+    __swig_destroy__ = _otmeshing.delete_UnionMesher
+
+# Register UnionMesher in _otmeshing:
+_otmeshing.UnionMesher_swigregister(UnionMesher)
+class VolumeMesher(openturns.common.PersistentObject):
+    r"""
+    Build a volume mesh from a surface mesh.
+
+    Tetrahedralizes a closed triangular surface mesh by creating a fan of
+    tetrahedra from an apex vertex to each boundary triangle.
+
+    """
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+
+    def getClassName(self):
+        r"""
+        Accessor to the object's name.
+
+        Returns
+        -------
+        class_name : str
+            The object class name (`object.__class__.__name__`).
+        """
+        return _otmeshing.VolumeMesher_getClassName(self)
+    CENTROID = _otmeshing.VolumeMesher_CENTROID
+    FIRST_VERTEX = _otmeshing.VolumeMesher_FIRST_VERTEX
+
+    def build(self, surface):
+        r"""
+        Build a volume mesh from a surface mesh.
+
+        Parameters
+        ----------
+        surface : :class:`~openturns.Mesh`
+            A surface mesh (triangles in dimension 3).
+
+        Returns
+        -------
+        volume : :class:`~openturns.Mesh`
+            A volume mesh (tetrahedra in dimension 3).
+
+        """
+        return _otmeshing.VolumeMesher_build(self, surface)
+
+    def setApexStrategy(self, strategy):
+        r"""
+        Apex strategy accessor.
+
+        Parameters
+        ----------
+        strategy : int 
+            VolumeMesher.CENTROID or VolumeMesher.FIRSTVERTEX.
+
+        """
+        return _otmeshing.VolumeMesher_setApexStrategy(self, strategy)
+
+    def getApexStrategy(self):
+        r"""
+        Apex strategy accessor.
+
+        Returns
+        -------
+        strategy : int
+            VolumeMesher.CENTROID or VolumeMesher.FIRSTVERTEX.
+
+        """
+        return _otmeshing.VolumeMesher_getApexStrategy(self)
+
+    def __repr__(self):
+        return _otmeshing.VolumeMesher___repr__(self)
+
+    def __init__(self, *args):
+        _otmeshing.VolumeMesher_swiginit(self, _otmeshing.new_VolumeMesher(*args))
+    __swig_destroy__ = _otmeshing.delete_VolumeMesher
+
+# Register VolumeMesher in _otmeshing:
+_otmeshing.VolumeMesher_swigregister(VolumeMesher)
+

otmeshing-0.2dev0.dist-info/METADATA

@@ -0,0 +1,19 @@
+Metadata-Version: 1.2
+Name: otmeshing
+Version: 0.2dev0
+Summary: Meshing module
+Home-page: http://www.openturns.org
+Author: OpenTURNS Developers
+Author-email: users@openturns.org
+License: LGPL
+Keywords: probability reliability sensitivity metamodel
+Platform: any
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 or later (LGPLv3+)
+Classifier: Programming Language :: C++
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Intended Audience :: Science/Research
+Requires-Dist: openturns (>=1.20)
+
+Meshing module for OpenTURNS
+It provides mesh intersection, convex decomposition etc

otmeshing-0.2dev0.dist-info/RECORD

@@ -0,0 +1,11 @@
+otmeshing-0.2dev0.dist-info/METADATA,sha256=oZRQsDKuL4W9TMak1V7T5E1b-rstuUDKHbOcghjs0Y0,682
+otmeshing-0.2dev0.dist-info/WHEEL,sha256=BMraOaMe_VaVqUbhxgZ6LABQPl0iQ1n5hRY4Ab8wbZc,85
+otmeshing-0.2dev0.dist-info/RECORD,,
+otmeshing/libotmeshing.dll,sha256=7M-VuGpzriiApI7dyYn3IM7X-zzMkIH3Rp4zjGv_8Y4,2779648
+otmeshing/libcdd-0.dll,sha256=SiEB4QZnxV7uTqyMdf1Kf-nq_e3wqPSHYspsyMbYwn4,129612
+otmeshing/_otmeshing.pyd,sha256=Ln8KIsS7D-22lcCEbFyGvNuiY4XUiuVIc5aHCO5BEmQ,683520
+otmeshing/libqhull_r.dll,sha256=kYMzRLfSzVTa8oXn-vAEQVr-IGdBtn3CUY6-ewPyeBs,498272
+otmeshing/otmeshing.py,sha256=LjQkwWrhSSbtB6kAU9Y-DbKG6VCDxKewMU3PYSY26rE,35988
+otmeshing/lib_coacd.dll,sha256=P4Tt-WDyUvs-PM4EFY6QIu4goX0qRuqs0EjvvKZsoqg,1262381
+otmeshing/libcddgmp-0.dll,sha256=xr-LpGKlJOxXBNuKuf6rf9DrSJVKyJ4LxTuPFJLejc0,249222
+otmeshing/__init__.py,sha256=IObjf0BwzXDauDGCl7AC0COX_yngR7BYnqa6BDeESrw,294

otmeshing-0.2dev0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: custom
+Root-Is-Purelib: false
+Tag: cp39-abi3-win_amd64