Python中的交互式BSpline拟合 [英] Interactive BSpline fitting in Python

问题描述

使用以下函数，可以在输入点P上拟合三次样条：

  def plotCurve（P）：
 pts = np.vstack（[P，P [0]]）
x，y = pts.T 
i = np.arange（len（pts））
 
 interp_i = np.linspace（0，i.max（），100000 * i.max（））
 
 xi = interp1d（i，x，kind ='cubic'）（interp_i）
 yi = interp1d（i，y，kind ='cubic'）（interp_i）
 
图，ax = plt.subplots（）
图，ax = plt.subplots（）
 ax.plot（xi，yi）
 ax.plot（x，y，'ko'）
＃plt.show（）
 return xi，yi 
  

输入点P可以采用以下形式：

  P = [（（921,1181），（951,1230），（993,1243），（1035,1230），
（1065,1181），（1045,1130） ，（993,1130），（945,1130）] 
  

现在，我想提出以下几点P的可拖动对象，例如当我们更改任何点的位置时，样条线将重新拟合到新点上。

以此为参考：

我应该如何去做？

或者，如果还有其他合适的方法可以实现这一点，请推荐。

也欢迎使用MATLAB。

解决方案

当然，您需要添加您的函数。不过不要让它自己画任何东西。
然后在类中添加新行 self.line2 ，这将是要更新的行。

最后，让全班同学也画出新的线条。并使用插值函数的结果对其进行更新。

为方便起见，您可以将Polygon（ self.poly ）设置为不可见，同时也将 self.line 并且仅显示要点可能有意义。

 从scipy.interpolate导入numpy作为np 
从matplotlib.lines导入interp1d 
从matplotlib.artist导入Line2D 
从matplotlib.artist导入艺术家
从matplotlib.mlab导入dist_point_to_segment 
 
 
类PolygonInteractor（object）：
 
 
多边形编辑器。
 https://matplotlib.org/gallery/event_handling/poly_editor。 html 
 
键绑定
 
't'开启和关闭顶点标记当顶点标记打开时，
可以移动它们，删除它们
 
'd'删除点
 
'i'在点处插入一个顶点，您必须位于连接两个现有顶点
的
线的epsilon范围内
 
 
 showverts =真实
 epsilon = 5＃最大pi可算作顶点命中的xel距离
 
 def __init __（self，ax，poly，visible = False）：
如果poly.figure为None：
引发RuntimeError（'You必须先将多边形添加到图形'
'或画布中，然后再定义交互器''）
 self.ax =斧头
 $ canvas = poly.figure.canvas 
 self.poly = poly 
 self.poly.set_visible（visible）
 
x，y = zip（* self.poly.xy）
 self.line = Line2D（x，y，ls = ，
 marker ='o'，markerfacecolor ='r'，
animated = True）
 self.ax.add_line（self.line）
 
 self。 cid = self.poly.add_callback（self.poly_changed）
 self._ind = None＃活动版本
 
 canvas.mpl_connect（'draw_event'，self.draw_callback）
画布.mpl_connect（'button_press_event'，self.button_press_callback）
 canvas.mpl_connect（'key_press_e vent'，self.key_press_callback）
 canvas.mpl_connect（'button_release_event'，self.button_release_callback）
 canvas.mpl_connect（'motion_notify_event'，self.motion_notify_callback）
 self.canvas = canvas 
 
x，y = self.interpolate（）
 self.line2 = Line2D（x，y，animated = True）
 self.ax.add_line（self.line2）
 
 def interpolate（self）：
x，y = self.poly.xy [：]。T 
i = np.arange（len（x））
 
 interp_i = np.linspace（0，i.max（），100 * i.max（））
 
 xi = interp1d（i，x，kind ='cubic'）（interp_i）
 yi = interp1d（i，y，kind ='cubic'）（interp_i）
 
 return xi，yi 
 
 def draw_callback（self，event）：
 self .background = self.canvas.copy_from_bbox（self.ax.bbox）
 self.ax.draw_artist（self.poly）
 self.ax.draw_artist（self.line）
 self.ax .draw_artist（self.line2）
＃不需要对她开枪e，这将在屏幕是
之前触发＃更新
 
 def poly_changed（self，poly）：
'每当调用多边形对象时都会调用此方法'
＃仅将艺术家道具复制到该行（可见性除外）
 vis = self.line.get_visible（）
 Artist.update_from（self.line，poly）
 self.line.set_visible （可见）＃不要使用多边形可见性状态
 
 
 def get_ind_under_point（self，event）：
