生成更多数据点和绘图的问题

Question

赏金将在 16 小时后到期。 此问题的答案有资格获得+50声望赏金。 pro正在寻找这个问题的更详细的答案：

因为这在研究领域广泛适用。 我希望专家们能提出更好的解决这个问题的方法。谢谢。

我可以使用下面的代码像 plot 那样使用阶梯 plot

import numpy as np
from scipy.interpolate import interp1d
import matplotlib.pyplot as plt

x = np.array([3.45, 3.88, 3.99, 4.33])
y = np.array([14.0, 11.0, 14.0, 31.0])
y = np.cumsum(y)
y0 = np.array([0])
x0 = np.interp([0], y, x)
x = np.concatenate([x0, x])
y = np.concatenate([y0, y])

# Plot
fig, ax = plt.subplots()
ax.step(x, y, color='r', where='post')
ax.set_xlim(2, 5)
ax.set_ylim(0, y.max())
ax.invert_yaxis()
plt.show()

################################################## ###

现在我需要使用插值 function 生成更多的 x 和 y 数据点，并希望生成与上面生成的代码相同的 plot（如上所示）。 我尝试了下面提到的代码，但它产生了不同的情节（如下所示），但定义说插值后，我们应该有相同的 plot，我们只是有更多的数据点。

import numpy as np
from scipy.interpolate import interp1d
import matplotlib.pyplot as plt

x = np.array([3.45, 3.88, 3.99, 4.33])
y = np.array([14.0, 11.0, 14.0, 31.0])
y = np.cumsum(y)
y0 = np.array([0])
x0 = np.interp([0], y, x)
x = np.concatenate([x0, x])
y = np.concatenate([y0, y])

# I need to generate more data points
NUM = 100  # modify the number of points
funct = interp1d(x, y, kind='next')
x_cont = np.linspace(x[0], x[-1], NUM)
y_cont = funct(x_cont)

# Plot
fig, ax1 = plt.subplots()
ax1.step(x_cont, y_cont, color='r', where='post')
ax1.set_xlim(2, 5)
ax1.set_ylim(0, y.max())
ax1.invert_yaxis()
plt.show()

Answer 1

更新

IIUC，现在你想要线改变方向的点。 所以你可以使用np.repeat

# Original data
x = np.array([3.45, 3.88, 3.99, 4.33])
y = np.array([14.0, 11.0, 14.0, 31.0])
y = np.cumsum(y)

# Find breakpoints
x_cont = np.hstack([x[0], np.repeat(x, 2)[1:]])
y_cont = np.hstack([0, np.repeat(y, 2)[:-1]])

# Plot
fig, ax = plt.subplots()
ax.scatter(x_cont, y_cont, marker='.', color='blue')
ax.plot(x_cont, y_cont, color='red')
ax.set_xlim(2, 5)
ax.set_ylim(0, y.max())
ax.invert_yaxis()
plt.show()

Output：

>>> x_cont
array([3.45, 3.45, 3.88, 3.88, 3.99, 3.99, 4.33, 4.33])

>>> y_cont
array([ 0., 14., 14., 25., 25., 39., 39., 70.])

---

旧答案

你想增加每一步的点数。 您可以使用自定义 function 将值从 (x1, y1) 插入到 (x2, y1)，然后从 (x2, y1) 插入到 (x2, y2)。 这意味着您先计算 x 点，然后再计算 y。 function 有 3 个参数和步长：

• x , y ：你的中间步骤点（你的两个 arrays x 和 y）
• x0 , y0 : 开始坐标（这里你必须指定 y=0 因为它没有出现在你的数据中）
• xn , yn : 结束坐标（这里你可以重用 x 和 y 数组的最后一个值）
• step ：步长（我们将值近似为点均匀分布）

