Ë
    âQ(h=/  ã                   ót   — d Z ddlZddlmZmZmZmZ ddlm	Z	 g d¢Z
 G d„ de«      Zd	ej                  d
fd„Zy)zD
Convenience interface to N-D interpolation

.. versionadded:: 0.9

é    Né   )ÚLinearNDInterpolatorÚNDInterpolatorBaseÚCloughTocher2DInterpolatorÚ_ndim_coords_from_arrays)ÚcKDTree)ÚgriddataÚNearestNDInterpolatorr   r   c                   ó   — e Zd ZdZdd„Zd„ Zy)r
   aL  NearestNDInterpolator(x, y).

    Nearest-neighbor interpolator in N > 1 dimensions.

    .. versionadded:: 0.9

    Methods
    -------
    __call__

    Parameters
    ----------
    x : (npoints, ndims) 2-D ndarray of floats
        Data point coordinates.
    y : (npoints, ) 1-D ndarray of float or complex
        Data values.
    rescale : boolean, optional
        Rescale points to unit cube before performing interpolation.
        This is useful if some of the input dimensions have
        incommensurable units and differ by many orders of magnitude.

        .. versionadded:: 0.14.0
    tree_options : dict, optional
        Options passed to the underlying ``cKDTree``.

        .. versionadded:: 0.17.0

    See Also
    --------
    griddata :
        Interpolate unstructured D-D data.
    LinearNDInterpolator :
        Piecewise linear interpolator in N dimensions.
    CloughTocher2DInterpolator :
        Piecewise cubic, C1 smooth, curvature-minimizing interpolator in 2D.
    interpn : Interpolation on a regular grid or rectilinear grid.
    RegularGridInterpolator : Interpolator on a regular or rectilinear grid
                              in arbitrary dimensions (`interpn` wraps this
                              class).

    Notes
    -----
    Uses ``scipy.spatial.cKDTree``

    .. note:: For data on a regular grid use `interpn` instead.

    Examples
    --------
    We can interpolate values on a 2D plane:

    >>> from scipy.interpolate import NearestNDInterpolator
    >>> import numpy as np
    >>> import matplotlib.pyplot as plt
    >>> rng = np.random.default_rng()
    >>> x = rng.random(10) - 0.5
    >>> y = rng.random(10) - 0.5
    >>> z = np.hypot(x, y)
    >>> X = np.linspace(min(x), max(x))
    >>> Y = np.linspace(min(y), max(y))
    >>> X, Y = np.meshgrid(X, Y)  # 2D grid for interpolation
    >>> interp = NearestNDInterpolator(list(zip(x, y)), z)
    >>> Z = interp(X, Y)
    >>> plt.pcolormesh(X, Y, Z, shading='auto')
    >>> plt.plot(x, y, "ok", label="input point")
    >>> plt.legend()
    >>> plt.colorbar()
    >>> plt.axis("equal")
    >>> plt.show()

    Nc                 ó¼   — t        j                  | |||dd¬«       |€
t        «       }t        | j                  fi |¤Ž| _        t        j                  |«      | _        y )NF)ÚrescaleÚneed_contiguousÚneed_values)	r   Ú__init__Údictr   ÚpointsÚtreeÚnpÚasarrayÚvalues)ÚselfÚxÚyr   Útree_optionss        ú[/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/scipy/interpolate/_ndgriddata.pyr   zNearestNDInterpolator.__init__\   sQ   € Ü×#Ñ# D¨!¨Q¸Ø49Ø05õ	7ð ÐÜ›6ˆLÜ˜DŸK™KÑ8¨<Ñ8ˆŒ	Ü—j‘j “mˆ�ó    c                 óà  — t        || j                  j                  d   ¬«      }| j                  |«      }| j	                  |«      }|j                  d|j                  d   «      }|j                  }|j                  } | j                  j                  |fi |¤Ž\  }}t        j                  |«      }	| j                  j                  dkD  r |dd | j                  j                  dd z   }
n|dd }
t        j                  | j                  j                  t        j                  «      r;t        j                  |
t        j                   | j                  j                  ¬«      }n$t        j                  |
t        j                   «      }| j                  ||	   df   ||	<   | j                  j                  dkD  r |dd | j                  j                  dd z   }n|dd }|j                  |«      }|S )a�  
        Evaluate interpolator at given points.

        Parameters
        ----------
        x1, x2, ... xn : array-like of float
            Points where to interpolate data at.
            x1, x2, ... xn can be array-like of float with broadcastable shape.
            or x1 can be array-like of float with shape ``(..., ndim)``
        **query_options
            This allows ``eps``, ``p``, ``distance_upper_bound``, and ``workers``
            being passed to the cKDTree's query function to be explicitly set.
            See `scipy.spatial.cKDTree.query` for an overview of the different options.

            .. versionadded:: 1.12.0

        r   )ÚndiméÿÿÿÿN)Údtype.)r   r   ÚshapeÚ_check_call_shapeÚ_scale_xÚreshaper   Úqueryr   Úisfiniter   r   Ú