'如果在epsilon公差范围内，则获得该点下的顶点索引' 
 
＃显示坐标
 xy = np.asarray（self.poly.xy）
 xyt = self.poly.get_transform（）。transform（xy）
 xt ，yt = xyt [:, 0]，xyt [:, 1] 
d = np.hypot（xt-event.x，yt-event.y）
 indseq，= np.nonzero（d = = d.min（））
 ind = indseq [0] 
 
如果d [ind]> = self.epsilon：
 ind =无
 
返回索引
 
 def button_press_callback（self，event）：
'每当按下鼠标按钮'
如果不是self.showverts：
如果event.inaxes为None则返回
如果event.button！=则返回
：1：
 return 
 self._ind = self.get_ind_under_point（event）
 
 def button_release_callback（self，event）：
'每当释放鼠标按钮时'
，如果不是self.showverts：
如果event.button！=，则返回
 = 1：
返回
 self._ind = none 
 
 def key_press_callback（self，event）：
'每按一次键'
否event.inaxes：
如果有事件则返回
键=='t'：
 self.showverts =不是self.showverts 
 self.line.set_visible（self.showverts）
如果不是self.showverts：
 self._ind =无
 elif event.key =='d'：
 ind = self.get_ind_under_point（event）
如果ind不为None：
 self.poly.xy = np.delete（self.poly.xy，
 ind，axis = 0）
 self.line.set_data（zip（* self.poly.xy））
 elif event.key =='i'：
 xys = self.poly.get_transform（）。transform（self。 poly.xy）
p = event.x，event.y＃显示i在范围（len（xys）-1）中的坐标
：
 s0 = xys [i] 
 s1 = xys [i + 1] 
d = dist_point_to_segment（p，s0，s1）
如果d <= self.epsilon：
 self.poly.xy = np.insert（
 self.poly.xy，i + 1，
 [event.xdata，event.ydata]，
轴= 0）
 self.line.set_data（zip（* self.poly .xy））
如果self.line.stale破坏
：
 self.canva s.draw_idle（）
 
 def motion_notify_callback（self，event）：
'在鼠标移动时'
如果不是self.showverts：
如果返回
 self._ind为None：如果event.inaxes为None：
返回
如果event.button！= 1：
返回
：y：
返回
x，y = event.xdata，event.ydata 
 
 self.poly.xy [self._ind] = x，y 
，如果self._ind == 0：
 self.poly。 xy [-1] = x，y 
 elif self._ind == len（self.poly.xy）-1：
 self.poly.xy [0] = x，y 
 self.line.set_data（zip（* self.poly.xy））
 
x，y = self.interpolate（）
 self.line2.set_data（x，y）
 
 self.canvas.restore_region（self.background）
 self.ax.draw_artist（self.poly）
 self.ax.draw_artist（self.line）
self.ax。 draw_artist（self.line2）
 self.canvas.blit（self.ax.bbox）
 
 
如果_ _name__ =='__main__'：
从matplotlib.patches中以plt 
形式导入matplotlib.pyplot导入多边形
 
 #theta = np.arange（0，2 * np.pi， 0.1）
 #r = 1.5 
 
 #xs = r * np.cos（theta）
 #ys = r * np.sin（theta）
 xs = （921，951，993，1035，1065，1045，993，945）
 ys =（1181、1230、1243、1230、1181、1130、1130、1130）
 
 poly = Polygon（list（zip（zip（xs，ys）），animation = True）
 
图，ax = plt.subplots（）
 ax.add_patch（poly）
p = PolygonInteractor（ ax，poly，visible = False）
 
 ax.set_title（'单击并拖动一个点来移动它'）
 
 ax.set_xlim（（800，1300））
 ax.set_ylim（（1000，1300））
 
 plt.show（）
  

请注意，此处创建的曲线不是真正的循环。它有一个起点，曲线并不真正平滑。可以通过使用一组真正的贝塞尔曲线来避免这种情况，如创建随机形状/使用matplotlib绘制轮廓。

Using the following function, one can fit a cubic spline on input points P:

def plotCurve(P):
  pts = np.vstack([P, P[0]])
  x, y = pts.T
  i = np.arange(len(pts))

  interp_i = np.linspace(0, i.max(), 100000 * i.max())

  xi = interp1d(i, x, kind='cubic')(interp_i)  
  yi = interp1d(i, y, kind='cubic')(interp_i)

  fig, ax = plt.subplots()
  fig,ax=plt.subplots()
  ax.plot(xi, yi)
  ax.plot(x, y, 'ko')
  #plt.show()
  return xi,yi

