Expérience 10 génération de courbes bezier - amélioration expérimentale - génération de courbes B - spline par point de contrôle

Ce code est basé sur les points de contrôle connus( 10, 5, 0 ),( 5, 10, 0 ),( -5, 15, 0 ),( -10, -5, 0 ),( 4, -4, 0 ),( 10, 5, 0 ), ( 5, 10, 0 ), ( -5, 15, 0 ), ( -10, -5, 0 ),( 10, 5, 0 )Pour générer trois foisBSpline.

#include <GL/glut.h>
#include <stdio.h>
#include <stdlib.h>
#include <vector>

using namespace std;

struct Point
{
    
	float c[2];
	float& x = c[0];
	float& y = c[1];

	Point() {
     x = 0, y = 0; }
	Point(float x0, float y0) {
     x = x0, y = y0; }
	Point(const Point& pt) {
     x = pt.x, y = pt.y; }
	float& operator[](const int i) {
     return c[i]; }
};

vector<Point> GctrlPt, GbsCurvePt;
int GnumSegment = 10;

void CalcBSPoints()
{
    
	int numCtrPt = GctrlPt.size();
	float F0[2], F1[2], F2[2], F3[2];

	float t = 0;
	float dt = 1 / (float)GnumSegment;

	//Premier paragrapheNumSubSegment + 1Un point, Après le deuxième paragraphe, chaque paragraphe est libellé comme suit: NumSubSegmentUn point, Parce que le point de départ après le deuxième paragraphe est la fin du paragraphe précédent 
	int numCurvePoint = (GnumSegment + 1) + GnumSegment * (numCtrPt - 4);
	GbsCurvePt.resize(numCurvePoint);

	// Le premier paragraphe commence par 0, Après le deuxième paragraphe, lire: 1, Voir ci - dessus pour les raisons 
	for (int i = 0; i < (numCtrPt - 3); i++)
	{
    
		for (int j = 0; j < 2; j++)
		{
    
			F0[j] = (GctrlPt[i][j] + 4 * GctrlPt[1 + i][j] + GctrlPt[2 + i][j]) / 6.0f;
			F1[j] = (-3 * GctrlPt[i][j] + 3 * GctrlPt[2 + i][j]) / 6.0f;
			F2[j] = (3 * GctrlPt[i][j] - 6 * GctrlPt[1 + i][j] + 3 * GctrlPt[2 + i][j]) / 6.0f;
			F3[j] = (-GctrlPt[i][j] + 3 * GctrlPt[1 + i][j] - 3 * GctrlPt[2 + i][j] + GctrlPt[3 + i][j]) / 6.0f;
		}

		t = (i == 0) ? 0 : dt;// Le paramètre de départ du premier segment est 0, Après le deuxième paragraphe, lire: dt,Pour les mêmes raisons
		for (int j = (i == 0) ? 0 : 1; j < GnumSegment + 1; j++)
		{
    
			for (int k = 0; k < 2; k++)
			{
    
				GbsCurvePt[j + GnumSegment * i][k] = F0[k] + F1[k] * t + F2[k] * t*t + F3[k] * t*t*t;
			}
			t += dt;
		}
	}
}

void ControlPoint(const vector<Point>& vpt)
{
    
	glPointSize(3);
	glBegin(GL_POINTS);
	for (unsigned int i = 0; i < vpt.size(); i++)
	{
    
		glVertex2f(vpt[i].x, vpt[i].y);
	}
	glEnd();
}

void PolylineGL(const vector<Point>& vpt)
{
    
	glBegin(GL_LINE_STRIP);
	for (unsigned int i = 0; i < vpt.size(); i++)
	{
    
		glVertex2f(vpt[i].x, vpt[i].y);
	}
	glEnd();
}

void myDisplay()
{
    
	glClear(GL_COLOR_BUFFER_BIT);
	glColor3f(1.0f, 0.0f, 0.0f);
	ControlPoint(GctrlPt);

	glColor3f(0.0f, 1.0f, 0.0f);
	PolylineGL(GctrlPt);

	if (GctrlPt.size() >= 4)
	{
    
		glColor3f(1.0f, 1.0f, 1.0f);
		CalcBSPoints();
		PolylineGL(GbsCurvePt);
	}

	glFlush();
}

void Init()
{
    
	glClearColor(0.0, 0.0, 0.0, 0.0);
	glShadeModel(GL_SMOOTH);

	float points[9][3] = {
     {
     10, 5, 0 },	{
     5, 10, 0 },	{
     -5, 15, 0 },	{
     -10, -5, 0 },	{
     4, -4, 0 },
	{
     10, 5, 0 },	{
     5, 10, 0 },	{
     -5, 15, 0 },	{
     -10, -5, 0 } };
	Point pt;
	for (int i = 0; i < 9; i++)
	{
    
		Point pt = Point(points[i][0], points[i][1]);
		GctrlPt.push_back(pt);
	}
}

void myReshape(int w, int h)
{
    
	glViewport(0, 0, (GLsizei)w, (GLsizei)h);
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	glOrtho(-30.0, 30.0, -30.0*(GLfloat)h / (GLfloat)w, 30.0*(GLfloat)h / (GLfloat)w, 0.0, 100.0);
}

int main(int argc, char *argv[])
{
    
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_RGB | GLUT_SINGLE);
	glutInitWindowPosition(100, 100);
	glutInitWindowSize(640, 480);
	glutCreateWindow("B-Spline Curve");

	Init();
	glutDisplayFunc(myDisplay);
	glutReshapeFunc(myReshape);
	glutMainLoop();
	return 0;
}