issubdtyper    ÚcomplexfloatingÚfullÚnan)r   ÚargsÚquery_optionsÚxiÚxi_flatÚoriginal_shapeÚflattened_shapeÚdistÚiÚ
valid_maskÚinterp_shapeÚinterp_valuesÚ	new_shapes                r   Ú__call__zNearestNDInterpolator.__call__e   sœ  € ô* & d°·±×1BÑ1BÀ1Ñ1EÔFˆØ×#Ñ# BÓ'ˆØ�]‰]˜2Óˆð —*‘*˜R §¡¨"¡Ó.ˆØŸ™ˆØ!Ÿ-™-ˆð "�$—)‘)—/‘/ 'Ñ;¨]Ñ;‰ˆˆaÜ—[‘[ Ó&ˆ
ð �;‰;×Ñ˜aÒØ*¨3¨BÐ/°$·+±+×2CÑ2CÀAÀBÐ2GÑG‰Là*¨3¨BÐ/ˆLä�=‰=˜Ÿ™×*Ñ*¬B×,>Ñ,>Ô?ÜŸG™G L´"·&±&ÀÇÁ×@QÑ@QÔR‰MäŸG™G L´"·&±&Ó9ˆMà$(§K¡K°°*±¸sÐ0BÑ$Cˆ�jÑ!à�;‰;×Ñ˜aÒØ& s¨Ð+¨d¯k©k×.?Ñ.?ÀÀÐ.CÑC‰Ià& s¨Ð+ˆIØ%×-Ñ-¨iÓ8ˆàÐr   )FN)Ú__name__Ú
__module__Ú__qualname__Ú__doc__r   r7   © r   r   r
   r
      s   „ ñEóN$óAr   r
   ÚlinearFc                 óN  — t        | «      } | j                  dk  r| j                  }n| j                  d   }|dk(  rƒ|dv rddlm} | j                  «       } t        |t        «      rt        |«      dk7  rt        d«      ‚|\  }t        j                  | «      }| |   } ||   }|dk(  rd} || ||d	d
