二次与三次B样条曲线实现

最新推荐文章于 2024-06-12 23:50:51 发布
最新推荐文章于 2024-06-12 23:50:51 发布
阅读量1.7k 收藏 6
点赞数
CC 4.0 BY-SA版权
分类专栏： C++ 文章标签： B样条插值
原文链接：http://www.360doc.com/content/19/0831/21/13328254_858345500.shtml

BSpline.h文件


#pragma once
typedef struct tagPosition
{
	double  x;
	double  y;
	tagPosition(double _x, double _y) { x = _x; y = _y; }
	tagPosition() {};
	bool operator==(const tagPosition& pt) { return (x == pt.x && y == pt.y); }
} CPosition;

class CBSpline
{
public:
	CBSpline(void);
	~CBSpline(void);

	void TwoOrderBSplineSmooth(CPosition* pt, int Num);
	void TwoOrderBSplineInterpolatePt(CPosition*& pt, int& Num, int* InsertNum);
	double F02(double t);
	double F12(double t);
	double F22(double t);

	void ThreeOrderBSplineSmooth(CPosition* pt, int Num);
	void ThreeOrderBSplineInterpolatePt(CPosition*& pt, int& Num, int* InsertNum);
	double F03(double t);
	double F13(double t);
	double F23(double t);
	double F33(double t);
};

BSpline.cpp文件

#include "pch.h"
#include "BSpline.h"

/****************************     BSpline.cpp     ***********************************
包含功能：二次B样条平滑，三次B样条平滑；二次B样条平滑后节点插值

 作者：    蒋锦朋   1034378054@qq.com
 单位：    中国地质大学（武汉） 地球物理与空间信息学院
 日期：    2014/12/03
*************************************************************************************/
#include "pch.h"
#include "Spline.h"


CBSpline::CBSpline(void)
{
}


CBSpline::~CBSpline(void)
{
}
//======================================================================
// 函数功能： 二次B样条平滑，把给定的点，平滑到B样条曲线上，不增加点的数目
// 输入参数： *pt ：给定点序列，执行完成后，会被替换成新的平滑点
//            Num：点个数
// 返回值：   无返回值

// 编辑日期：    2014/12/03
//======================================================================
void CBSpline::TwoOrderBSplineSmooth(CPosition* pt, int Num)
{
	CPosition* temp = new CPosition[Num];
	for (int i = 0; i < Num; i++)
		temp[i] = pt[i];

	temp[0].x = 2 * temp[0].x - temp[1].x;                  //  将折线两端点换成延长线上两点
	temp[0].y = 2 * temp[0].y - temp[1].y;

	temp[Num - 1].x = 2 * temp[Num - 1].x - temp[Num - 2].x;
	temp[Num - 1].y = 2 * temp[Num - 1].y - temp[Num - 2].y;

	CPosition NodePt1, NodePt2, NodePt3;
	double t;
	for (int i = 0; i < Num - 2; i++)
	{
		NodePt1 = temp[i]; NodePt2 = temp[i + 1]; NodePt3 = temp[i + 2];
		if (i == 0)                                     //  第一段取t=0和t=0.5点
		{
			t = 0;
			pt[i].x = F02(t) * NodePt1.x + F12(t) * NodePt2.x + F22(t) * NodePt3.x;
			pt[i].y = F02(t) * NodePt1.y + F12(t) * NodePt2.y + F22(t) * NodePt3.y;
			t = 0.5;
			pt[i + 1].x = F02(t) * NodePt1.x + F12(t) * NodePt2.x + F22(t) * NodePt3.x;
			pt[i + 1].y = F02(t) * NodePt1.y + F12(t) * NodePt2.y + F22(t) * NodePt3.y;
		}
		else if (i == Num - 3)                          //  最后一段取t=0.5和t=1点
		{
			t = 0.5;
			pt[i + 1].x = F02(t) * NodePt1.x + F12(t) * NodePt2.x + F22(t) * NodePt3.x;
			pt[i + 1].y = F02(t) * NodePt1.y + F12(t) * NodePt2.y + F22(t) * NodePt3.y;
			t = 1;
			pt[i + 2].x = F02(t) * NodePt1.x + F12(t) * NodePt2.x + F22(t) * NodePt3.x;
			pt[i + 2].y = F02(t) * NodePt1.y + F12(t) * NodePt2.y + F22(t) * NodePt3.y;
		}
		else                                      //  中间段取t=0.5点
		{
			t = 0.5;
			pt[i + 1].x = F02(t) * NodePt1.x + F12(t) * NodePt2.x + F22(t) * NodePt3.x;
			pt[i + 1].y = F02(t) * NodePt1.y + F12(t) * NodePt2.y + F22(t) * NodePt3.y;
		}
	}
	delete[]temp;
}

