o
    Eb6L                     @   s"  d dl mZmZmZmZmZmZmZmZm	Z	m
Z
mZ d dlmZmZmZmZmZmZmZmZmZ ddlmZmZ d dlmZ d dlmZ g dZd,d	d
Zi Zdd Z dd Z!dd Z"dd Z#dd Z$dd Z%dd Z&dd Z'dd Z(dd Z)dd  Z*d-d"d#Z+d-d$d%Z,d.d'd(Z-d.d)d*Z.d+S )/    )logical_andasarraypi
zeros_like	piecewisearrayarctan2tanzerosarangefloor)	sqrtexpgreaterlesscosaddsin
less_equalgreater_equal   )	cspline2dsepfir2d)comb)float_factorial)	spline_filterbsplinegauss_splinecubic	quadratic	cspline1d	qspline1dcspline1d_evalqspline1d_eval      @c           	      C   s   | j j}tg ddd }|dv r9| d} t| j|}t| j|}t|||}t|||}|d|  |}|S |dv rOt| |}t|||}||}|S td)	a  Smoothing spline (cubic) filtering of a rank-2 array.

    Filter an input data set, `Iin`, using a (cubic) smoothing spline of
    fall-off `lmbda`.

    Parameters
    ----------
    Iin : array_like
        input data set
    lmbda : float, optional
        spline smooghing fall-off value, default is `5.0`.

    Returns
    -------
    res : ndarray
        filterd input data

    Examples
    --------
    We can filter an multi dimentional signal (ex: 2D image) using cubic
    B-spline filter:

    >>> from scipy.signal import spline_filter
    >>> import matplotlib.pyplot as plt
    >>> orig_img = np.eye(20)  # create an image
    >>> orig_img[10, :] = 1.0
    >>> sp_filter = spline_filter(orig_img, lmbda=0.1)
    >>> f, ax = plt.subplots(1, 2, sharex=True)
    >>> for ind, data in enumerate([[orig_img, "original image"],
    ...                             [sp_filter, "spline filter"]]):
    ...     ax[ind].imshow(data[0], cmap='gray_r')
    ...     ax[ind].set_title(data[1])
    >>> plt.tight_layout()
    >>> plt.show()

    )      ?g      @r%   f      @)FDr(   y              ?)r&   dzInvalid data type for Iin)	dtypecharr   astyper   realimagr   	TypeError)	ZIinZlmbdaZintypeZhcolZckrZckiZoutrZoutiout r2   8/usr/lib/python3/dist-packages/scipy/signal/_bsplines.pyr      s    %


r   c                    s   zt  W S  ty   Y nw dd }d d }d r d}nd}|dd|g}| td|d D ]}||d  d   d  q2||ddd  d  t fd	d
fddt|D }||ft < ||fS )a  Returns the function defined over the left-side pieces for a bspline of
    a given order.

    The 0th piece is the first one less than 0. The last piece is a function
    identical to 0 (returned as the constant 0). (There are order//2 + 2 total
    pieces).

    Also returns the condition functions that when evaluated return boolean
    arrays for use with `numpy.piecewise`.
    c                    s8   | dkr fddS | dkrfddS  fddS )Nr   c                       t t|  t| S N)r   r   r   xval1val2r2   r3   <lambda>\      
 z>_bspline_piecefunctions.<locals>.condfuncgen.<locals>.<lambda>   c                    s
   t |  S r5   )r   r6   )r:   r2   r3   r;   _   s   
 c                    r4   r5   )r   r   r   r6   r8   r2   r3   r;   a   r<   r2   )numr9   r:   r2   r8   r3   condfuncgenZ   s
   z,_bspline_piecefunctions.<locals>.condfuncgenr=   g      g      r   r          @c                    sd   d |    dk rdS fddt  d D fddt  d D  fdd}|S )	Nr=   r   c              	      s6   g | ]}d d|d   t td  |d d   qS )r   r=   )exact)floatr   .0k)fvalorderr2   r3   
