Как определить, когда расстояние между двумя линиями попадает в определенный порог?

Question

У меня есть график с основными точками данных (синяя линия) и максимумами (зеленый) и минимумами (красный).

Обратите внимание, что значения x минимумов и максимумов не одинаковы, и при этом они не гарантируют одинаковое количество значений.

Теперь моя цель состоит в том, чтобы определить, когда расстояние вдоль оси y (целое? Извините, прошло некоторое время с момента вычисления в универе) между линиями максимума и минимума, становится меньше 10% (или любого другого произвольного порога)) от среднего расстояния по оси Y.

Вот код, используемый для генерации:

# Finding the min and max
c_max_index = argrelextrema(df.flow.values, np.greater, order=3)
c_min_index = argrelextrema(df.flow.values, np.less, order=3)

df['min_extreme'] = df.flow[c_min_index[0]]
df['max_extreme'] = df.flow[c_max_index[0]]

# Plotting the values for the graph above
plt.plot(df.flow.values)
upper_bound = plt.plot(c_max_index[0], df.flow.values[c_max_index[0]], linewidth=0.8, c='g')
lower_bound = plt.plot(c_min_index[0], df.flow.values[c_min_index[0]], linewidth=0.8, c='r')

Если это имеет значение, я использую Pandas Dataframe, scipyи matplotlib.

Answer 1

Это идеальное решение ни в коем случае.Он направлен на то, чтобы дать вам некоторые идеи о том, как это можно сделать, поскольку данных больше нет.

Основная проблема, которую вы пытаетесь решить, - это иметь дело с двумя кусочно-прямыми линиями.И кусочки не совпадают.Очевидное решение состоит в том, чтобы интерполировать оба и получить объединение х.Тогда вычисление расстояний будет проще.

import numpy as np
import matplotlib.pyplot as plt

# Toy data
x1 = [0, 1, 2, 3, 4, 5, 6]
y1 = [9, 8, 9, 10, 7, 6, 9]
x2 = [0.5, 3, 5, 6, 9]
y2 = [0, 1, 3, 2, 1]

# Interpolation for both lines
points1 = list(zip(x1, y1))
y1_interp = np.interp(x2, x1, y1)
interp_points1 = list(zip(x2, y1_interp))
l1 = list(set(points1 + interp_points1))
all_points1 = sorted(l1, key = lambda x: x[0])

points2 = list(zip(x2, y2))
y2_interp = np.interp(x1, x2, y2)
interp_points2 = list(zip(x1, y2_interp))
l2 = list(set(points2 + interp_points2))
all_points2 = sorted(l2, key = lambda x: x[0])

assert(len(all_points1) == len(all_points2))

# Since I do not have data points on the blue line, 
# I will calculate the average distance based on x's of all interpolated points
sum_d = 0
for i in range(len(all_points1)):
    sum_d += all_points1[i][1] - all_points2[i][1]
avg_d = sum_d / len(all_points1)
threshold = 0.5
d_threshold = avg_d * threshold

for i in range(len(all_points1)):
    d = all_points1[i][1] - all_points2[i][1]
    if d / avg_d < threshold:
        print("Distance below threshold between", all_points1[i], "and", all_points2[i])

Обратите внимание, что np.interp также экстраполирует значения, но они не участвуют в вычислении.

Теперь остается вопрос:вам на самом деле нужно знать , когда расстояние падает ниже порогового значения, кроме только интерполированных точек, нужно аналитически искать первую и последнюю точки в каждом отрезке линий.Вот образец:

for i in range(len(all_points1) - 1):
    (pre_x1, pre_y1) = all_points1[i]
    (post_x1, post_y1) = all_points1[i + 1]
    (pre_x2, pre_y2) = all_points2[i]
    (post_x2, post_y2) = all_points2[i + 1]
    # Skip the pieces that will never have qualified points
    if (pre_y1 - pre_y2) / avg_d >= threshold and (post_y1 - post_y2) / avg_d >= threshold:
        continue
    k1 = (post_y1 - pre_y1) / (post_x1 - pre_x1)
    b1 = (post_x1 * pre_y1 - pre_x1 * post_y1) / (post_x1 - pre_x1)
    k2 = (post_y2 - pre_y2) / (post_x2 - pre_x2)
    b2 = (post_x2 * pre_y2 - pre_x2 * post_y2) / (post_x2 - pre_x2)
    x_start = (d_threshold - b1 + b2) / (k1 - k2)
    print("The first point where the distance falls below threshold is at x=", x_start)
    break

Answer 2

Ваша проблема в том, что min_extreme и max_extreme не выровнены / определены полностью.Мы можем решить это по interpolate:

# this will interpolate values linearly, i.e data on the upper and lower lines
df = df.interpolate()

# vertical distance between upper and lower lines:
df['dist'] = df.max_extreme - df.min_extreme

# thresholding, thresh can be scalar or series
# thresh = 0.5 -- absolute value
# thresh = df.max_extreme / 2 -- relative to the current max_extreme

thresh = df.dist.quantile(0.5) # larger than 50% of the distances

df['too_far'] = df.dist.gt(thresh)

# visualize:
tmp_df = df[df.too_far]

upper_bound = plt.plot(c_max_index[0], df.flow.values[c_max_index[0]], linewidth=0.8, c='g')
lower_bound = plt.plot(c_min_index[0], df.flow.values[c_min_index[0]], linewidth=0.8, c='r')

df.flow.plot()

plt.scatter(tmp_df.index, tmp_df.min_extreme, s=10)
plt.scatter(tmp_df.index, tmp_df.max_extreme, s=10)
plt.show()

Вывод:

Answer 3

Если я правильно понимаю ваш вопрос, вы в основном хотите интерполировать строки, определенные экстремальными значениями.Похищая ответ из этого поста Интерполируя значения NaN в массиве NumPy , вы можете сделать это

# Finding the min and max
c_max_index = argrelextrema(df.flow.values, np.greater, order=3)
c_min_index = argrelextrema(df.flow.values, np.less, order=3)

df['min_extreme'] = df.flow[c_min_index[0]]
df['max_extreme'] = df.flow[c_max_index[0]]

# Interpolate so you get no 'nan' values
df['min_extreme'] = df['min_extreme'].interpolate()
df['max_extreme'] = df['max_extreme'].interpolate() 

Отсюда должно быть легко сделать все виды вещей с расстояниями междудве строки.Например

# Get the average distance between the upper and lower extrema-lines
df['distance'] = df['max_extreme'] - df['min_extreme']
avg_dist = np.mean(df['distance'])

# Find indexes where distance is within some tolerance
df.index[df['distance']< avg_dist * .95]