//================================================================
// 函数功能： 二次B样条拟合,在节点之间均匀插入指定个数点
// 输入参数： *pt ：给定点序列，执行完成后，会被替换成新的数据点
//            Num：节点点个数
//            *InsertNum: 节点之间需要插入的点个数指针 
// 返回值：   无返回值
//
// 编辑日期：   2014/12/07
//=================================================================
void CBSpline::TwoOrderBSplineInterpolatePt(CPosition*& pt, int& Num, int* InsertNum)
{
	if (pt == NULL || InsertNum == NULL) return;

	int InsertNumSum = 0;                               //  计算需要插入的点总数
	for (int i = 0; i < Num - 1; i++)  InsertNumSum += InsertNum[i];

	CPosition* temp = new CPosition[Num];               //  二次B样条不需要增加点数，需要将首尾点替换掉
	for (int i = 0; i < Num; i++)
		temp[i] = pt[i];

	temp[0].x = 2 * temp[0].x - temp[1].x;                  //  将折线两端点换成延长线上两点
	temp[0].y = 2 * temp[0].y - temp[1].y;

	temp[Num - 1].x = 2 * temp[Num - 1].x - temp[Num - 2].x;
	temp[Num - 1].y = 2 * temp[Num - 1].y - temp[Num - 2].y;

	delete[]pt;                                      //  点数由原来的Num个增加到Num+InsertNumSum个，删除旧的存储空间，开辟新的存储空间

	pt = new CPosition[Num + InsertNumSum];

	CPosition NodePt1, NodePt2, NodePt3, NodePt4;        //  两节点间均匀插入点，需要相邻两段样条曲线,因此需要四个节点

	double t;
	int totalnum = 0;
	for (int i = 0; i < Num - 1; i++)                          //  每条线段均匀插入点
	{
		if (i == 0)                                      //  第一段只需计算第一条样条曲线，无NodePt1
		{
			NodePt2 = temp[i]; NodePt3 = temp[i + 1]; NodePt4 = temp[i + 2];

			double dt = 0.5 / (InsertNum[i] + 1);
			for (int j = 0; j < InsertNum[i] + 1; j++)
			{
				t = 0 + dt * j;
				pt[totalnum].x = F02(t) * NodePt2.x + F12(t) * NodePt3.x + F22(t) * NodePt4.x;
				pt[totalnum].y = F02(t) * NodePt2.y + F12(t) * NodePt3.y + F22(t) * NodePt4.y;
				totalnum++;
			}
		}
		else if (i == Num - 2)                            //  最后一段只需计算最后一条样条曲线，无NodePt4
		{
			NodePt1 = temp[i - 1]; NodePt2 = temp[i]; NodePt3 = temp[i + 1];

			double dt = 0.5 / (InsertNum[i] + 1);
			for (int j = 0; j < InsertNum[i] + 2; j++)
			{
				t = 0.5 + dt * j;
				pt[totalnum].x = F02(t) * NodePt1.x + F12(t) * NodePt2.x + F22(t) * NodePt3.x;
				pt[totalnum].y = F02(t) * NodePt1.y + F12(t) * NodePt2.y + F22(t) * NodePt3.y;
				totalnum++;
			}
		}
		else
		{
			NodePt1 = temp[i - 1], NodePt2 = temp[i]; NodePt3 = temp[i + 1]; NodePt4 = temp[i + 2];    // NodePt1,2,3计算第一条曲线，NodePt2,3,4计算第二条曲线

			int LeftInsertNum, RightInsertNum;          //  计算线段间左右曲线段上分别需要插入的点数
			double rightoffset = 0;                      //  左边曲线段从t=0.5开始，又边曲线段从t=rightoffset开始
			double Leftdt = 0, Rightdt = 0;                 //  左右曲线取点t步长
			if (InsertNum[i] == 0)
			{
				LeftInsertNum = 0;
				RightInsertNum = 0;
			}
			else if (InsertNum[i] % 2 == 1)                //  插入点数为奇数，左边曲线段插入点个数比右边多一点
			{
				RightInsertNum = InsertNum[i] / 2;
				LeftInsertNum = RightInsertNum + 1;
				Leftdt = 0.5 / (LeftInsertNum);
				Rightdt = 0.5 / (RightInsertNum + 1);
				rightoffset = Rightdt;
			}
			else                                      //  插入点数为偶数，左右边曲线段插入个数相同
			{
				RightInsertNum = InsertNum[i] / 2;
				LeftInsertNum = RightInsertNum;
				Leftdt = 0.5 / (LeftInsertNum + 0.5);
				Rightdt = 0.5 / (RightInsertNum + 0.5);
				rightoffset = Rightdt / 2;
			}

			for (int j = 0; j < LeftInsertNum + 1; j++)
			{
				t = 0.5 + Leftdt * j;
				pt[totalnum].x = F02(t) * NodePt1.x + F12(t) * NodePt2.x + F22(t) * NodePt3.x;
				pt[totalnum].y = F02(t) * NodePt1.y + F12(t) * NodePt2.y + F22(t) * NodePt3.y;
				totalnum++;
			}

			for (int j = 0; j < RightInsertNum; j++)
			{
				t = rightoffset + Rightdt * j;
				pt[totalnum].x = F02(t) * NodePt2.x + F12(t) * NodePt3.x + F22(t) * NodePt4.x;
				pt[totalnum].y = F02(t) * NodePt2.y + F12(t) * NodePt3.y + F22(t) * NodePt4.y;
				totalnum++;
			}
		}
	}
	delete[]temp;
	Num = Num + InsertNumSum;

}
//================================================================
// 函数功能： 二次样条基函数
//
// 编辑日期：    2014/12/03
//================================================================
double CBSpline::F02(double t)
{
	return 0.5 * (t - 1) * (t - 1);
}
double CBSpline::F12(double t)
{
	return 0.5 * (-2 * t * t + 2 * t + 1);
}
double CBSpline::F22(double t)
{
	return 0.5 * t * t;
}
//========================================================================
// 函数功能： 三次B样条平滑，把给定的点，平滑到B样条曲线上，不增加点的数目
// 输入参数： *pt ：给定点序列，执行完成后，会被替换成新的平滑点
//            Num：点个数
// 返回值：   无返回值
//
// 编辑日期：    2014/12/03
//========================================================================
void CBSpline::ThreeOrderBSplineSmooth(CPosition* pt, int Num)
{
	CPosition* temp = new CPosition[Num + 2];
	for (int i = 0; i < Num; i++)
		temp[i + 1] = pt[i];

	temp[0].x = 2 * temp[1].x - temp[2].x;                  //  将折线延长线上两点加入作为首点和尾点
	temp[0].y = 2 * temp[1].y - temp[2].y;

	temp[Num + 1].x = 2 * temp[Num].x - temp[Num - 1].x;
	temp[Num + 1].y = 2 * temp[Num].y - temp[Num - 1].y;

	CPosition NodePt1, NodePt2, NodePt3, NodePt4;
	double t;
	for (int i = 0; i < Num - 1; i++)
	{
		NodePt1 = temp[i]; NodePt2 = temp[i + 1]; NodePt3 = temp[i + 2]; NodePt4 = temp[i + 3];

		if (i == Num - 4)                          //  最后一段取t=0.5和t=1点
		{
			t = 0;
			pt[i].x = F03(t) * NodePt1.x + F13(t) * NodePt2.x + F23(t) * NodePt3.x + F33(t) * NodePt4.x;
			pt[i].y = F03(t) * NodePt1.y + F13(t) * NodePt2.y + F23(t) * NodePt3.y + F33(t) * NodePt4.y;
			t = 1;
			pt[i + 1].x = F03(t) * NodePt1.x + F13(t) * NodePt2.x + F23(t) * NodePt3.x + F33(t) * NodePt4.x;
			pt[i + 1].y = F03(t) * NodePt1.y + F13(t) * NodePt2.y + F23(t) * NodePt3.y + F33(t) * NodePt4.y;
		}
		else                                      //  中间段取t=0.5点
		{
			t = 0;
			pt[i].x = F03(t) * NodePt1.x + F13(t) * NodePt2.x + F23(t) * NodePt3.x + F33(t) * NodePt4.x;
			pt[i].y = F03(t) * NodePt1.y + F13(t) * NodePt2.y + F23(t) * NodePt3.y + F33(t) * NodePt4.y;
		}
	}
	delete[]temp;
}

