Hermite （埃尔米特）曲线

最新推荐文章于 2024-04-24 13:35:29 发布
最新推荐文章于 2024-04-24 13:35:29 发布
阅读量1.3k 收藏 2
点赞数
文章标签： python 游戏 数据结构与算法
原文链接：http://www.cnblogs.com/jqm304775992/p/5044728.html
版权

Hermite 曲线

　　已知曲线的两个端点坐标P0、P1，和端点处的切线R0、R1，确定的一条曲线。

参数方程

　　1. 几何形式

　　

　　2. 矩阵形式

　　　

　　3. 推导

　　　　

 

　　

 

　　

 

 

 

　　

 

　　

 

　　

 

例子分析

　　

　　如上图有四个点，假如P0、P2是端点，那么向量R0=(P1-P0)，R1=(P3-P2)，将数据带入调和函数，即求得曲线。

　　在程序中，我们通常会使用特殊方法处理顶点之间的关系。

　　

　　图中含有3个顶点，我们把每挨着的两个顶点看做是一条Hermite曲线，P0和P1是两个端点，那么现在，我们如何求得R1呢？ 我们现在构建连个参考点F1,F2。

　　　　令  F1 = P0; 　　F2 = P2;  

　　　　那么 R1 = P1-F1;　　R2 = F2-P1;

　　然后将此值带入曲线函数，即可为求得的曲线。　　

程序代码

该代码是Unity脚本代码:

　　1. 实现编辑器闭合曲线和非闭合曲线的绘制；

　　2. 运行脚本，可以实现物体跟随曲线路径移动，可以勾选旋转跟随与不跟随；

　　3. 如果不进行自动跟随曲线路径，可以修改时间值，移动物体。

using UnityEngine;
using System.Collections;
using System.Collections.Generic;
public class HermitCurve : Curve_Root {

    public Transform CurveParent;
    public int lineCount;
    private List<NodePath> nodePath;
    public float smoothFactor = 2.0f;

    private Transform[] transforms;
    private Vector3[] node;
    public float Speed = 10.0f;

    Vector3 curPos;
    Vector3 nextPos;
    Quaternion curRotate;
    Quaternion nextRotate;
    float moveTime;
    float curTime;
    public GameObject Tar;
    int index;
    private Transform T;

    public float time;


    /// <summary>
    /// 数据校正
    /// </summary>
    void DadaCorrection()
    {
        //根节点验证
        if (CurveParent == null)
        {
            Debug.LogError("Please add curve the root node.");
            return;
        }

        //修正平滑因子： 2时，较为理想。
        smoothFactor = smoothFactor >= 10.0f ? 10.0f : smoothFactor;
        smoothFactor = smoothFactor <= 1.0f ? 1.0f : smoothFactor;
    }

    /// <summary>
    /// 计算路径节点
    /// </summary>
    void ComputeNode()
    {
        //将节点添加入链表
        Component[] mTrans = CurveParent.GetComponentsInChildren(typeof(Transform));//物体和子物体的Trans
        if (mTrans.Length - 1 < 2)
        {
            Debug.LogError("Please add at least two points.");
            return;
        }

        //非闭合曲线与闭合曲线的顶点时间计算：非闭合曲线，最后个顶点的时间为1.0，闭合曲线的最后个顶点的时间为倒数第二个顶点，因为他的最后个点是原点。
        float t;
        if (closedCurve)
        {
            t = 1.0f / (mTrans.Length - 1);
            nodePath = new List<NodePath>();
            for (int i = 1; i < mTrans.Length; i++)//根节点不参与路径节点的计算
            {
                nodePath.Add(new NodePath(mTrans[i].transform.position, (i - 1) * t));
            }
            //闭合曲线完整的节点
            AddClosedCurveNode();
        }
        else
        {
            t = 1.0f / (mTrans.Length - 2);
            nodePath = new List<NodePath>();
            for (int i = 1; i < mTrans.Length; i++)//根节点不参与路径节点的计算
            {
                nodePath.Add(new NodePath(mTrans[i].transform.position, (i - 1) * t));
            }
            //非闭合曲线完整的节点
            AddCurveNode();
        }
    }


    // Use this for initialization
    void Start () {
        
        DadaCorrection();

        ComputeNode();

        node = new Vector3[lineCount+1];
        //Vector3 start = nodePath[1].point;
        //Vector3 end;

        node[0] = nodePath[1].point;
        Vector3 end;
        //绘制节点
        for (int i = 1; i <= lineCount; i++)
        {
            float ti = i / (float)lineCount;
            end = GetHermitAtTime(ti);
            if (node != null)
            {
                node[i] = end;
            }
        }
  
        T = new GameObject().transform;
        
        curPos = node[0];
        nextPos = node[1];
        moveTime = (nextPos - curPos).magnitude / Speed;

        Tar.transform.position = curPos;
        Tar.transform.transform.LookAt(nextPos);
        curRotate = Tar.transform.rotation;
        T.position = node[1];
        T.LookAt(node[2]);
        nextRotate = T.rotation;
        curTime = 0;
        index = 1;
    }
    
    // Update is called once per frame
    void Update () {

        if (AutoCurve)
        {
            if (moveTime > curTime)
            {
                Tar.transform.position = Vector3.Lerp(curPos, nextPos, curTime / moveTime);
                if (AutoRotate)
                {
                    Tar.transform.rotation = Quaternion.Slerp(curRotate, nextRotate, curTime / moveTime);
                }

                curTime += Time.deltaTime;
            }
            else
            {
                if (closedCurve)
                {
                    index = ((index + 1) % (lineCount + 1) == 0) ? 0 : index + 1;
                }
                else
                {
                    index = ((index + 1) % (lineCount+1) == 0) ? index : index + 1;
                }
                curPos = nextPos;
                nextPos = node[index];

                curTime = 0;
                moveTime = (nextPos - curPos).magnitude / Speed;

                T.position = node[index];
                curRotate = nextRotate;

                if (closedCurve)
                {
                    int c1;
                    if (index == node.Length-1)
                    {
                        c1 = 0;
                    }
                    else
                    {
                        c1 = index + 1;
                    }
                    T.LookAt(node[c1]);
                }
                else
                {
                    int c1;
                    if (index == node.Length - 1)
                    {
                        c1 = 0;
                    }
                    else
                    {
                        c1 = index + 1;
                        T.LookAt(node[c1]);
                    }
                }

                nextRotate = T.rotation;
            }
        }
        else
        {
            if (closedCurve)
            {
                if (AutoRotate)
                {
                    time = time > 1.0f ? 0.0f : time;
                    time = time < 0.0f ? 1.0f : time;
                    Vector3 cur = GetHermitAtTime(time);
                    Tar.transform.position = cur;

                    float del = 1.0f / lineCount;
                    Vector3 next0 = GetHermitAtTime(time + del);
                    Tar.transform.LookAt(next0);
                }
                else
                {
                    time = time > 1.0f ? 0.0f : time;
                    time = time < 0.0f ? 1.0f : time;
                    Vector3 cur = GetHermitAtTime(time);
                    Tar.transform.position = cur;
                }
            }
            else
            {
                if (AutoRotate)
                {
                    time = time > 1.0f ? 1.0f : time;
                    time = time < 0.0f ? 0.0f : time;
                    Vector3 cur = GetHermitAtTime(time);
                    Tar.transform.position = cur;

                    float del = 1.0f / lineCount;
                    Vector3 next0 = GetHermitAtTime(time + del);

                    Tar.transform.LookAt(next0);
                }
                else
                {
                    time = time > 1.0f ? 1.0f : time;
                    time = time < 0.0f ? 0.0f : time;
                    Vector3 cur = GetHermitAtTime(time);
                    Tar.transform.position = cur;
                }
            }

        }
        
    }



    /// <summary>
    /// 绘制曲线
    /// </summary>
    void DrawCurve()
    {
        if (closedCurve)
        {
            Vector3 start = nodePath[1].point;
            Vector3 end;

            Gizmos.color = _Color;
            //绘制节点
            for (int i = 1; i < lineCount; i++)
            {
                float time = i / (float)lineCount;
                end = GetHermitAtTime(time);
                //Debug.Log(end);
                Gizmos.DrawLine(start, end);

                start = end;
            }
            Gizmos.DrawLine(start, nodePath[nodePath.Count - 2].point);
        }
        else
        {
            Vector3 start = nodePath[1].point;
            Vector3 end;

            Gizmos.color = _Color;
            //绘制节点
            for (int i = 1; i < lineCount; i++)
            {
                float time = i / (float)lineCount;
                end = GetHermitAtTime(time);
                //Debug.Log(end);
                Gizmos.DrawLine(start, end);
                start = end;
            }
            Gizmos.DrawLine(start, nodePath[nodePath.Count - 2].point);
        }
    }