The input points P can be of the following form:

P=[(921,1181),(951,1230),(993,1243),(1035,1230),
    (1065,1181),(1045,1130),(993,1130),(945,1130)]

Now, I wish to make these points of P draggable, such that as and when we change the position of any point, the spline gets refitted on the new points.

Using this as a reference: https://matplotlib.org/1.4.3/examples/event_handling/poly_editor.html (event handling in matplotlib), I have the following code:

"""
This is an example to show how to build cross-GUI applications using
matplotlib event handling to interact with objects on the canvas

"""
import numpy as np
from matplotlib.lines import Line2D
from matplotlib.artist import Artist
from matplotlib.mlab import dist_point_to_segment

class PolygonInteractor:
    """
    An polygon editor.
Key-bindings

  't' toggle vertex markers on and off.  When vertex markers are on,
      you can move them, delete them

  'd' delete the vertex under point

  'i' insert a vertex at point.  You must be within epsilon of the
      line connecting two existing vertices

"""
showverts = True
epsilon = 5  # max pixel distance to count as a vertex hit

def __init__(self, ax, poly):
    if poly.figure is None:
        raise RuntimeError('You must first add the polygon to a figure or canvas before defining the interactor')
    self.ax = ax
    canvas = poly.figure.canvas
    self.poly = poly

    x, y = zip(*self.poly.xy)
    self.line = Line2D(x, y, marker='o', markerfacecolor='r', animated=True)
    self.ax.add_line(self.line)
    #self._update_line(poly)

    cid = self.poly.add_callback(self.poly_changed)
    self._ind = None # the active vert

    canvas.mpl_connect('draw_event', self.draw_callback)
    canvas.mpl_connect('button_press_event', self.button_press_callback)
    canvas.mpl_connect('key_press_event', self.key_press_callback)
    canvas.mpl_connect('button_release_event', self.button_release_callback)
    canvas.mpl_connect('motion_notify_event', self.motion_notify_callback)
    self.canvas = canvas


def draw_callback(self, event):
    self.background = self.canvas.copy_from_bbox(self.ax.bbox)
    self.ax.draw_artist(self.poly)
    self.ax.draw_artist(self.line)
    self.canvas.blit(self.ax.bbox)

def poly_changed(self, poly):
    'this method is called whenever the polygon object is called'
    # only copy the artist props to the line (except visibility)
    vis = self.line.get_visible()
    Artist.update_from(self.line, poly)
    self.line.set_visible(vis)  # don't use the poly visibility state


def get_ind_under_point(self, event):
    'get the index of the vertex under point if within epsilon tolerance'

    # display coords
    xy = np.asarray(self.poly.xy)
    xyt = self.poly.get_transform().transform(xy)
    xt, yt = xyt[:, 0], xyt[:, 1]
    d = np.sqrt((xt-event.x)**2 + (yt-event.y)**2)
    indseq = np.nonzero(np.equal(d, np.amin(d)))[0]
    ind = indseq[0]

    if d[ind]>=self.epsilon:
        ind = None

    return ind

def button_press_callback(self, event):
    'whenever a mouse button is pressed'
    if not self.showverts: return
    if event.inaxes==None: return
    if event.button != 1: return
    self._ind = self.get_ind_under_point(event)

def button_release_callback(self, event):
    'whenever a mouse button is released'
    if not self.showverts: return
    if event.button != 1: return
    self._ind = None

def key_press_callback(self, event):
    'whenever a key is pressed'
    if not event.inaxes: return
    if event.key=='t':
        self.showverts = not self.showverts
        self.line.set_visible(self.showverts)
        if not self.showverts: self._ind = None
    elif event.key=='d':
        ind = self.get_ind_under_point(event)
        if ind is not None:
            self.poly.xy = [tup for i,tup in enumerate(self.poly.xy) if i!=ind]
            self.line.set_data(zip(*self.poly.xy))
    elif event.key=='i':
        xys = self.poly.get_transform().transform(self.poly.xy)
        p = event.x, event.y # display coords
        for i in range(len(xys)-1):
            s0 = xys[i]
            s1 = xys[i+1]
            d = dist_point_to_segment(p, s0, s1)
            if d<=self.epsilon:
                self.poly.xy = np.array(
                    list(self.poly.xy[:i]) +
                    [(event.xdata, event.ydata)] +
                    list(self.poly.xy[i:]))
                self.line.set_data(zip(*self.poly.xy))
                break


    self.canvas.draw()

