精华内容
下载资源
问答
  • 匀速贝塞尔曲线路径规划工具

    千次阅读 热门讨论 2020-01-16 20:17:27
    在做游戏开发的时候经常会用到贝塞尔曲线规划路径,并且在网上也没找到合适的demo,要么就是不支持高阶贝塞尔,要么就是不能匀速运动。所以决定趁着闲余时间自己写一个工具,方便以后用。 并且我已经把源码放在...

    在做游戏开发的时候经常会用到贝塞尔曲线来规划路径,在网上也没找到合适的demo,要么就是不支持高阶贝塞尔,要么就是不能匀速运动。所以决定趁着闲余时间自己写一个工具,方便以后用。
    于是就有了该项目,并且我已经把源码放在GitHub上了,有兴趣的可以看看,希望能帮到有所需要的朋友。

    更新日志:

    2020.2.7:

    • 新添加三阶贝塞尔曲线
    • 平滑度自定义

    该工程基于cocos creator 2.2.2版本的!

    GitHub项目地址

    在线演示地址(可以直接在上面规划好后导出json文件)

    下面来简单演示一下该工程:
    在这里插入图片描述
    在这里插入图片描述
    目前支持二阶和三阶贝塞尔曲线绘制匀速运动导出路径的JSON数据
    在项目中可以直接读取json文件,里面存储了许多连续的曲线点,直接拿来用即可。
    可以根据不同的需求来达到想要的效果。

    匀速运动实现思路很简单,其实就是利用了微积分思想,把曲线分割成许多份,每一份此时就可以看作直线运动了!

    需要注意的是,该项目分辨率是1920*1080的,在不同的项目中使用可能需要转换下坐标!

    导出的json数据格式如下:

    {
        "time": 2, //路径运行总时长
        "length": 1718.4689669565246, //路径长度
        "points": [  //曲线点集合
            {
                "x": 588.1929046563193,  //x 坐标
                "y": 375.9645232815965,  //y 坐标
                "length": 0,  //上一点到该点的距离,由于该点是起点,所以为0
                "time": 0  //上一点到该点需要的时间,由于该点是起点,所以为0
                
            },
            {
                "x": 595.209865415573,
                "y": 362.11259538476247,
                "length": 15.527834515990738,
                "time": 0.018071707798705424
            },
            {
                "x": 601.8241340965079,
                "y": 348.46733368343007,
                "length": 15.163829235435424,
                "time": 0.01764806874841756
            },
            {
                "x": 608.0357106991243,
                "y": 335.02873817759905,
                "length": 14.804713204230342,
                "time": 0.017230119936876214
            },
            {
                "x": 613.8445952234222,
                "y": 321.7968088672695,
                "length": 14.450850933083036,
                "time": 0.016818285591361077
            },
            {
                "x": 619.2507876694015,
                "y": 308.7715457524413,
                "length": 14.102637908330035,
                "time": 0.0164130259894147
            },
            ...
    

    如果你们有什么好的建议,或者发现了bug可以留言告诉我,我会尽力去完善它。(毕竟是我的第一个开源项目,我还是会好好维护的,23333)

    如果觉得好用的朋友希望能点个赞,关注一下哟,你们的每一个star都是对我最大的鼓励和动力!

    展开全文
  • 给一系列顶点,如果只是用直线将...一种很直观的思路就是将连接各点的直线替换成平滑的曲线,只要各段曲线在顶点处是平滑的过度,那么对应的曲线图就是所需的了。因此问题变成了寻找一种容易实现的曲线来连接各个顶点。

    在这里插入图片描述
    前言: 给一系列顶点,如果只是用直线将其中的各个点依次连接起来,最终形成一个折线图,这种很容易实现。但是现实中事物的变化往往具有连续的特性,即使是给定了一系列离散的点,基于以往的生活经验,人们也更愿意接受那种曲线连接的趋势图。可是在程序中绘制直线很容易,要是绘制曲线将各个顶点连接起来,这又要如何实现呢?一种很直观的思路就是将连接各点的直线替换成平滑的曲线,只要各段曲线在顶点处是平滑的过度,那么对应的曲线图就是所需的了。因此问题变成了寻找一种容易实现的曲线来连接各个顶点。

    一、理论

    1. 贝塞尔曲线:

    计算机图形学中有一类很常用的曲线,俗称贝塞尔曲线。1962年,法国数学家Pierre Bézier第一个研究了这种矢量绘制曲线的方法,并给出了详细的计算公式,因此按照这样的公式绘制出来的曲线就用他的姓氏来命名是为贝塞尔曲线。很多程序语言都有实现贝塞尔曲线的API,而该曲线本身也拥有强大的近似其它曲线的能力,即使一条不能够胜任,那么分段的多条贝塞尔曲线也足够用来近似我们想绘制的曲线。

    2. 贝塞尔曲线数学表示:

    一阶贝塞尔曲线:

    给定点P0、P1,一阶贝塞尔曲线只是一条两点之间的直线。这条线由下式给出:
    在这里插入图片描述
    其中P0和P1为两个端点,P对应于贝塞尔曲线上的点,随着t在[0,1]中变化,P点的集合构成一条连接P0与P1的线段。
    在这里插入图片描述

    二阶贝塞尔曲线:

    当引入一个控制点P1的时候,就可以生成二阶贝塞尔曲线,它是一个由二次函数描述的曲线,最多有一个顶点。
    在这里插入图片描述
    如下图所示,P点的集合构成一个抛物线:
    在这里插入图片描述
    这里解释下上图的绿线是如何产生的:
    在这里插入图片描述
    首先,我们已知端点P0、P2以及控制点P1,那么如何确定确定当t取某个固定值时位于贝塞尔曲线上的点P?一种简单的方式可以通过贝塞尔曲线的公式,算出P的x和y坐标。但如何通过几何画法来计算出来呢?

    根据贝塞尔曲线的定义,首先P0A/P0P1 = t,P1B/P1P2 = t,这样我们可以分别确定点A与点B。然后连接AB,取AP/AB = t,那么P点就是贝塞尔曲线上的点了。

    三阶贝塞尔曲线:

    在这里插入图片描述
    三阶贝塞尔曲线可以用一个三次函数描述,最多拥有两个拐点。用来做两点之间的曲线连接已经够用了。我们来看下它的直观形式:
    在这里插入图片描述

    一般参数公式:

    给定点P0、P1、…、Pn,其贝塞尔曲线即:
    在这里插入图片描述
    公式说明:
    (1)开始于P0并结束于Pn的曲线,即所谓的端点插值法属性。
    (2) 曲线是直线的充分必要条件是所有的控制点都位在曲线上。同样的,贝塞尔曲线是直线的充分必要条件是控制点共线。
    (3) 曲线的起始点(结束点)相切于贝塞尔多边形的第一节(最后一节)。
    (4)一条曲线可在任意点切割成两条或任意多条子曲线,每一条子曲线仍是贝塞尔曲线。
    (5)一些看似简单的曲线(如圆)无法以贝塞尔曲线精确的描述,或分段成贝塞尔曲线(虽然当每个内部控制点对单位圆上的外部控制点水平或垂直的的距离为时,分成四段的贝兹曲线,可以小于千分之一的最大半径误差近似于圆)。
    (6)位于固定偏移量的曲线(来自给定的贝塞尔曲线),又称作偏移曲线(假平行于原来的曲线,如两条铁轨之间的偏移)无法以贝兹曲线精确的形成(某些琐屑实例除外)。无论如何,现存的启发法通常可为实际用途中给出近似值。

    已知P0、P1…PN如何确定贝塞尔曲线上的点呢?
    在这里插入图片描述
    如上图所示,存在顶点00,05;控制点01,02,03,04;实际上这是一条5阶贝塞尔曲线。首先我们将点00到05连接起来,这样它会有5条边,这些边用棕色表示。针对边00-01,我们取一个点10,使得该点将边00-01分成比例为t和1-t的两部分。针对每条边我们都取一个这样的点。然后将这一系列点再次连接起来,这次会有4条边,在上图用墨绿色表示。注意到我们这样操作之后,边会比前面少一条。重复上面的操作,直到只有一条边。在上图中用绿色表示,我们取到点50,该点将这条边分成t与(1-t)的两部分。点50就是最终在贝塞尔曲线上的点。

    上述操作可以用如下公式表示:
    在这里插入图片描述

    3. 回到我们最初的问题

    我们已经了解关于贝塞尔曲线的公式以及几何画法,但是要如何来解决我们用曲线来连接各个顶点的问题呢?

    前面已经提到,对于两个点之间我们可以使用三阶贝塞尔曲线来连接,这样通过多段贝塞尔曲线相连,就可以得到我们想要的曲线。而三阶贝塞尔曲线需要两个控制点来确定,很显然贝塞尔曲线不一定通过控制点,但是肯定通过端点。所以给定的顶点只能做端点,那问题就变成了如何计算所需要的控制点?

    首先要保证曲线在顶点处连续,就要求左边曲线在顶点处的切线和右边曲线在顶点处的切线一致。即函数的左导数等于右导数。根据前面的公式说明3 曲线的起始点(结束点)相切于贝塞尔多边形的第一节(最后一节),我们知道,保持连续的必要条件是顶点和它前后的控制点在同一条直线上,而该直线就是曲线在该顶点的切线。

    总结一下如下图所示:
    在这里插入图片描述
    如上图所示:如果需要绘制一条通过点A、B、C的曲线,我们需要计算各条用于连接的贝塞尔曲线的控制点。

    以顶点B为例:
    (1)取AB和BC的中点E、F,并连接E、F
    (2)在EF上取点D,使得FD/DE = BC/AB
    (3)将直线EF按照矢量DB平移到通过B点,并且使得平移后的D和B点重合
    (4)得到E’与F’点用作贝塞尔曲线的控制点。

    二、源代码

    # -*- coding:UTF-8 -*-
    # 参考链接 https://www.jianshu.com/p/55099e3a2899#
    
    from matplotlib import pyplot as plt
    import numpy as np
    import math
    
    # 生成单个点的控制点
    
    def gen_con_dot(a, b):
        A = np.array([a[0], b[0]])
        B = np.array([a[1], b[1]])
        C = np.array([a[2], b[2]])
        AB = B - A
        CB = B - C
        lab = math.hypot(AB[0], AB[1])
        lcb = math.hypot(CB[0], CB[1])
        e = (A + B) / 2
        f = (B + C) / 2
        D = f + (e - f) * lcb / (lcb + lab)
        DB = B - D
        E = e + DB
        F = f + DB
        return [[E[0].tolist(), F[0].tolist()], [E[1].tolist(), F[1].tolist()]]
    
    
    # 生成全部点的控制点
    
    def gen_who_dot(a, b):
        s = gen_con_dot([a[0], a[1], a[2]], [b[0], b[1], b[2]])
        x = [a[0], (s[0][0] + a[0]) / 2]
        y = [b[0], (s[1][0] + b[0]) / 2]
        for i in range(len(a) - 2):
            s = gen_con_dot([a[i], a[i + 1], a[i + 2]], [b[i], b[i + 1], b[i + 2]])
            x.extend([s[0][0], a[i + 1], s[0][1]])
            y.extend([s[1][0], b[i + 1], s[1][1]])
        x.extend([(a[len(a) - 1] + x[len(x) - 1]) / 2, a[len(a) - 1]])
        y.extend([(b[len(b) - 1] + y[len(y) - 1]) / 2, b[len(b) - 1]])
        return [x, y]
    
    
    # 规划两点之间的路径(三阶贝塞尔曲线)
    
    def gen_sep_bezier(a, b, t):
        x = a[0] * (1 - t) ** 3 + 3 * a[1] * t * (1 - t) ** 2 + 3 * a[2] * t * t * (1 - t) + a[3] * t ** 3
        y = b[0] * (1 - t) ** 3 + 3 * b[1] * t * (1 - t) ** 2 + 3 * b[2] * t * t * (1 - t) + b[3] * t ** 3
        return [x.tolist(), y.tolist()]
    
    
    # 规划所有点之间的路径
    
    def gen_bezuer(a, b, t):
        m = gen_who_dot(a, b)[0]
        n = gen_who_dot(a, b)[1]
    
        p = [m[0], m[1], m[2], m[3]]
        q = [n[0], n[1], n[2], n[3]]
        x = gen_sep_bezier(p, q, t)[0]
        y = gen_sep_bezier(p, q, t)[1]
    
        for i in range(len(m) // 3 - 1):
            p = [m[3 * i + 3], m[3 * i + 4], m[3 * i + 5], m[3 * i + 6]]
            q = [n[3 * i + 3], n[3 * i + 4], n[3 * i + 5], n[3 * i + 6]]
            x.extend(gen_sep_bezier(p, q, t)[0])
            y.extend(gen_sep_bezier(p, q, t)[1])
    
        return [x, y]
    
    if __name__ == "__main__":
        x = input("请输入所有点横坐标:").split(" ")
        y = input("请输入所有点纵坐标:").split(" ")
        n = eval(input("请输入间隔:"))
    
        x = [float(a) for a in x]
        y = [float(b) for b in y]
    
        t = np.linspace(0.0, 1.0, n)
        data = gen_bezuer(x, y, t)
    
        plt.plot(data[0], data[1], 'r.', x, y, 'b*')
        plt.show()
    

    三、运行结果

    在这里插入图片描述
    在这里插入图片描述
    参考链接:https://www.jianshu.com/p/55099e3a2899

    后续改进:

    • 改进Bizuer,避免在重复输出控制点,
    • 将等间隔的Bizuer曲线改进为等间距的Bizuer曲线,避免因为距离过短导致点过于密集
    • 增加速度规划的功能

    链接:https://pan.baidu.com/s/1xFC-ijj2-jcVYJg71w9J7A
    提取码:hk5w

    码文不易,如果觉得对你有用的话,点个赞再走吧,谢谢宁!

    (才疏学浅,如果有什么说的不对的地方,欢迎大家在评论区或者私信进行指正。)

    展开全文
  • 不使用bezier库;改进Bizuer,避免在重复输出控制点; 同时将等间隔的Bizuer曲线改进为等间距的Bizuer曲线,避免因为距离过短导致点过于密集;增加速度规划的功能
  • 对于控制点Pi,N阶贝塞尔(Bezier)曲线的公式如下: 即横、纵坐标分别表示如下: 式中Pix和Piy分别为控制点Pi的横纵坐标。...不难发现,三阶贝塞尔曲线的曲率存在突变的情况,而五阶贝塞尔曲

    对于控制点Pi,N阶贝塞尔(Bezier)曲线的公式如下:

    即横、纵坐标分别表示如下:

    式中Pix和Piy分别为控制点Pi的横纵坐标。

    对于三阶贝塞尔曲线,仿真中取控制点P0(0,0)、P1(20,1)、P2(60,8)、P3(80,9);对于五阶贝塞尔曲线,仿真中取控制点P0(0,0)、P1(20,0)、P2(40,0)、P3(40,9)、P4(60,9)、P4(80,9)。三阶和五阶贝塞尔曲线及其曲率的仿真结果如下图所示:

    不难发现,三阶贝塞尔曲线的曲率存在突变的情况,而五阶贝塞尔曲线的曲率变化相对平缓,根据车辆运动学模型可知,曲率的突变会引起方向盘转角的突变平缓变化的曲率对应的方向盘转角变化也相对平稳,所以,在车辆变道的路径规划中,更推荐使用五阶贝塞尔曲线

    同样不难看出,贝塞尔曲线不经过所有控制点,但是头尾两个控制点是经过的。这和插值还不太一样插值是要求经过所有的给定点

    展开全文
  • 轨迹规划-贝塞尔曲线

    千次阅读 2020-11-24 10:08:48
    贝塞尔曲线有着很多特殊的性质, 在图形设计和路径规划中应用都非常广泛, 贝塞尔曲线完全由其控制点决定其形状, n个控制点对应着n-1阶的贝塞尔曲线,并且可以通过递归的方式来绘制. 先感受一下贝塞尔曲线: ...

    1. 简介

    贝塞尔曲线于 1962 年,由法国工程师皮埃尔·贝济埃(Pierre Bézier)所广泛发表,他运用贝塞尔曲线来为汽车的主体进行设计,贝塞尔曲线最初由保尔·德·卡斯特里奥于1959年运用德卡斯特里奥算法开发,以稳定数值的方法求出贝塞尔曲线.

    贝塞尔曲线有着很多特殊的性质, 在图形设计和路径规划中应用都非常广泛, 贝塞尔曲线完全由其控制点决定其形状, n个控制点对应着n-1阶的贝塞尔曲线,并且可以通过递归的方式来绘制.

    先感受一下贝塞尔曲线:
    贝塞尔曲线
    在这里插入图片描述

    2. 公式及原理

    一阶贝塞尔曲线

    在这里插入图片描述

    中间点运动的轨迹为:
    在这里插入图片描述

    一阶曲线就是很好理解, 就是根据t来的线性插值. P0表示的是一个向量 [x ,y], 其中x和y是分别按照这个公式来计算的.

    二阶贝塞尔曲线

    既然重点是递归, 那么二阶贝塞尔必然和一阶有关系.

    在这里插入图片描述

    在平面内任选 3 个不共线的点,依次用线段连接。在第一条线段上任选一个点 D。计算该点到线段起点的距离 AD,与该线段总长 AB 的比例。
    根据上一步得到的比例,从第二条线段上找出对应的点 E,使得 AD:AB = BE:BC。
    在这里插入图片描述
    这时候DE又是一条直线了, 就可以按照一阶的贝塞尔方程来进行线性插值了, t= AD:AB

    这时候就可以推出公式了.
    在这里插入图片描述在这里插入图片描述

    三阶贝塞尔曲线

    在这里插入图片描述
    二阶的贝塞尔通过在控制点之间再采点的方式实现降阶, 每一次选点都是一次的降阶.

    四个点对应是三次的贝塞尔曲线. 分别在 AB BC CD 之间采EFG点, EFG三个点对应着二阶贝塞尔, 在EF FG之间采集HI点来降阶为一阶贝塞尔曲线.

    在这里插入图片描述在这里插入图片描述

    贝塞尔曲线公式

    可以通过递归的方式来理解贝塞尔曲线, 但是还是给出公式才方便计算的.
    在这里插入图片描述仔细看可以发现, 贝塞尔的参数B是二项式(t+(1-t))^n = (1)^n的展开公式. 划重点了: 系数是二项式的展开. 后面的很多的贝塞尔曲线的性质都可以用这个来解释

    3. 贝塞尔曲线的性质

    贝塞尔曲线具有众多特性,例如:递归性、凸包性、对称性、几何不变性、仿射不变性、拟局部性,保证了生成曲线的平滑性、连续性和可控性。

    3.1 各项系数之和为1.
    这个很好理解,因为是系数是二项式的展开(t+(1-t))^n = (1)^n非负性. 好理解, 二项式的展开啊

    3.2 递归性
    递归性指其系数满足下式:
    在这里插入图片描述3.3一阶导数性质
    在这里插入图片描述假设上图中贝塞尔的t是由左到右从0到1增加的,那么贝塞尔曲线在t=0时的导数是和P0P1的斜率(导数)是相同,t=1时的导数是和P2 P3的斜率(导数)是相同

    这一点的性质可以用在贝塞尔曲线的拼接,只要保证三点一线中的中间点是两段贝塞尔曲线的连接点,就可以保证两端贝塞尔曲线的导数连续连续.

    4. 如何确定贝塞尔曲线的控制点

    假设道路上已经有(n+1)个采样点Pi(i=0,1,…,n),需要在相邻的每两个点P(i)和P(i+1)之间,用一条3次Bezier曲线连接。即由4个点确定, P0为起点、P3为终点,另外中间2个控制点P1和P2。

    由四个控制点定义的平面三阶贝塞尔曲线可以形式化地表示为:

    在这里插入图片描述如图所示,在轨迹生成过程中,将目标车辆的中心点坐标作为起点P0,以目标车辆的驶意图为引导推理得到的目标点作为P3,其他两个控制点由车辆的约束条件计算得到。

    由于车辆在运动过程中无法进行原地滑动移动,所以生成的曲线需要满足起点方向约束。另外,在执行换道和转弯动作时,在终点处行驶轨迹要遵从道路结构化特征的约束,行驶轨迹的切线方向和道路的走势要相同,所以生成轨迹的终点需要满足终点方向约束。为了满足上述方向约束,P1和P2分别通过以起点坐标为起点沿起点航向向前移动距离d,以终点P3为起点沿终点航向的反方向向后移动距离d得到。

    简单来说,考虑到车辆起止点速度方向的连续性,即要求曲线函数的一阶导数连续。

    5. 代码实现

    import matplotlib.pyplot as plt
    import numpy as np
    import scipy.special
    
    show_animation = True
    
    
    def calc_4points_bezier_path(sx, sy, syaw, ex, ey, eyaw, offset):
        """
        Compute control points and path given start and end position.
    
        :param sx: (float) x-coordinate of the starting point
        :param sy: (float) y-coordinate of the starting point
        :param syaw: (float) yaw angle at start
        :param ex: (float) x-coordinate of the ending point
        :param ey: (float) y-coordinate of the ending point
        :param eyaw: (float) yaw angle at the end
        :param offset: (float)
        :return: (numpy array, numpy array)
        """
        dist = np.hypot(sx - ex, sy - ey) / offset
        control_points = np.array(
            [[sx, sy],
             [sx + dist * np.cos(syaw), sy + dist * np.sin(syaw)],
             [ex - dist * np.cos(eyaw), ey - dist * np.sin(eyaw)],
             [ex, ey]])
    
        path = calc_bezier_path(control_points, n_points=100)
    
        return path, control_points
    
    
    def calc_bezier_path(control_points, n_points=100):
        """
        Compute bezier path (trajectory) given control points.
    
        :param control_points: (numpy array)
        :param n_points: (int) number of points in the trajectory
        :return: (numpy array)
        """
        traj = []
        for t in np.linspace(0, 1, n_points):
            traj.append(bezier(t, control_points))
    
        return np.array(traj)
    
    
    def bernstein_poly(n, i, t):
        """
        Bernstein polynom.
    
        :param n: (int) polynom degree
        :param i: (int)
        :param t: (float)
        :return: (float)
        """
        return scipy.special.comb(n, i) * t ** i * (1 - t) ** (n - i)
    
    
    def bezier(t, control_points):
        """
        Return one point on the bezier curve.
    
        :param t: (float) number in [0, 1]
        :param control_points: (numpy array)
        :return: (numpy array) Coordinates of the point
        """
        n = len(control_points) - 1
        return np.sum([bernstein_poly(n, i, t) * control_points[i] for i in range(n + 1)], axis=0)
    
    
    def bezier_derivatives_control_points(control_points, n_derivatives):
        """
        Compute control points of the successive derivatives of a given bezier curve.
    
        A derivative of a bezier curve is a bezier curve.
        See https://pomax.github.io/bezierinfo/#derivatives
        for detailed explanations
    
        :param control_points: (numpy array)
        :param n_derivatives: (int)
        e.g., n_derivatives=2 -> compute control points for first and second derivatives
        :return: ([numpy array])
        """
        w = {0: control_points}
        for i in range(n_derivatives):
            n = len(w[i])
            w[i + 1] = np.array([(n - 1) * (w[i][j + 1] - w[i][j])
                                 for j in range(n - 1)])
        return w
    
    
    def curvature(dx, dy, ddx, ddy):
        """
        Compute curvature at one point given first and second derivatives.
    
        :param dx: (float) First derivative along x axis
        :param dy: (float)
        :param ddx: (float) Second derivative along x axis
        :param ddy: (float)
        :return: (float)
        """
        return (dx * ddy - dy * ddx) / (dx ** 2 + dy ** 2) ** (3 / 2)
    
    
    def plot_arrow(x, y, yaw, length=1.0, width=0.5, fc="r", ec="k"):  # pragma: no cover
        """Plot arrow."""
        if not isinstance(x, float):
            for (ix, iy, iyaw) in zip(x, y, yaw):
                plot_arrow(ix, iy, iyaw)
        else:
            plt.arrow(x, y, length * np.cos(yaw), length * np.sin(yaw),
                      fc=fc, ec=ec, head_width=width, head_length=width)
            plt.plot(x, y)
    
    
    def main():
        """Plot an example bezier curve."""
        start_x = 10.0  # [m]
        start_y = 1.0  # [m]
        start_yaw = np.radians(180.0)  # [rad]
    
        end_x = -0.0  # [m]
        end_y = -3.0  # [m]
        end_yaw = np.radians(-45.0)  # [rad]
        offset = 3.0
    
        path, control_points = calc_4points_bezier_path(
            start_x, start_y, start_yaw, end_x, end_y, end_yaw, offset)
    
        # Note: alternatively, instead of specifying start and end position
        # you can directly define n control points and compute the path:
        # control_points = np.array([[5., 1.], [-2.78, 1.], [-11.5, -4.5], [-6., -8.]])
        # path = calc_bezier_path(control_points, n_points=100)
    
        # Display the tangent, normal and radius of cruvature at a given point
        t = 0.86  # Number in [0, 1]
        x_target, y_target = bezier(t, control_points)
        derivatives_cp = bezier_derivatives_control_points(control_points, 2)
        point = bezier(t, control_points)
        dt = bezier(t, derivatives_cp[1])
        ddt = bezier(t, derivatives_cp[2])
        # Radius of curvature
        radius = 1 / curvature(dt[0], dt[1], ddt[0], ddt[1])
        # Normalize derivative
        dt /= np.linalg.norm(dt, 2)
        tangent = np.array([point, point + dt])
        normal = np.array([point, point + [- dt[1], dt[0]]])
        curvature_center = point + np.array([- dt[1], dt[0]]) * radius
        circle = plt.Circle(tuple(curvature_center), radius,
                            color=(0, 0.8, 0.8), fill=False, linewidth=1)
    
        assert path.T[0][0] == start_x, "path is invalid"
        assert path.T[1][0] == start_y, "path is invalid"
        assert path.T[0][-1] == end_x, "path is invalid"
        assert path.T[1][-1] == end_y, "path is invalid"
    
        if show_animation:  # pragma: no cover
            fig, ax = plt.subplots()
            ax.plot(path.T[0], path.T[1], label="Bezier Path")
            ax.plot(control_points.T[0], control_points.T[1],
                    '--o', label="Control Points")
            ax.plot(x_target, y_target)
            ax.plot(tangent[:, 0], tangent[:, 1], label="Tangent")
            ax.plot(normal[:, 0], normal[:, 1], label="Normal")
            ax.add_artist(circle)
            plot_arrow(start_x, start_y, start_yaw)
            plot_arrow(end_x, end_y, end_yaw)
            ax.legend()
            ax.axis("equal")
            ax.grid(True)
            plt.show()
    
    
    def main2():
        """Show the effect of the offset."""
        start_x = 10.0  # [m]
        start_y = 1.0  # [m]
        start_yaw = np.radians(180.0)  # [rad]
    
        end_x = -0.0  # [m]
        end_y = -3.0  # [m]
        end_yaw = np.radians(-45.0)  # [rad]
    
        for offset in np.arange(1.0, 5.0, 1.0):
            path, control_points = calc_4points_bezier_path(
                start_x, start_y, start_yaw, end_x, end_y, end_yaw, offset)
            assert path.T[0][0] == start_x, "path is invalid"
            assert path.T[1][0] == start_y, "path is invalid"
            assert path.T[0][-1] == end_x, "path is invalid"
            assert path.T[1][-1] == end_y, "path is invalid"
    
            if show_animation:  # pragma: no cover
                plt.plot(path.T[0], path.T[1], label="Offset=" + str(offset))
    
        if show_animation:  # pragma: no cover
            plot_arrow(start_x, start_y, start_yaw)
            plot_arrow(end_x, end_y, end_yaw)
            plt.legend()
            plt.axis("equal")
            plt.grid(True)
            plt.show()
    
    
    if __name__ == '__main__':
        main()
    

    参考文章:
    1.曲线篇-贝塞尔曲线
    2.运动规划-贝塞尔Bezier曲线
    3.自动驾驶-初探轨迹规划

    展开全文
  • 在对以上问题进行分析后提出了一种基于Bezier曲线与A*算法融合的方法来实现移动机器人的路径规划,再通过MATLAB、VREP仿真工具来实现Bezier_A*融合算法与平滑A*算法及A*算法的对比。通过Bezier_A*融合算法使得...
  • 基于贝塞尔曲线的变道轨迹规划

    千次阅读 2019-06-04 19:36:33
    基于贝塞尔曲线的变道轨迹规划 车辆的换道与超车是驾驶员常见的驾驶操作之一,无人驾驶车辆在行驶过程中也会频繁的面临此工况,车辆行驶过程中必须根据行驶环境中车车之间的相对速度与距离,以及车辆周边其他环境的...
  • 用于自动生成贝塞斯曲面的喷涂路径,实现融合喷涂工艺的小曲率自由曲面喷枪的自动路径规划
  • 用于创建贝塞尔曲线路径,可匀速运动 - Used to create a Bezier curve path with uniform motion 更新日志: 2020.2.7: 新添加三阶贝塞尔曲线 平滑度自定义 该工程基于cocos creator 2.2.2版本! (可以直接在上面...
  • 贝塞尔曲线生成路径

    2020-08-10 18:53:34
    使用贝塞尔曲线生成路径 已知:若干个二维路径点(x, y),生成一段由一系列(x, y)点组成的点集 公式 网上有很多贝塞尔曲线的概念和知识,这里不做赘述 贝塞尔曲线上的路径点计算公式: P(t)  =∑i=0nk(i,  n,  ...
  • 然后可以通过以下方式获得贝塞尔路径使用贝塞尔曲线来拟合避免碰撞规划器提供的一系列目标点。 在算法的指导下,车辆可以以预定的方向到达目标点。 模拟实验进行得很好证明规划路径是可行的,并且符合人类专家的...
  • Path(0)贝塞尔曲线

    千次阅读 2018-05-09 08:45:33
    4.贝塞尔曲线路径规划中的应用[1]  路径只包含几何信息:对于一个三维空间中的光滑路径,我们能计算这条路径上每一点处的切线和法线,它们刚好能唯一地确定一个右手直角坐标系(这个坐标系又被称为  Frenet 标架...
  • 笔触的可变宽度贝塞尔曲线偏移 通过偏移四倍贝塞尔曲线路径来演示可变贝塞尔曲线笔划。 /数学论文,为
  • 贝塞尔曲线

    2019-05-27 20:32:08
    RT,马三最近在参与一款足球游戏...最早的版本中马三是使用物理引擎加力的方式实现的足球各种运动,后来的版本中使用了根据物理学公式手动计算位置和物体速度的方式实现,现在这个版本中使用的是DoTween+贝塞尔曲线...
  • 贝塞尔曲线(Bézier curve),又称贝兹曲线或贝济埃曲线,是应用于二维图形应用程序的数学曲线。一般的矢量图形软件通过它来精确画出曲线,贝兹曲线由线段与节点组成,节点是可拖动的支点,线段像可伸缩的皮筋,我们...
  • 一阶贝塞尔曲线(包含两个控制点) 假设控制点为P0P_0P0​和P1P_1P1​,曲线方程为: B(t)=(1−t)P0+tP1=P0+(P1−P0)t \begin{aligned} B(t)&=(1-t)P_0+tP_1\\ &=P_0+(P_1-P_0)t \end{aligned} B(t)​=(1−t...
  • 贝塞尔曲线的特性总结

    千次阅读 2020-02-15 19:06:33
    2.贝塞尔曲线通过起始点和终止点,并与起始点和终止点的折线相切,在对自车路径规划过程中可根据曲线的起始点和终止点的切线方向确定自车起始点姿态和目标点姿态; 3.至少需要三阶贝塞尔曲线(四个控制点)才能生成...
  • 基于贝塞尔曲线的自动驾驶汽车避障路径规划.pdf
  • 本文实例为大家分享了Android贝塞尔曲线实现手指轨迹的具体代码,供大家参考,具体内容如下 1、使用贝塞尔曲线前 MyView.java public class MyView extends View { // 实例一个路径对象 private Path mPath = new...
  • 在原有轨迹上,根据障碍物规划出新的轨迹: xs = 0 ; ys = 0 ; Ldis = sqrt ( ( X ( 200 ) - X ( 350 ) ) . ^ 2 + ( Y ( 200 ) - Y ( 350 ) ) . ^ 2 ) ; xe = Ldis ; ye = 0 ; p = ...
  • 贝塞尔曲线的渲染脚本,可以在Unity的scene中,通过拖动TargetObject(即圆盘的位置变化), 可以观察到整体曲线的变化。 设计之初是为了,用于HTC VIVE 手柄 触发的位移传送曲线的显示。 参考了教程: 贝塞尔...
  • python 路径平滑(3)贝塞尔曲线优化 贝塞尔曲线图示 这篇博文里有贝塞尔曲线的动态绘制方法,辅助图可以帮助理解贝塞尔曲线 大佬代码实现 我接下来的代码基本上是大量参考(chao)大佬的代码 import matplotlib....
  • 贝塞尔曲线 贝塞尔曲线起始点和终止点在曲线上,方向控制点不再曲线上。 <!doctype html> <html> <head> <meta charset="utf-8"> <title>初识贝塞尔曲线</title> <style>...
  • 贝塞尔月亮 在两个贝塞尔曲线路径形状之间设置动画 一些技巧可以正确地做到这一点。 这是一个测试应用程序,在其他应用程序中使用的技术。
  • 贝塞尔曲线绘制路径

    千次阅读 2016-08-19 21:09:19
    最近项目中需要用到用贝塞尔曲线去绘制路径 ,然后往路径里面填充图片,找到这篇文章挺好,记录下来 自己学习! 转至 http://blog.csdn.net/guo_hongjun1611/article/details/7839371 使用UIBezierPath类...
  • 贝塞尔曲线一般用在绘制canvas图层上,这里主要是ObjectAnimation动画及插值器和估值器实现将贝塞尔曲线作为控件移动的动画路径。 项目demo图:一、ObjectAnimator动画原理 ObjectAnimator.ofObject(….,”xxx”,估值...
  • Android 属性动画-绘制贝塞尔曲线路径 以前对属性动画的知识,只是停留在值动画和一般的移动、渐变、缩放,原来它还可以自定义,利用反射来回调自己的方法,真是设计的6 而且一直想了解路径动画是怎么计算路径的...
  • 首先规划出reference line, 探测到障碍物后,进行贝塞尔曲线轨迹规划,绕开障碍物,给出新的reference line, 然后根据pure pursuit模型进行软件在环测试,pure pursuit部分参考之前的博文。 clc clear all k = 0.1;...
  • 2次贝塞尔曲线算法

    热门讨论 2011-10-25 17:50:09
    2次贝塞尔曲线算法 用三次Bezier逼近圆弧:圆弧要等分成多少段 用三次Bezier逼近圆弧: 得到控制顶点数组 用三次Bezier逼近圆弧片段

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,540
精华内容 4,216
关键字:

贝塞尔曲线路径规划