python - 有效计算图像上所有像素到样条曲线的距离

Question

我的问题是我有一个 2D 参数样条线列表，我需要一种更有效的方法将它们渲染到图像网格上。每个样条线由一系列点、线半径/粗细(以像素为单位)和不透明度确定。

我想到的原始实现与讨论的问题类似here ，它会迭代图像上的每个像素，找到到曲线的最小距离，然后在最小距离低于所需半径时标记该像素。

import math
import matplotlib.pyplot as plt
import numpy as np
import scipy.interpolate
import time

from PIL import Image

class GenePainter(object):
    def __init__(self, source):
        self.source = source

    def render(self):
        output = np.zeros(self.source.shape, dtype=np.float32)
        Ny, Nx = output.shape[0], output.shape[1]

        #x = np.array([5, 10, 15, 20, 5, 5])
        #y = np.array([5, 5, 20, 15, 10, 30])

        x = np.array(np.random.random(4) * 128, dtype=np.float32)
        y = np.array(np.random.random(4) * 128, dtype=np.float32)

        sx, sy = spline(x, y, 1000)

        t = time.time()
        for yi in xrange(Ny):
            for xi in xrange(Nx):
                d = min_distance(sx, sy, xi, yi)
                if d < 10.: # radius
                    output[yi, xi, :] = np.array([1, 1, 0, 0.5])
        print time.time() - t

        # t = time.time()
        # for _ in xrange(100):
        #   plt.plot(sx, sy, label='spline', linewidth=10, aa=False, solid_capstyle="round")
        # print time.time() - t

        plt.imshow(output, interpolation='none')
        plt.show()

    def score(self, image):
        return np.linalg.norm(self.source - image, 2)

def spline(x, y, n):
    if x.ndim != 1 or y.ndim != 1 or x.size != y.size:
        raise Exception()

    t = np.linspace(0, 1, x.size)

    sx = scipy.interpolate.interp1d(t, x, kind='cubic')
    sy = scipy.interpolate.interp1d(t, y, kind='cubic')

    st = np.linspace(0, 1, n)

    return sx(st), sy(st)

def min_distance(sx, sy, px, py):
    dx = sx - px
    dy = sy - py
    d = dx ** 2 + dy ** 2
    return math.sqrt(np.amin(d))

def read_image(file):
    image_raw = Image.open(file)
    image_raw.load()
    # return np.array(image_raw, dtype=np.float32)
    image_rgb = Image.new('RGB', image_raw.size)
    image_rgb.paste(image_raw, None)
    return np.array(image_rgb, dtype=np.float32)

if __name__ == "__main__":

    # source = read_image('ML129.png')
    source = np.zeros((256, 256, 4), dtype=np.float32)

    p = GenePainter(source)
    p.render()

问题是，由于每个像素的迭代未经优化，在 256 x 256 RGBA 图像上绘制每个样条线大约需要 1.5 秒，这对于我的目的来说太慢了。我计划在单个图像上拥有最多约 250 个样条线，并且将为一个作业处理最多约 100 个图像，并且总共可能最多有约 1000 个作业，因此我正在寻找任何可以削减的优化减少我的计算时间。

我研究过的另一种方法是将所有样条线绘制到 PyPlot 图上，然后将最终图像转储到 numpy 数组中，我可以将其用于其他计算，这似乎运行得更快一些，〜 0.15 秒绘制 100 条样条线。

plt.plot(sx, sy, label='spline', linewidth=10, aa=False, solid_capstyle="round")

问题在于，线宽参数似乎对应于屏幕上的像素，而不是图像上的像素数(在 256 x 256 网格上)，因此当我调整窗口大小时，线条的比例会发生变化与窗口，但线宽保持不变。我希望曲线宽度与 256 x 256 网格上的像素相对应。

我更愿意通过找到一种极大优化第一个数值实现的方法来解决这个问题，而不是 PyPlot 绘图。我还研究了对图像进行下采样(仅计算像素子集而不是每个像素的距离)，但即使使用 10% 像素，每个样条线 0.15 秒仍然太慢。

预先感谢您的任何帮助或建议!

Answer 1

您可以使用matplotlib进行绘图，这是一个示例:

我创建了一个 RendererAgg 和一个 ndarray 与其共享相同的内存。然后创建 Line2D 艺术家，并调用 RendererAgg 对象的 draw() 方法。

import numpy as np
from matplotlib.backends.backend_agg import RendererAgg
w, h = 256, 256
r = RendererAgg(w, h, 72)
arr = np.frombuffer(r.buffer_rgba(), np.uint8)
arr.shape = r.height, r.width, -1
t = np.linspace(0, 2*np.pi, 100)
x = np.sin(2*t) * w*0.45 + w*0.5
y = np.cos(3*t) * h*0.45 + h*0.5

from matplotlib.lines import Line2D
line = Line2D(x, y, linewidth=5, color=(1.0, 0.0, 0.0), alpha=0.3)
line.draw(r)
pl.imsave("test.png", arr)

这是输出: