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; }