int
BrepHandler::extractCircularArc(const DirectoryEntry* de, const ParameterData& params) {
point_t center, start, end;
double offset_z = params.getReal(1);
center[X] = params.getReal(2);
center[Y] = params.getReal(3);
center[Z] = offset_z;
start[X] = params.getReal(4);
start[Y] = params.getReal(5);
start[Z] = offset_z;
end[X] = params.getReal(6);
end[Y] = params.getReal(7);
end[Z] = offset_z;
mat_t xform;
MAT_IDN(xform);
_iges->getTransformation(de->xform(), xform);
// choose the circle/interval representation
// so, calculate the circle params, and then the angle the arc subtends
double dx = start[X] - center[X];
double dy = start[Y] - center[Y];
double radius = sqrt(dx*dx + dy*dy);
point_t tcenter, tstart, tend;
MAT4X3PNT(tcenter, xform, center);
MAT4X3PNT(tstart, xform, start);
MAT4X3PNT(tend, xform, end);
vect_t normal = {0,0,1};
vect_t tnormal;
MAT4X3VEC(tnormal, xform, normal);
return handleCircularArc(radius, tcenter, tnormal, tstart, tend);
}
int
BrepHandler::extractVertex(const DirectoryEntry* de, int index) {
VertKey k = make_pair(de,index);
VertMap::iterator i = vertices.find(k);
if (i == vertices.end()) {
// XXX: fix this...
ParameterData params;
_iges->getParameter(de->paramData(), params);
int num_verts = params.getInteger(1);
debug("num verts: " << num_verts);
debug("index : " << index);
assert(index <= num_verts);
int i = 3*index-1;
point_t pt;
pt[X] = params.getReal(i);
pt[Y] = params.getReal(i+1);
pt[Z] = params.getReal(i+2);
// XXX: xform matrix application?
vertices[k] = handleVertex(pt);
return vertices[k];
} else {
return i->second;
}
}
int
BrepHandler::extractLine(const DirectoryEntry* de, const ParameterData& params)
{
point_t start, end;
start[X] = params.getReal(1);
start[Y] = params.getReal(2);
start[Z] = params.getReal(3);
end[X] = params.getReal(4);
end[Y] = params.getReal(5);
end[Z] = params.getReal(6);
// probably need to transform this line?
return handleLine(start, end);
}
int
BrepHandler::extractSurfaceOfRevolution(const ParameterData& params) {
Pointer linePtr = params.getPointer(1);
Pointer curvePtr = params.getPointer(2);
double startAngle = params.getReal(3);
double endAngle = params.getReal(4);
// load the line (axis of revolution)
int line = extractLine(linePtr);
// load the curve (generatrix)
int curve = extractCurve(_iges->getDirectoryEntry(curvePtr), false);
return handleSurfaceOfRevolution(line, curve, startAngle, endAngle);
}
int
BrepHandler::extractRationalBSplineCurve(const DirectoryEntry* de, const ParameterData& params) {
int k = params.getInteger(1);
int degree = params.getInteger(2);
bool planar = (params.getInteger(3)() == 1) ? true : false;
bool closed = (params.getInteger(4)() == 1) ? true : false;
bool rational = (params.getInteger(5)() == 0) ? true : false;
bool periodic = (params.getInteger(6)() == 1) ? true : false;
int num_control_points = k + 1;
int n = k + 1 - degree;
int num_knots = n + 2 * degree + 1;
double* knots = new double[num_knots];
int i = 7;
for (int _i = 0; _i < num_knots; _i++) {
knots[_i] = params.getReal(i);
i++;
}
double* weights = new double[num_control_points];
for (int _i = 0; _i < num_control_points; _i++) {
weights[_i] = params.getReal(i);
i++;
}
double* ctl_points = new double[num_control_points * 3];
for (int _i = 0; _i < num_control_points; _i++) {
ctl_points[_i*3] = params.getReal(i);
ctl_points[_i*3+1] = params.getReal(i+1);
ctl_points[_i*3+2] = params.getReal(i+2);
i += 3;
}
double umin = params.getReal(i); i++;
double umax = params.getReal(i); i++;
vect_t unit_normal;
if (planar) {
VSET(unit_normal, params.getReal(i), params.getReal(i+1), params.getReal(i+2));
i += 3;
}
int val = handleRationalBSplineCurve(degree,
umin,
umax,
planar,
unit_normal,
closed,
rational,
periodic,
num_knots,
knots,
num_control_points,
weights,
ctl_points);
delete [] knots;
delete [] weights;
delete [] ctl_points;
return val;
}
int
BrepHandler::extractRationalBSplineSurface(const ParameterData& params) {
// possible to do optimization of form type???
// see spec
const int ui = params.getInteger(1);
const int vi = params.getInteger(2);
int u_degree = params.getInteger(3);
int v_degree = params.getInteger(4);
bool u_closed = params.getInteger(5)() == 1;
bool v_closed = params.getInteger(6)() == 1;
bool rational = params.getInteger(7)() == 0;
bool u_periodic = params.getInteger(8)() == 1;
bool v_periodic = params.getInteger(9)() == 1;
const int n1 = 1+ui-u_degree;
const int n2 = 1+vi-v_degree;
const int u_num_knots = n1 + 2 * u_degree;
const int v_num_knots = n2 + 2 * v_degree;
const int num_weights = (1+ui)*(1+vi);
// read the u knots
int i = 10; // first u knot
double* u_knots = new double[u_num_knots+1];
for (int _i = 0; _i <= u_num_knots; _i++) {
u_knots[_i] = params.getReal(i);
i++;
}
i = 11 + u_num_knots; // first v knot
double* v_knots = new double[v_num_knots+1];
for (int _i = 0; _i <= v_num_knots; _i++) {
v_knots[_i] = params.getReal(i);
i++;
}
// read the weights (w)
i = 11 + u_num_knots + v_num_knots;
double* weights = new double[num_weights];
for (int _i = 0; _i < num_weights; _i++) {
weights[_i] = params.getReal(i);
i++;
}
// read the control points
i = 12 + u_num_knots + v_num_knots + num_weights;
double* ctl_points = new double[(ui+1)*(vi+1)*3];
const int numu = ui+1;
const int numv = vi+1;
for (int _v = 0; _v < numv; _v++) {
for (int _u = 0; _u < numu; _u++) {
int index = _v*numu*3 + _u*3;
ctl_points[index+0] = params.getReal(i);
ctl_points[index+1] = params.getReal(i+1);
ctl_points[index+2] = params.getReal(i+2);
i += 3;
}
}
// read the domain intervals
double umin = params.getReal(i);
double umax = params.getReal(i+1);
double vmin = params.getReal(i+2);
double vmax = params.getReal(i+3);
debug("u: [" << umin << "," << umax << "]");
debug("v: [" << vmin << "," << vmax << "]");
int controls[] = {ui+1,vi+1};
int degrees[] = {u_degree,v_degree};
int index = handleRationalBSplineSurface( controls,
degrees,
u_closed,
v_closed,
rational,
u_periodic,
v_periodic,
u_num_knots+1,
v_num_knots+1,
u_knots,
v_knots,
weights,
ctl_points);
delete [] ctl_points;
delete [] weights;
delete [] v_knots;
delete [] u_knots;
return index;
}
