如何根据x值展平时的步长函数数组进行分块

Question

I am running into a problem that I am having trouble figuring out in python (which I will currently blame on sever jetlag).

I have an array, let's call it x. The plot of x where y-axis is generic value, x-axis is index of array, looks like:

What I want to do is isolate the flat sections after the initial bump (see next picture that I am interested in):

I want to ignore the leading flat line and bump, and make an array of the five red boxes in the second image such that I have something like

x_chunk = [[box 0], [box 1], [box 2], [box 3], [box 4]]

I want to ignore all of the sloped transition line between the red chunks. I am having trouble figuring out the proper iterating procedure and setting the condition such that I get what I need.

Answer 1

So, this is probably not the cleanest solution, however it works:

import numpy as np
import matplotlib.pyplot as plt

# Create data
r=np.random.random(50)
y1 = np.array([50,40,30,20,10])
y=np.repeat(y1,10)
y[9]=y[9]+10
y=y+r

# Plot data
x=np.arange(len(y))
plt.plot(x,y)
plt.show()

Will give you something like this:

# Find maximum and start from there
idxStart=np.argmax(y)
y2=y[idxStart:]

# Grab jump indices
idxs=np.where(np.diff(y2)<-1)[0]+1

# Put into boxes
boxs=[]
for i in range(len(idxs)-1):
    boxs.append(y2[idxs[i]:idxs[i+1]])

print boxs  

Of course you will need to find the right threshold to distinguish the "jumps/drops" in the data, in my case -1 was good enough since random returns values between 0 and 1. Hope your jetlag gets better soon.

Answer 2

Not tested as I have no data, but something like this should work

def findSteps(arr, thr=.02, window=10, disc=np.std):
    d = disc(np.lib.stride_tricks.as_strided(arr, strides = arr.strides*2, shape = (arr.size-window+1, window)), axis = 1)
    m = np.minimum(np.abs(d[:-window]), np.abs(d[window:])) < thr
    i = np.nonzero(np.diff(m))
    return np.split(arr[window:-window], i)[::2]

May have to play around with the window and threshold value, and you may want to write a slope function for disc if np.std doesn't work, but the basic idea is looking forward and backward by window steps and seeing if the standard deviation (or slope) of the stride is close to 0.

You'll end up with blocks of True values, which you find the start and end of by np.nonzero(np.diff())

You then np.split the array into a list of arrays by the blocks and only take every other member of the list (since the other sub-arrays will be the transitions).