<listcomp>|   s    .zA_bspline_piecefunctions.<locals>.piecefuncgen.<locals>.<listcomp>r   c                    s   g | ]}  | qS r2   r2   rC   )boundr2   r3   rH   ~   s    c                    s6   d}t  d D ]}|| | |    7 }q|S )N        r   range)r7   resrE   )MkcoeffsrG   shiftsr2   r3   thefunc   s   z>_bspline_piecefunctions.<locals>.piecefuncgen.<locals>.thefuncrK   )r>   rQ   )rI   rF   rG   )rN   rO   rP   r3   piecefuncgenx   s   
z-_bspline_piecefunctions.<locals>.piecefuncgenc                    s   g | ]} |qS r2   r2   rC   )rR   r2   r3   rH          z+_bspline_piecefunctions.<locals>.<listcomp>)_splinefunc_cacheKeyErrorrL   appendr   )rG   r?   ZlastZ
startbound	condfuncsr>   funclistr2   )rI   rF   rG   rR   r3   _bspline_piecefunctionsJ   s*   


rY   c                    s8   t t|   t|\}} fdd|D }t ||S )a\  B-spline basis function of order n.

    Parameters
    ----------
    x : array_like
        a knot vector
    n : int
        The order of the spline. Must be non-negative, i.e., n >= 0

    Returns
    -------
    res : ndarray
        B-spline basis function values

    See Also
    --------
    cubic : A cubic B-spline.
    quadratic : A quadratic B-spline.

    Notes
    -----
    Uses numpy.piecewise and automatic function-generator.

    Examples
    --------
    We can calculate B-Spline basis function of several orders:

    >>> from scipy.signal import bspline, cubic, quadratic
    >>> bspline(0.0, 1)
    1

    >>> knots = [-1.0, 0.0, -1.0]
    >>> bspline(knots, 2)
    array([0.125, 0.75, 0.125])

    >>> np.array_equal(bspline(knots, 2), quadratic(knots))
    True

    >>> np.array_equal(bspline(knots, 3), cubic(knots))
    True

    c                    s   g | ]}| qS r2   r2   )rD   funcaxr2   r3   rH      rS   zbspline.<locals>.<listcomp>)absr   rY   r   )r7   nrX   rW   Zcondlistr2   r[   r3   r      s   +r   c                 C   s>   t | } |d d }dtdt |  t| d  d |  S )a  Gaussian approximation to B-spline basis function of order n.

    Parameters
    ----------
    x : array_like
        a knot vector
    n : int
        The order of the spline. Must be non-negative, i.e., n >= 0

    Returns
    -------
    res : ndarray
        B-spline basis function values approximated by a zero-mean Gaussian
        function.

    Notes
    -----
    The B-spline basis function can be approximated well by a zero-mean
    Gaussian function with standard-deviation equal to :math:`\sigma=(n+1)/12`
    for large `n` :

    .. math::  \frac{1}{\sqrt {2\pi\sigma^2}}exp(-\frac{x^2}{2\sigma})

    References
    ----------
    .. [1] Bouma H., Vilanova A., Bescos J.O., ter Haar Romeny B.M., Gerritsen
       F.A. (2007) Fast and Accurate Gaussian Derivatives Based on B-Splines. In:
       Sgallari F., Murli A., Paragios N. (eds) Scale Space and Variational
       Methods in Computer Vision. SSVM 2007. Lecture Notes in Computer
       Science, vol 4485. Springer, Berlin, Heidelberg
    .. [2] http://folk.uio.no/inf3330/scripting/doc/python/SciPy/tutorial/old/node24.html

    Examples
    --------
    We can calculate B-Spline basis functions approximated by a gaussian
    distribution:

    >>> from scipy.signal import gauss_spline, bspline
    >>> knots = np.array([-1.0, 0.0, -1.0])
    >>> gauss_spline(knots, 3)
    array([0.15418033, 0.6909883, 0.15418033])  # may vary

    >>> bspline(knots, 3)
    array([0.16666667, 0.66666667, 0.16666667])  # may vary

    r   g      (@r=   )r   r   r   r   )r7   r^   Zsignsqr2   r2   r3   r      s   /*r   c                 C   s   t t| }t|}t|d}| r%|| }dd|d  d|   ||< | t|d@ }| r?|| }dd| d  ||< |S )a  A cubic B-spline.

    This is a special case of `bspline`, and equivalent to ``bspline(x, 3)``.

    Parameters
    ----------
    x : array_like
        a knot vector

    Returns
    -------
    res : ndarray
        Cubic B-spline basis function values

    See Also
    --------
    bspline : B-spline basis function of order n
    quadratic : A quadratic B-spline.

    Examples
    --------
    We can calculate B-Spline basis function of several orders:

    >>> from scipy.signal import bspline, cubic, quadratic
    >>> bspline(0.0, 1)
    1

    >>> knots = [-1.0, 0.0, -1.0]
    >>> bspline(knots, 2)
    array([0.125, 0.75, 0.125])

    >>> np.array_equal(bspline(knots, 2), quadratic(knots))
    True

    >>> np.array_equal(bspline(knots, 3), cubic(knots))
    True

    r   gUUUUUU?      ?r=   gUUUUUU?   r]   r   r   r   anyr7   r\   rM   cond1Zax1cond2Zax2r2   r2   r3   r      s   '
r   c                 C   sv   t t| }t|}t|d}| r|| }d|d  ||< | t|d@ }| r9|| }|d d d ||< |S )a  A quadratic B-spline.

    This is a special case of `bspline`, and equivalent to ``bspline(x, 2)``.

    Parameters
    ----------
    x : array_like
        a knot vector

    Returns
    -------
    res : ndarray
        Quadratic B-spline basis function values

    See Also
    --------
    bspline : B-spline basis function of order n
    cubic : A cubic B-spline.

    Examples
    --------
    We can calculate B-Spline basis function of several orders:

    >>> from scipy.signal import bspline, cubic, quadratic
    >>> bspline(0.0, 1)
    1

    >>> knots = [-1.0, 0.0, -1.0]
    >>> bspline(knots, 2)
    array([0.125, 0.75, 0.125])

    >>> np.array_equal(bspline(knots, 2), quadratic(knots))
    True

    >>> np.array_equal(bspline(knots, 3), cubic(knots))
    True

    r_   g      ?r=         ?r@   ra   rc   r2   r2   r3   r   (  s   '
r   c                 C   s   dd|   d|  t dd|     }tt d|  d t |}d|  d t | d|   }|t d|  d|  t dd|     |  }||fS )Nr   `      r`      0   )r   r   )ZlamZxiZomegrhor2   r2   r3   _coeff_smooth\  s
   $,rl   c                 C   s.   |t | ||   t || d   t| d S )Nr   )r   r   )rE   csrk   omegar2   r2   r3   _hcd  s   "rp   c                 C   s   || d||   d||   dd| | t d|   |d   }d||  d||   t| }t| }|||  t || |t||    S )Nr   r=      )r   r	   r]   r   )rE   rn   rk   ro   Zc0ZgammaZakr2   r2   r3   _hsi  s   " (rr   c           
      C   s   t |\}}dd| t|  ||  }t| }t|f| jj}t|}td|||| d  t	t|d ||||   |d< td|||| d  td|||| d   t	t|d ||||   |d< t
d|D ]"}|| |  d| t| ||d    || ||d    ||< qjt|f| jj}	t	t||||t|d ||| | d d d  |	|d < t	t|d |||t|d ||| | d d d  |	|d < t
|d ddD ]"}|||  d| t| |	|d    || |	|d    |	|< q|	S )Nr   r=   r   rm   r`   )rl   r   lenr
   r+   r,   r   rp   r   reducerL   rr   )
signallambrk   ro   rn   KZyprE   r^   yr2   r2   r3   _cubic_smooth_coeffq  sB   &
&
ry   c                 C   s   dt d }t| }t|f| jj}|t| }| d |t||    |d< td|D ]}| | |||d    ||< q,t|f| j}||d  ||d   ||d < t|d ddD ]}|||d  ||   ||< q\|d S )Nr`   r   r   r=   rm   r'   	r   rs   r
   r+   r,   r   r   rt   rL   ru   Zzirw   ZyplusZpowersrE   outputr2   r2   r3   _cubic_coeff  s    r~   c                 C   s   ddt d  }t| }t|f| jj}|t| }| d |t||    |d< td|D ]}| | |||d    ||< q.t|f| jj}||d  ||d   ||d < t|d ddD ]}|||d  ||   ||< q_|d S )Nr=   r@   r   r   rm   g       @r{   r|   r2   r2   r3   _quadratic_coeff  s    r   rJ   c                 C   s   |dkr	t | |S t| S )a  
    Compute cubic spline coefficients for rank-1 array.

    Find the cubic spline coefficients for a 1-D signal assuming
    mirror-symmetric boundary conditions. To obtain the signal back from the
    spline representation mirror-symmetric-convolve these coefficients with a
    length 3 FIR window [1.0, 4.0, 1.0]/ 6.0 .

    Parameters
    ----------
    signal : ndarray
        A rank-1 array representing samples of a signal.
    lamb : float, optional
        Smoothing coefficient, default is 0.0.

    Returns
    -------
    c : ndarray
        Cubic spline coefficients.

    See Also
    --------
    cspline1d_eval : Evaluate a cubic spline at the new set of points.

    Examples
    --------
    We can filter a signal to reduce and smooth out high-frequency noise with
    a cubic spline:

    >>> import matplotlib.pyplot as plt
    >>> from scipy.signal import cspline1d, cspline1d_eval
    >>> rng = np.random.default_rng()
    >>> sig = np.repeat([0., 1., 0.], 100)
    >>> sig += rng.standard_normal(len(sig))*0.05  # add noise
    >>> time = np.linspace(0, len(sig))
    >>> filtered = cspline1d_eval(cspline1d(sig), time)
    >>> plt.plot(sig, label="signal")
    >>> plt.plot(time, filtered, label="filtered")
    >>> plt.legend()
    >>> plt.show()

    rJ   )ry   r~   ru   rv   r2   r2   r3   r      s   +
r    c                 C   s   |dkrt dt| S )a+  Compute quadratic spline coefficients for rank-1 array.

    Parameters
    ----------
    signal : ndarray
        A rank-1 array representing samples of a signal.
    lamb : float, optional
        Smoothing coefficient (must be zero for now).

    Returns
    -------
    c : ndarray
        Quadratic spline coefficients.

    See Also
    --------
    qspline1d_eval : Evaluate a quadratic spline at the new set of points.

    Notes
    -----
    Find the quadratic spline coefficients for a 1-D signal assuming
    mirror-symmetric boundary conditions. To obtain the signal back from the
    spline representation mirror-symmetric-convolve these coefficients with a
    length 3 FIR window [1.0, 6.0, 1.0]/ 8.0 .

    Examples
    --------
    We can filter a signal to reduce and smooth out high-frequency noise with
    a quadratic spline:

    >>> import matplotlib.pyplot as plt
    >>> from scipy.signal import qspline1d, qspline1d_eval
    >>> rng = np.random.default_rng()
    >>> sig = np.repeat([0., 1., 0.], 100)
    >>> sig += rng.standard_normal(len(sig))*0.05  # add noise
    >>> time = np.linspace(0, len(sig))
    >>> filtered = qspline1d_eval(qspline1d(sig), time)
    >>> plt.plot(sig, label="signal")
    >>> plt.plot(time, filtered, label="filtered")
    >>> plt.legend()
    >>> plt.show()

    rJ   z.Smoothing quadratic splines not supported yet.)
ValueErrorr   r   r2   r2   r3   r!     s   ,r!   r%   c                 C   s  t || t| }t|| jd}|jdkr|S t| }|dk }||d k}||B  }t| ||  ||< t| d|d  ||  ||< || }|jdkrO|S t|| jd}	t|d t	d }
t
dD ]}|
| }|d|d }|	| | t||  7 }	qe|	||< |S )a  Evaluate a cubic spline at the new set of points.

    `dx` is the old sample-spacing while `x0` was the old origin. In
    other-words the old-sample points (knot-points) for which the `cj`
    represent spline coefficients were at equally-spaced points of:

      oldx = x0 + j*dx  j=0...N-1, with N=len(cj)

    Edges are handled using mirror-symmetric boundary conditions.

    Parameters
    ----------
    cj : ndarray
        cublic spline coefficients
    newx : ndarray
        New set of points.
    dx : float, optional
        Old sample-spacing, the default value is 1.0.
    x0 : int, optional
        Old origin, the default value is 0.

    Returns
    -------
    res : ndarray
        Evaluated a cubic spline points.

    See Also
    --------
    cspline1d : Compute cubic spline coefficients for rank-1 array.

    Examples
    --------
    We can filter a signal to reduce and smooth out high-frequency noise with
    a cubic spline:

    >>> import matplotlib.pyplot as plt
    >>> from scipy.signal import cspline1d, cspline1d_eval
    >>> rng = np.random.default_rng()
    >>> sig = np.repeat([0., 1., 0.], 100)
    >>> sig += rng.standard_normal(len(sig))*0.05  # add noise
    >>> time = np.linspace(0, len(sig))
    >>> filtered = cspline1d_eval(cspline1d(sig), time)
    >>> plt.plot(sig, label="signal")
    >>> plt.plot(time, filtered, label="filtered")
    >>> plt.legend()
    >>> plt.show()

    )r+   r   r   r=   rq   )r   rB   r   r+   sizers   r"   r   r-   intrL   clipr   ZcjZnewxZdxZx0rM   Nrd   re   Zcond3resultZjloweriZthisjZindjr2   r2   r3   r"     s*   1


r"   c                 C   s   t || | }t|}|jdkr|S t| }|dk }||d k}||B  }t| ||  ||< t| d|d  ||  ||< || }|jdkrJ|S t|}	t|d td }
tdD ]}|
| }|	d|d }|	| | t
||  7 }	q]|	||< |S )a  Evaluate a quadratic spline at the new set of points.

    Parameters
    ----------
    cj : ndarray
        Quadratic spline coefficients
    newx : ndarray
        New set of points.
    dx : float, optional
        Old sample-spacing, the default value is 1.0.
    x0 : int, optional
        Old origin, the default value is 0.

    Returns
    -------
    res : ndarray
        Evaluated a quadratic spline points.

    See Also
    --------
    qspline1d : Compute quadratic spline coefficients for rank-1 array.

    Notes
    -----
    `dx` is the old sample-spacing while `x0` was the old origin. In
    other-words the old-sample points (knot-points) for which the `cj`
    represent spline coefficients were at equally-spaced points of::

      oldx = x0 + j*dx  j=0...N-1, with N=len(cj)

    Edges are handled using mirror-symmetric boundary conditions.

    Examples
    --------
    We can filter a signal to reduce and smooth out high-frequency noise with
    a quadratic spline:

    >>> import matplotlib.pyplot as plt
    >>> from scipy.signal import qspline1d, qspline1d_eval
    >>> rng = np.random.default_rng()
    >>> sig = np.repeat([0., 1., 0.], 100)
    >>> sig += rng.standard_normal(len(sig))*0.05  # add noise
    >>> time = np.linspace(0, len(sig))
    >>> filtered = qspline1d_eval(qspline1d(sig), time)
    >>> plt.plot(sig, label="signal")
    >>> plt.plot(time, filtered, label="filtered")
    >>> plt.legend()
    >>> plt.show()

    r   r   r=   rf   r`   )r   r   r   rs   r#   r   r-   r   rL   r   r   r   r2   r2   r3   r#   Z  s*   3


r#   N)r$   )rJ   )r%   r   )/Znumpyr   r   r   r   r   r   r   r	   r
   r   r   Znumpy.core.umathr   r   r   r   r   r   r   r   r   Z_spliner   r   Zscipy.specialr   Zscipy._lib._utilr   __all__r   rT   rY   r   r   r   r   rl   rp   rr   ry   r~   r   r    r!   r"   r#   r2   r2   r2   r3   <module>   s.   4 ,
7D2444

1
2I