    /// <summary>
    /// 在Scene场景中，绘制Hermite曲线
    /// </summary>
    void OnDrawGizmos()
    {
        /*数据校正*/
        DadaCorrection();
        /*计算顶点*/
        ComputeNode();
        /*计算曲线*/
        DrawCurve();
    }

    /// <summary>
    /// 1. 非闭合曲线
    /// </summary>
    public void AddCurveNode()
    {
        nodePath.Insert(0, nodePath[0]);
        nodePath.Add(nodePath[nodePath.Count - 1]);
    }

    /// <summary>
    /// 2. 闭合曲线
    /// </summary>
    public void AddClosedCurveNode()
    {
        //nodePath.Insert(0, nodePath[0]);
        nodePath.Add(new NodePath(nodePath[0]));
        nodePath[nodePath.Count - 1].time = 1.0f;

        Vector3 vInitDir = (nodePath[1].point - nodePath[0].point).normalized;
        Vector3 vEndDir = (nodePath[nodePath.Count - 2].point - nodePath[nodePath.Count - 1].point).normalized;
        float firstLength = (nodePath[1].point - nodePath[0].point).magnitude;
        float lastLength = (nodePath[nodePath.Count - 2].point - nodePath[nodePath.Count - 1].point).magnitude;

        NodePath firstNode = new NodePath(nodePath[0]);
        firstNode.point = nodePath[0].point + vEndDir * firstLength;

        NodePath lastNode = new NodePath(nodePath[nodePath.Count - 1]);
        lastNode.point = nodePath[0].point + vInitDir * lastLength;

        nodePath.Insert(0, firstNode);
        nodePath.Add(lastNode); 
    }

    /// <summary>
    /// 通过节点段数的时间大小，获取每段节点
    /// </summary>
    /// <param name="t"></param>
    /// <returns></returns>
    public Vector3 GetHermitAtTime(float t)
    {
        //Debug.Log(t);
        int k;
        //最后一个顶点
        if (t >= nodePath[nodePath.Count - 2].time)
        {
            return nodePath[nodePath.Count - 2].point;
        }
        for (k = 1; k < nodePath.Count-2; k++)
        {
            if (nodePath[k].time > t)
                break;
        }

        k = k - 1;
        float param = (t - nodePath[k].time) / (nodePath[k+1].time - nodePath[k].time);
        return GetHermitNode(k, param);
    }

    /// <summary>
    /// Herimite曲线：获取节点
    /// </summary>
    /// <param name="index">节点最近的顶点</param>
    /// <param name="t"></param>
    /// <returns></returns>
    public Vector3 GetHermitNode(int index,float t)
    {
        Vector3 v;
        Vector3 P0 = nodePath[index - 1].point;
        Vector3 P1 = nodePath[index].point;
        Vector3 P2 = nodePath[index + 1].point;
        Vector3 P3 = nodePath[index + 2].point;

        //调和函数
        float h1 = 2 * t * t * t - 3 * t * t + 1;
        float h2 = -2 * t * t * t + 3 * t * t;
        float h3 = t * t * t - 2 * t * t + t;
        float h4 = t * t * t - t * t;

        v = h1 * P1 + h2 * P2 + h3 * (P2 - P0) / smoothFactor + h4 * (P3 - P1) / smoothFactor;
        //Debug.Log(index + "  "+ t+"  "+v);
        return v;
    }
}


/// <summary>
/// 节点类
/// </summary>
public class NodePath
{
    public Vector3 point;
    public float time;

    public NodePath(Vector3 v,float t)
    {
        point = v;
        time = t;
    }

    public NodePath(NodePath n)
    {
        point = n.point;
        time = n.time;
    }
}
View Code

 

基类代码

using UnityEngine;
using System.Collections;

public class Curve_Root : MonoBehaviour {

    //曲线是否为闭合曲线
    public bool closedCurve = false;

    //曲线的颜色
    public Color _Color = Color.white;

    //自动跟随路径
    public bool AutoCurve = false;

    //旋转跟随
    public bool AutoRotate = false;
}
View Code

 

 路径漫游

　　在曲线函数中，参数t取值[0,1]，将曲线进行分段。那么能够计算出每一个点的位置。因此，在路径漫游中，我们从原点出发，将t的增量作为下一个点位置，进行插值移动。就实现了路径漫游，同时进行朝向下一个顶点旋转，就可以使看的方向随着曲线变化。

