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

Question

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

我想到的原始实现类似于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")

问题是 linewidth 参数似乎对应于我屏幕上的像素，而不是图像上的像素数（在 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)

这是输出：