blocks|key|2072890|text|Python中有类似的函数可以做到这一点吗？|type|blockquote|depth|inlineStyleRanges|entityRanges|data|2072891|据我所知，在Numpy+/+Scipy+/+Python中没有这样的函数。然而，创建一个并不是那么困难。总的想法如下：|unstyled|2072892|给定一个(一个)值向量：|2072893|找出峰的位置。我们叫他们(u)|ordered-list-item|2072894|找出他们的位置，我们叫他们(l)。|2072895|将模型拟合到(u)值对。让我们称之为(u_p)|2072896|将模型与(l)值对相匹配。让我们称之为(l_p)|2072897|在(s)区域上求值(u_p)，得到上包络的插值值。(我们叫他们(Q_u)吧)|2072898|在(s)区域上求值(l_p)，得到下包络的插值值。(我们叫他们(q_l))。|2072899|如您所见，这是三个步骤的顺序(查找位置、拟合模型、评估模型)，但应用了两次，一次用于信封的上部，一次用于较低的部分。|2072900|要收集(s)的“峰”，你需要定位斜率由正变为负的点，并收集(s)的“凹槽”，你需要定位斜率由负变为正的点。|2072901|峰值示例:s=+4,5,+4+-+5+-4为正，4-5为负。|2072902|槽例:s=+5,4,5+4-5为负5-4为正。|2072903|下面是一个示例脚本，可以让您开始使用大量的内联注释：|2072904|from+numpy+import+array,+sign,+zeros
from+scipy.interpolate+import+interp1d
from+matplotlib.pyplot+import+plot,show,hold,grid

s+=+array([1,4,3,5,3,2,4,3,4,5,4,3,2,5,6,7,8,7,8])+#This+is+your+noisy+vector+of+values.

q_u+=+zeros(s.shape)
q_l+=+zeros(s.shape)

#Prepend+the+first+value+of+(s)+to+the+interpolating+values.+This+forces+the+model+to+use+the+same+starting+point+for+both+the+upper+and+lower+envelope+models.

u_x+=+[0,]
u_y+=+[s[0],]

l_x+=+[0,]
l_y+=+[s[0],]

#Detect+peaks+and+troughs+and+mark+their+location+in+u_x,u_y,l_x,l_y+respectively.

for+k+in+xrange(1,len(s)-1):
++++if+(sign(s[k]-s[k-1])==1)+and+(sign(s[k]-s[k%2B1])==1):
++++++++u_x.append(k)
++++++++u_y.append(s[k])

++++if+(sign(s[k]-s[k-1])==-1)+and+((sign(s[k]-s[k%2B1]))==-1):
++++++++l_x.append(k)
++++++++l_y.append(s[k])

#Append+the+last+value+of+(s)+to+the+interpolating+values.+This+forces+the+model+to+use+the+same+ending+point+for+both+the+upper+and+lower+envelope+models.

u_x.append(len(s)-1)
u_y.append(s[-1])

l_x.append(len(s)-1)
l_y.append(s[-1])

#Fit+suitable+models+to+the+data.+Here+I+am+using+cubic+splines,+similarly+to+the+MATLAB+example+given+in+the+question.

u_p+=+interp1d(u_x,u_y,+kind+=+'cubic',bounds_error+=+False,+fill_value=0.0)
l_p+=+interp1d(l_x,l_y,kind+=+'cubic',bounds_error+=+False,+fill_value=0.0)

#Evaluate+each+model+over+the+domain+of+(s)
for+k+in+xrange(0,len(s)):
++++q_u[k]+=+u_p(k)
++++q_l[k]+=+l_p(k)