def interpolate(x, y, x0, y0, xn, yn, step):
    # create arrays with all points
    x = np.hstack([x0, x, xn])
    y = np.hstack([y0, y, yn])
    x_cont = []
    y_cont = []

    # get points pairwise
    for x1, x2, y1, y2 in zip(x, x[1:], y, y[1:]):
        # approximate the number of samples per segment
        numx = int(np.abs(x2 - x1) / step)
        numy = int(np.abs(y2 - y1) / step)

        # x-first (left or right move)
        a = np.linspace(x1, x2, numx, endpoint=False)
        b = np.repeat(y1, numx)
        # y-second (top or down move)
        c = np.repeat(x2, numy)
        d = np.linspace(y1, y2, numy, endpoint=False)

        # save points
        x_cont.append([*a, *c])
        y_cont.append([*b, *d])

    # flat all computed values
    return np.hstack([*x_cont, xn]), np.hstack([*y_cont, yn])

# Original data
x = np.array([3.45, 3.88, 3.99, 4.33])
y = np.array([14.0, 11.0, 14.0, 31.0])
y = np.cumsum(y)  # It seems you want the cumulative sum of y

x_cont, y_cont = interpolate(x, y, x[0], 0, x[-1], y[-1], step=0.1)

Plot 值：

fig, ax = plt.subplots()
ax.step(x_cont, y_cont, color='red', where='post')
ax.set_xlim(2, 5)
ax.set_ylim(0, y.max())
ax.invert_yaxis()
plt.show()

Output：

Answer 2

看起来你正在寻找一个 function 作为输入的枢轴数p和点数n放置在连接这些枢轴的水平和垂直直线上。 我假设您希望额外的点均匀（线性）间隔。

本质上，您需要：

1. 识别pivot点
2. 确保len(p) <= n
3. 当线条垂直时，对x使用重复值，对y使用线性间隔值
4. 当线条是水平时，对y使用重复值，对x使用线性间隔值

使用 NumPy （特别是np.linspace()和np.repeat() ）的简单实现可以是：

import typing as typ
import numpy as np


def upscale_steps_equi(
    p_x: typ.Sequence[float],
    p_y: typ.Sequence[float],
    n: int,
    start_hor: typ.Optional[str] = None,
    dtype: np.dtype = np.float_,
):
    """
    The points are equi-spaced (except near the pivots).
    The pivots are, in general, not included.
    
    Args:
        p_x: Must be strictly monotonic increasing.
        p_y: Must be strictly monotonic increasing.
        n: Must be larger than max(len(p_x), len(p_y))
        start_hor: Must be True for horizontal, False for vertical.
            Only used (and needed) if len(p_x) == len(p_y)
    """
    p_x_n = len(p_x)
    p_y_n = len(p_y)
    is_same_len = p_x_n == p_y_n
    p_n = max(p_x_n, p_y_n) + 1  # number of points
    if p_x_n > p_y_n:
        start_hor = True
    elif p_x_n < p_y_n:
        start_hor = False
    elif start_hor is None or not isinstance(start_hor, bool):
        raise ValueError("`start_hor` required if len(p_x) == len(p_y)")
    p_x_ = np.repeat(p_x, 2)  # x-coords of pivots
    p_y_ = np.repeat(p_y, 2)  # y-coords of pivots
    if is_same_len:
        if start_hor:
            p_x_ = p_x_[1:]
            p_y_ = p_y_[:-1]
        else:
            p_x_ = p_x_[:-1]
            p_y_ = p_y_[1:]
    else:
        if start_hor:
            p_x_ = p_x_[1:-1]
        else:
            p_y_ = p_y_[1:-1]
    dx = max(p_x) - min(p_x)  # distance covered along x
    dy = max(p_y) - min(p_y)  # distance covered along y
    d = dx + dy
    ll = np.linspace(0, d, n, endpoint=False)
    x = min(p_x) + ll
    y = min(p_y) + ll
    last_x_ = last_y_ = last_d_ = None
    d_ = d_x_ = d_y_ = 0
    for x_, y_ in zip(p_x_, p_y_):
        if x_ == last_x_:
            dd_y_ = y_ - last_y_
            d_y_ += dd_y_
            d_ += dd_y_
            mask = (ll >= last_d_) & (ll < d_)
            x[mask] = x_
            y[mask] -= d_x_
        elif y_ == last_y_:
            dd_x_ = x_ - last_x_
            d_x_ += dd_x_
            d_ += dd_x_
            mask = (ll >= last_d_) & (ll < d_)
            y[mask] = y_
            x[mask] -= d_y_
        last_x_ = x_
        last_y_ = y_
        last_d_ = d_
    return x, y

