| Server IP : 217.160.0.135 / Your IP : 216.73.217.85 Web Server : Apache System : Linux www 6.18.52-i1-ampere #1203 SMP Mon Sep 14 18:29:59 CEST 2026 aarch64 User : sws1074145052 ( 1074145052) PHP Version : 8.3.32 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : OFF | Pkexec : OFF Directory : /usr/lib/python3/dist-packages/scipy/signal/__pycache__/ |
Upload File : |
�
d�c�� � �� � d Z ddlZddlZddlmZmZ ddlmZ ddl m
Z
m Z m Z m
Z
g d�Zdd �Zdd
�Zdd �Zdd �Zd
� Zd� Zd� Zd d�Zd d�Zd� Zd� Zd� Z d d�Zd� Z d d�Z d d�Z dS )!z-
Functions for identifying peaks in signals.
� N)�cwt�ricker)�scoreatpercentile� )�_local_maxima_1d�_select_by_peak_distance�_peak_prominences� _peak_widths)� argrelmin� argrelmax�
argrelextrema�peak_prominences� peak_widths�
find_peaks�find_peaks_cwt�clipc � � t |� � |k s|dk rt d� � �| j | }t j d|� � }t j | j t �� � }| � |||�� � }t d|dz � � D ]o} | � || z ||�� � }
| � || z
||�� � } | |||
� � z }| ||| � � z }|� � � r|c S �p|S )a�
Calculate the relative extrema of `data`.
Relative extrema are calculated by finding locations where
``comparator(data[n], data[n+1:n+order+1])`` is True.
Parameters
----------
data : ndarray
Array in which to find the relative extrema.
comparator : callable
Function to use to compare two data points.
Should take two arrays as arguments.
axis : int, optional
Axis over which to select from `data`. Default is 0.
order : int, optional
How many points on each side to use for the comparison
to consider ``comparator(n,n+x)`` to be True.
mode : str, optional
How the edges of the vector are treated. 'wrap' (wrap around) or
'clip' (treat overflow as the same as the last (or first) element).
Default 'clip'. See numpy.take.
Returns
-------
extrema : ndarray
Boolean array of the same shape as `data` that is True at an extrema,
False otherwise.
See also
--------
argrelmax, argrelmin
Examples
--------
>>> import numpy as np
>>> testdata = np.array([1,2,3,2,1])
>>> _boolrelextrema(testdata, np.greater, axis=0)
array([False, False, True, False, False], dtype=bool)
r zOrder must be an int >= 1r ��dtype)�axis�mode)
�int�
ValueError�shape�np�arange�ones�bool�take�range�any) �data�
comparatorr �orderr �datalen�locs�results�main�shift�plus�minuss �</usr/lib/python3/dist-packages/scipy/signal/_peak_finding.py�_boolrelextremar- s � �T �E�
�
�e��������4�5�5�5��j�� �G�
�9�Q�� � �D��g�d�j��-�-�-�G� �9�9�T��4�9� 0� 0�D��q�%�!�)�$�$� � ���y�y��� �D�t�y�<�<��� � �$��,�T�� �=�=���:�:�d�D�)�)�)���:�:�d�E�*�*�*�� �K�K�M�M�>� ��N�N�N� � �N� c �< � t | t j |||� � S )a�
Calculate the relative minima of `data`.
Parameters
----------
data : ndarray
Array in which to find the relative minima.
axis : int, optional
Axis over which to select from `data`. Default is 0.
order : int, optional
How many points on each side to use for the comparison
to consider ``comparator(n, n+x)`` to be True.
mode : str, optional
How the edges of the vector are treated.
Available options are 'wrap' (wrap around) or 'clip' (treat overflow
as the same as the last (or first) element).
Default 'clip'. See numpy.take.
Returns
-------
extrema : tuple of ndarrays
Indices of the minima in arrays of integers. ``extrema[k]`` is
the array of indices of axis `k` of `data`. Note that the
return value is a tuple even when `data` is 1-D.
See Also
--------
argrelextrema, argrelmax, find_peaks
Notes
-----
This function uses `argrelextrema` with np.less as comparator. Therefore, it
requires a strict inequality on both sides of a value to consider it a
minimum. This means flat minima (more than one sample wide) are not detected.
In case of 1-D `data` `find_peaks` can be used to detect all
local minima, including flat ones, by calling it with negated `data`.
.. versionadded:: 0.11.0
Examples
--------
>>> import numpy as np
>>> from scipy.signal import argrelmin
>>> x = np.array([2, 1, 2, 3, 2, 0, 1, 0])
>>> argrelmin(x)
(array([1, 5]),)
>>> y = np.array([[1, 2, 1, 2],
... [2, 2, 0, 0],
... [5, 3, 4, 4]])
...
>>> argrelmin(y, axis=1)
(array([0, 2]), array([2, 1]))
)r
r �less�r" r r$ r s r, r r R s � �n ��r�w��e�T� :� :�:r. c �< � t | t j |||� � S )a�
Calculate the relative maxima of `data`.
Parameters
----------
data : ndarray
Array in which to find the relative maxima.
axis : int, optional
Axis over which to select from `data`. Default is 0.
order : int, optional
How many points on each side to use for the comparison
to consider ``comparator(n, n+x)`` to be True.
mode : str, optional
How the edges of the vector are treated.
Available options are 'wrap' (wrap around) or 'clip' (treat overflow
as the same as the last (or first) element).
Default 'clip'. See `numpy.take`.
Returns
-------
extrema : tuple of ndarrays
Indices of the maxima in arrays of integers. ``extrema[k]`` is
the array of indices of axis `k` of `data`. Note that the
return value is a tuple even when `data` is 1-D.
See Also
--------
argrelextrema, argrelmin, find_peaks
Notes
-----
This function uses `argrelextrema` with np.greater as comparator. Therefore,
it requires a strict inequality on both sides of a value to consider it a
maximum. This means flat maxima (more than one sample wide) are not detected.
In case of 1-D `data` `find_peaks` can be used to detect all
local maxima, including flat ones.
.. versionadded:: 0.11.0
Examples
--------
>>> import numpy as np
>>> from scipy.signal import argrelmax
>>> x = np.array([2, 1, 2, 3, 2, 0, 1, 0])
>>> argrelmax(x)
(array([3, 6]),)
>>> y = np.array([[1, 2, 1, 2],
... [2, 2, 0, 0],
... [5, 3, 4, 4]])
...
>>> argrelmax(y, axis=1)
(array([0]), array([1]))
)r
r �greaterr1 s r, r r � s � �l ��r�z�4��� =� =�=r. c �P � t | ||||� � }t j |� � S )a�
Calculate the relative extrema of `data`.
Parameters
----------
data : ndarray
Array in which to find the relative extrema.
comparator : callable
Function to use to compare two data points.
Should take two arrays as arguments.
axis : int, optional
Axis over which to select from `data`. Default is 0.
order : int, optional
How many points on each side to use for the comparison
to consider ``comparator(n, n+x)`` to be True.
mode : str, optional
How the edges of the vector are treated. 'wrap' (wrap around) or
'clip' (treat overflow as the same as the last (or first) element).
Default is 'clip'. See `numpy.take`.
Returns
-------
extrema : tuple of ndarrays
Indices of the maxima in arrays of integers. ``extrema[k]`` is
the array of indices of axis `k` of `data`. Note that the
return value is a tuple even when `data` is 1-D.
See Also
--------
argrelmin, argrelmax
Notes
-----
.. versionadded:: 0.11.0
Examples
--------
>>> import numpy as np
>>> from scipy.signal import argrelextrema
>>> x = np.array([2, 1, 2, 3, 2, 0, 1, 0])
>>> argrelextrema(x, np.greater)
(array([3, 6]),)
>>> y = np.array([[1, 2, 1, 2],
... [2, 2, 0, 0],
... [5, 3, 4, 4]])
...
>>> argrelextrema(y, np.less, axis=1)
(array([0, 2]), array([2, 1]))
)r- r �nonzero)r" r# r r$ r r' s r, r
r
� s/ � �h �d�J� "�E�4�1� 1�G�
�:�g� � � r. c �| � t j | dt j �� � } | j dk rt d� � �| S )a= Ensure argument `x` is a 1-D C-contiguous array of dtype('float64').
Used in `find_peaks`, `peak_prominences` and `peak_widths` to make `x`
compatible with the signature of the wrapped Cython functions.
Returns
-------
value : ndarray
A 1-D C-contiguous array with dtype('float64').
�C)r$ r r z`x` must be a 1-D array)r �asarray�float64�ndimr ��values r, �_arg_x_as_expectedr= � s; � �
�J�u�C�r�z� :� :� :�E� �z�Q����2�3�3�3� �Lr. c �H � t j | � � } | j dk r t j g t j �� � } | � t j dddd�� � } n"# t $ r}t
d� � |�d}~ww xY w| j d k rt d
� � �| S ) a1 Ensure argument `peaks` is a 1-D C-contiguous array of dtype('intp').
Used in `peak_prominences` and `peak_widths` to make `peaks` compatible
with the signature of the wrapped Cython functions.
Returns
-------
value : ndarray
A 1-D C-contiguous array with dtype('intp').
r r r7 �safeF)r$ �casting�subok�copyz+cannot safely cast `peaks` to dtype('intp')Nr z`peaks` must be a 1-D array) r r8 �size�array�intp�astype� TypeErrorr: r )r< �es r, �_arg_peaks_as_expectedrI s� � �
�J�u� � �E� �z�Q������2�7�+�+�+��N�� � �R�W�C��#(�u� � 6� 6���� � N� N� N��E�F�F�A�M�����N���� �z�Q����6�7�7�7� �Ls �$A& �&
B�0B � Bc �� � | �d} nqd| k rIt j | t j d� � st j | � � } t j | � � } n"t d� | � � � � �| S )z�Ensure argument `wlen` is of type `np.intp` and larger than 1.
Used in `peak_prominences` and `peak_widths`.
Returns
-------
value : np.intp
The original `value` rounded up to an integer or -1 if `value` was
None.
N���r r? z$`wlen` must be larger than 1, was {})r �can_castrE �math�ceilr �formatr; s r, �_arg_wlen_as_expectedrP ) sv � �
�}� ���
�U����{�5�"�'�6�2�2� %��I�e�$�$�E���������?� �&��-�-�)� )� )� �Lr. c �~ � t | � � } t |� � }t |� � }t | ||� � S )a
Calculate the prominence of each peak in a signal.
The prominence of a peak measures how much a peak stands out from the
surrounding baseline of the signal and is defined as the vertical distance
between the peak and its lowest contour line.
Parameters
----------
x : sequence
A signal with peaks.
peaks : sequence
Indices of peaks in `x`.
wlen : int, optional
A window length in samples that optionally limits the evaluated area for
each peak to a subset of `x`. The peak is always placed in the middle of
the window therefore the given length is rounded up to the next odd
integer. This parameter can speed up the calculation (see Notes).
Returns
-------
prominences : ndarray
The calculated prominences for each peak in `peaks`.
left_bases, right_bases : ndarray
The peaks' bases as indices in `x` to the left and right of each peak.
The higher base of each pair is a peak's lowest contour line.
Raises
------
ValueError
If a value in `peaks` is an invalid index for `x`.
Warns
-----
PeakPropertyWarning
For indices in `peaks` that don't point to valid local maxima in `x`,
the returned prominence will be 0 and this warning is raised. This
also happens if `wlen` is smaller than the plateau size of a peak.
Warnings
--------
This function may return unexpected results for data containing NaNs. To
avoid this, NaNs should either be removed or replaced.
See Also
--------
find_peaks
Find peaks inside a signal based on peak properties.
peak_widths
Calculate the width of peaks.
Notes
-----
Strategy to compute a peak's prominence:
1. Extend a horizontal line from the current peak to the left and right
until the line either reaches the window border (see `wlen`) or
intersects the signal again at the slope of a higher peak. An
intersection with a peak of the same height is ignored.
2. On each side find the minimal signal value within the interval defined
above. These points are the peak's bases.
3. The higher one of the two bases marks the peak's lowest contour line. The
prominence can then be calculated as the vertical difference between the
peaks height itself and its lowest contour line.
Searching for the peak's bases can be slow for large `x` with periodic
behavior because large chunks or even the full signal need to be evaluated
for the first algorithmic step. This evaluation area can be limited with the
parameter `wlen` which restricts the algorithm to a window around the
current peak and can shorten the calculation time if the window length is
short in relation to `x`.
However, this may stop the algorithm from finding the true global contour
line if the peak's true bases are outside this window. Instead, a higher
contour line is found within the restricted window leading to a smaller
calculated prominence. In practice, this is only relevant for the highest set
of peaks in `x`. This behavior may even be used intentionally to calculate
"local" prominences.
.. versionadded:: 1.1.0
References
----------
.. [1] Wikipedia Article for Topographic Prominence:
https://en.wikipedia.org/wiki/Topographic_prominence
Examples
--------
>>> import numpy as np
>>> from scipy.signal import find_peaks, peak_prominences
>>> import matplotlib.pyplot as plt
Create a test signal with two overlayed harmonics
>>> x = np.linspace(0, 6 * np.pi, 1000)
>>> x = np.sin(x) + 0.6 * np.sin(2.6 * x)
Find all peaks and calculate prominences
>>> peaks, _ = find_peaks(x)
>>> prominences = peak_prominences(x, peaks)[0]
>>> prominences
array([1.24159486, 0.47840168, 0.28470524, 3.10716793, 0.284603 ,
0.47822491, 2.48340261, 0.47822491])
Calculate the height of each peak's contour line and plot the results
>>> contour_heights = x[peaks] - prominences
>>> plt.plot(x)
>>> plt.plot(peaks, x[peaks], "x")
>>> plt.vlines(x=peaks, ymin=contour_heights, ymax=x[peaks])
>>> plt.show()
Let's evaluate a second example that demonstrates several edge cases for
one peak at index 5.
>>> x = np.array([0, 1, 0, 3, 1, 3, 0, 4, 0])
>>> peaks = np.array([5])
>>> plt.plot(x)
>>> plt.plot(peaks, x[peaks], "x")
>>> plt.show()
>>> peak_prominences(x, peaks) # -> (prominences, left_bases, right_bases)
(array([3.]), array([2]), array([6]))
Note how the peak at index 3 of the same height is not considered as a
border while searching for the left base. Instead, two minima at 0 and 2
are found in which case the one closer to the evaluated peak is always
chosen. On the right side, however, the base must be placed at 6 because the
higher peak represents the right border to the evaluated area.
>>> peak_prominences(x, peaks, wlen=3.1)
(array([2.]), array([4]), array([6]))
Here, we restricted the algorithm to a window from 3 to 7 (the length is 5
samples because `wlen` was rounded up to the next odd integer). Thus, the
only two candidates in the evaluated area are the two neighboring samples
and a smaller prominence is calculated.
)r= rI rP r )�x�peaks�wlens r, r r C s> � �T �1� � �A� "�5� )� )�E� �� &� &�D� �Q��t� ,� ,�,r. � �?c � � t | � � } t |� � }|� t |� � }t | ||� � }t | ||g|�R � S )a�
Calculate the width of each peak in a signal.
This function calculates the width of a peak in samples at a relative
distance to the peak's height and prominence.
Parameters
----------
x : sequence
A signal with peaks.
peaks : sequence
Indices of peaks in `x`.
rel_height : float, optional
Chooses the relative height at which the peak width is measured as a
percentage of its prominence. 1.0 calculates the width of the peak at
its lowest contour line while 0.5 evaluates at half the prominence
height. Must be at least 0. See notes for further explanation.
prominence_data : tuple, optional
A tuple of three arrays matching the output of `peak_prominences` when
called with the same arguments `x` and `peaks`. This data are calculated
internally if not provided.
wlen : int, optional
A window length in samples passed to `peak_prominences` as an optional
argument for internal calculation of `prominence_data`. This argument
is ignored if `prominence_data` is given.
Returns
-------
widths : ndarray
The widths for each peak in samples.
width_heights : ndarray
The height of the contour lines at which the `widths` where evaluated.
left_ips, right_ips : ndarray
Interpolated positions of left and right intersection points of a
horizontal line at the respective evaluation height.
Raises
------
ValueError
If `prominence_data` is supplied but doesn't satisfy the condition
``0 <= left_base <= peak <= right_base < x.shape[0]`` for each peak,
has the wrong dtype, is not C-contiguous or does not have the same
shape.
Warns
-----
PeakPropertyWarning
Raised if any calculated width is 0. This may stem from the supplied
`prominence_data` or if `rel_height` is set to 0.
Warnings
--------
This function may return unexpected results for data containing NaNs. To
avoid this, NaNs should either be removed or replaced.
See Also
--------
find_peaks
Find peaks inside a signal based on peak properties.
peak_prominences
Calculate the prominence of peaks.
Notes
-----
The basic algorithm to calculate a peak's width is as follows:
* Calculate the evaluation height :math:`h_{eval}` with the formula
:math:`h_{eval} = h_{Peak} - P \cdot R`, where :math:`h_{Peak}` is the
height of the peak itself, :math:`P` is the peak's prominence and
:math:`R` a positive ratio specified with the argument `rel_height`.
* Draw a horizontal line at the evaluation height to both sides, starting at
the peak's current vertical position until the lines either intersect a
slope, the signal border or cross the vertical position of the peak's
base (see `peak_prominences` for an definition). For the first case,
intersection with the signal, the true intersection point is estimated
with linear interpolation.
* Calculate the width as the horizontal distance between the chosen
endpoints on both sides. As a consequence of this the maximal possible
width for each peak is the horizontal distance between its bases.
As shown above to calculate a peak's width its prominence and bases must be
known. You can supply these yourself with the argument `prominence_data`.
Otherwise, they are internally calculated (see `peak_prominences`).
.. versionadded:: 1.1.0
Examples
--------
>>> import numpy as np
>>> from scipy.signal import chirp, find_peaks, peak_widths
>>> import matplotlib.pyplot as plt
Create a test signal with two overlayed harmonics
>>> x = np.linspace(0, 6 * np.pi, 1000)
>>> x = np.sin(x) + 0.6 * np.sin(2.6 * x)
Find all peaks and calculate their widths at the relative height of 0.5
(contour line at half the prominence height) and 1 (at the lowest contour
line at full prominence height).
>>> peaks, _ = find_peaks(x)
>>> results_half = peak_widths(x, peaks, rel_height=0.5)
>>> results_half[0] # widths
array([ 64.25172825, 41.29465463, 35.46943289, 104.71586081,
35.46729324, 41.30429622, 181.93835853, 45.37078546])
>>> results_full = peak_widths(x, peaks, rel_height=1)
>>> results_full[0] # widths
array([181.9396084 , 72.99284945, 61.28657872, 373.84622694,
61.78404617, 72.48822812, 253.09161876, 79.36860878])
Plot signal, peaks and contour lines at which the widths where calculated
>>> plt.plot(x)
>>> plt.plot(peaks, x[peaks], "x")
>>> plt.hlines(*results_half[1:], color="C2")
>>> plt.hlines(*results_full[1:], color="C3")
>>> plt.show()
)r= rI rP r r
)rR rS �
rel_height�prominence_datarT s r, r r � s] � �p �1� � �A� "�5� )� )�E�� �$�T�*�*��+�A�u�d�;�;�� ��5�*� ?�� ?� ?� ?�?r. c �R � | \ }}n# t t f$ r | d}}Y nw xY wt |t j � � r'|j |j k rt d� � �|| }t |t j � � r'|j |j k rt d� � �|| }||fS )a
Parse condition arguments for `find_peaks`.
Parameters
----------
interval : number or ndarray or sequence
Either a number or ndarray or a 2-element sequence of the former. The
first value is always interpreted as `imin` and the second, if supplied,
as `imax`.
x : ndarray
The signal with `peaks`.
peaks : ndarray
An array with indices used to reduce `imin` and / or `imax` if those are
arrays.
Returns
-------
imin, imax : number or ndarray or None
Minimal and maximal value in `argument`.
Raises
------
ValueError :
If interval border is given as array and its size does not match the size
of `x`.
Notes
-----
.. versionadded:: 1.1.0
Nz0array size of lower interval border must match xz0array size of upper interval border must match x)rG r �
isinstancer �ndarrayrC )�intervalrR rS �imin�imaxs r, �_unpack_condition_argsr_ T s� � �@&� �
��d�d�� �z� "� &� &� &� ��d����&���� �$��
�#�#� � �9��� � � � O�P�P� P��E�{���$��
�#�#� � �9��� � � � O�P�P� P��E�{�� ��:�s � � � c �r � t j | j t �� � }|� ||| k z }|� || |k z }|S )a�
Evaluate where the generic property of peaks confirms to an interval.
Parameters
----------
peak_properties : ndarray
An array with properties for each peak.
pmin : None or number or ndarray
Lower interval boundary for `peak_properties`. ``None`` is interpreted as
an open border.
pmax : None or number or ndarray
Upper interval boundary for `peak_properties`. ``None`` is interpreted as
an open border.
Returns
-------
keep : bool
A boolean mask evaluating to true where `peak_properties` confirms to the
interval.
See Also
--------
find_peaks
Notes
-----
.. versionadded:: 1.1.0
r )r r rC r )�peak_properties�pmin�pmax�keeps r, �_select_by_propertyre � sJ � �< �7�?�'�t� 4� 4� 4�D� �� �� �(�)�� �� � �D�(�)�� �Kr. c �\ � t j | | | |dz
z
| | | |dz z
g� � }t j |j t �� � }|� t j |d�� � }|||k z }|� t j |d�� � }|||k z }||d |d fS )a�
Evaluate which peaks fulfill the threshold condition.
Parameters
----------
x : ndarray
A 1-D array which is indexable by `peaks`.
peaks : ndarray
Indices of peaks in `x`.
tmin, tmax : scalar or ndarray or None
Minimal and / or maximal required thresholds. If supplied as ndarrays
their size must match `peaks`. ``None`` is interpreted as an open
border.
Returns
-------
keep : bool
A boolean mask evaluating to true where `peaks` fulfill the threshold
condition.
left_thresholds, right_thresholds : ndarray
Array matching `peak` containing the thresholds of each peak on
both sides.
Notes
-----
.. versionadded:: 1.1.0
r r Nr �r )r �vstackr rC r �min�max)rR rS �tmin�tmax�stacked_thresholdsrd �min_thresholds�max_thresholdss r, �_select_by_peak_thresholdrp � s� � �@ ��A�e�H�q����|�$;�$%�e�H�q����|�$;�$=� >� >��
�7�5�:�T� *� *� *�D� ���� 2��;�;�;�� �� �'�(�� ���� 2��;�;�;�� � �4�'�(�� �#�A�&�(:�1�(=� =�=r. c � �� t | � � } |�|dk rt d� � �t | � � \ } }
} i } |�d| |
z
dz }
t || | � � \ }}t |
||� � �| � } |
| d< |
| d< | | d< �fd�| � � � D � � } |�Z| | }t || | � � \ }}t |||� � �| � } || d< �fd �| � � � D � � } |�\t || | � � \ }}t
| | ||� � \ �}}| � } || d
< || d < �fd �| � � � D � � } |�?t | | | |� � �| � } �fd
�| � � � D � � } |�|�Dt |� � }| � t g d�t | | |�� � � � � � |�St || | � � \ }}t | d ||� � �| � } �fd�| � � � D � � } |��| � t g d�t | | || d | d | d � � � � � � t || | � � \ }}t | d ||� � �| � } �fd�| � � � D � � } | | fS )ae%
Find peaks inside a signal based on peak properties.
This function takes a 1-D array and finds all local maxima by
simple comparison of neighboring values. Optionally, a subset of these
peaks can be selected by specifying conditions for a peak's properties.
Parameters
----------
x : sequence
A signal with peaks.
height : number or ndarray or sequence, optional
Required height of peaks. Either a number, ``None``, an array matching
`x` or a 2-element sequence of the former. The first element is
always interpreted as the minimal and the second, if supplied, as the
maximal required height.
threshold : number or ndarray or sequence, optional
Required threshold of peaks, the vertical distance to its neighboring
samples. Either a number, ``None``, an array matching `x` or a
2-element sequence of the former. The first element is always
interpreted as the minimal and the second, if supplied, as the maximal
required threshold.
distance : number, optional
Required minimal horizontal distance (>= 1) in samples between
neighbouring peaks. Smaller peaks are removed first until the condition
is fulfilled for all remaining peaks.
prominence : number or ndarray or sequence, optional
Required prominence of peaks. Either a number, ``None``, an array
matching `x` or a 2-element sequence of the former. The first
element is always interpreted as the minimal and the second, if
supplied, as the maximal required prominence.
width : number or ndarray or sequence, optional
Required width of peaks in samples. Either a number, ``None``, an array
matching `x` or a 2-element sequence of the former. The first
element is always interpreted as the minimal and the second, if
supplied, as the maximal required width.
wlen : int, optional
Used for calculation of the peaks prominences, thus it is only used if
one of the arguments `prominence` or `width` is given. See argument
`wlen` in `peak_prominences` for a full description of its effects.
rel_height : float, optional
Used for calculation of the peaks width, thus it is only used if `width`
is given. See argument `rel_height` in `peak_widths` for a full
description of its effects.
plateau_size : number or ndarray or sequence, optional
Required size of the flat top of peaks in samples. Either a number,
``None``, an array matching `x` or a 2-element sequence of the former.
The first element is always interpreted as the minimal and the second,
if supplied as the maximal required plateau size.
.. versionadded:: 1.2.0
Returns
-------
peaks : ndarray
Indices of peaks in `x` that satisfy all given conditions.
properties : dict
A dictionary containing properties of the returned peaks which were
calculated as intermediate results during evaluation of the specified
conditions:
* 'peak_heights'
If `height` is given, the height of each peak in `x`.
* 'left_thresholds', 'right_thresholds'
If `threshold` is given, these keys contain a peaks vertical
distance to its neighbouring samples.
* 'prominences', 'right_bases', 'left_bases'
If `prominence` is given, these keys are accessible. See
`peak_prominences` for a description of their content.
* 'width_heights', 'left_ips', 'right_ips'
If `width` is given, these keys are accessible. See `peak_widths`
for a description of their content.
* 'plateau_sizes', left_edges', 'right_edges'
If `plateau_size` is given, these keys are accessible and contain
the indices of a peak's edges (edges are still part of the
plateau) and the calculated plateau sizes.
.. versionadded:: 1.2.0
To calculate and return properties without excluding peaks, provide the
open interval ``(None, None)`` as a value to the appropriate argument
(excluding `distance`).
Warns
-----
PeakPropertyWarning
Raised if a peak's properties have unexpected values (see
`peak_prominences` and `peak_widths`).
Warnings
--------
This function may return unexpected results for data containing NaNs. To
avoid this, NaNs should either be removed or replaced.
See Also
--------
find_peaks_cwt
Find peaks using the wavelet transformation.
peak_prominences
Directly calculate the prominence of peaks.
peak_widths
Directly calculate the width of peaks.
Notes
-----
In the context of this function, a peak or local maximum is defined as any
sample whose two direct neighbours have a smaller amplitude. For flat peaks
(more than one sample of equal amplitude wide) the index of the middle
sample is returned (rounded down in case the number of samples is even).
For noisy signals the peak locations can be off because the noise might
change the position of local maxima. In those cases consider smoothing the
signal before searching for peaks or use other peak finding and fitting
methods (like `find_peaks_cwt`).
Some additional comments on specifying conditions:
* Almost all conditions (excluding `distance`) can be given as half-open or
closed intervals, e.g., ``1`` or ``(1, None)`` defines the half-open
interval :math:`[1, \infty]` while ``(None, 1)`` defines the interval
:math:`[-\infty, 1]`. The open interval ``(None, None)`` can be specified
as well, which returns the matching properties without exclusion of peaks.
* The border is always included in the interval used to select valid peaks.
* For several conditions the interval borders can be specified with
arrays matching `x` in shape which enables dynamic constrains based on
the sample position.
* The conditions are evaluated in the following order: `plateau_size`,
`height`, `threshold`, `distance`, `prominence`, `width`. In most cases
this order is the fastest one because faster operations are applied first
to reduce the number of peaks that need to be evaluated later.
* While indices in `peaks` are guaranteed to be at least `distance` samples
apart, edges of flat peaks may be closer than the allowed `distance`.
* Use `wlen` to reduce the time it takes to evaluate the conditions for
`prominence` or `width` if `x` is large or has many local maxima
(see `peak_prominences`).
.. versionadded:: 1.1.0
Examples
--------
To demonstrate this function's usage we use a signal `x` supplied with
SciPy (see `scipy.datasets.electrocardiogram`). Let's find all peaks (local
maxima) in `x` whose amplitude lies above 0.
>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> from scipy.datasets import electrocardiogram
>>> from scipy.signal import find_peaks
>>> x = electrocardiogram()[2000:4000]
>>> peaks, _ = find_peaks(x, height=0)
>>> plt.plot(x)
>>> plt.plot(peaks, x[peaks], "x")
>>> plt.plot(np.zeros_like(x), "--", color="gray")
>>> plt.show()
We can select peaks below 0 with ``height=(None, 0)`` or use arrays matching
`x` in size to reflect a changing condition for different parts of the
signal.
>>> border = np.sin(np.linspace(0, 3 * np.pi, x.size))
>>> peaks, _ = find_peaks(x, height=(-border, border))
>>> plt.plot(x)
>>> plt.plot(-border, "--", color="gray")
>>> plt.plot(border, ":", color="gray")
>>> plt.plot(peaks, x[peaks], "x")
>>> plt.show()
Another useful condition for periodic signals can be given with the
`distance` argument. In this case, we can easily select the positions of
QRS complexes within the electrocardiogram (ECG) by demanding a distance of
at least 150 samples.
>>> peaks, _ = find_peaks(x, distance=150)
>>> np.diff(peaks)
array([186, 180, 177, 171, 177, 169, 167, 164, 158, 162, 172])
>>> plt.plot(x)
>>> plt.plot(peaks, x[peaks], "x")
>>> plt.show()
Especially for noisy signals peaks can be easily grouped by their
prominence (see `peak_prominences`). E.g., we can select all peaks except
for the mentioned QRS complexes by limiting the allowed prominence to 0.6.
>>> peaks, properties = find_peaks(x, prominence=(None, 0.6))
>>> properties["prominences"].max()
0.5049999999999999
>>> plt.plot(x)
>>> plt.plot(peaks, x[peaks], "x")
>>> plt.show()
And, finally, let's examine a different section of the ECG which contains
beat forms of different shape. To select only the atypical heart beats, we
combine two conditions: a minimal prominence of 1 and width of at least 20
samples.
>>> x = electrocardiogram()[17000:18000]
>>> peaks, properties = find_peaks(x, prominence=1, width=20)
>>> properties["prominences"], properties["widths"]
(array([1.495, 2.3 ]), array([36.93773946, 39.32723577]))
>>> plt.plot(x)
>>> plt.plot(peaks, x[peaks], "x")
>>> plt.vlines(x=peaks, ymin=x[peaks] - properties["prominences"],
... ymax = x[peaks], color = "C1")
>>> plt.hlines(y=properties["width_heights"], xmin=properties["left_ips"],
... xmax=properties["right_ips"], color = "C1")
>>> plt.show()
Nr z(`distance` must be greater or equal to 1�
plateau_sizes�
left_edges� right_edgesc �( �� i | ]\ }}||� ��S � rv ��.0�keyrD rd s �r, �
<dictcomp>z find_peaks.<locals>.<dictcomp>� �# �� �L�L�L�:�3��c�5��;�L�L�Lr. � peak_heightsc �( �� i | ]\ }}||� ��S rv rv rw s �r, rz z find_peaks.<locals>.<dictcomp>� r{ r. �left_thresholds�right_thresholdsc �( �� i | ]\ }}||� ��S rv rv rw s �r, rz z find_peaks.<locals>.<dictcomp>� r{ r. c �( �� i | ]\ }}||� ��S rv rv rw s �r, rz z find_peaks.<locals>.<dictcomp>� r{ r. )� prominences�
left_bases� right_bases)rT r� c �( �� i | ]\ }}||� ��S rv rv rw s �r, rz z find_peaks.<locals>.<dictcomp>� r{ r. )�widths�
width_heights�left_ips� right_ipsr� r� r� c �( �� i | ]\ }}||� ��S rv rv rw s �r, rz z find_peaks.<locals>.<dictcomp>� r{ r. )
r= r r r_ re �itemsrp r rP �update�zipr r
)rR �height� threshold�distance�
prominence�widthrT rW � plateau_sizerS rs rt �
propertiesrr rb rc r| �hmin�hmaxrk rl r~ r �wmin�wmaxrd s @r, r r � s� �� �d �1� � �A����1� � ��C�D�D�D�%5�a�%8�%8�"�E�:�{��J�� �#�j�0�1�4�
�+�L�!�U�C�C�
��d�"�=�$��=�=���d� ��&3�
�?�#�#-�
�<� �$/�
�=�!�L�L�L�L��9I�9I�9K�9K�L�L�L�
�
����x� �+�F�A�u�=�=�
��d�"�<��t�<�<���d� ��%1�
�>�"�L�L�L�L��9I�9I�9K�9K�L�L�L�
�� �+�I�q�%�@�@�
��d�2K�
�u�d�D�3"� 3"�/��o� /��d� ��(7�
�$�%�)9�
�%�&�L�L�L�L��9I�9I�9K�9K�L�L�L�
���'��q��x��B�B���d� ��L�L�L�L��9I�9I�9K�9K�L�L�L�
�� ��!2�$�T�*�*�����#� 8� 8� 8� �a��T� 2� 2� 2�
�
� � � �
� �+�J��5�A�A�
��d�"�:�m�#<�d�D�I�I���d� ��L�L�L�L��9I�9I�9K�9K�L�L�L�
� �����#� @� @� @� ��E�:�z�-�/H�#�L�1�:�m�3L�
N�
N�
�
� � � � ,�E�1�e�<�<�
��d�"�:�h�#7��t�D�D���d� ��L�L�L�L��9I�9I�9K�9K�L�L�L�
� �*� � r. c �� �� t |� � | j d k rt d� � �t | t j dd�� � }t j |� d�� � � � d }t |� � dk rg S |d ��fd�t j |� � � d D � � }g }t j �dz
dd� � }t j d| j d � � }|D �]]} ||| }
|D ]} | dxx dz
cc< �t j d � |D � � � � } t |
� � D ]�\ }
}d
} t | � � dk rEt j || z
� � }t j |� � }|| || k r|| } | �<| d �
|� � | d �
| � � d| d< ��| g|gdg}|�
|� � ��t t |� � dz
dd� � D ].}
||
} | d |k r|�
| � � ||
= �/��_g }||z D ]�} t j t j | d � � � � }t j |� � t j |� � }}| d ||< | d ||< |�
||g� � ��|S ) a�
Identify ridges in the 2-D matrix.
Expect that the width of the wavelet feature increases with increasing row
number.
Parameters
----------
matr : 2-D ndarray
Matrix in which to identify ridge lines.
max_distances : 1-D sequence
At each row, a ridge line is only connected
if the relative max at row[n] is within
`max_distances`[n] from the relative max at row[n+1].
gap_thresh : int
If a relative maximum is not found within `max_distances`,
there will be a gap. A ridge line is discontinued if
there are more than `gap_thresh` points without connecting
a new relative maximum.
Returns
-------
ridge_lines : tuple
Tuple of 2 1-D sequences. `ridge_lines`[ii][0] are the rows of the
ii-th ridge-line, `ridge_lines`[ii][1] are the columns. Empty if none
found. Each ridge-line will be sorted by row (increasing), but the
order of the ridge lines is not specified.
References
----------
.. [1] Bioinformatics (2006) 22 (17): 2059-2065.
:doi:`10.1093/bioinformatics/btl355`
Examples
--------
>>> import numpy as np
>>> rng = np.random.default_rng()
>>> data = rng.random((5,5))
>>> max_dist = 3
>>> max_distances = np.full(20, max_dist)
>>> ridge_lines = _identify_ridge_lines(data, max_distances, 1)
Notes
-----
This function is intended to be used in conjunction with `cwt`
as part of `find_peaks_cwt`.
r z5Max_distances must have at least as many rows as matrr )r r$ rg rK c � �� g | ] }�g|gd g��
S )r rv )rx �col� start_rows �r, �
<listcomp>z)_identify_ridge_lines.<locals>.<listcomp>2 s> �� � I� I� I� � �K��5��� I� I� Ir. � c �* � g | ]}|d d ��S )r rK rv )rx �lines r, r� z)_identify_ridge_lines.<locals>.<listcomp>C s � �#H�#H�#H�D�D��G�B�K�#H�#H�#Hr. N)�lenr r r- r r3 r5 r! r rD � enumerate�abs�argmin�appendr �argsort�
zeros_like)�matr�
max_distances�
gap_thresh� all_max_cols�
has_relmax� ridge_lines� final_lines�rows�cols�row�
this_max_colsr� �prev_ridge_cols�indr� �diffs�closest�new_line� out_lines�sortargsr� s @r, �_identify_ridge_linesr� � sI �� �b �=���D�J�q�M�)�)�� #� $� $� $� #�4���!�1�E�E�E�L���L� ,� ,�!� ,� 4� 4�5�5�a�8�J�
�:���!���� ��2��I�I� I� I� I�!#��L��,C�!D�!D�Q�!G�I� I� I�K� �K�
�9�Y��]�B�� +� +�D�
�9�Q��
�1�
� &� &�D�� +%� +%�� �\�#� .�/�
� � � �D� ��G�G�G�q�L�G�G�G�G�
�(�#H�#H�K�#H�#H�#H�I�I�� "�-�0�0� -� -�H�C�� �D��?�#�#�a�'�'���s�_� 4�5�5�� �)�E�*�*����>�]�3�%7�7�7�&�w�/�D�� ��Q����s�#�#�#��Q����s�#�#�#���Q��� �E� �E� � �� �"�"�8�,�,�,�,� ��[�)�)�A�-�r�2�6�6� %� %�C� �s�#�D��A�w��#�#��"�"�4�(�(�(� ��$�� %� �I� �{�*� '� '���8�B�J�t�A�w� /� /�0�0���]�8�,�,�b�m�H�.E�.E�d�� �a���X�� �a���X�����$�� �&�&�&�&� �r. �
c � � ���� � j d }��"t j � j d dz � � �|�t j |dz � � }t |� � }t |d� � \ }}� ddd�f } t j | � � �t
| � � D ]J\ }
} t |
|z
d� � } t |
|z |z |� � }
t | | |
� |�� � �|
< �K� ���fd�}t t ||� � � � S ) a-
Filter ridge lines according to prescribed criteria. Intended
to be used for finding relative maxima.
Parameters
----------
cwt : 2-D ndarray
Continuous wavelet transform from which the `ridge_lines` were defined.
ridge_lines : 1-D sequence
Each element should contain 2 sequences, the rows and columns
of the ridge line (respectively).
window_size : int, optional
Size of window to use to calculate noise floor.
Default is ``cwt.shape[1] / 20``.
min_length : int, optional
Minimum length a ridge line needs to be acceptable.
Default is ``cwt.shape[0] / 4``, ie 1/4-th the number of widths.
min_snr : float, optional
Minimum SNR ratio. Default 1. The signal is the value of
the cwt matrix at the shortest length scale (``cwt[0, loc]``), the
noise is the `noise_perc`th percentile of datapoints contained within a
window of `window_size` around ``cwt[0, loc]``.
noise_perc : float, optional
When calculating the noise floor, percentile of data points
examined below which to consider noise. Calculated using
scipy.stats.scoreatpercentile.
References
----------
.. [1] Bioinformatics (2006) 22 (17): 2059-2065.
:doi:`10.1093/bioinformatics/btl355`
r Nr � � r� )�perc �� �� t | d � � �k rdS t �| d d | d d f �| d d z � � }|�k rdS dS )Nr Fr T)r� r� )r� �snrr �
min_length�min_snr�noisess ����r, � filt_funcz&_filter_ridge_lines.<locals>.filt_func� si �� � �t�A�w�<�<�*� $� $��5��#�d�1�g�a�j�$�q�'�!�*�,�-��t�A�w�q�z�0B�B�C�C�� ��=�=��5��tr. ) r r rN r �divmod�
empty_liker� rj ri r �list�filter)r r� � window_sizer� r� �
noise_perc�
num_points� hf_window�odd�row_oner� �val� window_start�
window_endr� r� s ` `` @r, �_filter_ridge_linesr� p s@ ����� �F ��1� �J����W�S�Y�q�\�A� -�.�.�
����g�j�2�o�.�.� ��k�"�"�K��K��+�+�N�I�s� �!�Q�Q�Q�$�i�G�
�]�7�
#�
#�F� �g�&�&� 8� 8���S��3��?�A�.�.� ���y� �3�.�
�;�;�
�'�� �Z�0G�(H�,6�8� 8� 8��s� � �� � � � � � � � ��y�+�.�.� /� /�/r. c �^ � t j |dd�� � }|�t j |d � � }|�|dz }|�t }t | ||� � } t | ||� � }
t
| |
||||�� � } t j d� | D � � � � } | � � � | S ) ab
Find peaks in a 1-D array with wavelet transformation.
The general approach is to smooth `vector` by convolving it with
`wavelet(width)` for each width in `widths`. Relative maxima which
appear at enough length scales, and with sufficiently high SNR, are
accepted.
Parameters
----------
vector : ndarray
1-D array in which to find the peaks.
widths : float or sequence
Single width or 1-D array-like of widths to use for calculating
the CWT matrix. In general,
this range should cover the expected width of peaks of interest.
wavelet : callable, optional
Should take two parameters and return a 1-D array to convolve
with `vector`. The first parameter determines the number of points
of the returned wavelet array, the second parameter is the scale
(`width`) of the wavelet. Should be normalized and symmetric.
Default is the ricker wavelet.
max_distances : ndarray, optional
At each row, a ridge line is only connected if the relative max at
row[n] is within ``max_distances[n]`` from the relative max at
``row[n+1]``. Default value is ``widths/4``.
gap_thresh : float, optional
If a relative maximum is not found within `max_distances`,
there will be a gap. A ridge line is discontinued if there are more
than `gap_thresh` points without connecting a new relative maximum.
Default is the first value of the widths array i.e. widths[0].
min_length : int, optional
Minimum length a ridge line needs to be acceptable.
Default is ``cwt.shape[0] / 4``, ie 1/4-th the number of widths.
min_snr : float, optional
Minimum SNR ratio. Default 1. The signal is the maximum CWT coefficient
on the largest ridge line. The noise is `noise_perc` th percentile of
datapoints contained within the same ridge line.
noise_perc : float, optional
When calculating the noise floor, percentile of data points
examined below which to consider noise. Calculated using
`stats.scoreatpercentile`. Default is 10.
window_size : int, optional
Size of window to use to calculate noise floor.
Default is ``cwt.shape[1] / 20``.
Returns
-------
peaks_indices : ndarray
Indices of the locations in the `vector` where peaks were found.
The list is sorted.
See Also
--------
cwt
Continuous wavelet transform.
find_peaks
Find peaks inside a signal based on peak properties.
Notes
-----
This approach was designed for finding sharp peaks among noisy data,
however with proper parameter selection it should function well for
different peak shapes.
The algorithm is as follows:
1. Perform a continuous wavelet transform on `vector`, for the supplied
`widths`. This is a convolution of `vector` with `wavelet(width)` for
each width in `widths`. See `cwt`.
2. Identify "ridge lines" in the cwt matrix. These are relative maxima
at each row, connected across adjacent rows. See identify_ridge_lines
3. Filter the ridge_lines using filter_ridge_lines.
.. versionadded:: 0.11.0
References
----------
.. [1] Bioinformatics (2006) 22 (17): 2059-2065.
:doi:`10.1093/bioinformatics/btl355`
Examples
--------
>>> import numpy as np
>>> from scipy import signal
>>> xs = np.arange(0, np.pi, 0.05)
>>> data = np.sin(xs)
>>> peakind = signal.find_peaks_cwt(data, np.arange(1,10))
>>> peakind, xs[peakind], data[peakind]
([32], array([ 1.6]), array([ 0.9995736]))
Fr )rB �ndminNr g @)r� r� r� r� c �* � g | ]}|d d ��S )r r rv )rx rR s r, r� z"find_peaks_cwt.<locals>.<listcomp> s � �5�5�5�q�1�Q�4��7�5�5�5r. ) r rD rN r r r� r� r8 �sort)
�vectorr� �waveletr� r� r� r� r� r� �cwt_datr� �filtered�max_locss
r, r r � s� � �| �X�f�5��
2�
2�
2�F����W�V�A�Y�'�'�
�� � �� �
������&�'�6�*�*�G�'�� �
�K�K�K�"�7�K�J�/:�G�.8�:� :� :�H� �z�5�5�H�5�5�5�6�6�H� �M�M�O�O�O� �Or. )r r r )N)rU NN)NNNNNNrU N)NNr r� )NNNNr r� N) �__doc__rM �numpyr �scipy.signal._waveletsr r � scipy.statsr �_peak_finding_utilsr r r r
�__all__r- r r r
r= rI rP r r r_ re rp r r� r� r rv r. r, �<module>r� s ��� � � � � � � � � � .� .� .� .� .� .� .� .� )� )� )� )� )� )�� � � � � � � � � � � � :� :� :��9� 9� 9� 9�x7;� 7;� 7;� 7;�t6>� 6>� 6>� 6>�r6 � 6 � 6 � 6 �r� � �"� � �4� � �4M-� M-� M-� M-�`~@� ~@� ~@� ~@�B/� /� /�d#� #� #�L*>� *>� *>�Z 9=�BE� �Y � Y � Y � Y �xx� x� x�v HL�.0�=0� =0� =0� =0�@ @D�/3�9=�o� o� o� o� o� or.