3
6Ad]†0  ã               @   s,   d Z ddlZddlmZ G dd„ deƒZdS )z
Tools for triangular grids.
é    N)ÚTriangulationc               @   sP   e Zd ZdZdd„ Zedd„ ƒZddd„Zdd
d„Zddd„Z	e
ddd„ƒZdS )ÚTriAnalyzera§  
    Define basic tools for triangular mesh analysis and improvement.

    A TriAnalyzer encapsulates a :class:`~matplotlib.tri.Triangulation`
    object and provides basic tools for mesh analysis and mesh improvement.

    Parameters
    ----------
    triangulation : :class:`~matplotlib.tri.Triangulation` object
        The encapsulated triangulation to analyze.

    Attributes
    ----------
    `scale_factors`

    c             C   s   t |tƒstdƒ‚|| _d S )NzExpected a Triangulation object)Ú
isinstancer   Ú
ValueErrorÚ_triangulation)ÚselfÚtriangulation© r	   ú‚/home/yuhw/wc/wire-cell-python/wcpy/lib/python3.6/site-packages/matplotlib-3.1.1-py3.6-linux-x86_64.egg/matplotlib/tri/tritools.pyÚ__init__   s    
zTriAnalyzer.__init__c             C   sT   | j jƒ }tjtj|ƒ| j jjd�dk}dtj| j j| ƒ dtj| j j| ƒ fS )ar  
        Factors to rescale the triangulation into a unit square.

        Returns *k*, tuple of 2 scale factors.

        Returns
        -------
        k : tuple of 2 floats (kx, ky)
            Tuple of floats that would rescale the triangulation :
            ``[triangulation.x * kx, triangulation.y * ky]``
            fits exactly inside a unit square.

        )Ú	minlengthr   é   )	r   Úget_masked_trianglesÚnpÚbincountÚravelÚxÚsizeÚptpÚy)r   Úcompressed_trianglesZ	node_usedr	   r	   r
   Úscale_factors    s
    
