| Server IP : 93.86.61.54 / Your IP : 216.73.216.206 Web Server : Apache/2.4.62 (Ubuntu) System : Linux rasin.ddns.net 6.8.0-124-generic #124~22.04.1-Ubuntu SMP PREEMPT_DYNAMIC Tue May 26 21:05:19 UTC x86_64 User : www-data ( 33) PHP Version : 8.4.22 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : ON | Pkexec : ON Directory : /lib/python3/dist-packages/scipy/spatial/__pycache__/ |
Upload File : |
o
��Eb�5 � @ sT d Z ddlZddlZddlZddlmZ ddlmZ dgZ dd� Z
G d d� d�Z dS )
z3
Spherical Voronoi Code
.. versionadded:: 0.18.0
� N� )�_voronoi)�cKDTree�SphericalVoronoic C s� t j�| �}dt �d| dd�df | dd�df �t �d| dd�df | dd�df � t �d| dd�df | dd�df � }t �dt �||� �S )z�Calculates the solid angles of plane triangles. Implements the method of
Van Oosterom and Strackee [VanOosterom]_ with some modifications. Assumes
that input points have unit norm.r �ij,ij->iNr � )�np�linalg�det�einsum�abs�arctan2)�R� numerator� denominator� r �B/usr/lib/python3/dist-packages/scipy/spatial/_spherical_voronoi.py�calculate_solid_angles s &$�$�r c @ sB e Zd ZdZddd�Zdd� Zd d
� Zd d � Zd
d� Zdd� Z dS )r a� Voronoi diagrams on the surface of a sphere.
.. versionadded:: 0.18.0
Parameters
----------
points : ndarray of floats, shape (npoints, ndim)
Coordinates of points from which to construct a spherical
Voronoi diagram.
radius : float, optional
Radius of the sphere (Default: 1)
center : ndarray of floats, shape (ndim,)
Center of sphere (Default: origin)
threshold : float
Threshold for detecting duplicate points and
mismatches between points and sphere parameters.
(Default: 1e-06)
Attributes
----------
points : double array of shape (npoints, ndim)
the points in `ndim` dimensions to generate the Voronoi diagram from
radius : double
radius of the sphere
center : double array of shape (ndim,)
center of the sphere
vertices : double array of shape (nvertices, ndim)
Voronoi vertices corresponding to points
regions : list of list of integers of shape (npoints, _ )
the n-th entry is a list consisting of the indices
of the vertices belonging to the n-th point in points
Methods
-------
calculate_areas
Calculates the areas of the Voronoi regions. For 2D point sets, the
regions are circular arcs. The sum of the areas is `2 * pi * radius`.
For 3D point sets, the regions are spherical polygons. The sum of the
areas is `4 * pi * radius**2`.
Raises
------
ValueError
If there are duplicates in `points`.
If the provided `radius` is not consistent with `points`.
Notes
-----
The spherical Voronoi diagram algorithm proceeds as follows. The Convex
Hull of the input points (generators) is calculated, and is equivalent to
their Delaunay triangulation on the surface of the sphere [Caroli]_.
The Convex Hull neighbour information is then used to
order the Voronoi region vertices around each generator. The latter
approach is substantially less sensitive to floating point issues than
angle-based methods of Voronoi region vertex sorting.
Empirical assessment of spherical Voronoi algorithm performance suggests
quadratic time complexity (loglinear is optimal, but algorithms are more
challenging to implement).
References
----------
.. [Caroli] Caroli et al. Robust and Efficient Delaunay triangulations of
points on or close to a sphere. Research Report RR-7004, 2009.
.. [VanOosterom] Van Oosterom and Strackee. The solid angle of a plane
triangle. IEEE Transactions on Biomedical Engineering,
2, 1983, pp 125--126.
See Also
--------
Voronoi : Conventional Voronoi diagrams in N dimensions.
Examples
--------
Do some imports and take some points on a cube:
>>> import matplotlib.pyplot as plt
>>> from scipy.spatial import SphericalVoronoi, geometric_slerp
>>> from mpl_toolkits.mplot3d import proj3d
>>> # set input data
>>> points = np.array([[0, 0, 1], [0, 0, -1], [1, 0, 0],
... [0, 1, 0], [0, -1, 0], [-1, 0, 0], ])
Calculate the spherical Voronoi diagram:
>>> radius = 1
>>> center = np.array([0, 0, 0])
>>> sv = SphericalVoronoi(points, radius, center)
Generate plot:
>>> # sort vertices (optional, helpful for plotting)
>>> sv.sort_vertices_of_regions()
>>> t_vals = np.linspace(0, 1, 2000)
>>> fig = plt.figure()
>>> ax = fig.add_subplot(111, projection='3d')
>>> # plot the unit sphere for reference (optional)
>>> u = np.linspace(0, 2 * np.pi, 100)
>>> v = np.linspace(0, np.pi, 100)
>>> x = np.outer(np.cos(u), np.sin(v))
>>> y = np.outer(np.sin(u), np.sin(v))
>>> z = np.outer(np.ones(np.size(u)), np.cos(v))
>>> ax.plot_surface(x, y, z, color='y', alpha=0.1)
>>> # plot generator points
>>> ax.scatter(points[:, 0], points[:, 1], points[:, 2], c='b')
>>> # plot Voronoi vertices
>>> ax.scatter(sv.vertices[:, 0], sv.vertices[:, 1], sv.vertices[:, 2],
... c='g')
>>> # indicate Voronoi regions (as Euclidean polygons)
>>> for region in sv.regions:
... n = len(region)
... for i in range(n):
... start = sv.vertices[region][i]
... end = sv.vertices[region][(i + 1) % n]
... result = geometric_slerp(start, end, t_vals)
... ax.plot(result[..., 0],
... result[..., 1],
... result[..., 2],
... c='k')
>>> ax.azim = 10
>>> ax.elev = 40
>>> _ = ax.set_xticks([])
>>> _ = ax.set_yticks([])
>>> _ = ax.set_zticks([])
>>> fig.set_size_inches(4, 4)
>>> plt.show()
r N���ư>c C s |d u r d}t �dt� t|�| _t�|��tj�| _ | j j
d | _ |d u r.t� | j �| _
ntj|td�| _
tjj| j | j d || j d�| _| j| j k rVtd�| j ���t| j ��|| j �retd��tjj| j | j
dd �}t�|| j ��� }||| j kr�td
��| �� d S ) Ng �?z{`radius` is `None`. This will raise an error in a future version. Please provide a floating point number (i.e. `radius=1`).r )�dtyper )�tolz)Rank of input points must be at least {0}z Duplicate generators present.)�axisz$Radius inconsistent with generators.)�warnings�warn�DeprecationWarning�float�radiusr �array�astype�double�points�shape�_dim�zeros�centerr � matrix_rank�_rank�
ValueError�formatr � query_pairs�normr �max�_calc_vertices_regions)�selfr r r$ � threshold�radii�max_discrepancyr r r �__init__� s. �
� zSphericalVoronoi.__init__c s� t j�| j�}| j|jdd�dd�f | j | _|j| _ t
� t | j ��}t
�
|g| j ��� }| j �� }t
j|dd�}|| �t
j�� t
�t
�|d ���� �fdd�tt ��d �D �}|| _dS )a:
Calculates the Voronoi vertices and regions of the generators stored
in self.points. The vertices will be stored in self.vertices and the
regions in self.regions.
This algorithm was discussed at PyData London 2015 by
Tyler Reddy, Ross Hemsley and Nikolai Nowaczyk
N���� mergesort)�kindr c s( g | ]}t � �| �|d � ��qS )r )�list)�.0�i��flattened_groups� intervalsr r �
<listcomp>� s �z;SphericalVoronoi._calc_vertices_regions.<locals>.<listcomp>)�scipy�spatial�
ConvexHullr r � equationsr$ �vertices� simplices�
_simplicesr �arange�len� column_stackr" �ravel�argsortr �intp�cumsum�bincount�range�regions)r- �conv�simplex_indices� tri_indices�
point_indices�indices�groupsr r8 r r, � s
$
�
z'SphericalVoronoi._calc_vertices_regionsc C s& | j dkr td��t�| j| j� dS )a3 Sort indices of the vertices to be (counter-)clockwise ordered.
Raises
------
TypeError
If the points are not three-dimensional.
Notes
-----
For each region in regions, it sorts the indices of the Voronoi
vertices such that the resulting points are in a clockwise or
counterclockwise order around the generator point.
This is done as follows: Recall that the n-th region in regions
surrounds the n-th generator in points and that the k-th
Voronoi vertex in vertices is the circumcenter of the k-th triangle
in self._simplices. For each region n, we choose the first triangle
(=Voronoi vertex) in self._simplices and a vertex of that triangle
not equal to the center n. These determine a unique neighbor of that
triangle, which is then chosen as the second triangle. The second
triangle will have a unique vertex not equal to the current vertex or
the center. This determines a unique neighbor of the second triangle,
which is then chosen as the third triangle and so forth. We proceed
through all the triangles (=Voronoi vertices) belonging to the
generator in points and obtain a sorted version of the vertices
of its surrounding region.
� z/Only supported for three-dimensional point setsN)r" � TypeErrorr �sort_vertices_of_regionsrB rL �r- r r r rU � s
z)SphericalVoronoi.sort_vertices_of_regionsc
C s | � � dd� | jD �}t�|�}|d }dd� t|�D �}t�dd� | jD ��}t�|d�}t�|d�}d|d< ||d ||< | j| j | j }| j
| j | j } t� || | | | | g�� |ddf�}
t
|
�} t�| �|d } | dd � | d d� 8 < | | j d S )
Nc S s g | ]}t |��qS r )rD )r6 �regionr r r r; s z8SphericalVoronoi._calculate_areas_3d.<locals>.<listcomp>r2 c S s" g | ]
\}}t |�D ]}|�q
qS r )rK )r6 r7 �size�jr r r r; s
�
�c S s g | ] }|D ]}|�qqS r r )r6 rW �rr r r r; s r r rS r )rU rL r rI � enumerater �rollr r$ r r@ �hstack�reshaper )
r- �sizes�csizes� num_regionsrP �nbrs1�nbrs2rQ � pnormalized� vnormalized� triangles�triangle_solid_angles� solid_anglesr r r �_calculate_areas_3d
s,
� � z$SphericalVoronoi._calculate_areas_3dc C s� | j | j | j }t�d|d d �df |d d �df �}t�tj�|��}t�||�}| j | }t�
t�d|d d �df | j | j ��}t� |dk �}dtj
| j || ||< |S )Nr r r r )r rB r$ r r r r r
r
r �signr@ �where�pi)r- �arcs�cosine�sine�theta�areas�signsrQ r r r �_calculate_areas_2d1 s &
� z$SphericalVoronoi._calculate_areas_2dc C s, | j dkr | �� S | j dkr| �� S td��)a� Calculates the areas of the Voronoi regions.
For 2D point sets, the regions are circular arcs. The sum of the areas
is `2 * pi * radius`.
For 3D point sets, the regions are spherical polygons. The sum of the
areas is `4 * pi * radius**2`.
.. versionadded:: 1.5.0
Returns
-------
areas : double array of shape (npoints,)
The areas of the Voronoi regions.
r rS z'Only supported for 2D and 3D point sets)r" rs ri rT rV r r r �calculate_areasD s
z SphericalVoronoi.calculate_areas)r Nr )
�__name__�
__module__� __qualname__�__doc__r1 r, rU ri rs rt r r r r r % s
"! ' ) rx r �numpyr r< � r �
scipy.spatialr �__all__r r r r r r �<module> s