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;
}
}
/**
* Set parameters. Use all the parameters in the reader.
*/
void SeparatedOutput::setParameters(const ParameterData& pr) {
std::vector<std::string> l = pr.getList();
std::vector<std::string>::const_iterator p;
for (p = l.begin(); p != l.end(); ++p) {
params.push_back(*p+" = "+pr.getString(*p));
}
}
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);
}
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;
}
}
void CD3DTable::setParameters(const ParameterData& p) {
if (p.contains("D")) {
D = p.getValue("D");
}
if (p.contains("H")) {
H = p.getValue("H");
}
}
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);
}
QVariant ParamItemModel::data(const QModelIndex& index, int role) const
{
if (!index.isValid())
{
return QVariant();
}
TreeNode* pNode = static_cast<TreeNode*>(index.internalPointer());
ParameterBaseData* pData = static_cast<ParameterBaseData*>(pNode->getData());
switch (role)
{
case Qt::ToolTipRole:
{
ParameterData* pParameterData = static_cast<ParameterData*>(pData);
Parameter* pParameter = pParameterData->getParameter();
if (pParameter)
{
return pParameter->getDescription();
}
break;
}
case Qt::DisplayRole:
{
if (index.column()==0)
{
return pData->getName();
}
break;
}
case Qt::EditRole:
{
if (index.column() == 1)
{
ParameterData* pParameterData = static_cast<ParameterData*>(pData);
QVariant variant;
variant.setValue(*pParameterData->getParameter());
return variant;
}
break;
}
default:
{
break;
}
}
return QVariant();
}
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);
}
}
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 WCVTable::setParameters(const ParameterData& p) {
if (p.contains("WCV_DTHR")) {
DTHR = p.getValue("WCV_DTHR");
}
if (p.contains("WCV_ZTHR")) {
ZTHR = p.getValue("WCV_ZTHR");
}
if (p.contains("WCV_TTHR")) {
TTHR = p.getValue("WCV_TTHR");
}
if (p.contains("WCV_TCOA")) {
TCOA = p.getValue("WCV_TCOA");
}
}
void ParamItemModel::setDataNoUndo( const QModelIndex& index,
const QVariant& newData,
int role)
{
TreeNode* pNode = static_cast<TreeNode*>(index.internalPointer());
ParameterBaseData* pData = static_cast<ParameterBaseData*>(pNode->getData());
// Data given by the editor
switch (role)
{
case Qt::EditRole:
{
switch (pData->getType())
{
case ParameterBaseData::GROUP:
case ParameterBaseData::PARAMETER:
{
ParameterData* pParameterData = static_cast<ParameterData*>(pData);
const Parameter& newParameter = newData.value<Parameter>();
pParameterData->getParameter()->setValue(newParameter.getValue());
// Disable stack to avoid new undo commands
QUndoStack* pStack = getUndoStack();
setUndoStack(NULL);
emit dataChanged(index, index);
setUndoStack(pStack);
break;
}
default:
{
break;
}
}
break;
}
}
}
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 TCASTable::updateParameterData(ParameterData& p) const {
p.setBool("TCAS_HMDilter", HMDFilter);
for (int i = 0; i < 7; i++) {
p.setInternal("TCAS_TAU_"+Fmi(i+2),TAU[i],"s",4);
}
for (int i = 0; i < 7; i++) {
p.setInternal("TCAS_TCOA_"+Fmi(i+2),TCOA[i],"s",4);
}
for (int i = 0; i < 7; i++) {
p.setInternal("TCAS_DMOD_"+Fmi(i+2),DMOD[i],"nmi",4);
}
for (int i = 0; i < 7; i++) {
p.setInternal("TCAS_ZTHR_"+Fmi(i+2),ZTHR[i],"ft",4);
}
for (int i = 0; i < 7; i++) {
p.setInternal("TCAS_HMD_"+Fmi(i+2),HMD[i],"ft",4);
}
}
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;
}
}
void TCASTable::setParameters(const ParameterData& p) {
if (p.contains("TCAS_HMDilter")) {
HMDFilter = p.getBool("TCAS_HMDilter");
}
for (int i = 0; i < 7; i++) {
if (p.contains("TCAS_TAU_"+Fmi(i+2))) {
TAU[i] = p.getValue("TCAS_TAU_"+Fmi(i+2));
}
}
for (int i = 0; i < 7; i++) {
if (p.contains("TCAS_TCOA_"+Fmi(i+2))) {
TCOA[i] = p.getValue("TCAS_TCOA_"+Fmi(i+2));
}
}
for (int i = 0; i < 7; i++) {
if (p.contains("TCAS_DMOD_"+Fmi(i+2))) {
DMOD[i] = p.getValue("TCAS_DMOD_"+Fmi(i+2));
}
}
for (int i = 0; i < 7; i++) {
if (p.contains("TCAS_ZTHR_"+Fmi(i+2))) {
ZTHR[i] = p.getValue("TCAS_ZTHR_"+Fmi(i+2));
}
}
for (int i = 0; i < 7; i++) {
if (p.contains("TCAS_HMD_"+Fmi(i+2))) {
HMD[i] = p.getValue("TCAS_HMD_"+Fmi(i+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;
}
void WCV_tvar::updateParameterData(ParameterData& p) const {
table.updateParameterData(p);
p.set("id",id);
}
void WCV_tvar::setParameters(const ParameterData& p) {
table.setParameters(p);
if (p.contains("id")) {
id = p.getString("id");
}
}
void WCVTable::updateParameterData(ParameterData& p) const {
p.setInternal("WCV_DTHR",DTHR,"nmi",4);
p.setInternal("WCV_ZTHR",ZTHR,"ft",4);
p.setInternal("WCV_TTHR",TTHR,"s",4);
p.setInternal("WCV_TCOA",TCOA,"s",4);
}
void CD3DTable::updateParameterData(ParameterData& p) const {
p.setInternal("D",D,"nmi");
p.setInternal("H",H,"ft");
}
// Set value of property from parameter.
void
PropertyBoolean::set(const ParameterData ¶meter)
{
_val = parameter.asBool();
}
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;
}
int main(int argc, const char* argv[]) {
DaidalusBatch walker;
int a;
std::string config = "";
std::string output = "";
std::string options = "";
ParameterData params;
int precision = 6;
for (a=1;a < argc && argv[a][0]=='-'; ++a) {
std::string arga = argv[a];
options += arga + " ";
if (walker.processOptions(argv,a)) {
++a;
options += walker.getOptionsString();
} if (arga == "--help" || arga == "-help" || arga == "-h") {
DaidalusBatch::printHelpMsg();
} else if (startsWith(arga,"--conf") || startsWith(arga,"-conf") || arga == "-c") {
config = argv[++a];
arga = argv[a];
options += arga + " ";
} else if (startsWith(arga,"--out") || startsWith(arga,"-out") || arga == "-o") {
output = argv[++a];
arga = argv[a];
} else if (arga == "--verbose" || arga == "-verbose" || arga == "-v") {
walker.verbose = true;
} else if (arga == "--raw" || arga == "-raw" || arga == "-r") {
walker.raw = true;
} else if (arga == "--pvs" || arga == "-pvs") {
walker.format = PVS;
} else if (startsWith(arga,"--proj") || startsWith(arga,"-proj")) {
++a;
walker.prj_t = Util::parse_double(argv[a]);
options += arga+" ";
} else if (startsWith(arga,"-") && arga.find('=') != std::string::npos) {
std::string keyval = arga.substr(arga.find_last_of('-')+1);
params.set(keyval);
} else if (argv[a][0] == '-') {
std::cout << "Invalid option: " << arga << std::endl;
exit(0);
}
}
std::vector<std::string> txtFiles = std::vector<std::string>();
for (;a < argc; ++a) {
std::string arga(argv[a]);
txtFiles.push_back(arga);
}
if (txtFiles.empty()) {
walker.printHelpMsg();
}
std::ofstream fout;
if (output != "") {
fout.open(output.c_str());
walker.out = &fout;
}
Daidalus daa;
if (config != "") {
daa.parameters.loadFromFile(config);
}
if (params.size() > 0) {
daa.parameters.setParameters(params);
}
switch (walker.format) {
case STANDARD:
if (walker.verbose) {
(*walker.out) << "# " << Daidalus::release() << std::endl;
(*walker.out) << "# Options: " << options << std::endl;
(*walker.out) << "#\n" << daa.toString() << "#\n" << std::endl;
}
break;
case PVS:
(*walker.out) << "%%% " << Daidalus::release() << std::endl;
(*walker.out) << "%%% Options: " << options << std::endl;
(*walker.out) << "%%% Parameters:\n"+daa.parameters.toPVS(precision) << std::endl;
break;
default:
break;
}
for (unsigned int i=0; i < txtFiles.size(); ++i) {
std::string filename(txtFiles[i]);
switch (walker.format) {
case STANDARD:
(*walker.out) << "# File: "<< filename << std::endl;
break;
case PVS:
(*walker.out) << "%%% File: " << filename << std::endl;
break;
default:
break;
}
walker.processFile(filename,daa);
}
if (output != "") {
fout.close();
}
}//main
// Set value of property from parameter.
void
PropertyFloat::set(const ParameterData ¶meter)
{
_val = parameter.asFloat();
}