//================================================================
// 函数功能： 三次B样条拟合,在节点之间均匀插入指定个数点
// 输入参数： *pt ：给定点序列，执行完成后，会被替换成新的数据点
//            Num：节点点个数
//            *InsertNum: 节点之间需要插入的点个数指针 
// 返回值：   无返回值
//
// 编辑日期：   2014/12/07
//=================================================================
void CBSpline::ThreeOrderBSplineInterpolatePt(CPosition*& pt, int& Num, int* InsertNum)
{
	if (pt == NULL || InsertNum == NULL) return;

	int InsertNumSum = 0;                               //  计算需要插入的点总数
	for (int i = 0; i < Num - 1; i++)  InsertNumSum += InsertNum[i];

	CPosition* temp = new CPosition[Num + 2];
	for (int i = 0; i < Num; i++)
		temp[i + 1] = pt[i];

	temp[0].x = 2 * temp[1].x - temp[2].x;                  //  将折线延长线上两点加入作为首点和尾点
	temp[0].y = 2 * temp[1].y - temp[2].y;

	temp[Num + 1].x = 2 * temp[Num].x - temp[Num - 1].x;
	temp[Num + 1].y = 2 * temp[Num].y - temp[Num - 1].y;

	CPosition NodePt1, NodePt2, NodePt3, NodePt4;
	double t;

	delete[]pt;                                      //  点数由原来的Num个增加到Num+InsertNumSum个，删除旧的存储空间，开辟新的存储空间

	pt = new CPosition[Num + InsertNumSum];

	int totalnum = 0;
	for (int i = 0; i < Num - 1; i++)                          //  每条线段均匀插入点
	{
		NodePt1 = temp[i]; NodePt2 = temp[i + 1]; NodePt3 = temp[i + 2]; NodePt4 = temp[i + 3];
		double dt = 1.0 / (InsertNum[i] + 1);

		for (int j = 0; j < InsertNum[i] + 1; j++)
		{
			t = dt * j;
			pt[totalnum].x = F03(t) * NodePt1.x + F13(t) * NodePt2.x + F23(t) * NodePt3.x + F33(t) * NodePt4.x;
			pt[totalnum].y = F03(t) * NodePt1.y + F13(t) * NodePt2.y + F23(t) * NodePt3.y + F33(t) * NodePt4.y;
			totalnum++;
		}

		if (i == Num - 2) {              //  最后一个尾点
			t = 1;
			pt[totalnum].x = F03(t) * NodePt1.x + F13(t) * NodePt2.x + F23(t) * NodePt3.x + F33(t) * NodePt4.x;
			pt[totalnum].y = F03(t) * NodePt1.y + F13(t) * NodePt2.y + F23(t) * NodePt3.y + F33(t) * NodePt4.y;
			totalnum++;
		}
	}

	delete[]temp;
	Num = Num + InsertNumSum;

}