def motion_notify_callback(self, event):
    'on mouse movement'
    if not self.showverts: return
    if self._ind is None: return
    if event.inaxes is None: return
    if event.button != 1: return
    x,y = event.xdata, event.ydata

    self.poly.xy[self._ind] = x,y
    self.line.set_data(zip(*self.poly.xy))

    self.canvas.restore_region(self.background)
    self.ax.draw_artist(self.poly)
    self.ax.draw_artist(self.line)
    self.canvas.blit(self.ax.bbox)


if __name__ == '__main__':
import matplotlib.pyplot as plt
from matplotlib.patches import Polygon

#theta = np.arange(0, 2*np.pi, 0.1)
#r = 1.5

#xs = r*np.cos(theta)
#ys = r*np.sin(theta)
xs = (921, 951, 993, 1035, 1065, 1045, 993, 945)
ys = (1181, 1230, 1243, 1230, 1181, 1130, 1130, 1130)

poly = Polygon(list(zip(xs, ys)), animated=True)

fig, ax = plt.subplots()
ax.add_patch(poly)
p = PolygonInteractor(ax, poly)

#ax.add_line(p.line)
ax.set_title('Click and drag a point to move it')
#ax.set_xlim((-2,2))
#ax.set_ylim((-2,2))

ax.set_xlim((800, 1300))
ax.set_ylim((1000, 1300))

plt.show()

Now, what I wish to do is to replace the polygon fitting with my spline fitting function. As I am new to this I am not able to figure out how to do it. Is there any way to keep all the same functionalities, but only to fit the spline instead of polygon through the given points, making it interactive and refitting the spline as per point movement?

My spline would look somewhat like this :

How should I go about doing it?

Or, if there is any other suitable method to achieve the same, kindly recommend.

Suggestions are also welcome using MATLAB.

解决方案

Of course you need to add your function to the PolygonInteractor. Don't let it draw anything itself though. Then add a new line to the class, self.line2 which will be the line to update.

Finally, let the class draw your new line as well. And update it with the result from your interpolation function.

For convenience you may turn the Polygon (self.poly) invisible, also removing the line from the self.line and only showing the points may make sense.

import numpy as np
from  scipy.interpolate import interp1d
from matplotlib.lines import Line2D
from matplotlib.artist import Artist
from matplotlib.mlab import dist_point_to_segment