zTriAnalyzer.scale_factorsTc             C   s:  |r| j \}}nd\}}tj| jj| | jj| gƒj}|| jj }|dd…ddd…f |dd…ddd…f  }|dd…ddd…f |dd…ddd…f  }|dd…ddd…f |dd…ddd…f  }tj|dd…df |dd…df ƒ}tj|dd…df |dd…df ƒ}tj|dd…df |dd…df ƒ}|| | d }	|	|| |	  || |	  || |	  }
|
dk}tj	|ƒ�rÖ|j
d }tj|tjd�}tj||< || | }||  d	tj|
|  ƒ  || < n|| | d	tj|
ƒ  }|| | d	| |	  }|| }| jj}|dk�r&|S tjj||d
�S dS )a§  
        Returns a measure of the triangulation triangles flatness.

        The ratio of the incircle radius over the circumcircle radius is a
        widely used indicator of a triangle flatness.
        It is always ``<= 0.5`` and ``== 0.5`` only for equilateral
        triangles. Circle ratios below 0.01 denote very flat triangles.

        To avoid unduly low values due to a difference of scale between the 2
        axis, the triangular mesh can first be rescaled to fit inside a unit
        square with :attr:`scale_factors` (Only if *rescale* is True, which is
        its default value).

        Parameters
        ----------
        rescale : boolean, optional
            If True, a rescaling will be internally performed (based on
            :attr:`scale_factors`, so that the (unmasked) triangles fit
            exactly inside a unit square mesh. Default is True.

        Returns
        -------
        circle_ratios : masked array
            Ratio of the incircle radius over the
            circumcircle radius, for each 'rescaled' triangle of the
            encapsulated triangulation.
            Values corresponding to masked triangles are masked out.

        ç      ð?Nr   r   é   g      à?g        )Údtypeg      @)Úmask)r   r   )r   r   Úvstackr   r   r   ÚTÚ	trianglesÚhypotÚanyÚshapeÚemptyÚfloat64ÚinfÚsqrtr   ÚmaÚarray)r   ÚrescaleZkxÚkyÚptsZtri_ptsÚaÚbÚcÚsÚprodZ	bool_flatÚntriZcircum_radiusÚabcZ	in_radiusZcircle_ratior   r	   r	   r
   Úcircle_ratios5   s:    ,,,$$$(


zTriAnalyzer.circle_ratiosç{®Gáz„?c             C   sØ   | j jjd }| j|ƒ|k }| j j}|dkr:tj|td�}tj| j j	ƒ}tj
|tjd�}d}xl|dkrÈtj|dd�dk| @ }	|	|@ }
|
|B }tj|
ƒ}d	||
dd…f< d
||
< tj|dkd|| ƒ}q^W tjj|dƒS )a‰  
        Eliminates excessively flat border triangles from the triangulation.

        Returns a mask *new_mask* which allows to clean the encapsulated
        triangulation from its border-located flat triangles
        (according to their :meth:`circle_ratios`).
        This mask is meant to be subsequently applied to the triangulation
        using :func:`matplotlib.tri.Triangulation.set_mask`.
        *new_mask* is an extension of the initial triangulation mask
        in the sense that an initially masked triangle will remain masked.

        The *new_mask* array is computed recursively; at each step flat
        triangles are removed only if they share a side with the current mesh
        border. Thus no new holes in the triangulated domain will be created.

        Parameters
        ----------
        min_circle_ratio : float, optional
            Border triangles with incircle/circumcircle radii ratio r/R will
            be removed if r/R < *min_circle_ratio*. Default value: 0.01
        rescale : boolean, optional
            If True, a rescaling will first be internally performed (based on
            :attr:`scale_factors` ), so that the (unmasked) triangles fit
            exactly inside a unit square mesh. This rescaling accounts for the
            difference of scale which might exist between the 2 axis. Default
            (and recommended) value is True.

        Returns
        -------
        new_mask : array-like of booleans
            Mask to apply to encapsulated triangulation.
            All the initially masked triangles remain masked in the
            *new_mask*.

        Notes
        -----
        The rationale behind this function is that a Delaunay
        triangulation - of an unstructured set of points - sometimes contains
        almost flat triangles at its border, leading to artifacts in plots
        (especially for high-resolution contouring).
        Masked with computed *new_mask*, the encapsulated
        triangulation would contain no more unmasked border triangles
        with a circle ratio below *min_circle_ratio*, thus improving the
        mesh quality for subsequent plots or interpolation.
        r   N)r   r   )ÚaxisTéÿÿÿÿr5   r5   r5   r5   r5   )r   r   r!   r2   r   r   ÚzerosÚboolÚcopyÚ	neighborsÚarangeÚint32ÚminÚsumÚwherer&   Úfilled)r   Zmin_circle_ratior(   r0   Zmask_bad_ratioÚcurrent_maskZvalid_neighborsZrenum_neighborsZnaddZ	wavefrontZ
added_maskr	   r	   r
   Úget_flat_tri_maskz   s$    1

zTriAnalyzer.get_flat_tri_maskFc             C   sº   | j j}| j jƒ }| j jjd }| j||ƒ}tjtj|ƒ| j j	j
d�dk}| j j	|  }| j j|  }	| j|ƒ}
|
| }|s˜|sŠ|||	fS |||	|
fS n|s¨|||	|fS |||	||
fS dS )a8  
        Compress (if masked) the encapsulated triangulation.

        Returns minimal-length triangles array (*compressed_triangles*) and
        coordinates arrays (*compressed_x*, *compressed_y*) that can still
        describe the unmasked triangles of the encapsulated triangulation.

        Parameters
        ----------
        return_tri_renum : boolean, optional
            Indicates whether a renumbering table to translate the triangle
            numbers from the encapsulated triangulation numbering into the
            new (compressed) renumbering will be returned.
        return_node_renum : boolean, optional
            Indicates whether a renumbering table to translate the nodes
            numbers from the encapsulated triangulation numbering into the
            new (compressed) renumbering will be returned.

        Returns
        -------
        compressed_triangles : array-like
            the returned compressed triangulation triangles
        compressed_x : array-like
            the returned compressed triangulation 1st coordinate
        compressed_y : array-like
            the returned compressed triangulation 2nd coordinate
        tri_renum : array-like of integers
            renumbering table to translate the triangle numbers from the
            encapsulated triangulation into the new (compressed) renumbering.
            -1 for masked triangles (deleted from *compressed_triangles*).
            Returned only if *return_tri_renum* is True.
        node_renum : array-like of integers
            renumbering table to translate the point numbers from the
            encapsulated triangulation into the new (compressed) renumbering.
            -1 for unused points (i.e. those deleted from *compressed_x* and
            *compressed_y*). Returned only if *return_node_renum* is True.

        r   )r   N)r   r   r   r   r!   Ú_total_to_compress_renumr   r   r   r   r   r   )r   Zreturn_tri_renumZreturn_node_renumZtri_maskr   r0   Z	tri_renumZ	node_maskZcompressed_xZcompressed_yZ
node_renumr	   r	   r
   Ú_get_compressed_triangulationÆ   s(    )


z)TriAnalyzer._get_compressed_triangulationNc             C   sv   |dkrt j| ƒ}| dk	rbt j|dt jd�}t j|t jd�|   }t jt j|dƒt jd�||< |S t j|t jd�S dS )aT  
        Parameters
        ----------
        mask : 1d boolean array or None
            mask
        n : integer
            length of the mask. Useful only id mask can be None

        Returns
        -------
        renum : integer array
            array so that (`valid_array` being a compressed array
            based on a `masked_array` with mask *mask*) :

                  - For all i such as mask[i] = False:
                    valid_array[renum[i]] = masked_array[i]
                  - For all i such as mask[i] = True:
                    renum[i] = -1 (invalid value)

        Nr   )r   r   r5   )r   r   Úfullr;   r:   )r   ÚnZrenumÚvalidr	   r	   r
   rB     s    
z$TriAnalyzer._total_to_compress_renum)T)r3   T)FF)N)Ú__name__Ú
__module__Ú__qualname__Ú__doc__r   Úpropertyr   r2   rA   rC   ÚstaticmethodrB   r	   r	   r	   r
   r   
   s   
E
L 
Fr   )rJ   Únumpyr   Úmatplotlib.trir   Úobjectr   r	   r	   r	   r
   Ú<module>   s   