openGL如何画有理B样条曲线和曲面?

[stef3390]

需要将iges文件里的数据读出来用openGL显示.

曲线的数据有基函数的阶, 节点序列的值, 加权值, 控制点, 始参数值, 终参数值, 单位法矢

曲面的数据就是两条曲线.

如何用openGL画出?

[schlafenhamster]

不知道有没有用：
// bspline.c
#include "bspline.h"
// spline control points 8s.
point control[]={// x== +
{0.19879,0.00000,0},
{0.22891,0.07229,0},
{0.36747,0.06626,0},
{0.55422,0.08434,0},
{0.72289,0.15663,0},
{0.78313,0.48193,0},
{0.80120,0.98193,0},
{0.90361,1.00000,0}};
/*********************************************************************
Parameters:
n - the number of control points minus 1
t - the degree of the polynomial plus 1
control - control point array made up of point stucture
output - array in which the calculate spline points are to be put
num_output - how many points on the spline are to be calculated

Pre-conditions:
n+2>t (no curve results if n+2<=t)
control array contains the number of points specified by n
output array is the proper size to hold num_output point structures
**********************************************************************/
int bspline(int n, int t, point *control, point *output, int num_output)
{
int u[20];//[n+t+1]=7+4+1=12
double increment,interval;
point calcxyz;
int output_index;

compute_intervals(u, n, t);
// how much parameter goes up each time
increment=(double) (n-t+2)/(num_output-1);
interval=0;

for (output_index=0; output_index<num_output-1; output_index++)
{
compute_point(u, n, t, interval, control, &calcxyz);
output[output_index].x = calcxyz.x;
output[output_index].y = calcxyz.y;
output[output_index].z = calcxyz.z;
interval=interval+increment; // increment our parameter
}
output[num_output-1].x=control[n].x;// put in the last point
output[num_output-1].y=control[n].y;
output[num_output-1].z=control[n].z;
// as many as you want !
return (output_index+1);// total
}
/* this function is recursive */
double blend(int k, int t, int *u, double v) // calculate the blending value
{
double value;

if (t==1) // base case for the recursion
{
if ((u[k]<=v) && (v<u[k+1])) value=1;
else value=0;
}
else
{
if ((u[k+t-1]==u[k]) && (u[k+t]==u[k+1])) // check for divide by zero
{
value = 0;
}
else if (u[k+t-1]==u[k]) // if a term's denominator is zero,use just the other
{
value = (u[k+t] - v) / (u[k+t] - u[k+1]) * blend(k+1, t-1, u, v);
}
else if (u[k+t]==u[k+1])
{
value = (v - u[k]) / (u[k+t-1] - u[k]) * blend(k, t-1, u, v);
}
else
{
value = (v - u[k]) / (u[k+t-1] - u[k]) * blend(k, t-1, u, v) +
(u[k+t] - v) / (u[k+t] - u[k+1]) * blend(k+1, t-1, u, v);
}
}
return value;
}
//
void compute_intervals(int *u, int n, int t) // figure out the knots
{
int j;

for (j=0; j<=n+t; j++)
{
if (j<t) u[j]=0;
else if ((t<=j) && (j<=n)) u[j]=j-t+1;
else if (j>n) u[j]=n-t+2;
// if n-t=-2 then we're screwed, everything goes to 0
}
}
//
void compute_point(int *u, int n, int t, double v, point *control, point *output)
{
int k;
double temp;

// initialize the variables that will hold our outputted point
output->x=0;
output->y=0;
output->z=0;

for (k=0; k<=n; k++)
{
temp = blend(k,t,u,v); // same blend is used for each dimension coordinate
output->x = output->x + (control[k]).x * temp;
output->y = output->y + (control[k]).y * temp;
output->z = output->z + (control[k]).z * temp;
}
}

[libralibra]

楼主有了阶, 节点序列的值, 加权值, 控制点这些参数
去看glut的gluNurbsSurface函数定义,opengl api有讲

[stef3390]

[Quote=引用 2 楼 libralibra 的回复:]

楼主有了阶, 节点序列的值, 加权值, 控制点这些参数
去看glut的gluNurbsSurface函数定义,opengl api有讲
[/Quote]

gluNurbsSurface函数得参数有点弄不明白啊

[Cacar]

找计算机图形学方面的书看一下，B样条、贝塞尔函数之类的，都有公式，根据几个控制点的位置，在其间插值就行~

[stef3390]

看来还是自己研究好了