Unity 3D 项目工程

http://download.csdn.net/detail/familycsd000/9365859

 

　　

　　

转载于:https://www.cnblogs.com/jqm304775992/p/5044728.html

dianruiwo7869
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
三次Hermite样条曲线绘制
05-26
三次Hermite样条曲线的绘制，在编辑菜单下有一个编辑的选项，可改动参数，其中有两个因任务需要已设为已知，遂只有6个参数。（是利用矩阵算的）
hermite插值matlab代码-numerical-methods:McGill-数值方法（电气工程课程，由DennisGiannacop
05-24
埃尔米特插值matlab代码电气工程中的数值方法：赋值 该存储库是我为McGill（ECSE 543）的一门课程编写的数值方法分配的集合。 这些文件夹中的每一个都包含作业的代码以及讨论方法和结果的文章。 作业1 1.1。 作业1的第一部分由编写的代码组成，该代码被编写为从“从头开始”执行矩阵处理，包括通过Cholesky分解的矩阵方程求解器。 然后，我编写了一个程序，该程序从文件中读取网络分支的列表（Jk，Rk，Ek）和简化的入射矩阵，并使用此Cholesky求解器查找网络节点处的电压。 要运行此代码，请在MATLAB中转到“ Numerical-Methods/Assignment1/Q1并运行test 。 1.2。 在作业的第二部分中，要求我编写一个程序，以找到N x N电阻器网格的电阻。 在MATLAB中，转到“ Numerical-Methods/Assignment1/Q2并运行test以查看比较N随时间增加的计算时间的曲线，以及说明R随着N的增加如何变化的曲线。 1.3。 作业的第三部分包括使用通过（1）连续阶数弛豫和（2）Jacobi方法求解的五点差分公式来求解具有平移对
Curves2x3:绘制 2 条曲线 3 种方式 Bezier Spline Hermite，4 个控制点 Java-开源
06-01
用 4 个控制点绘制 2 条曲线，三种方式之一：贝塞尔曲线、埃尔米特曲线和样条曲线。 Java 小程序和应用程序。 请参阅 BestWavesLive.com 进行演示。
埃尔米特函数的计算（C++）
Ivan 的专栏
03-18 5122
前两篇博客介绍了埃尔米特多项式和埃尔米特函数的基本性质。我研究这些的目的其实是为了解决一个函数逼近问题。也就是我要用埃尔米特函数去逼近另外一个函数。有了前两篇的铺垫，这个工作似乎挺简单。上一篇讲到了： f(x)=∑n=0∞fnψn(x) f(x) = \sum_{n=0}^{\infty} f_n \psi_n(x) 其中： fn=∫∞−∞f(x)ψn(x)dx f_n = \int_{-\
1165：Hermite多项式（C C++）
ネロ・クラウディウス
11-09 2648
【题目描述】 【输入】 给定的n和正整数x。 【输出】 多项式的值。 【输入样例】 1 2 【输出样例】 4.00 【代码】
Hermite （埃尔米特）曲线 公式-易语言
06-11
有种东西叫做轨迹方程，这是贝塞尔进阶版 厄米特矩阵，只是对他的矩阵算法和轨迹算法进行了翻译 依据https://www.cnblogs.com/jqm304775992/p/5044728.html 这个文章进行了 易语言 算法还原
图形学笔记(五) 空间图形的几何表示(加工中)
by UPiracy
07-20 1013
空间图形的几何表示 曲线 什么是埃尔米特曲线？ **埃尔米特曲线(Hermit)**是一种插值曲线，也是样条曲线家族中最好理解的一种曲线。 Hermit曲线给定曲线两个端点的位置矢量P0P_0P0​、P1P_1P1​和切线矢量T0T_0T0​、T1T_1T1​，通过插值获得曲线在定义域[0,1]上的三次参数方程： 我们设目标参数方程为P(t)=at3+bt2+ct+dP(t)=at^3+bt^2+ct+dP(t)=at3+bt2+ct+d，则有P′(t)=3at2+2bt+cP'(t)=3at^2+2bt
埃尔米特曲线
CCCStudyer的专栏
12-28 5605
介绍   埃尔米特曲线是非常有用和容易计算，常被用于关键点的平滑插值，了解埃尔米特曲线的数学原理将会对你了解整个样条曲线族有很大的帮助，可能你在没有了解它之前已经在3D程序实现过他。 原理 让我们从一些简单的原理开始吧，我们同样也讨论一些二维曲线，如果你需要处理一些三维曲线仅仅需要像处理X坐标和Y坐标一样处理Z坐标，埃尔米特可以在多维空间中实现。   P1: 曲线的开始点 T1: 切线
图形学中的Hermite曲线
迪玛希的女朋友的博客
01-02 5099
Hermite曲线       三次Hermite曲线是以法国数学家Charles Hermite命名的。他是三次参数样条曲线的基础。
曲线绘制（Bezier、三次B样条、Hermite）
04-20
MFC下曲线绘制（Bezier、三次B样条、Hermite），每种曲线一个工程，每个工程下都有简要使用说明
Hermite曲线和Bezier曲线实现
09-25
基于vc6.0 MFC编写的实现Hermite曲线和Bezier曲线的代码。
分段三次埃尔米特插值_分段三次埃尔米特插值_分段曲线拟合_
10-02
该程序能够实现分段三次埃尔米特插值，可用拟合曲线中的插值部分。
论文研究-有理三次三角Hermite插值样条曲线及其应用.pdf
09-13
给出一种有理三次三角Hermite插值样条曲线，具有三次Hermite插值样条相似的性质。该样条含有三角函数和形状参数，利用形状参数的不同取值可以调控插值曲线的形状，甚至不用解方程组，就能使曲线达到C2连续。此外，...
有理三次Hermite插值样条及其逼近性质* (2011年)
05-18
提高插值曲线曲面的逼近性是计算辅助几何设计中的一个重要问题．...结果表明，对于给定的插值条件，通过选择合适的参数，依本文方法所生成的插值曲线曲面在逼近效果上好于标准三次Hermite插值曲线曲面．
[python3] 读取一个正在更新的日志文件
最新发布
言之。
04-24 894
等同于–follow=name --retry，根据文件名进行追踪，并保持重试，即该文件被删除或改名后，如果再次创建相同的文件名，会继续追踪。这两种方法都会持续监听日志文件的变化，并实时读取新增的日志内容。你可以根据实际需求选择其中一种方法。要读取一个正在更新的日志文件（即实时写入的日志文件），你可以使用 Python 的。的技巧来实现实时读取。函数打开文件，并使用。
实现自定义注解、实现自定义幂等性注解
qq_44721738的博客
04-23 1039
添加 Spring AOP 依赖。创建自定义注解。创建一个新的 Java 注解类，通过@interface关键字来定义，并可以添加元注解以及属性。@Target(ElementType.METHOD) //表示作用于方法上@Retention(RetentionPolicy.RUNTIME) // 表示这个注解在运行时是可见的，这样 AOP 代理才能在运行时读取到这个注解编写 AOP 拦截（自定义注解）的逻辑代码。@Aspect@Component// 方法执行前的处理。
Pandas 2.2 中文官方教程和指南（二十二）
龙哥盟
04-24 1154
原文：pandas.pydata.org/docs/ 时间增量 原文：pandas.pydata.org/docs/user_guide/timedeltas.html 时间增量是时间之间的差异，以不同的单位表示，例如天、小时、分钟、秒。它们可以是正数也可以是负数。 Timedelta是datetime.timedelta的子类，并且行为类似，但也允许与np.timedelta64类型兼容，以及一系列自定义表示、解析和属性。 解析 您可以通过各种参数构造一个Timedelta标量，包括ISO 860
Pandas 2.2 中文官方教程和指南（十五）
龙哥盟
04-24 761
原文：pandas.pydata.org/docs/ 处理文本数据 原文：pandas.pydata.org/docs/user_guide/text.html 文本数据类型 在 pandas 中有两种存储文本数据的方式： object -dtype NumPy 数组。 StringDtype 扩展类型。 我们建议使用StringDtype来存储文本数据。 在 pandas 1.0 之前，object dtype 是唯一的选项。这在很多方面都是不幸的： 你可能会在object dty
三次hermite差值曲线
04-26
Hermite插值曲线是一种通过给定的一组点和割线斜率，在该点处生成一条平滑曲线的方法。Hermite插值曲线可以使用三个点和三个割线斜率来确定曲线。具体来说，对于给定的三个点，我们可以使用它们的函数值和割线斜率来...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值