void writeToNrrd(float* data, int w, int h, int l, const char *name) {
char buffer[255];
// Write the header file
sprintf(buffer,"%s.nhdr",name);
std::ofstream fo(buffer, std::ios::binary);
sprintf(buffer,"%s.raw",name);
fo << "NRRD0004" << std::endl;
fo << "# Complete NRRD file format specification at: "<< std::endl;
fo << "# http://teem.sourceforge.net/nrrd/format.html"<< std::endl;
fo << "content: resample "<< std::endl;
fo << "type: float"<< std::endl;
fo << "dimension: 3"<< std::endl;
fo << "space: left-posterior-superior"<< std::endl;
fo << "sizes: " <<w << " " << h << " " << l << std::endl;
fo << "space directions: (1,0,0) (0,1,0) (0,0,1) "<< std::endl;
fo << "centerings: cell cell cell"<< std::endl;
fo << "kinds: domain domain domain"<< std::endl;
fo << "endian: little"<< std::endl;
fo << "encoding: raw"<< std::endl;
fo << "space origin: (0,0,0)"<< std::endl;
fo << "data file: " << buffer << std::endl;
fo.close();
unsigned int len = w * h * l;
std::ofstream fo1(buffer, std::ios::binary);
fo1.write((char*)data, len * sizeof(float));
fo1.close();
}
bool logical_and(T t)
{
///////////////////////////////////////////////////
FO1 fo1;
FO2 fo2;
///////////////////////////////////////////////////
return fo1(t) && fo2(t);
///////////////////////////////////////////////////
}
void QamTachymeter::drawBackground(QPainter& painter )
{
float w, h ; // épaisseur et longueur du trait de graduation
QColor black1(15,13,11) ;
QColor black2(34,32,27) ;
QColor white(210,200,190) ;
QColor red(221,65,57) ;
QColor yellow(205,185,83) ;
QColor green(101,149,112) ;
QFont fo1("arial.ttf", 60 ) ;
QFont fo2("arial.ttf", 50 ) ;
// fond
qfiBackground(painter, m_radius[ROTOR]+ 50, 10 ) ;
// graduations "Turbine"
painter.save() ;
painter.rotate( m_start[TURBINE] ) ;
for ( int i = 0 ; i <= ( m_max[TURBINE] - m_min[TURBINE] ) ; ++i ) {
if ( i % 10 == 0 ) { w = 20 ; h = 70 ; }
else if ( i % 5 == 0 ) { w = 10 ; h = 60 ; }
else { w = 4 ; h = 40 ; }
qfiMarker(painter, white, m_radius[TURBINE] - 10, QSize( w, h ) ) ;
painter.rotate( m_step[TURBINE] ) ;
}
painter.restore() ;
// sérigraphie "Turbine"
for ( int i = 0 ; i <= ( m_max[TURBINE] - m_min[TURBINE] ) ; i += 10 ) {
float alpha = qDegreesToRadians( m_start[TURBINE] + i * m_step[TURBINE] ) ;
float r = m_radius[TURBINE] - 120 ;
qfiText(painter, fo1, white, QPoint( r * qCos(alpha), r * qSin(alpha) ), QString("%1").arg(i) ) ;
}
qfiText(painter, fo1, white, QPoint( 0, 0.8 * m_radius[TURBINE] ), label(TURBINE) ) ;
qfiText(painter, fo2, white, QPoint( 0, 0.9 * m_radius[TURBINE] ), unit(TURBINE) ) ;
// seuils "Turbine"
w = 20 ; h = 90 ;
painter.save() ;
painter.rotate(m_start[TURBINE] + m_step[TURBINE] * lowThreshold(TURBINE) / 1000 ) ;
qfiMarker(painter, red, m_radius[TURBINE] - 10, QSize(w, h ) ) ;
painter.restore() ;
painter.save() ;
painter.rotate(m_start[TURBINE] + m_step[TURBINE] * highThreshold(TURBINE) / 1000 ) ;
qfiMarker(painter, red, m_radius[TURBINE] - 10, QSize(w, h ) ) ;
painter.restore() ;
// zones colorées "Turbine"
float radius = m_radius[TURBINE] - 80 ;
float start = m_start[TURBINE] + m_step[TURBINE] * lowThreshold(TURBINE) / 100 + 4 ;
float span = m_step[TURBINE] * ( ( ( highThreshold(TURBINE) - lowThreshold(TURBINE) ) / 1000 ) / 3 - 0.75 ) ;
qfiArc(painter, yellow, radius, start, span, 24 ) ;
start += span + 4 ;
span = m_step[TURBINE] * ( ( ( highThreshold(TURBINE) - lowThreshold(TURBINE) ) / 1000 ) / 3 - 0.5 ) ;
qfiArc(painter, green, radius, start, span, 24 ) ;
start += span + 4 ;
span = m_step[TURBINE] * ( ( ( highThreshold(TURBINE) - lowThreshold(TURBINE) ) / 1000 ) / 3 - 0.8 ) ;
qfiArc(painter, yellow, radius, start, span, 24 ) ;
// graduations "Rotor"
painter.save() ;
radius = m_radius[ROTOR] ;
qfiArc(painter, white, radius, m_start[ROTOR], m_span[ROTOR], 5 ) ;
QPen pen( white ) ;
pen.setWidth(1) ;
painter.setPen( pen ) ;
painter.setBrush( white ) ;
painter.rotate( m_start[ROTOR] ) ;
for ( int i = 0 ; i <= ( m_max[ROTOR] - m_min[ROTOR] ) ; ++i ) {
if ( i % 5 == 0 ) { w = 10 ; h = 60 ; }
else { w = 6 ; h = 40 ; }
qfiMarker(painter, white, m_radius[ROTOR], QSize(w, h ) ) ;
painter.rotate( m_step[ROTOR] ) ;
}
painter.restore() ;
// sérigraphie "Rotor"
for ( int i = 0 ; i <= ( m_max[ROTOR] - m_min[ROTOR] ) ; i += 10 ) {
float alpha = qDegreesToRadians( m_start[ROTOR] + i * m_step[ROTOR] ) ;
float r = m_radius[ROTOR] - 90 ;
qfiText(painter, fo2, white, QPoint( r * qCos(alpha), r * qSin(alpha) ), QString("%1").arg(i/10) ) ;
}
qfiText(painter, fo1, white, QPoint( 0, m_radius[ROTOR] / 4 ), label(ROTOR) ) ;
qfiText(painter, fo2, white, QPoint( 0, -m_radius[ROTOR] / 4 ), unit(ROTOR) ) ;
// seuils "Rotor"
w = 20 ; h = 100 ;
painter.save() ;
painter.rotate(m_start[ROTOR] + m_step[ROTOR] * lowThreshold(ROTOR) / 10 ) ;
qfiMarker(painter, red, m_radius[ROTOR] + 40, QSize(w, h ) ) ;
painter.restore() ;
painter.save() ;
painter.rotate(m_start[ROTOR] + m_step[ROTOR] * highThreshold(ROTOR) / 10 ) ;
qfiMarker(painter, red, m_radius[ROTOR] + 40, QSize(w, h ) ) ;
painter.restore() ;
// zones colorées "Rotor"
radius = m_radius[ROTOR] + 25 ;
start = m_start[ROTOR] + m_step[ROTOR] * lowThreshold(ROTOR) / 10 + 5 ;
span = m_step[ROTOR] * 3.5 ;
qfiArc(painter, yellow, radius, start, span, 24 ) ;
start += span + 5 ;
span = m_step[ROTOR] * ( ( highThreshold(ROTOR) - lowThreshold(ROTOR) ) / 10 - 5.5 ) ;
qfiArc(painter, green, radius, start, span, 24 ) ;
}
void QHA::drawForeground(QPainter& painter )
{
painter.save();
qfiBackground(painter, m_radius[QHE], 100) ;
painter.restore();
QColor black1(230,230,230) ;
QColor black2(160,160,160) ;
QColor yellow(250,250,0) ; //couleur triangle
QColor white (250,250,250);
QFont fo1("Arial", 100 ) ;
QFont fo2("Arial", 50 ) ;
QColor bleuexterieur (83,123,216);
QColor marronexterieur (76,36,11);
QColor bleuinterieur (83,123,216);
QColor marroninterieur (76,36,11);
// fond
QConicalGradient cg(QPointF(0.0, 0.0), 360 ) ;
cg.setColorAt(0.0, Qt::white ) ;
cg.setColorAt(1.0, QColor (139,69,19) ) ;
//pies bague
painter.save();
painter.rotate(0+value(QHE));
painter.setBrush(bleuexterieur);
//largeur hauteur élargie largeur elargie hauteur
painter.drawPie (-0.831*QFI_RADIUS, -0.83*QFI_RADIUS, 2.075*0.8*QFI_RADIUS, 2.07*0.8*QFI_RADIUS, 16*0,16*180);
painter.restore();
painter.save();
painter.rotate(0+value(QHE));
painter.setBrush(marronexterieur);
painter.drawPie (-0.831*QFI_RADIUS,-0.83*QFI_RADIUS, 2.075*0.8* QFI_RADIUS, 2.08*0.8 * QFI_RADIUS, 16*180,16*180);
painter.restore();
//pies rond central
painter.save();
painter.rotate(0+value(QHE));
painter.setBrush(bleuinterieur);
//largeur hauteur élargie largeur elargie hauteur
painter.drawPie (-0.635*QFI_RADIUS, -0.64*QFI_RADIUS, 1.59*0.8*QFI_RADIUS, 1.61*0.8*QFI_RADIUS, 16*0,16*180);
painter.restore();
painter.save();
painter.rotate(0+value(QHE));
//painter.translate(60, 60);
painter.setBrush(marroninterieur);
painter.drawPie (-0.635*QFI_RADIUS,-0.63*QFI_RADIUS, 1.59*0.8* QFI_RADIUS, 1.58*0.8 * QFI_RADIUS, 16*180,16*180);
painter.restore();
painter.save();
painter.rotate(0+value(QHE));
//triangles
float w = 0;
float h = 30;
float r = 0.64*QFI_RADIUS;
float hbis = h + 5 ;
QPolygon triangle, triangle2, triangle3;
triangle << QPoint ( r, 0) << QPoint (r + 1.5 * hbis, - 0.75 * hbis) << QPoint(r + 1.5 * hbis, 0.75* hbis) ;
triangle2 << QPoint ( r, 0) << QPoint (0.82*QFI_RADIUS, - hbis) << QPoint(0.82*QFI_RADIUS, hbis) ;
triangle3 << QPoint ( r, 0) << QPoint (0.45*QFI_RADIUS, - hbis) << QPoint(0.45*QFI_RADIUS, hbis );
painter.save();
// traingle graduation
painter.rotate(-90);
for ( int i = 0 ; i < 360 ; ++i) {
painter.save();
painter.setBrush(white);
if (i == 0) painter.drawConvexPolygon(triangle2);
painter.restore();
painter.save();
painter.setBrush(yellow);
if (i == 0) painter.drawConvexPolygon(triangle3);
painter.restore();
painter.save();
painter.setBrush(white);
if (i == 45)painter.drawConvexPolygon(triangle);
if (i == 315)painter.drawConvexPolygon(triangle);// BY AXEL
painter.restore();
if (i % 5 == 0) painter.drawRect(r, 10000, hbis, hbis );
else if (i % 5 == 0 ) painter.drawEllipse(r, 10000, hbis, hbis);
else qfiMarker(painter, white, r + h, QSize(w, h) ) ;
painter.rotate(1.0) ;
}
painter.restore();
//2 lignes rond central + ligne d'horiz
painter.setPen(QPen(Qt::white,3));
painter.save();
painter.drawLine(-314, 0, 317, 0);
painter.rotate(0+value(QHE2));
painter.restore();
painter.drawLine(-45, -150, 45, -150); //1 ligne (P)
painter.drawLine(-45, -100, 45, -100); //2 ligne (P)
// graduations
painter.save() ;
painter.rotate(180.0) ;
QPen pen( Qt::white ) ;
pen.setWidth(5) ;
painter.setPen( pen ) ;
for ( int i = 0 ; i < 31 ; ++i ) {
int len = ( (i % 5) == 0 ? 90: 0 ) ;
if (i != 15){
if (( i== 12) || (i == 13) | (i == 17) || (i == 18 ))
len = 45 ;
if (len != 0)
painter.drawLine(0.82 * QFI_RADIUS - 90, 0,0.82 * QFI_RADIUS - 90 + len, 0 );
}
painter.rotate(6.0) ;
}
painter.restore() ;
}
// pre: root != NULL
void doParse(ParseNode *root, std::string inFileName, std::string outBaseName)
{
std::map<std::string, std::string> firstManualToken;
FaSymbolTable symTab;
FaRuleIr ruleIr(&symTab);
// Iterate thru children of start symbol.
for(ParseNode::iterator_type i = root->begin(); i != root->end(); ++i)
{
ParseNode *statement = *i;
ParseNode *statementHead = *statement->begin();
std::string statementHeadText = statementHead->getTokenText();
if(statementHeadText.empty())
{
// name "::=" alternate { '|' alternate } ';'
// name ::= IDENT | "start" ;
///std::cout << "[name]" << std::endl;
std::string ruleName = (*statementHead->begin())->getTokenText();
ParseNode::iterator_type j = statement->begin();
++j; // skip ruleName
++j; // skip "::="
for(;;)
{
ParseNode *alternate = *j;
parseAlternate(symTab, ruleIr, alternate, ruleName);
++j; // skip alternate
if((*j)->getTokenText() != "|")
break; // found ';' at end
++j; // skip '|'
}
}
else
if(statementHeadText == "token")
{
for(ParseNode::iterator_type j = ++statement->begin(); j != statement->end(); ++j)
{
std::string s = (*j)->getTokenText();
if(s == ";")
break;
ruleIr.addToken(s);
}
}
else
if(statementHeadText == "keyword")
{
std::string s1 = (*(++statement->begin()))->getTokenText();
std::string s2 = (*(++(++statement->begin())))->getTokenText();
ruleIr.addKeyword(s1, s2);
}
else
if(statementHeadText == "copyright")
{
ruleIr.setCopyright(unquote((*(++statement->begin()))->getTokenText()));
}
else
if(statementHeadText == "prefix")
{
ruleIr.setPrefix(unquote((*(++statement->begin()))->getTokenText()));
}
else
if(statementHeadText == "manual")
{
ParseNode::iterator_type j = ++statement->begin();
std::string s0 = (*j)->getTokenText();
++j;
std::string s1 = unquote((*j)->getTokenText());
++j;
ruleIr.addToken(s0);
firstManualToken[s0] = s1;
if(s1.empty() || (s1.size() & 1) != 0)
{
std::string msg = "invalid manual token definition (both string literals must be nonempty and even in length)";
throw ParseSpecificError((*i)->getLine(), (*i)->getFile(), msg);
}
}
}
std::string err = ruleIr.convertGrammar();
if(!err.empty())
{
std::cerr << "error: " << inFileName << ": " << err << std::endl;
throw ParseError();
}
std::string fn1 = "out_" + outBaseName + "_parser.h";
std::string fn2 = "out_" + outBaseName + "_header.h";
std::string fn3 = "out_" + outBaseName + "_lexer.h";
std::ofstream fo1(fn1.c_str());
ruleIr.writeParser(fo1, fn1);
std::ofstream fo2(fn2.c_str());
ruleIr.writeHeader(fo2, fn2);
std::ofstream fo3(fn3.c_str());
ruleIr.writeLexer(fo3, fn3, firstManualToken);
}
int main()
{
FaSymbolTable symTab;
FaRuleIr ruleIr(&symTab);
ruleIr.setCopyright("Copyright (C) 2009 Willow Schlanger");
ruleIr.setPrefix("rc");
ruleIr.addToken("IDENT");
ruleIr.addToken("LITCHAR");
ruleIr.addToken("LITSTRING");
ruleIr.addKeyword("\"::=\"", "ISDEFAS");
// 'start' symbol.
{
FaNfa *fa;
bool ok;
unsigned q1;
fa = ruleIr.addProduction("start", q1);
unsigned q2 = ruleIr.addState(*fa);
ruleIr.makeFinal(*fa, q2);
ok = ruleIr.addEdge(*fa, q1, q2, "statement");
if(!ok) { std::cerr << "Error on line " << __LINE__ << std::endl; return 0; }
ok = ruleIr.addEdge(*fa, q2, q2, "statement");
if(!ok) { std::cerr << "Error on line " << __LINE__ << std::endl; return 0; }
}
// 'statement' symbol.
{
FaNfa *fa;
bool ok;
unsigned q1;
fa = ruleIr.addProduction("statement", q1);
unsigned q2 = ruleIr.addState(*fa);
unsigned q3 = ruleIr.addState(*fa);
unsigned q4 = ruleIr.addState(*fa);
ruleIr.makeFinal(*fa, q4);
ok = ruleIr.addEdge(*fa, q1, q2, "\"token\"");
if(!ok) { std::cerr << "Error on line " << __LINE__ << std::endl; return 0; }
ok = ruleIr.addEdge(*fa, q2, q3, "IDENT");
if(!ok) { std::cerr << "Error on line " << __LINE__ << std::endl; return 0; }
ok = ruleIr.addEdge(*fa, q3, q3, "IDENT");
if(!ok) { std::cerr << "Error on line " << __LINE__ << std::endl; return 0; }
ok = ruleIr.addEdge(*fa, q3, q4, "';'");
if(!ok) { std::cerr << "Error on line " << __LINE__ << std::endl; return 0; }
unsigned q10;
fa = ruleIr.addProduction("statement", q10);
unsigned q11 = ruleIr.addState(*fa);
unsigned q12 = ruleIr.addState(*fa);
unsigned q13 = ruleIr.addState(*fa);
unsigned q14 = ruleIr.addState(*fa);
ruleIr.makeFinal(*fa, q14);
ok = ruleIr.addEdge(*fa, q10, q11, "name");
if(!ok) { std::cerr << "Error on line " << __LINE__ << std::endl; return 0; }
ok = ruleIr.addEdge(*fa, q11, q12, "\"::=\"");
if(!ok) { std::cerr << "Error on line " << __LINE__ << std::endl; return 0; }
ok = ruleIr.addEdge(*fa, q12, q13, "alternate");
if(!ok) { std::cerr << "Error on line " << __LINE__ << std::endl; return 0; }
ok = ruleIr.addEdge(*fa, q13, q12, "'|'");
if(!ok) { std::cerr << "Error on line " << __LINE__ << std::endl; return 0; }
ok = ruleIr.addEdge(*fa, q13, q14, "';'");
if(!ok) { std::cerr << "Error on line " << __LINE__ << std::endl; return 0; }
unsigned q20;
fa = ruleIr.addProduction("statement", q20);
unsigned q21 = ruleIr.addState(*fa);
unsigned q22 = ruleIr.addState(*fa);
unsigned q23 = ruleIr.addState(*fa);
unsigned q24 = ruleIr.addState(*fa);
ruleIr.makeFinal(*fa, q24);
ok = ruleIr.addEdge(*fa, q20, q21, "\"keyword\"");
if(!ok) { std::cerr << "Error on line " << __LINE__ << std::endl; return 0; }
ok = ruleIr.addEdge(*fa, q21, q22, "LITSTRING");
if(!ok) { std::cerr << "Error on line " << __LINE__ << std::endl; return 0; }
ok = ruleIr.addEdge(*fa, q22, q23, "IDENT");
if(!ok) { std::cerr << "Error on line " << __LINE__ << std::endl; return 0; }
ok = ruleIr.addEdge(*fa, q23, q24, "';'");
if(!ok) { std::cerr << "Error on line " << __LINE__ << std::endl; return 0; }
unsigned q30;
fa = ruleIr.addProduction("statement", q30);
unsigned q31 = ruleIr.addState(*fa);
unsigned q32 = ruleIr.addState(*fa);
ruleIr.makeFinal(*fa, q32);
ok = ruleIr.addEdge(*fa, q30, q31, "\"copyright\"");
if(!ok) { std::cerr << "Error on line " << __LINE__ << std::endl; return 0; }
ok = ruleIr.addEdge(*fa, q31, q32, "LITSTRING");
if(!ok) { std::cerr << "Error on line " << __LINE__ << std::endl; return 0; }
unsigned q40;
fa = ruleIr.addProduction("statement", q40);
unsigned q41 = ruleIr.addState(*fa);
unsigned q42 = ruleIr.addState(*fa);
ruleIr.makeFinal(*fa, q42);
ok = ruleIr.addEdge(*fa, q40, q41, "\"prefix\"");
if(!ok) { std::cerr << "Error on line " << __LINE__ << std::endl; return 0; }
ok = ruleIr.addEdge(*fa, q41, q42, "LITSTRING");
if(!ok) { std::cerr << "Error on line " << __LINE__ << std::endl; return 0; }
}
// 'name' symbol.
{
FaNfa *fa;
bool ok;
unsigned q1;
fa = ruleIr.addProduction("name", q1);
unsigned q2 = ruleIr.addState(*fa);
ruleIr.makeFinal(*fa, q2);
ok = ruleIr.addEdge(*fa, q1, q2, "IDENT");
if(!ok) { std::cerr << "Error on line " << __LINE__ << std::endl; return 0; }
ok = ruleIr.addEdge(*fa, q1, q2, "\"start\"");
if(!ok) { std::cerr << "Error on line " << __LINE__ << std::endl; return 0; }
}
// 'alternate' symbol.
{
FaNfa *fa;
bool ok;
unsigned q1;
fa = ruleIr.addProduction("alternate", q1);
unsigned q2 = ruleIr.addState(*fa);
ruleIr.makeFinal(*fa, q2);
ok = ruleIr.addEdge(*fa, q1, q2, "symbol");
if(!ok) { std::cerr << "Error on line " << __LINE__ << std::endl; return 0; }
ok = ruleIr.addEdge(*fa, q2, q2, "symbol");
if(!ok) { std::cerr << "Error on line " << __LINE__ << std::endl; return 0; }
}
// 'symbol' symbol.
{
FaNfa *fa;
bool ok;
unsigned q1;
fa = ruleIr.addProduction("symbol", q1);
unsigned q2 = ruleIr.addState(*fa);
unsigned q3 = ruleIr.addState(*fa);
unsigned q4 = ruleIr.addState(*fa);
unsigned q5 = ruleIr.addState(*fa);
unsigned q6 = ruleIr.addState(*fa);
unsigned q7 = ruleIr.addState(*fa);
unsigned q8 = ruleIr.addState(*fa);
ruleIr.makeFinal(*fa, q2);
ruleIr.makeFinal(*fa, q5);
ruleIr.makeFinal(*fa, q8);
ok = ruleIr.addEdge(*fa, q1, q2, "item");
if(!ok) { std::cerr << "Error on line " << __LINE__ << std::endl; return 0; }
ok = ruleIr.addEdge(*fa, q1, q3, "'{'");
if(!ok) { std::cerr << "Error on line " << __LINE__ << std::endl; return 0; }
ok = ruleIr.addEdge(*fa, q3, q4, "alternate");
if(!ok) { std::cerr << "Error on line " << __LINE__ << std::endl; return 0; }
ok = ruleIr.addEdge(*fa, q4, q5, "'}'");
if(!ok) { std::cerr << "Error on line " << __LINE__ << std::endl; return 0; }
ok = ruleIr.addEdge(*fa, q1, q6, "'['");
if(!ok) { std::cerr << "Error on line " << __LINE__ << std::endl; return 0; }
ok = ruleIr.addEdge(*fa, q6, q7, "alternate");
if(!ok) { std::cerr << "Error on line " << __LINE__ << std::endl; return 0; }
ok = ruleIr.addEdge(*fa, q7, q8, "']'");
if(!ok) { std::cerr << "Error on line " << __LINE__ << std::endl; return 0; }
}
// 'item' symbol.
{
FaNfa *fa;
bool ok;
unsigned q1;
fa = ruleIr.addProduction("item", q1);
unsigned q2 = ruleIr.addState(*fa);
ruleIr.makeFinal(*fa, q2);
ok = ruleIr.addEdge(*fa, q1, q2, "LITCHAR");
if(!ok) { std::cerr << "Error on line " << __LINE__ << std::endl; return 0; }
ok = ruleIr.addEdge(*fa, q1, q2, "LITSTRING");
if(!ok) { std::cerr << "Error on line " << __LINE__ << std::endl; return 0; }
ok = ruleIr.addEdge(*fa, q1, q2, "IDENT");
if(!ok) { std::cerr << "Error on line " << __LINE__ << std::endl; return 0; }
}
std::string err;
err = ruleIr.convertGrammar();
if(!err.empty())
{
std::cerr << "bootstrap grammar error: " << err << std::endl;
return 1;
}
std::ofstream fo1("out_rulecom_parser.h");
std::ofstream fo2("out_rulecom_header.h");
ruleIr.writeParser(fo1, "out_rulecom_parser.h");
ruleIr.writeHeader(fo2, "out_rulecom_header.h");
return 0;
}