//================================================================
// 函数功能： 三次样条基函数
//
// 编辑日期：    2014/12/03
//================================================================
double CBSpline::F03(double t)
{
	return 1.0 / 6 * (-t * t * t + 3 * t * t - 3 * t + 1);
}
double CBSpline::F13(double t)
{
	return 1.0 / 6 * (3 * t * t * t - 6 * t * t + 4);
}
double CBSpline::F23(double t)
{
	return 1.0 / 6 * (-3 * t * t * t + 3 * t * t + 3 * t + 1);
}
double CBSpline::F33(double t)
{
	return 1.0 / 6 * t * t * t;
}

使用

#include "stdafx.h"
#include "math.h"
#include "BSpline.h"

int _tmain(int argc, _TCHAR* argv[])
{
	int num=8;
	double x[8]={9.59,60.81,105.57,161.59,120.5,100.1,50.0,10.0};
	double y[8]={61.97,107.13,56.56,105.27,120.5,150.0,110.0,180.0};

	CPosition *testpt=new CPosition[num];
	for(int i=0;i<num;i  ) testpt[i]=CPosition(x[i],y[i]);

	int *Intnum=new int[num-1]; 
	for(int i=0;i<num-1;i  ){
		Intnum[i]=10;  //  每一个样条曲线内插入10个点
	}

	int num2=num;
	CBSpline bspline;
	bspline.TwoOrderBSplineInterpolatePt(testpt,num2,Intnum);        //  二次B样条曲线
	//bspline.ThreeOrderBSplineInterpolatePt(testpt,num2,Intnum);    //  三次B样条曲线
	delete Intnum;


	FILE *fp_m_x = fopen("Bspline_test_x.txt", "wt");
	FILE *fp_m_y = fopen("Bspline_test_y.txt", "wt");
	for (int i = 0; i < num2; i  ){
		fprintf(fp_m_x, "%lf\n", testpt[i].x);
		fprintf(fp_m_y, "%lf\n", testpt[i].y);
	}
	fclose(fp_m_x);
	fclose(fp_m_y);

	return 0;
}