#Plot+everything
plot(s);hold(True);plot(q_u,'r');plot(q_l,'g');grid(True);show()|code-block|syntax|javascript|2072905|这将产生这样的输出：|2072906|​|2072907|📷|atomic|offset|length|2072908|2072909|有待进一步改进的要点：|2072910|上述代码不过滤可能出现的比某个阈值“距离”(Tl)+(例如时间)更近的峰值或低谷。这类似于envelope的第二个参数。但是，通过检查u_x,u_y的连续值之间的差异，可以很容易地添加它。|style|CODE|2072911|然而，与前面提到的点相比，一个快速的改进是在插值上、下包络函数之前，用移动平均滤波器对数据进行低通滤波。通过使用合适的移动平均滤波器，您可以轻松地完成这一任务。在这里没有详细介绍(如果需要的话)，为了产生一个在N个连续样本上工作的移动平均过滤器，您可以这样做：s_filtered+=+numpy.convolve(s,+numpy.ones((1,N))/float(N)。(N)越高，你的数据就会越平滑。但是，请注意，这将使您的(s)值(N/2)值向右(在s_filtered中)，这是由于平滑滤波器的群延迟。有关移动平均线的更多信息，请参见此链接。|BOLD|2072912|希望这能有所帮助。|2072913|(如果提供了有关原始应用程序的更多信息，则很高兴对答复进行修正。也许可以用更合适的方式对数据进行预处理(?)|2072914|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://developer.qcloudimg.com/http-save/yehe-900000/32e2afaea96b1370973363f282a461c1.png|imageAlt|1|LINK|MUTABLE|url|https://en.wikipedia.org/wiki/Group_delay_and_phase_delay|2|https://en.wikipedia.org/wiki/Moving_average^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|1|0|0|0|0|19|8|1V|7|0|M|K|3M|1L|6E|A|71|3|1|7L|3|2|0|0|0^^$0|@$1|2|3|4|5|6|7|2B|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|2C|8|@]|9|@]|A|$]]|$1|E|3|F|5|D|7|2D|8|@]|9|@]|A|$]]|$1|G|3|H|5|I|7|2E|8|@]|9|@]|A|$]]|$1|J|3|K|5|I|7|2F|8|@]|9|@]|A|$]]|$1|L|3|M|5|I|7|2G|8|@]|9|@]|A|$]]|$1|N|3|O|5|I|7|2H|8|@]|9|@]|A|$]]|$1|P|3|Q|5|I|7|2I|8|@]|9|@]|A|$]]|$1|R|3|S|5|I|7|2J|8|@]|9|@]|A|$]]|$1|T|3|U|5|D|7|2K|8|@]|9|@]|A|$]]|$1|V|3|W|5|D|7|2L|8|@]|9|@]|A|$]]|$1|X|3|Y|5|D|7|2M|8|@]|9|@]|A|$]]|$1|Z|3|10|5|D|7|2N|8|@]|9|@]|A|$]]|$1|11|3|12|5|D|7|2O|8|@]|9|@]|A|$]]|$1|13|3|14|5|15|7|2P|8|@]|9|@]|A|$16|17]]|$1|18|3|19|5|D|7|2Q|8|@]|9|@]|A|$]]|$1|1A|3|1B|5|D|7|2R|8|@]|9|@]|A|$]]|$1|1C|3|1D|5|1E|7|2S|8|@]|9|@$1F|2T|1G|2U|1|2V]]|A|$]]|$1|1H|3|1B|5|D|7|2W|8|@]|9|@]|A|$]]|$1|1I|3|1J|5|D|7|2X|8|@]|9|@]|A|$]]|$1|1K|3|1L|5|I|7|2Y|8|@$1F|2Z|1G|30|1M|1N]|$1F|31|1G|32|1M|1N]]|9|@]|A|$]]|$1|1O|3|1P|5|I|7|33|8|@$1F|34|1G|35|1M|1Q]|$1F|36|1G|37|1M|1N]|$1F|38|1G|39|1M|1N]]|9|@$1F|3A|1G|3B|1|3C]|$1F|3D|1G|3E|1|3F]]|A|$]]|$1|1R|3|1S|5|D|7|3G|8|@]|9|@]|A|$]]|$1|1T|3|1U|5|D|7|3H|8|@]|9|@]|A|$]]|$1|1V|3|-4|5|D|7|3I|8|@]|9|@]|A|$]]]|1W|$1X|$5|1Y|1Z|20|A|$21|22|23|-4]]|24|$5|25|1Z|26|A|$27|28]]|29|$5|25|1Z|26|A|$27|2A]]]]

<blockquote>
 Is there a similar function in Python that can do that?
</blockquote>

As far as I am aware there is no such function in Numpy / Scipy / Python. However, it is not that difficult to create one. The general idea is as follows:

Given a vector of values (s):

<ol>
<li>Find the location of peaks of (s). Let's call them (u)</li>
<li>Find the location of troughs of s. Let's call them (l).</li>
<li>Fit a model to the (u) value pairs. Let's call it (u_p)</li>
<li>Fit a model to the (l) value pairs. Let's call it (l_p)</li>
<li>Evaluate (u_p) over the domain of (s) to get the interpolated values of the upper envelope. (Let's call them (q_u))</li>
<li>Evaluate (l_p) over the domain of (s) to get the interpolated values of the lower envelope. (Let's call them (q_l)).</li>
</ol>

As you can see, it is the sequence of three steps (Find location, fit model, evaluate model) but applied twice, once for the upper part of the envelope and one for the lower.

To collect the "peaks" of (s) you need to locate points where the slope of (s) changes from positive to negative and to collect the "troughs" of (s) you need to locate the points where the slope of (s) changes from negative to positive. 

A peak example: s = [4,5,4] 5-4 is positive 4-5 is negative

A trough example: s = [5,4,5] 4-5 is negative 5-4 is positive

Here is an example script to get you started with plenty of inline comments:

<pre><code>from numpy import array, sign, zeros
from scipy.interpolate import interp1d
from matplotlib.pyplot import plot,show,hold,grid

s = array([1,4,3,5,3,2,4,3,4,5,4,3,2,5,6,7,8,7,8]) #This is your noisy vector of values.

q_u = zeros(s.shape)
q_l = zeros(s.shape)

#Prepend the first value of (s) to the interpolating values. This forces the model to use the same starting point for both the upper and lower envelope models.

u_x = [0,]
u_y = [s[0],]

l_x = [0,]
l_y = [s[0],]

#Detect peaks and troughs and mark their location in u_x,u_y,l_x,l_y respectively.

for k in xrange(1,len(s)-1):
 if (sign(s[k]-s[k-1])==1) and (sign(s[k]-s[k+1])==1):
 u_x.append(k)
 u_y.append(s[k])

 if (sign(s[k]-s[k-1])==-1) and ((sign(s[k]-s[k+1]))==-1):
 l_x.append(k)
 l_y.append(s[k])

#Append the last value of (s) to the interpolating values. This forces the model to use the same ending point for both the upper and lower envelope models.

u_x.append(len(s)-1)
u_y.append(s[-1])

l_x.append(len(s)-1)
l_y.append(s[-1])

#Fit suitable models to the data. Here I am using cubic splines, similarly to the MATLAB example given in the question.

u_p = interp1d(u_x,u_y, kind = 'cubic',bounds_error = False, fill_value=0.0)
l_p = interp1d(l_x,l_y,kind = 'cubic',bounds_error = False, fill_value=0.0)

#Evaluate each model over the domain of (s)
for k in xrange(0,len(s)):
 q_u[k] = u_p(k)
 q_l[k] = l_p(k)

#Plot everything
plot(s);hold(True);plot(q_u,'r');plot(q_l,'g');grid(True);show()
</code></pre>

This produces this output:

<a href="https://i.stack.imgur.com/DYsVk.png" rel="noreferrer"><img src="https://i.stack.imgur.com/DYsVk.png" alt="Indicative output"></a>

Points for further improvement:

<ol>
<li>The above code does not filter peaks or troughs that may be occuring closer than some threshold "distance" (Tl) (e.g. time). This is similar to the second parameter of <code>envelope</code>. It is easy to add it though by examining the differences between consecutive values of <code>u_x,u_y</code>.</li>
<li>However, a quick improvement over the point mentioned previously is to lowpass filter your data with a moving average filter BEFORE interpolating an upper and lower envelope functions. You can do this easily by convolving your (s) with a suitable moving average filter. Without going to a great detail here (can do if required), to produce a moving average filter that operates over N consecutive samples, you would do something like this: <code>s_filtered = numpy.convolve(s, numpy.ones((1,N))/float(N)</code>. The higher the (N) the smoother your data will appear. Please note however that this will shift your (s) values (N/2) samples to the right (in <code>s_filtered</code>) due to something that is called <a href="https://en.wikipedia.org/wiki/Group_delay_and_phase_delay" rel="noreferrer">group delay</a> of the smoothing filter. For more information about the moving average, please see <a href="https://en.wikipedia.org/wiki/Moving_average" rel="noreferrer">this link</a>.</li>
</ol>

Hope this helps. 

(Happy to ammend the response if more information about the original application is provided. Perhaps the data can be pre-processed in a more suitable way (?) )

blocks|key|2629825|text|在@A_A答案的基础上，用nim/max测试代替符号检查，使其更加健壮。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2629826|import+numpy+as+np
import+scipy.interpolate
import+matplotlib.pyplot+as+pt
%25matplotlib+inline

t+=+np.multiply(list(range(1000)),+.1)
s+=+10*np.sin(t)*t**.5

u_x+=+[0]
u_y+=+[s[0]]

l_x+=+[0]
l_y+=+[s[0]]

#Detect+peaks+and+troughs+and+mark+their+location+in+u_x,u_y,l_x,l_y+respectively.
for+k+in+range(2,len(s)-1):
++++if+s[k]+>=+max(s[:k-1]):
++++++++u_x.append(t[k])
++++++++u_y.append(s[k])

for+k+in+range(2,len(s)-1):
++++if+s[k]+<=+min(s[:k-1]):
++++++++l_x.append(t[k])
++++++++l_y.append(s[k])

u_p+=+scipy.interpolate.interp1d(u_x,+u_y,+kind+=+'cubic',+bounds_error+=+False,+fill_value=0.0)
l_p+=+scipy.interpolate.interp1d(l_x,+l_y,+kind+=+'cubic',+bounds_error+=+False,+fill_value=0.0)

q_u+=+np.zeros(s.shape)
q_l+=+np.zeros(s.shape)
for+k+in+range(0,len(s)):
++++q_u[k]+=+u_p(t[k])
++++q_l[k]+=+l_p(t[k])

pt.plot(t,s)
pt.plot(t,+q_u,+'r')
pt.plot(t,+q_l,+'g')|code-block|syntax|javascript|2629827|如果您期望函数会增加，请尝试：|2629828|for+k+in+range(1,len(s)-2):
++++if+s[k]+<=+min(s[k%2B1:]):
++++++++l_x.append(t[k])
++++++++l_y.append(s[k])|2629829|下一个信封。|2629830|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Building on @A_A 's answer, replace the sign check with nim/max test to make it more robust.

<pre><code>import numpy as np
import scipy.interpolate
import matplotlib.pyplot as pt
%matplotlib inline

t = np.multiply(list(range(1000)), .1)
s = 10*np.sin(t)*t**.5

u_x = [0]
u_y = [s[0]]

l_x = [0]
l_y = [s[0]]

#Detect peaks and troughs and mark their location in u_x,u_y,l_x,l_y respectively.
for k in range(2,len(s)-1):
 if s[k] &gt;= max(s[:k-1]):
 u_x.append(t[k])
 u_y.append(s[k])

for k in range(2,len(s)-1):
 if s[k] &lt;= min(s[:k-1]):
 l_x.append(t[k])
 l_y.append(s[k])

u_p = scipy.interpolate.interp1d(u_x, u_y, kind = 'cubic', bounds_error = False, fill_value=0.0)
l_p = scipy.interpolate.interp1d(l_x, l_y, kind = 'cubic', bounds_error = False, fill_value=0.0)

q_u = np.zeros(s.shape)
q_l = np.zeros(s.shape)
for k in range(0,len(s)):
 q_u[k] = u_p(t[k])
 q_l[k] = l_p(t[k])

pt.plot(t,s)
pt.plot(t, q_u, 'r')
pt.plot(t, q_l, 'g')
</code></pre>

If you expect the function to be increasing, try:

<pre><code>for k in range(1,len(s)-2):
 if s[k] &lt;= min(s[k+1:]):
 l_x.append(t[k])
 l_y.append(s[k])
</code></pre>

for the lower envelope.

blocks|key|2629926|text|第一次尝试是利用didn+希尔伯特变换来确定振幅包络，但在许多情况下，这并没有像预期的那样工作，主要原因是，引用了数字信号处理应答的话|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2629927|希尔伯特包络，也称为能量-时间曲线(等)，只适用于窄带波动。产生一个分析信号，其中你后来取绝对值，是一个线性运算，所以它平等地对待你的信号的所有频率。如果你给它一个纯正弦波，它确实会返回给你一条直线。然而，当你给它白噪音，你很可能会得到噪音回来。|blockquote|2629928|从那时起，由于其他答案是使用三次样条插值，而且确实会变得繁琐、有点不稳定(虚假振荡)和非常长和噪音很大的数据数组所需的时间，我将在这里提供一个简单而有效的版本，这个版本看起来很好：|2629929|import+numpy+as+np
from+matplotlib+import+pyplot+as+plt

def+hl_envelopes_idx(s,+dmin=1,+dmax=1,+split=False):
++++"""
++++Input+:
++++s:+1d-array,+data+signal+from+which+to+extract+high+and+low+envelopes
++++dmin,+dmax:+int,+optional,+size+of+chunks,+use+this+if+the+size+of+the+input+signal+is+too+big
++++split:+bool,+optional,+if+True,+split+the+signal+in+half+along+its+mean,+might+help+to+generate+the+envelope+in+some+cases
++++Output+:
++++lmin,lmax+:+high/low+envelope+idx+of+input+signal+s
++++"""

++++#+locals+min++++++
++++lmin+=+(np.diff(np.sign(np.diff(s)))+>+0).nonzero()[0]+%2B+1+
++++#+locals+max
++++lmax+=+(np.diff(np.sign(np.diff(s)))+<+0).nonzero()[0]+%2B+1+
++++

++++if+split:
++++++++#+s_mid+is+zero+if+s+centered+around+x-axis+or+more+generally+mean+of+signal
++++++++s_mid+=+np.mean(s)+
++++++++#+pre-sorting+of+locals+min+based+on+relative+position+with+respect+to+s_mid+
++++++++lmin+=+lmin[s[lmin]<s_mid]
++++++++#+pre-sorting+of+local+max+based+on+relative+position+with+respect+to+s_mid+
++++++++lmax+=+lmax[s[lmax]>s_mid]


++++#+global+max+of+dmax-chunks+of+locals+max+
++++lmin+=+lmin[[i%2Bnp.argmin(s[lmin[i:i%2Bdmin]])+for+i+in+range(0,len(lmin),dmin)]]
++++#+global+min+of+dmin-chunks+of+locals+min+
++++lmax+=+lmax[[i%2Bnp.argmax(s[lmax[i:i%2Bdmax]])+for+i+in+range(0,len(lmax),dmax)]]
++++
++++return+lmin,lmax|code-block|syntax|javascript|2629930|示例1:+准周期振动|style|BOLD|2629931|t+=+np.linspace(0,8*np.pi,5000)
s+=+0.8*np.cos(t)**3+%2B+0.5*np.sin(np.exp(1)*t)
high_idx,+low_idx+=+hl_envelopes_idx(s)

#+plot
plt.plot(t,s,label='signal')
plt.plot(t[high_idx],+s[high_idx],+'r',+label='low')
plt.plot(t[low_idx],+s[low_idx],+'g',+label='high')|2629932|📷|atomic|2629933|示例2:+噪声衰减信号|2629934|t+=+np.linspace(0,2*np.pi,5000)
s+=+5*np.cos(5*t)*np.exp(-t)+%2B+np.random.rand(len(t))

high_idx,+low_idx+=+hl_envelopes_idx(s,dmin=15,dmax=15)

#+plot
plt.plot(t,s,label='signal')
plt.plot(t[high_idx],+s[high_idx],+'r',+label='low')
plt.plot(t[low_idx],+s[low_idx],+'g',+label='high')|2629935|2629936|示例3:+非对称调制啁啾|2629937|18867925样本的一个更复杂的信号(这里不包括)：|CODE|2629938|2629939|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.hilbert.html|1|https://dsp.stackexchange.com/questions/3463/envelope-of-time-domain-signal-hilbert-transform/3464#3464|2|IMAGE|IMMUTABLE|imageUrl|https://developer.qcloudimg.com/http-save/yehe-900000/37a8ad710861c19fece0fe7daf9515b7.png|imageAlt|3|https://developer.qcloudimg.com/http-save/yehe-900000/5977d1781bff59e98cfd97140e9bdf8f.png|4|https://developer.qcloudimg.com/http-save/yehe-900000/0a125ad2bb480aed14bc33adf59647a3.png^0|D|6|0|1L|8|1|0|0|0|0|0|4|5|5|0|0|0|1|2|0|0|4|5|6|0|0|0|1|3|0|0|4|5|7|0|0|8|0|0|1|4|0^^$0|@$1|2|3|4|5|6|7|1R|8|@]|9|@$A|1S|B|1T|1|1U]|$A|1V|B|1W|1|1X]]|C|$]]|$1|D|3|E|5|F|7|1Y|8|@]|9|@]|C|$]]|$1|G|3|H|5|6|7|1Z|8|@]|9|@]|C|$]]|$1|I|3|J|5|K|7|20|8|@]|9|@]|C|$L|M]]|$1|N|3|O|5|6|7|21|8|@$A|22|B|23|P|Q]|$A|24|B|25|P|Q]]|9|@]|C|$]]|$1|R|3|S|5|K|7|26|8|@]|9|@]|C|$L|M]]|$1|T|3|U|5|V|7|27|8|@]|9|@$A|28|B|29|1|2A]]|C|$]]|$1|W|3|X|5|6|7|2B|8|@$A|2C|B|2D|P|Q]|$A|2E|B|2F|P|Q]]|9|@]|C|$]]|$1|Y|3|Z|5|K|7|2G|8|@]|9|@]|C|$L|M]]|$1|10|3|U|5|V|7|2H|8|@]|9|@$A|2I|B|2J|1|2K]]|C|$]]|$1|11|3|12|5|6|7|2L|8|@$A|2M|B|2N|P|Q]|$A|2O|B|2P|P|Q]]|9|@]|C|$]]|$1|13|3|14|5|6|7|2Q|8|@$A|2R|B|2S|P|15]]|9|@]|C|$]]|$1|16|3|U|5|V|7|2T|8|@]|9|@$A|2U|B|2V|1|2W]]|C|$]]|$1|17|3|-4|5|6|7|2X|8|@]|9|@]|C|$]]]|18|$19|$5|1A|1B|1C|C|$1D|1E]]|1F|$5|1A|1B|1C|C|$1D|1G]]|1H|$5|1I|1B|1J|C|$1K|1L|1M|-4]]|1N|$5|1I|1B|1J|C|$1K|1O|1M|-4]]|1P|$5|1I|1B|1J|C|$1K|1Q|1M|-4]]]]

First attempt was to make use of scipy <a href="https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.hilbert.html" rel="noreferrer">Hilbert transform</a> to determine the amplitude envelope but this didn't work as expected in many cases, mainly reason because, citing from this <a href="https://dsp.stackexchange.com/questions/3463/envelope-of-time-domain-signal-hilbert-transform/3464#3464">digital signal processing answer</a>:
<blockquote>
Hilbert envelope, also called Energy-Time Curve (ETC), only works well
for narrow-band fluctuations. Producing an analytic signal, of which
you later take the absolute value, is a linear operation, so it treats
all frequencies of your signal equally. If you give it a pure sine
wave, it will indeed return to you a straight line. When you give it
white noise however, you will likely get noise back.
</blockquote>
From then, since the other answers were using cubic spline interpolation and did tend to become cumbersome, a bit unstable (spurious oscillations) and time consuming for very long and noisy data arrays, I will contribute here with a simple and numpy efficient version that seems to work pretty fine:
<pre><code>import numpy as np
from matplotlib import pyplot as plt

def hl_envelopes_idx(s, dmin=1, dmax=1, split=False):
 &quot;&quot;&quot;
 Input :
 s: 1d-array, data signal from which to extract high and low envelopes
 dmin, dmax: int, optional, size of chunks, use this if the size of the input signal is too big
 split: bool, optional, if True, split the signal in half along its mean, might help to generate the envelope in some cases
 Output :
 lmin,lmax : high/low envelope idx of input signal s
 &quot;&quot;&quot;

 # locals min 
 lmin = (np.diff(np.sign(np.diff(s))) &gt; 0).nonzero()[0] + 1 
 # locals max
 lmax = (np.diff(np.sign(np.diff(s))) &lt; 0).nonzero()[0] + 1 
 

 if split:
 # s_mid is zero if s centered around x-axis or more generally mean of signal
 s_mid = np.mean(s) 
 # pre-sorting of locals min based on relative position with respect to s_mid 
 lmin = lmin[s[lmin]&lt;s_mid]
 # pre-sorting of local max based on relative position with respect to s_mid 
 lmax = lmax[s[lmax]&gt;s_mid]


 # global max of dmax-chunks of locals max 
 lmin = lmin[[i+np.argmin(s[lmin[i:i+dmin]]) for i in range(0,len(lmin),dmin)]]
 # global min of dmin-chunks of locals min 
 lmax = lmax[[i+np.argmax(s[lmax[i:i+dmax]]) for i in range(0,len(lmax),dmax)]]
 
 return lmin,lmax
</code></pre>
Example 1: quasi-periodic vibration
<pre><code>t = np.linspace(0,8*np.pi,5000)
s = 0.8*np.cos(t)**3 + 0.5*np.sin(np.exp(1)*t)
high_idx, low_idx = hl_envelopes_idx(s)

# plot
plt.plot(t,s,label='signal')
plt.plot(t[high_idx], s[high_idx], 'r', label='low')
plt.plot(t[low_idx], s[low_idx], 'g', label='high')
</code></pre>
<img src="https://i.stack.imgur.com/onA3s.png" width="500" />
Example 2: noisy decaying signal
<pre><code>t = np.linspace(0,2*np.pi,5000)
s = 5*np.cos(5*t)*np.exp(-t) + np.random.rand(len(t))

high_idx, low_idx = hl_envelopes_idx(s,dmin=15,dmax=15)

# plot
plt.plot(t,s,label='signal')
plt.plot(t[high_idx], s[high_idx], 'r', label='low')
plt.plot(t[low_idx], s[low_idx], 'g', label='high')
</code></pre>
<img src="https://i.stack.imgur.com/niJtt.png" width="500" />
Example 3: nonsymmetric modulated chirp
A much more complex signal of <code>18867925</code> samples (which isn't included here):
<img src="https://i.stack.imgur.com/AG8dR.png" width="500" />

blocks|key|2073035|text|您可能想看看Hilbert变换，这很可能是MATLAB中信封函数背后的实际代码。用于nice的信号子模块有一个内置的Hilbert变换，在文档中有一个很好的例子，其中提取了振荡信号的包络：https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.hilbert.html。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2073036|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.hilbert.html^0|2M|26|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

You might want to look at the Hilbert transform, which is likely the actual code behind the envelope function in MATLAB. The signal sub-module for scipy has a built-in Hilbert transform, and there is a nice example in the documentation, where the envelope of an oscillatory signal is extracted:
<a href="https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.hilbert.html" rel="nofollow noreferrer">https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.hilbert.html</a>

blocks|key|1470939|text|我发现结合使用than函数比使用其他方法更好。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1470940|def+envelope(sig,+distance):
++++#+split+signal+into+negative+and+positive+parts
++++u_x+=+np.where(sig+>+0)[0]
++++l_x+=+np.where(sig+<+0)[0]
++++u_y+=+sig.copy()
++++u_y[l_x]+=+0
++++l_y+=+-sig.copy()
++++l_y[u_x]+=+0
++++
++++#+find+upper+and+lower+peaks
++++u_peaks,+_+=+scipy.signal.find_peaks(u_y,+distance=distance)
++++l_peaks,+_+=+scipy.signal.find_peaks(l_y,+distance=distance)
++++
++++#+use+peaks+and+peak+values+to+make+envelope
++++u_x+=+u_peaks
++++u_y+=+sig[u_peaks]
++++l_x+=+l_peaks
++++l_y+=+sig[l_peaks]
++++
++++#+add+start+and+end+of+signal+to+allow+proper+indexing
++++end+=+len(sig)
++++u_x+=+np.concatenate((u_x,+[0,+end]))
++++u_y+=+np.concatenate((u_y,+[0,+0]))
++++l_x+=+np.concatenate((l_x,+[0,+end]))
++++l_y+=+np.concatenate((l_y,+[0,+0]))
++++
++++#+create+envelope+functions
++++u+=+scipy.interpolate.interp1d(u_x,+u_y)
++++l+=+scipy.interpolate.interp1d(l_x,+l_y)
++++return+u,+l

def+test():
++++x+=+np.arange(200)
++++sig+=+np.sin(x)
++++u,+l+=+envelope(sig,+1)
++++
++++plt.figure(figsize=(25,5))
++++plt.plot(x,+u(x))
++++plt.plot(x,+l(x))
++++plt.plot(x,+sig*0.9)
++++plt.show()
++++
test()|code-block|syntax|javascript|1470941|​|1470942|📷|atomic|offset|length|1470943|1470944|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://developer.qcloudimg.com/http-save/yehe-900000/7da4a01b344e13f65bb6623d8ac100d8.png|imageAlt^0|0|0|0|0|1|0|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Y|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Z|8|@]|9|@]|A|$]]|$1|I|3|J|5|K|7|10|8|@]|9|@$L|11|M|12|1|13]]|A|$]]|$1|N|3|H|5|6|7|14|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V|W|-4]]]]

I found using a combination of scipy functions better performing than alternatives
<pre class="lang-py prettyprint-override"><code>def envelope(sig, distance):
 # split signal into negative and positive parts
 u_x = np.where(sig &gt; 0)[0]
 l_x = np.where(sig &lt; 0)[0]
 u_y = sig.copy()
 u_y[l_x] = 0
 l_y = -sig.copy()
 l_y[u_x] = 0
 
 # find upper and lower peaks
 u_peaks, _ = scipy.signal.find_peaks(u_y, distance=distance)
 l_peaks, _ = scipy.signal.find_peaks(l_y, distance=distance)
 
 # use peaks and peak values to make envelope
 u_x = u_peaks
 u_y = sig[u_peaks]
 l_x = l_peaks
 l_y = sig[l_peaks]
 
 # add start and end of signal to allow proper indexing
 end = len(sig)
 u_x = np.concatenate((u_x, [0, end]))
 u_y = np.concatenate((u_y, [0, 0]))
 l_x = np.concatenate((l_x, [0, end]))
 l_y = np.concatenate((l_y, [0, 0]))
 
 # create envelope functions
 u = scipy.interpolate.interp1d(u_x, u_y)
 l = scipy.interpolate.interp1d(l_x, l_y)
 return u, l

def test():
 x = np.arange(200)
 sig = np.sin(x)
 u, l = envelope(sig, 1)
 
 plt.figure(figsize=(25,5))
 plt.plot(x, u(x))
 plt.plot(x, l(x))
 plt.plot(x, sig*0.9)
 plt.show()
 
test()
</code></pre>
<a href="https://i.stack.imgur.com/V2u8O.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/V2u8O.png" alt="resulting image" /></a>

blocks|key|2630083|text|或者你用熊猫。这里我只需要两行代码：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2630084|import+pandas+as+pd
import+numpy+as+np


x=np.linspace(0,5*np.pi,1000)
y=np.sin(x)%2B0.4*np.cos(x/4)*np.sin(x*20)

df=pd.DataFrame(data={"y":y},index=x)

windowsize+=+20
df["y_upperEnv"]=df["y"].rolling(window=windowsize).max().shift(int(-windowsize/2))
df["y_lowerEnv"]=df["y"].rolling(window=windowsize).min().shift(int(-windowsize/2))

df.plot(figsize=(20,10))|code-block|syntax|javascript|2630085|输出：|offset|length|style|BOLD|2630086|​|2630087|📷|atomic|2630088|2630089|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://developer.qcloudimg.com/http-save/yehe-900000/fc5032a7b63bf845b0e37cd894afba49.png|imageAlt^0|0|0|0|3|0|0|0|1|0|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|12|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|13|8|@$I|14|J|15|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|16|8|@]|9|@]|A|$]]|$1|O|3|P|5|Q|7|17|8|@]|9|@$I|18|J|19|1|1A]]|A|$]]|$1|R|3|N|5|6|7|1B|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|1C|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|Z|10|-4]]]]

Or you use pandas. Here I only need two lines of code:
<pre class="lang-py prettyprint-override"><code>import pandas as pd
import numpy as np


x=np.linspace(0,5*np.pi,1000)
y=np.sin(x)+0.4*np.cos(x/4)*np.sin(x*20)

df=pd.DataFrame(data={&quot;y&quot;:y},index=x)

windowsize = 20
df[&quot;y_upperEnv&quot;]=df[&quot;y&quot;].rolling(window=windowsize).max().shift(int(-windowsize/2))
df[&quot;y_lowerEnv&quot;]=df[&quot;y&quot;].rolling(window=windowsize).min().shift(int(-windowsize/2))

df.plot(figsize=(20,10))
</code></pre>
Output:
<img src="https://i.stack.imgur.com/wHKzY.png" alt="image" />

I have quite a noisy data, and I am trying to work out a high and low envelope to the signal. It is kind of like this example in MATLAB:
<a href="http://uk.mathworks.com/help/signal/examples/signal-smoothing.html" rel="noreferrer">http://uk.mathworks.com/help/signal/examples/signal-smoothing.html</a>
in &quot;Extracting Peak Envelope&quot;. Is there a similar function in Python that can do that? My entire project has been written in Python, worst case scenario I can extract my numpy array and throw it into MATLAB and use that example. But I prefer the look of matplotlib... and really cba doing all of those I/O between MATLAB and Python...
Thanks,

How to get high and low envelope of a signal

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我有一个相当嘈杂的数据，我正试图计算出一个高低包络的信号。就像MATLAB中的这个例子：在“提取峰包络”中。Python中有类似的函数可以做到这一点吗？我的整个项目都是用Python编写的，最坏的情况是，我可以提取我的numpy数组，并将其放入MATLAB并使用该示例。但我更喜欢matplotlib的样子..。真正的c...

问如何获得信号的高低包络
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何获得信号的高低包络EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何获得信号的高低包络
EN