��// B-Spline.
cpp
//////////////////////////////////////////////////////////////////////////////
// Note:
//
// This code is for demo purpose only.
// There is no warranty that my code is totally bug-free or no-harm at all,
// anyone likes to copy or try it has to take the risk by her or him-self.
//
// Copyright is reserved.
//
//
// Author comment:
// The major purpose of this program is used to demo how to convert any NURBS
// curve into poly-Bezier segments via the algorithm of my "Knots Equations".
//
// Once you finished a NURBS drawing with this program, you can verify it with
// OpenGL command "gluNurbsCurve()" by press the 'V' key.
//
//
// Author: Hunt Chang 20150524
//////////////////////////////////////////////////////////////////////////////
#include <direct.h>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <vector>
#include <crtdbg.h>
#include <freeglut.h>
// key function
//
// 2 Bez2 B-Spline curve
// 3 Bez3 B-Spline curve
// 4 Bez4 B-Spline curve
// c/C clear Control Points
// u/U Toggle Uniform or Non-Uniform B-Spline mode
// f/F Toggle clamped mode on first-end
// l/L Toggle clamped mode on last-end
// b/B if B-Spline is in closed loop then break it at its original ends
// k/K reset knots array
// h/H show BezPts[] of all Bez3 segments in Non-Uniform mode
// v/V if B-Spline is in Non-Uniform mode then verify it by a double draw of
B-Spline with OpenGL command
// s/S saveData(): CtrlPts/RingPts, OpenNuts/RingNuts & BezPts to
<dataLog.txt> file.
// ESC quit
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
class BitAry
std::vector<unsigned int> bits;
int _max;
public:
BitAry(int m = 0) { bits.resize(m/32+1); _max = m; }
void SetBit(int k)
_ASSERTE(k <= _max);
bits[k/32] |= (1 << (k%32));
void ClearBit(int k)
_ASSERTE(k <= _max);
bits[k/32] &= ~(1 << (k%32));
bool ChkBit(int k)
_ASSERTE(k <= _max);
unsigned int kk = k%32, bit = (bits[k/32] & (1 << kk));
return (1 == bit >> kk);
void SetAll()
_ASSERTE(_max > 0);
int n = bits.size();
memset(&bits[0], 0xFF, n*sizeof(int));
void Resize(int m)
bits.clear(); bits.resize(m/32+1);
_max = m;
};
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
const double FLT_EPSILON = 1.192092896e-07F;
struct Vec2D
double x, y;
Vec2D(double dx = 0.0, double dy = 0.0) { x = dx; y = dy; }
Vec2D operator-() { return Vec2D(-x, -y); }
Vec2D operator+(Vec2D pt) { return Vec2D(x+pt.x, y+pt.y); }
Vec2D operator-(Vec2D pt) { return Vec2D(x-pt.x, y-pt.y); }
Vec2D operator*(double d) { return Vec2D(x*d, y*d); }
Vec2D operator/(double d) { return Vec2D(x/d, y/d); }
bool operator==(Vec2D pt) { return (FLT_EPSILON >= abs(x-pt.x) &&
FLT_EPSILON >= abs(y-pt.y)); }
bool operator!=(Vec2D pt) { return (FLT_EPSILON < abs(x-pt.x) ||
FLT_EPSILON < abs(y-pt.y)); }
};
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
#define NoteMsg(msg) ::MessageBox(::GetActiveWindow(), msg, "Notice:",
MB_ICONINFORMATION)
enum BSpl_Const { QUAD = 2, CUBIC = 3, QUART = 4, };
#define SEG 64
#define KEY_ESC 27
// window size
int ww = 800;
int wh = 640;
int NDEG;
int pickRadius = 5;
int lIdx = -1; // used to remember the moving control index
bool bUnif = true; // set to use uniform B-Spline
bool bRing = false; // B-Spline is in Ring mode
bool bClampF = true; // set clamp at first end
bool bClampL = true; // set clamp at Last end
bool bVerify = false; // draw a verification curve by gluNurbsCurve()
command
bool bHull = false; // show poly-Bezier segments' control hull
char txtBuf[64];
char title[] = "NURBS";
char deg2[] = "Quadratic", deg3[] = "Cubic", deg4[] = "Quartic";
char typ0[] = "Uniform ", typ1[] = "Non-uniform ";
std::vector<Vec2D> CtrlPts; // core record of NURBS' control points
std::vector<Vec2D> RingPts; // RingPts[], control-points used by Ring-NURBS.
std::vector<double> coreNuts; // coreNuts is the base of Knots[]
std::vector<double> OpenNuts; // knots array used by Open-NURBS
std::vector<double> RingNuts; // knots array used by Ring-NURBS.
std::vector<Vec2D> BezPts; // this is the polyBez array used to draw NURBS.
std::vector<Vec2D> tFL(2); // records the cF(Cubic) or dF(Quartic) and bL of
polyBez.
BitAry Bits; // records the validity of each curve-segment.
GLUnurbsObj *pNurb = NULL;
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
void clearData()
bRing = false; CtrlPts.clear(); coreNuts.clear();
void drawCtrlPoly(int n, Vec2D pt[])
glLineWidth(1.0); glColor3f(0.85f, 0.85f, 0.98f); // silver
glPushAttrib(GL_ENABLE_BIT);
glLineStipple(1, 0x00FF);
glEnable(GL_LINE_STIPPLE);
glBegin(GL_LINE_STRIP);
for (int i=0; i<n; i++) glVertex2d(pt[i].x, pt[i].y);
glEnd();
glDisable(GL_LINE_STIPPLE);
glPopAttrib();
void drawPts(int n, Vec2D pt[])
glBegin(GL_POINTS);
for (int i=0; i<n; i++) glVertex2d(pt[i].x, pt[i].y);
glEnd();
void drawHullPts(int n, Vec2D pt[])
glBegin(GL_POINTS);
for (int i=0; i<n; i++) {
if (0 == i%NDEG) { glColor3f(0.66f,0.66f,0.66f); glPointSize(8.0);
} // gray
else { glColor3f(0.8f,0.5f,0.2f);
glPointSize(5.0); } // gold
glVertex2d(pt[i].x, pt[i].y);
glEnd();
void drawHullLine(int n, Vec2D pt[])
glPushAttrib(GL_ENABLE_BIT); glLineWidth(1.0);
glLineStipple(1, 0x0707); glEnable(GL_LINE_STIPPLE); // dashed
pattern
for (int j=0; j<n/NDEG; j++) {
if (! Bits.ChkBit(j)) continue;
glBegin(GL_LINE_STRIP);
for (int i=0; i<=NDEG; i++) glVertex2d(pt[j*NDEG+i].x,
pt[j*NDEG+i].y);
glEnd();
glDisable(GL_LINE_STIPPLE);
glPopAttrib();
}
void pickPt(int button, int state, int xPos, int yPos)
double dx, dy, newX = xPos, newY = wh - yPos; int n =
CtrlPts.size();
if (state == GLUT_DOWN) {
if (button == GLUT_LEFT_BUTTON) {
for (int i = 0; i < n; i++) {
dx = CtrlPts[i].x-newX; dy = CtrlPts[i].y-newY;
if (sqrt(dx*dx+dy*dy) <= pickRadius) {
lIdx = i; break;
if (state == GLUT_UP) {
if (button == GLUT_LEFT_BUTTON) {
if (-1 == lIdx) {
if (bRing) return;
CtrlPts.push_back(Vec2D(newX, newY));
} else if (-1 < lIdx) {
CtrlPts[lIdx].x = newX; CtrlPts[lIdx].y = newY;
if (bRing) {
if (0 == lIdx) CtrlPts[n-1] = CtrlPts[0];
else if (n-1 == lIdx) CtrlPts[0] = CtrlPts[n-1];
RingPts.clear();
lIdx = -1;
}
}
glutPostRedisplay();
void mouseMove(int xPos, int yPos)
int n = CtrlPts.size(), newX = xPos, newY = wh - yPos;
double dx, dy;
if (lIdx > -1) {
CtrlPts[lIdx].x = newX; CtrlPts[lIdx].y = newY;
if (n > 3) {
if (! bRing) {
if (0 == lIdx) {
dx = newX-CtrlPts[n-1].x; dy = newY-CtrlPts[n-1].y;
bRing = (sqrt(dx*dx+dy*dy) <= pickRadius) ? true : false;
if (bRing) { CtrlPts[n-1] = CtrlPts[0]; RingPts.clear();
}
} else if (n-1 == lIdx) {
dx = newX-CtrlPts[0].x; dy = newY-CtrlPts[0].y;
bRing = (sqrt(dx*dx+dy*dy) <= pickRadius) ? true : false;
if (bRing) { CtrlPts[0] = CtrlPts[n-1]; RingPts.clear();
}
} else {
if (0 == lIdx) CtrlPts[n-1] = CtrlPts[0];
if (n-1 == lIdx) CtrlPts[0] = CtrlPts[n-1];
RingPts.clear();
glutPostRedisplay();
}
void setKnots()
int n = CtrlPts.size(), ORD = NDEG+1, nNuts = n+ORD, m =
coreNuts.size();
if (m != nNuts) { RingPts.clear(); BezPts.clear(); }
coreNuts.resize(nNuts);
if (bUnif) {
for (int i=0; i<nNuts; i++) coreNuts[i] = i;
} else {
srand(GetTickCount());
if (0 == m) {
coreNuts[0] = 0;
for (int i=1; i<nNuts; i++) coreNuts[i] = coreNuts[i-1]+((double)
(rand() % 10));
} else if (m < nNuts) {
for (int i=m; i<nNuts; i++) coreNuts[i] = coreNuts[i-1]+((double)
(rand() % 10));
if (bRing) {
m = NDEG-1; nNuts += m; RingNuts.resize(nNuts);
int k = n+1; memcpy(&RingNuts[0], &coreNuts[0], sizeof(double)*k);
for (int i=k; i<nNuts; i++) RingNuts[i] = RingNuts[i-n+1]-RingNuts[i-
n]+RingNuts[i-1];
if (0 == RingPts.size()) {
k = n+m; RingPts.resize(k); memcpy(&RingPts[0], &CtrlPts[0],
sizeof(Vec2D)*n);
for (int i=n; i<k; i++) RingPts[i] = CtrlPts[i-n+1];
}
} else {
OpenNuts.resize(nNuts); memcpy(&OpenNuts[0], &coreNuts[0],
sizeof(double)*nNuts);
if (bClampF) { for (int i=NDEG; i>0; i--) OpenNuts[i-
1] = OpenNuts[i]; }
if (bClampL) { for (int i=n; i<(n+NDEG); i++)
OpenNuts[i+1] = OpenNuts[i]; }
void verifyGL(int nPt, Vec2D pt[], double nut[])
int ORD = NDEG+1, k = nPt+ORD;
std::vector<float> fPt(nPt*3); std::vector<float> fNut(k);
for(int j=0; j<nPt; ++j) { fPt[j*3] = (float) pt[j].x; fPt[j*3+1] =
(float) pt[j].y; fPt[j*3+2] = 0; }
for(int j=0; j<k; ++j) fNut[j] = (float) nut[j];
glLineWidth(1); glColor3ub(255,0,255); // purple B-Spline
pNurb = gluNewNurbsRenderer();
gluNurbsProperty(pNurb, GLU_SAMPLING_TOLERANCE, 15);
gluBeginCurve(pNurb);
gluNurbsCurve(pNurb, k, &fNut[0], 3, &fPt[0], ORD, GL_MAP1_VERTEX_3);
gluEndCurve(pNurb);
if (pNurb) gluDeleteNurbsRenderer(pNurb);
void drawBez2Cuv()
Vec2D A, B, pt; double u; int n = BezPts.size();
glLineWidth(1);
for (int j=0; j<n/QUAD; j++) {
if (! Bits.ChkBit(j)) continue;
B = BezPts[j*2+1]-BezPts[j*2]; A = BezPts[j*2+2]-
BezPts[j*2+1]*2+BezPts[j*2];
glBegin(GL_LINE_STRIP);
for (int k=0; k<=SEG; k++) {
u = ((double) k)/SEG; pt = (A*u+B*2)*u+BezPts[j*2];
glVertex2d(pt.x, pt.y);
glEnd();
void drawBez3Cuv()
Vec2D A, B, C, pt; double u; int n = BezPts.size();
glLineWidth(1);
for (int j=0; j<n/CUBIC; j++) {
if (! Bits.ChkBit(j)) continue;
A = BezPts[j*3+3]-BezPts[j*3]-(BezPts[j*3+2]-BezPts[j*3+1])*3;
C = BezPts[j*3+1]-BezPts[j*3]; B = BezPts[j*3+2]-
BezPts[j*3+1]*2+BezPts[j*3];
glBegin(GL_LINE_STRIP);
for (int k=0; k<=SEG; k++) {
u = ((double) k)/SEG; pt = (A*u*u+(B*u+C)*3)*u+BezPts[j*3];
glVertex2d(pt.x, pt.y);
glEnd();
void drawBez4Cuv()
{
Vec2D A, B, C, D, pt; double u, uu; int n = BezPts.size();
glLineWidth(1);
for (int j=0; j<n/QUART; j++) {
if (! Bits.ChkBit(j)) continue;
A = BezPts[j*4+4]+BezPts[j*4]+BezPts[j*4+2]*6-
(BezPts[j*4+3]+BezPts[j*4+1])*4;
B = BezPts[j*4+3]-BezPts[j*4]-(BezPts[j*4+2]-BezPts[j*4+1])*3;
D = BezPts[j*4+1]-BezPts[j*4]; C = BezPts[j*4+2]-
BezPts[j*4+1]*2+BezPts[j*4];
glBegin(GL_LINE_STRIP);
for (int k=0; k<=SEG; k++) {
u = ((double) k)/SEG; uu= u*u; pt = ((A*uu+C*6)*u+
(B*uu+D)*4)*u+BezPts[j*4];
glVertex2d(pt.x, pt.y);
glEnd();
void setPolyBez2(int n, double nut[], Vec2D pt[])
_ASSERTE(n > QUAD);
double d, t; int mx = n-2, m = mx*2+3, k = m-2;
std::vector<Vec2D> tv(m);
Bits.Resize(mx); Bits.SetAll(); tv[0] = pt[0]; tv[m-1] =
pt[n-1];
for (int i=0; i<mx; i++) {
tv[i*2+2] = pt[i+1]; d = nut[i+3]-nut[i+1];
if (0 != d) { t = (nut[i+2]-nut[i+1])/d; tv[i*2+1] = (pt[i+1]-
pt[i])*t+pt[i]; }
else {
Bits.ClearBit(i);
if (0 < i) Bits.ClearBit(i-1);
d = nut[mx+3]-nut[mx+1];
if (0 != d) { t = (nut[mx+2]-nut[mx+1])/d; tv[k] = (pt[n-1]-pt[n-
2])*t+pt[n-2]; }
else Bits.ClearBit(mx-1);
BezPts.resize(k); memcpy(&BezPts[0], &tv[1], sizeof(Vec2D)*k);
void setPolyBez3(int n, double nut[], Vec2D pt[])
_ASSERTE(n > CUBIC);
Vec2D cF, bL; int mx = n-3, m = mx*3+3, k = m-2;
std::vector<Vec2D> tv(m);
double t, d = nut[4]-nut[1]; Bits.Resize(mx); Bits.SetAll();
if (0 != d) { t = (nut[4]-nut[3])/d; tv[0] =
pt[0]*t+pt[1]*(1.0-t); }
for (int i=0; i<mx; i++) {
if (0 != (d = nut[i+5]-nut[i+2])) {
t = (nut[i+5]-nut[i+3])/d; tv[i*3+2] = pt[i+1]*t+pt[i+2]*(1.0-t);
t = (nut[i+5]-nut[i+4])/d; tv[i*3+3] = pt[i+1]*t+pt[i+2]*(1.0-t);
if (0 == (d = nut[i+4]-nut[i+2])) Bits.ClearBit(i);
else { t = (nut[i+3]-nut[i+2])/d; tv[i*3+1] =
tv[i*3+2]*t+tv[i*3]*(1.0-t); }
} else Bits.ClearBit(i);
if ((! Bits.ChkBit(i)) && (0 < i)) Bits.ClearBit(i-1);
if (0 != (d = nut[mx+5]-nut[mx+2])) {
t = (nut[mx+5]-nut[mx+3])/d; tv[m-1] = pt[n-2]*t+pt[n-1]*(1.0-t);
if (0 == (d = nut[mx+4]-nut[mx+2])) Bits.ClearBit(mx-1);
else { t = (nut[mx+3]-nut[mx+2])/d; tv[k] = tv[k+1]*t+tv[k-
1]*(1.0-t); }
} else Bits.ClearBit(mx-1);
BezPts.resize(k); memcpy(&BezPts[0], &tv[1], sizeof(Vec2D)*k);
tFL[0] = tv[0]; tFL[1] = tv[m-1];
void setPolyBez4(int n, double nut[], Vec2D pt[])
_ASSERTE(QUART < n || (3 < n && bRing));
Vec2D cF, bL, tp0, tp1; int k, mx = n-4, m = mx*4+3;
double d0, d1, d2, n0, n1, n2, t0, t1, t2, t3; std::vector<Vec2D>
tv(m);
Bits.Resize(mx); Bits.SetAll();
d0 = nut[5]-nut[1]; d1 = nut[6]-nut[2]; d2 = nut[5]-nut[2];
if (0 != d2) {
n0 = nut[5]-nut[4]; n1 = nut[4]-nut[2]; t0 = n0/d0; t1 =
n1/d1; t2 = n0/d2;
tv[0] = (pt[0]*t0+pt[1]*(1.0-t0))*t2+(pt[2]*t1+pt[1]*(1.0-t1))*(1.0-t2);
for (int i=0; i<mx; i++) {
d0 = nut[i+6]-nut[i+2]; d1 = nut[i+7]-nut[i+3]; d2 = nut[i+6]-
nut[i+3];
if (0 == d2) Bits.ClearBit(i);
else {
n0 = nut[i+4]-nut[i+3]; n1 = nut[i+6]-nut[i+4]; n2 = nut[i+5]-
nut[i+3];
t0 = n1/d0; t1 = n0/d1; t2 = n0/d2; t3 = n2/d1;
tp0 = pt[i+1]*t0+pt[i+2]*(1.0-t0); tp1 = pt[i+3]*t3+pt[i+2]*(1.0-t3);
tv[i*4+2] = tp0*(1.0-t2)+(pt[i+3]*t1+pt[i+2]*(1.0-t1))*t2;
n0 = nut[i+5]-nut[i+4]; t1 = n0/d2; t0 = (nut[i+5]-
nut[i+2])/d0;
tv[i*4+3] = tp0*(1.0-t1-t2)+tp1*t2+pt[i+2]*t1;
t2 = n2/d2; tv[i*4+4] = (pt[i+1]*(1.0-t0)+pt[i+2]*t0)*(1.0-
t2)+tp1*t2;
if (0 != n2) { t0 = n0/n2; tv[i*4+1] = tv[i*4]*t0+tv[i*4+2]*(1.0-
t0); }
else Bits.ClearBit(i);
if ((! Bits.ChkBit(i)) && (0 < i)) Bits.ClearBit(i-1);
d1 = nut[mx+7]-nut[mx+3]; d2 = nut[mx+6]-nut[mx+3]; k = m-2;
if (0 != d2) {
t1 = n0/d1; t2 = n0/d2; tv[m-1] = tp1*(1-t2)+(pt[n-1]*t1+pt[n-
2]*(1.0-t1))*t2;
if (0 != n1) { t1 = n0/n1; tv[k] = tv[k-1]*(1.0-
t1)+tv[k+1]*t1; }
else Bits.ClearBit(mx-1);
} else Bits.ClearBit(mx-1);
BezPts.resize(k); memcpy(&BezPts[0], &tv[1], sizeof(Vec2D)*k);
tFL[0] = tv[0]; tFL[1] = tv[m-1];
void saveData()
FILE *fp; char buf[8192], file[] = "\\dataLog.txt", nL[] =
"---------------- New Log ----------------\n", *p;
_getcwd(buf, _MAX_PATH);
_ASSERTE(NULL != buf);
strcat_s(buf, file);
int k, m, n, L, o; Vec2D *pt; double *dk;
n = ((bRing) ? RingPts.size() : CtrlPts.size());
if ((NDEG == QUAD && 3 > n) || (NDEG == CUBIC && 4 > n) || (NDEG == QUART && 5 >
n)) {
NoteMsg("Number of Control points are too few to draw a Curve-Segment. ");
return;
}
if (bRing) { pt = &RingPts[0]; dk = &RingNuts[0]; k =
RingNuts.size(); }
else { pt = &CtrlPts[0]; dk = &OpenNuts[0]; k = OpenNuts.size();
}
if (0 != (fopen_s(&fp, buf,"a+"))) return;
fwrite(nL, sizeof(nL), 1, fp);
if (NDEG == QUAD) p = deg2;
else if (NDEG == CUBIC) p = deg3;
else p = deg4;
m = sprintf_s(buf, 8192, "\t%s%s B-Spline; \tRing-mode: %s\n", ((bUnif) ? typ0 :
typ1), p, ((bRing) ? "ON" : "OFF"));
fwrite(buf, m, 1, fp);
// list control points
m = sprintf_s(buf, 8192, "Control Points: %d\n", n); L = 5; o = n/L;
for (int i=0; i<o; i++) {
for(int j=0; j<L; ++j) {
m += sprintf_s(buf+m, 8192-m, " (%.02f, %.02f); ", pt[i*L+j].x,
pt[i*L+j].y);
m += sprintf_s(buf+m, 8192-m, "\n");
o *= L; L = n%L;
if (0 < L) {
for(int j=0; j<L; ++j) {
m += sprintf_s(buf+m, 8192-m, " (%.02f, %.02f); ", pt[o+j].x, pt[o+j].y);
m += sprintf_s(buf+m, 8192-m, "\n");
fwrite(buf, m, 1, fp);
// list knots array
m = sprintf_s(buf, 8192, "Knots array: %d\n", k); L = 10; o = k/L;
for (int i=0; i<o; i++) {
m += sprintf_s(buf+m, 8192-m, " { ");
for(int j=0; j<L; ++j) {
m += sprintf_s(buf+m, 8192-m, "%.04f, ", dk[i*L+j]);
m += sprintf_s(buf+m, 8192-m, "}\n");
o *= L; L = k%L;
if (0 < L) {
m += sprintf_s(buf+m, 8192-m, " { ");
for(int j=0; j<L; ++j) {
m += sprintf_s(buf+m, 8192-m, "%.04f, ", dk[o+j]);
m += sprintf_s(buf+m, 8192-m, "}\n");
fwrite(buf, m, 1, fp);
// list BezPts & Bits redords
m = sprintf_s(buf, 8192, "Control Points of Poly-Bezier Curve:\n");
k = BezPts.size(); o = k/NDEG; pt = &BezPts[0];
for (int i=0; i<o; i++) {
m += sprintf_s(buf+m, 8192-m, " %s\t", ((Bits.ChkBit(i)) ? "VALID" :
"NULL"));
for(int j=0; j<NDEG; ++j) {
m += sprintf_s(buf+m, 8192-m, " (%.15f, %.15f); ", pt[i*NDEG+j].x,
pt[i*NDEG+j].y);
m += sprintf_s(buf+m, 8192-m, "\n");
m += sprintf_s(buf+m, 8192-m, "\t (%.15f, %.15f); \n\n", pt[k-1].x, pt[k-1].y);
fwrite(buf, m, 1, fp); fclose(fp); NoteMsg("Data have been saved.
");
void drawNURBS()
int n = CtrlPts.size(), m = n-4; Vec2D *pt; double *pNut;
if (0 == n) return;
glPointSize(4.0); glColor3f(1.0f, 0, 1.0f); // purple
drawPts(n, &CtrlPts[0]); drawCtrlPoly(n, &CtrlPts[0]);
if (bRing || (QUAD < n && NDEG == QUAD) || (CUBIC < n && NDEG == CUBIC) ||
(QUART < n && NDEG == QUART))
setKnots();
else return;
// set BezPts[]
if (bRing) { pt = &RingPts[0]; pNut = &RingNuts[0]; n =
RingPts.size(); }
else { pt = &CtrlPts[0]; pNut = &OpenNuts[0]; }
if (NDEG == QUAD) setPolyBez2(n, pNut, pt);
else if (NDEG == CUBIC) setPolyBez3(n, pNut, pt);
else if (NDEG == QUART) setPolyBez4(n, pNut, pt);
// draw B-Spline
if (bUnif) glColor3f(0,1.0f,0); // green uniform B-Spline
else glColor3f(0,0,1.0f); // blue non-uniform B-Spline
if (NDEG == QUAD) drawBez2Cuv();
else if (NDEG == CUBIC) drawBez3Cuv();
else if (NDEG == QUART) drawBez4Cuv();
// verify curve with OpenGL command
if (bVerify) {
verifyGL(n, pt, pNut); bVerify = false;
if (bHull) {
drawHullPts(BezPts.size(), &BezPts[0]);
if ((NDEG == CUBIC || NDEG == QUART) && (!bRing)) {
glColor3f(0,0,0); drawPts (2, &tFL[0]);
glColor3f(0,0.8f,0.8f); drawHullLine(BezPts.size(), &BezPts[0]); //
cyan
bHull = false;
void init()
NDEG = CUBIC; bUnif = bClampF = bClampL = false;
glClearColor(1.0, 1.0, 1.0, 0.0);
clearData();
void setTitle()
char *p;
int k = sprintf_s(txtBuf, 64, "%s: %s", title, ((bUnif) ? typ0 : typ1));
if (NDEG == QUAD) p = deg2;
else if (NDEG == CUBIC) p = deg3;
else p = deg4;
sprintf_s(txtBuf+k, 64-k, "%s mode", p);
void keyIn(unsigned char ch, int x, int y)
int oldMode = NDEG; bool bTxt = false;
switch(ch) {
case '2':
NDEG = QUAD;
if (oldMode == NDEG) return;
else { coreNuts.clear(); bTxt = true; }
break;
case '3':
NDEG = CUBIC;
if (oldMode == NDEG) return;
else { coreNuts.clear(); bTxt = true; }
break;
case '4':
NDEG = QUART;
if (oldMode == NDEG) return;
else { coreNuts.clear(); bTxt = true; }
break;
case 'u': case 'U':
bUnif = ! bUnif; RingPts.clear(); bTxt = true;
break;
case 'f': case 'F': bClampF = ! bClampF; break;
case 'l': case 'L': bClampL = ! bClampL; break;
case 'b': case 'B':
if (bRing) {
CtrlPts[0].x -= 15; CtrlPts[0].y += 15;
RingPts.clear(); bRing = false;
} else return;
break;
case 'k': case 'K':
if (bUnif) return;
else coreNuts.clear();
break;
case 'v': case 'V':
if ((QUAD == NDEG && 2 < CtrlPts.size()) || (CUBIC == NDEG && 3 <
CtrlPts.size()) || (QUART == NDEG && 4 < CtrlPts.size()))
bVerify = true;
else if (bRing && (QUART == NDEG && 3 < CtrlPts.size())) bVerify =
true;
else return;
break;
case 'h': case 'H':
if ((QUAD == NDEG && 2 < CtrlPts.size()) || (CUBIC == NDEG && 3 <
CtrlPts.size())) bHull = true;
else if (QUART == NDEG) {
if (bRing && 3 < CtrlPts.size()) bHull = true;
else if (4 < CtrlPts.size()) bHull = true;
else return;
break;
case 'c': case 'C': clearData(); break;
case 's': case 'S': saveData(); return;
case KEY_ESC: exit(EXIT_SUCCESS);
if (bTxt) { setTitle(); glutSetWindowTitle(txtBuf); }
glutPostRedisplay();
void display()
glClear(GL_COLOR_BUFFER_BIT);
drawNURBS();
glutSwapBuffers();
void reshape(int w, int h)
glViewport(0, 0, (GLsizei) w, (GLsizei) h);
ww = w; wh = h;
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0.0, w, 0.0, h);
void listCommand()
printf("\nkey function:\n\n");
printf("\tmouse-click\tadd new control point\n");
printf("\tmouse-drag \tmove control point\n");
printf("\t2\tdraw Quadratic B-Spline curve\n");
printf("\t3\tdraw Cubic B-Spline curve\n");
printf("\t4\tdraw Quartic B-Spline curve\n");
printf("\tu or U\ttoggle Uniform or Non-Uniform B-Spline mode\n");
printf("\tf or F\ttoggle clamped curve on first-end\n");
printf("\tl or L\ttoggle clamped curve on last-end\n");
printf("\tb or B\tbreak ring-curve mode\n");
printf("\tk or K\treset knot array (Non-Uniform mode only)\n");
printf("\th or H\tshow poly-Bezier control points\n");
printf("\tv or V\tverify NURBS curve by OpenGL-command <gluNurbsCurve()>\n");
printf("\tc or C\tclear all control point(s)\n");
printf("\ts or S\tsave data to file <dataLog.txt>\n");
printf("\tESC \tquit\n\n");
printf(" Author: Hunt Chang 20141130\n");
int main(int argc, char **argv)
glutInit(&argc, argv);
listCommand();
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
glutInitWindowSize(ww, wh);
glutInitWindowPosition(400,50);
setTitle();
glutCreateWindow(txtBuf);
glutDisplayFunc(display);
glutMouseFunc(pickPt);
glutMotionFunc(mouseMove);
glutKeyboardFunc(keyIn);
glutReshapeFunc(reshape);
init();
glutMainLoop();
return 0;
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