class PolygonInteractor(object):

    """
    A polygon editor.
    https://matplotlib.org/gallery/event_handling/poly_editor.html

    Key-bindings

      't' toggle vertex markers on and off.  When vertex markers are on,
          you can move them, delete them

      'd' delete the vertex under point

      'i' insert a vertex at point.  You must be within epsilon of the
          line connecting two existing vertices

    """

    showverts = True
    epsilon = 5  # max pixel distance to count as a vertex hit

    def __init__(self, ax, poly, visible=False):
        if poly.figure is None:
            raise RuntimeError('You must first add the polygon to a figure '
                               'or canvas before defining the interactor')
        self.ax = ax
        canvas = poly.figure.canvas
        self.poly = poly
        self.poly.set_visible(visible)

        x, y = zip(*self.poly.xy)
        self.line = Line2D(x, y, ls="",
                           marker='o', markerfacecolor='r',
                           animated=True)
        self.ax.add_line(self.line)

        self.cid = self.poly.add_callback(self.poly_changed)
        self._ind = None  # the active vert

        canvas.mpl_connect('draw_event', self.draw_callback)
        canvas.mpl_connect('button_press_event', self.button_press_callback)
        canvas.mpl_connect('key_press_event', self.key_press_callback)
        canvas.mpl_connect('button_release_event', self.button_release_callback)
        canvas.mpl_connect('motion_notify_event', self.motion_notify_callback)
        self.canvas = canvas

        x,y = self.interpolate()
        self.line2 = Line2D(x, y, animated=True)
        self.ax.add_line(self.line2)

    def interpolate(self):
        x, y = self.poly.xy[:].T
        i = np.arange(len(x))

        interp_i = np.linspace(0, i.max(), 100 * i.max())

        xi = interp1d(i, x, kind='cubic')(interp_i)  
        yi = interp1d(i, y, kind='cubic')(interp_i)

        return xi,yi

    def draw_callback(self, event):
        self.background = self.canvas.copy_from_bbox(self.ax.bbox)
        self.ax.draw_artist(self.poly)
        self.ax.draw_artist(self.line)
        self.ax.draw_artist(self.line2)
        # do not need to blit here, this will fire before the screen is
        # updated

    def poly_changed(self, poly):
        'this method is called whenever the polygon object is called'
        # only copy the artist props to the line (except visibility)
        vis = self.line.get_visible()
        Artist.update_from(self.line, poly)
        self.line.set_visible(vis)  # don't use the poly visibility state


    def get_ind_under_point(self, event):
        'get the index of the vertex under point if within epsilon tolerance'

        # display coords
        xy = np.asarray(self.poly.xy)
        xyt = self.poly.get_transform().transform(xy)
        xt, yt = xyt[:, 0], xyt[:, 1]
        d = np.hypot(xt - event.x, yt - event.y)
        indseq, = np.nonzero(d == d.min())
        ind = indseq[0]

        if d[ind] >= self.epsilon:
            ind = None

        return ind

    def button_press_callback(self, event):
        'whenever a mouse button is pressed'
        if not self.showverts:
            return
        if event.inaxes is None:
            return
        if event.button != 1:
            return
        self._ind = self.get_ind_under_point(event)

    def button_release_callback(self, event):
        'whenever a mouse button is released'
        if not self.showverts:
            return
        if event.button != 1:
            return
        self._ind = None

    def key_press_callback(self, event):
        'whenever a key is pressed'
        if not event.inaxes:
            return
        if event.key == 't':
            self.showverts = not self.showverts
            self.line.set_visible(self.showverts)
            if not self.showverts:
                self._ind = None
        elif event.key == 'd':
            ind = self.get_ind_under_point(event)
            if ind is not None:
                self.poly.xy = np.delete(self.poly.xy,
                                         ind, axis=0)
                self.line.set_data(zip(*self.poly.xy))
        elif event.key == 'i':
            xys = self.poly.get_transform().transform(self.poly.xy)
            p = event.x, event.y  # display coords
            for i in range(len(xys) - 1):
                s0 = xys[i]
                s1 = xys[i + 1]
                d = dist_point_to_segment(p, s0, s1)
                if d <= self.epsilon:
                    self.poly.xy = np.insert(
                        self.poly.xy, i+1,
                        [event.xdata, event.ydata],
                        axis=0)
                    self.line.set_data(zip(*self.poly.xy))
                    break
        if self.line.stale:
            self.canvas.draw_idle()

    def motion_notify_callback(self, event):
        'on mouse movement'
        if not self.showverts:
            return
        if self._ind is None:
            return
        if event.inaxes is None:
            return
        if event.button != 1:
            return
        x, y = event.xdata, event.ydata

        self.poly.xy[self._ind] = x, y
        if self._ind == 0:
            self.poly.xy[-1] = x, y
        elif self._ind == len(self.poly.xy) - 1:
            self.poly.xy[0] = x, y
        self.line.set_data(zip(*self.poly.xy))

        x,y = self.interpolate()
        self.line2.set_data(x,y)

        self.canvas.restore_region(self.background)
        self.ax.draw_artist(self.poly)
        self.ax.draw_artist(self.line)
        self.ax.draw_artist(self.line2)
        self.canvas.blit(self.ax.bbox)


if __name__ == '__main__':
    import matplotlib.pyplot as plt
    from matplotlib.patches import Polygon

    #theta = np.arange(0, 2*np.pi, 0.1)
    #r = 1.5

    #xs = r*np.cos(theta)
    #ys = r*np.sin(theta)
    xs = (921, 951, 993, 1035, 1065, 1045, 993, 945)
    ys = (1181, 1230, 1243, 1230, 1181, 1130, 1130, 1130)

    poly = Polygon(list(zip(xs, ys)), animated=True)

    fig, ax = plt.subplots()
    ax.add_patch(poly)
    p = PolygonInteractor(ax, poly, visible=False)

    ax.set_title('Click and drag a point to move it')

    ax.set_xlim((800, 1300))
    ax.set_ylim((1000, 1300))

    plt.show()

Note that the curve created here is not truely cyclic. It has a start point where the curve is not really smooth. This can be circumvented by using a truely cyclic set of bezier curves as shown in Create random shape/contour using matplotlib.

这篇关于Python中的交互式BSpline拟合的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！