像这样使用：

import matplotlib.pyplot as plt


x, y = upscale_steps_equi([1, 4, 5], [2, 3, 7, 9], 20)
plt.scatter(x, y, marker='o')
plt.axis('scaled')

---

上面的 function 通常不包括枢轴。 但是，如果必须包括枢轴，则需要放弃确切的点数以及 x 和 y 的相同间距。 这是一个可能的解决方案，其中点在每个段内等距分布：

import typing as typ
import numpy as np



def upscale_steps_with_pivots(
    p_x: typ.Sequence[float],
    p_y: typ.Sequence[float],
    n: int,
    start_hor: typ.Optional[bool] = None,
    dtype: np.dtype = np.float_,
):
    """
    The points are equi-spaced only within each segment.
    The pivots are strictly included.    

    Args:
        p_x: Must be strictly monotonic increasing.
        p_y: Must be strictly monotonic increasing.
        n: Must be larger than max(len(p_x), len(p_y))
        start_hor: Must be `h` for horizontal, `v` for vertical.
            Only used (and needed) if len(p_x) == len(p_y)
    """
    p_x_n = len(p_x)
    p_y_n = len(p_y)
    is_same_len = p_x_n == p_y_n
    p_n = max(p_x_n, p_y_n) + 1  # number of points
    if p_x_n > p_y_n:
        start_hor = True
    elif p_x_n < p_y_n:
        start_hor = False
    elif start_hor is None or not isinstance(start_hor, bool):
        raise ValueError("`start_hor` required if len(p_x) == len(p_y)")
    p_x_ = np.repeat(p_x, 2)  # x-coords of pivots
    p_y_ = np.repeat(p_y, 2)  # y-coords of pivots
    if is_same_len:
        if start_hor:
            p_x_ = p_x_[1:]
            p_y_ = p_y_[:-1]
        else:
            p_x_ = p_x_[:-1]
            p_y_ = p_y_[1:]
    else:
        if start_hor:
            p_x_ = p_x_[1:-1]
        else:
            p_y_ = p_y_[1:-1]
    dx = max(p_x) - min(p_x)  # distance covered along x
    dy = max(p_y) - min(p_y)  # distance covered along y
    d = dx + dy
    n_x = (np.diff(p_x) / d * (n - p_n)).astype(np.int_)
    n_y = (np.diff(p_y) / d * (n - p_n)).astype(np.int_)
    r = np.ones(len(n_x) + len(n_y) + 1, dtype=np.int_)
    if start_hor:
        r[:-1 if is_same_len else None:2] = n_x + 1
        r[1:-1:2] = n_y + 1
    else:
        r[:-1 if is_same_len else None:2] = n_y + 1
        r[1:-1:2] = n_x + 1   
    x = np.repeat(p_x_, r).astype(dtype)
    y = np.repeat(p_y_, r).astype(dtype)
    j = 0
    for i, r_ in enumerate(r[:-1]):
        if i % 2 != start_hor:
            k = np.linspace(p_x_[i], p_x_[i + 1], r_, endpoint=False)
            x[j : j + len(k)] = k
        else:
            k = np.linspace(p_y_[i], p_y_[i + 1], r_, endpoint=False)
            y[j : j + len(k)] = k
        j += r_
    return x, y

像这样使用：

import matplotlib.pyplot as plt


x, y = upscale_steps_with_pivots([1, 4, 5], [2, 3, 7, 9], 20)
plt.scatter(x, y, marker='o')
plt.axis('scaled')

（请注意，在d的计算之前，这两个函数是相同的，并且它主要包含处理段的不同可能配置的逻辑。）

Answer 3

这条线

funct = interp1d(x, y, kind='next')

需要改变

funct = interp1d(x, y, kind='previous')

这是因为您希望 [3.99, 4.33]（例如）中的值引用 3.99 的 cumsum 值，即 ~40（上一个）而不是与 4.33 相关的值，即 ~70（下一个）。