int BrepHandler::extractEdge(const DirectoryEntry* edgeListDE, int index) { EdgeKey k = make_pair(edgeListDE, index); EdgeMap::iterator i = edges.find(k); if (i == edges.end()) { Pointer initVertexList; Integer initVertexIndex; Pointer termVertexList; Integer termVertexIndex; debug("########################## E X T R A C T E D G E"); ParameterData params; _iges->getParameter(edgeListDE->paramData(), params); int paramIndex = (index-1)*5 + 2; Pointer msCurvePtr = params.getPointer(paramIndex); initVertexList = params.getPointer(paramIndex+1); initVertexIndex = params.getInteger(paramIndex+2); termVertexList = params.getPointer(paramIndex+3); termVertexIndex = params.getInteger(paramIndex+4); // extract the model space curves int mCurveIndex = extractCurve(_iges->getDirectoryEntry(msCurvePtr), false); // extract the vertices int initVertex = extractVertex(_iges->getDirectoryEntry(initVertexList), initVertexIndex); int termVertex = extractVertex(_iges->getDirectoryEntry(termVertexList), termVertexIndex); edges[k] = handleEdge(mCurveIndex, initVertex, termVertex); return edges[k]; } else { return i->second; } }
void BrepHandler::extractFace(const DirectoryEntry* de, bool orientWithSurface) { // spec says the surface can be: // parametric spline surface // ruled surface // surface of revolution // tabulated cylinder // rational b-spline surface // offset surface // plane surface // rccyl surface // rccone surface // spherical surface // toroidal surface debug("########################## E X T R A C T F A C E"); ParameterData params; _iges->getParameter(de->paramData(), params); Pointer surfaceDE = params.getPointer(1); int surf = extractSurface(_iges->getDirectoryEntry(surfaceDE)); int face = handleFace(orientWithSurface, surf); int numLoops = params.getInteger(2); bool isOuter = params.getLogical(3) || true; // outer is not set in IGES from Pro/E! for (int i = 4; (i-4) < numLoops; i++) { Pointer loopDE = params.getPointer(i); extractLoop(_iges->getDirectoryEntry(loopDE), isOuter, face); isOuter = false; } }
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::extractLoop(const DirectoryEntry* de, bool isOuter, int face) { debug("########################## E X T R A C T L O O P"); ParameterData params; _iges->getParameter(de->paramData(), params); int loop = handleLoop(isOuter, face); int numberOfEdges = params.getInteger(1); int i = 2; // extract the edge uses! for (int _i = 0; _i < numberOfEdges; _i++) { bool isVertex = (1 == params.getInteger(i)) ? true : false; Pointer edgePtr = params.getPointer(i+1); int index = params.getInteger(i+2); // need to get the edge list, and extract the edge info int edge = extractEdge(_iges->getDirectoryEntry(edgePtr), index); bool orientWithCurve = params.getLogical(i+3); // handle this edge handleEdgeUse(edge, orientWithCurve); // deal with param-space curves (not generally included in Pro/E output) int numCurves = params.getInteger(i+4); int j = i+5; list<PSpaceCurve> pCurveIndices; for (int _j = 0; _j < numCurves; _j++) { // handle the param-space curves, which are generally not included in MSBO Logical iso = params.getLogical(j); Pointer ptr = params.getPointer(j+1); pCurveIndices.push_back(PSpaceCurve(_iges, this, iso, ptr)); j += 2; } i = j; } return loop; }
void BrepHandler::extractShell(const DirectoryEntry* de, bool isVoid, bool orientWithFace) { debug("########################### E X T R A C T S H E L L"); ParameterData params; _iges->getParameter(de->paramData(), params); handleShell(isVoid, orientWithFace); int numFaces = params.getInteger(1); for (int i = 1; i <= numFaces; i++) { Pointer facePtr = params.getPointer(i*2); bool orientWithSurface = params.getLogical(i*2+1); DirectoryEntry* faceDE = _iges->getDirectoryEntry(facePtr); extractFace(faceDE, orientWithSurface); } }
void BrepHandler::extractBrep(const DirectoryEntry* de) { debug("########################### E X T R A C T B R E P"); ParameterData params; _iges->getParameter(de->paramData(), params); Pointer shell = params.getPointer(1); extractShell(_iges->getDirectoryEntry(shell), false, params.getLogical(2)); int numVoids = params.getInteger(3); if (numVoids <= 0) return; int index = 4; for (int i = 0; i < numVoids; i++) { shell = params.getPointer(index); extractShell(_iges->getDirectoryEntry(shell), true, params.getLogical(index+1)); index += 2; } }
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; }