应用

自己测试的时候，使用60个点，在每两个点之间插值100个，得到的效果：

2次B样条曲线
希望记录下自己的一点一滴，慢慢成长。。
06-24 4831
void B2_Line(CDC *pDC,CPoint p1,CPoint p2,CPoint p3) { int x0=p1.x,y0=p1.y; int x1=p2.x,y1=p2.y; int x2=p3.x,y2=p3.y; float i,t,n=1000; i=1/n; double px,py; CPoint pp; px=x0; py=y
c++实现的二次B样条曲线绘制程序
03-26
c++实现的二次B样条曲线绘制程序，在屏幕上取点然后点绘制按钮即可绘制。
2次B样条曲线和3次B样条曲线的matlab绘制，适用于初学者
05-21
对多个点组成的数组进行插值拟合，在折点处得到光滑的曲线
简单的二次B样条曲线
weixin_34377919的博客
04-14 1568
//使用二次B样条曲线生成离散点 vector&lt;Point&gt;&amp; Route::bSpline() { double a0,a1,a2; double dt,t1,t2; Point tmp_p; //使首位相连 Point *newp = new Point[num_points+2]; for (int ...
MFC绘制二次均匀B样条曲线
ha0ha0xuexi的博客
06-15 1554
MFC绘制二次均匀B样条曲线 B样条具有比Bezier更好的局部修改性与凸包性，引入了节点与控制点一起控制曲线的生成，下面以二次均匀B样条的绘制为例，进行代码实现。 参考《计算几何算法与实现》–孔令德 新建MFC单文档程序，添加类Quadratic_BSpline，用来绘制曲线； #pragma once #include"P2.h" class Quadratic_BSpline { public: Quadratic_BSpline(void); ~Quadratic_BSpline(void)
二次与三次B样条曲线c++实现
热门推荐
jiangjjp2812的专栏
08-31 3万+
B样条曲线构建一条平滑曲线，接近而不通过控制点（首尾点除外）。如图 B样条曲线从Bezier曲线演变而来，了解B样条曲线首先得了解Bezier曲线。对于平面上的三个点P0，P1，P2，其坐标分别是(x0,y0)、(x1,y1)、(x2,y2)。二次Bezier曲线用一...
b样条曲线C语言代码-样条曲线算法实现代码-曲线拟合-曲线平滑-样条曲线计算-二次样条曲线-三次样条曲线
04-29
这是一份C语言版本的b样条曲线算法代码，可以实现二次和三次的b样条曲线绘制，可作为曲线平滑或者曲线拟合的代码使用。代码实现封装为连个函数，一个是实现给定三点或者四点计算样条曲线平滑点，一个是计算一些列...
b样条曲线python代码-样条曲线计算-二次样条曲线实现-三次样条曲线-曲线平滑算法-曲线拟合
04-29
这是一份python版本的b样条曲线算法代码，可以实现二次和三次的b样条曲线绘制，可作为曲线平滑或者曲线拟合的代码使用。代码实现封装为连个函数，一个是实现给定三点或者四点计算样条曲线平滑点，一个是计算一些列...
二、三次均匀B样条曲线.zip_B样条曲线_oxygeno8z_三次B样_二、三次均匀B样条曲线_二次b样条曲线
07-15
根据输入点坐标画出二次或三次均匀B样条曲线
二次与三次B样条曲线实现方法介绍
三次B样条曲线在每个控制点处都有二阶导数连续性（即C2连续性），这意味着曲线不仅在接点上平滑，而且曲线的弯曲程度（曲率）也是连续的。 三次B样条曲线的基函数通过de Boor-Cox递归公式求得，并且通常使用均匀B样...
B样条曲线,三次b样条曲线,matlab
09-10
本文将深入探讨B样条曲线的基本概念，尤其是2次和3次B样条曲线，并通过MATLAB这个强大的数值计算与图形化编程环境来阐述其绘制方法。 首先，我们了解B样条（Bezier Spline）的基础。B样条曲线由一系列控制点构成，...
2次和3次B样条曲线
06-21
这是我用vc做的关于B样条曲线的单文档程序，希望对大家有用
C++二次和三次B样条曲线
12-24
点击鼠标可以画出B样条曲线，VC++下编译通过，学OPENGL准备交作业的懂的~
B样条曲线的实现代码
12-06
该文档中包含了二次、三次B样条曲线的实现方法，可以进行整合调用
Pitstop Pro 11参考手册(中文版)
12-10
Pitstop Pro 11参考手册(中文版) 一共222页,内容蛮详细的 官方文档
B样条曲线
Glouds的专栏
12-24 9059
参考文献 B样条曲线 二次B样条曲线 代码实现参考文献B样条曲线 二次B样条曲线代码B样条曲线给定n+m+1n+m+1个平面或空间顶点Pi(i=0，1，…，n+m) P_i (i=0，1，…，n+m)，称为nn次参数曲线段： Pk,n(t)=∑i=0nPi+kGi,n(t) ,    t∈[0,1]P_{k,n}(t)=\sum_{i=0}^nP_{i+k}G_{i,n}(t)\space,\s
曲线拟合 | 二次B样条拟合曲线
最新发布
生物信息学专栏(BioMooc)
06-12 860
曲线平滑化的方法，C1级平滑的B样条曲线。
MFC绘制三次均匀B样条曲线
ha0ha0xuexi的博客
06-15 1699
MFC绘制三次均匀B样条曲线 基于de-Boor-Cox公式，实现B样条的绘制。 参考《计算几何算法与实现》–孔令德 节点矢量与控制点设置为： //节点初始化 knot[0]=-3/3.0, knot[1]=-2/3.0, knot[2]=-1/3.0; knot[3]=0.0, knot[4]=1/3.0, knot[5]=2/3.0; knot[6]=1.0, knot[7]= 4/3.0, knot[8]= 5/3.0; knot[9]=6/3.0; //控制点初始化 P
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值