|¬«      }	 |	|«      S |dk(  rt        | ||¬«      }	 |	|«      S |dk(  rt        | |||¬«      }	 |	|«      S |dk(  r|dk(  rt        | |||¬«      }	 |	|«      S t        d||fz  «      ‚)aX  
    Interpolate unstructured D-D data.

    Parameters
    ----------
    points : 2-D ndarray of floats with shape (n, D), or length D tuple of 1-D ndarrays with shape (n,).
        Data point coordinates.
    values : ndarray of float or complex, shape (n,)
        Data values.
    xi : 2-D ndarray of floats with shape (m, D), or length D tuple of ndarrays broadcastable to the same shape.
        Points at which to interpolate data.
    method : {'linear', 'nearest', 'cubic'}, optional
        Method of interpolation. One of

        ``nearest``
          return the value at the data point closest to
          the point of interpolation. See `NearestNDInterpolator` for
          more details.

        ``linear``
          tessellate the input point set to N-D
          simplices, and interpolate linearly on each simplex. See
          `LinearNDInterpolator` for more details.

        ``cubic`` (1-D)
          return the value determined from a cubic
          spline.

        ``cubic`` (2-D)
          return the value determined from a
          piecewise cubic, continuously differentiable (C1), and
          approximately curvature-minimizing polynomial surface. See
          `CloughTocher2DInterpolator` for more details.
    fill_value : float, optional
        Value used to fill in for requested points outside of the
        convex hull of the input points. If not provided, then the
        default is ``nan``. This option has no effect for the
        'nearest' method.
    rescale : bool, optional
        Rescale points to unit cube before performing interpolation.
        This is useful if some of the input dimensions have
        incommensurable units and differ by many orders of magnitude.

        .. versionadded:: 0.14.0

    Returns
    -------
    ndarray
        Array of interpolated values.

    See Also
    --------
    LinearNDInterpolator :
        Piecewise linear interpolator in N dimensions.
    NearestNDInterpolator :
        Nearest-neighbor interpolator in N dimensions.
    CloughTocher2DInterpolator :
        Piecewise cubic, C1 smooth, curvature-minimizing interpolator in 2D.
    interpn : Interpolation on a regular grid or rectilinear grid.
    RegularGridInterpolator : Interpolator on a regular or rectilinear grid
                              in arbitrary dimensions (`interpn` wraps this
                              class).

    Notes
    -----

    .. versionadded:: 0.9

    .. note:: For data on a regular grid use `interpn` instead.

    Examples
    --------

    Suppose we want to interpolate the 2-D function

    >>> import numpy as np
    >>> def func(x, y):
    ...     return x*(1-x)*np.cos(4*np.pi*x) * np.sin(4*np.pi*y**2)**2

    on a grid in [0, 1]x[0, 1]

    >>> grid_x, grid_y = np.mgrid[0:1:100j, 0:1:200j]

    but we only know its values at 1000 data points:

    >>> rng = np.random.default_rng()
    >>> points = rng.random((1000, 2))
    >>> values = func(points[:,0], points[:,1])

    This can be done with `griddata` -- below we try out all of the
    interpolation methods:

    >>> from scipy.interpolate import griddata
    >>> grid_z0 = griddata(points, values, (grid_x, grid_y), method='nearest')
    >>> grid_z1 = griddata(points, values, (grid_x, grid_y), method='linear')
    >>> grid_z2 = griddata(points, values, (grid_x, grid_y), method='cubic')

    One can see that the exact result is reproduced by all of the
    methods to some degree, but for this smooth function the piecewise
    cubic interpolant gives the best results:

    >>> import matplotlib.pyplot as plt
    >>> plt.subplot(221)
    >>> plt.imshow(func(grid_x, grid_y).T, extent=(0,1,0,1), origin='lower')
    >>> plt.plot(points[:,0], points[:,1], 'k.', ms=1)
    >>> plt.title('Original')
    >>> plt.subplot(222)
    >>> plt.imshow(grid_z0.T, extent=(0,1,0,1), origin='lower')
    >>> plt.title('Nearest')
    >>> plt.subplot(223)
    >>> plt.imshow(grid_z1.T, extent=(0,1,0,1), origin='lower')
    >>> plt.title('Linear')
    >>> plt.subplot(224)
    >>> plt.imshow(grid_z2.T, extent=(0,1,0,1), origin='lower')
    >>> plt.title('Cubic')
    >>> plt.gcf().set_size_inches(6, 6)
    >>> plt.show()

    é   r   r   )Únearestr=   Úcubic)Úinterp1dz"invalid number of dimensions in xir@   Úextrapolater   F)ÚkindÚaxisÚbounds_errorÚ
fill_value)r   r=   )rG   r   rA   z7Unknown interpolation method %r for %d dimensional data)r   r   r!   Ú_interpolaterB   ÚravelÚ
isinstanceÚtupleÚlenÚ
ValueErrorr   Úargsortr
   r   r   )
r   r   r-   ÚmethodrG   r   r   rB   ÚidxÚips
             r   r	   r	   ®   sQ  € ôt & fÓ-€Fà‡{�{�Q‚Ø�{‰{‰à�|‰|˜BÑˆàˆq‚y�VÐ=Ñ=Ý*Ø—‘“ˆÜ�bœ%Ô Ü�2‹w˜!Š|Ü Ð!EÓFÐFØ‰CˆBä�j‰j˜Ó ˆØ˜‘ˆØ˜‘ˆØ�YÒØ&ˆJÙ�f˜f¨6¸ÈØ!+ô-ˆá�"‹vˆØ	�9Ò	Ü" 6¨6¸7ÔCˆÙ�"‹vˆØ	�8Ò	Ü! &¨&¸ZØ*1ô3ˆá�"‹vˆØ	�7Ò	˜t qšyÜ'¨°À:Ø07ô9ˆá�"‹vˆäð /Ø28¸$°ñ@ó Að 	Ar   )r;   Únumpyr   Ú	_interpndr   r   r   r   Úscipy.spatialr   Ú__all__r
   r*   r	   r<   r   r   ú<module>rV      sH   ðñó ÷;ó ;å !ò)€ôRÐ.ô Rðt )1¸R¿V¹VØô^Ar   