int main(int args, char * argsv[])
{
if (args != 6)
{
printUsage();
exit(EXIT_FAILURE);
}
//the following flags are 'true' for row_major layout
bool layout_A;
bool layout_B;
bool layout_C;
readParameter(layout_A, argsv[1][0]);
readParameter(layout_B, argsv[2][0]);
readParameter(layout_C, argsv[3][0]);
bool transpose_A;
bool transpose_B;
readParameter(transpose_A, argsv[4][0]);
readParameter(transpose_B, argsv[5][0]);
printMatrixMatrixProduct(layout_A, layout_B, layout_C, transpose_A, transpose_B);
}
void Fidelity::Engine::SimulationXmlReader::readGlobals()
{
while(!atEnd()) {
readNext();
// Stop here if globals tag completed
if(isEndElement() && name() == "globals") {
break;
}
// Evaluate child tags
if (isStartElement()) {
// We expect parameter tags only
if (name() == "parameter") {
SimulationXmlParameter parameter = readParameter();
if(m_ContinueParsing) {
// Propagate parameter
emit globalParameterFound(parameter);
}
}
else {
unknownElement();
}
}
}
}
int main(int argc, char** argv)
{
int size = getFreeDiskSize();
int count = readParameter(0);
int times = readParameter(1);
int fp = creat("file1");
assertTrueWMsg(fp >= 0, "creat failed");
int i;
for (i = 0; i < times; i++){
assertTrueWMsg(write(fp, buf, count) == count, "write failed");
printf("create %d\r\n", i);
}
close(fp);
assertTrueWMsg(unlink("file1") == 0, "unlink failed");
assertTrueWMsg(size == getFreeDiskSize(), "size mismatch");
done();
return 0;
}
DialogSetParameter::DialogSetParameter(CWnd* pParent /*=NULL*/)
: CDialogEx(DialogSetParameter::IDD, pParent)
{
CString temp;
readParameter();
growthCycleList="";
for(int i=0;i<parameter.iteratorDay.size();i++)
{
temp.Format(_T("%d"),parameter.iteratorDay[i]);
growthCycleList=growthCycleList+temp+_T(" ");
}
}
void Fidelity::Engine::SimulationXmlReader::readComponent()
{
SimulationXmlComponent component;
// Get component attributes
component.setIdentifier(attributes().value("identifier").toString());
component.setLabel(attributes().value("label").toString());
component.setWorkbenchXPos(attributes().value("workbenchX").toString());
component.setWorkbenchYPos(attributes().value("workbenchY").toString());
component.setRotation(attributes().value("rotation").toString());
component.setUuid(attributes().value("uuid").toString());
while(!atEnd()) {
readNext();
// Stop here if component tag completed
if(isEndElement() && name() == "component") {
break;
}
// Evaluate child tags
if (isStartElement()) {
// We expect parameter tags only
if (name() == "parameter") {
// Add parameter to list
component.Parameters()->append(readParameter());
}
else {
unknownElement();
}
}
}
// Validate identifier
if(component.Identifier().isEmpty()) {
unknownElement();
}
// Validate UUID
else if(component.Uuid().isEmpty()) {
unknownElement();
}
else if(m_ContinueParsing) {
// Everything's fine -> propagate component
emit componentFound(component);
}
}
void Fidelity::Engine::SimulationXmlReader::readEngine()
{
SimulationXmlEngine engine;
// Get engine attributes
engine.setIdentifier(attributes().value("identifier").toString());
while(!atEnd()) {
readNext();
// Stop here if engine tag completed
if(isEndElement() && name() == "engine") {
break;
}
// Evaluate child tags
if (isStartElement()) {
// We expect parameter tags only
if (name() == "parameter") {
// Add parameter to list
engine.Parameters()->append(readParameter());
}
else {
unknownElement();
}
}
}
// Validate identifier
if(engine.Identifier().isEmpty()) {
unknownElement();
}
else if(m_ContinueParsing) {
// Everything's fine -> propagate engine
emit engineFound(engine);
}
}
bool
CImageSIX::
read(CFile *file, CImagePtr &image)
{
file->rewind();
CFileParse parse(file);
if (! parse.isChar('\033'))
return false;
parse.skipChar();
if (! parse.isChar('P'))
return false;
parse.skipChar();
// semi-colon separated values ending in 'q'
std::vector<int> parameters;
while (! parse.eof()) {
if (parse.isChar('q'))
break;
int p = parse.readChar();
parameters.push_back(p);
if (! parse.isChar(';'))
break;
parse.skipChar();
}
if (! parse.isChar('q'))
return false;
parse.skipChar();
int w = 0, h = 0;
std::vector<CRGBA> colors;
while (! parse.eof()) {
if (parse.isChar('\"')) {
parse.skipChar();
std::vector<int> parameters;
readParameters(parse, parameters);
if (parameters.size() == 4) {
w = parameters[2];
h = parameters[3];
}
}
else if (parse.isChar('#')) {
parse.skipChar();
std::vector<int> parameters;
readParameters(parse, parameters);
if (parameters.size() == 5) {
int r = parameters[2];
int g = parameters[3];
int b = parameters[4];
colors.push_back(CRGBA(r/255.0, g/255.0, b/255.0));
}
}
else {
break;
}
}
//------
image->setType(CFILE_TYPE_IMAGE_SIX);
image->setDataSize(w, h);
for (const auto &color : colors)
image->addColor(color);
uint *data = new uint [w*h];
//---
int c = 0;
int x = 0;
int y = 0;
while (! parse.eof()) {
if (parse.isChar('\033')) {
parse.skipChar();
if (parse.isChar('\\'))
break;
//data.push_back('\033');
return false;
}
// repeat data
else if (parse.isChar('!')) {
parse.skipChar();
int parameter;
if (! readParameter(parse, parameter))
break;
int d;
if (! readSixData(parse, d))
break;
for (int i = 0; i < parameter; ++i) {
for (int i = 0; i < 6; ++i) {
bool b = d & (1<<i);
if (b) data[x + (y + i)*w] = c;
}
++x;
}
}
// choose palette color
else if (parse.isChar('#')) {
parse.skipChar();
int parameter;
if (! readParameter(parse, parameter))
break;
c = parameter;
}
// carriage return
else if (parse.isChar('$')) {
parse.skipChar();
x = 0;
}
// next line
else if (parse.isChar('-')) {
parse.skipChar();
x = 0;
y += 6;
}
// add data
else {
int d;
if (! readSixData(parse, d))
break;
for (int i = 0; i < 6; ++i) {
bool b = d & (1<<i);
if (b) data[x + (y + i)*w] = c;
}
++x;
}
}
//------
image->setColorIndexData(data);
delete [] data;
//------
return true;
}
void mexFunction( int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[] )
{
const mxArray * haar_ptr;
const mxArray * parameter_ptr;
const mxArray * selector_ptr;
const mxArray * alpha_ptr;
int nfields, NStructElems, ifield, jstruct;
matrix2d haarfeature;
mxArray * tmp;
if(nrhs != 4) {
mexErrMsgTxt("tow input argument required.");
}
// read the prhs[0] sumimagedata
// read the prhs[1] the patches [x , y, w , h]
//
matrix<double> sumimagedata = matrix<double>(A_IN);
matrix<double> patches = matrix<double>(B_IN);
matrix<double> label = matrix<double>(C_IN);
matrix<double> importance = matrix<double>(D_IN);
// global values
haar_ptr = mexGetVariablePtr("caller", "haarfeature");
selector_ptr = mexGetVariablePtr("caller", "selectors");
alpha_ptr = mexGetVariablePtr("caller", "alpha");
parameter_ptr = mexGetVariablePtr("caller", "parameter");
matrix<double> selector = matrix<double>(selector_ptr);
matrix<double> alpha = matrix<double>(alpha_ptr);
// read haar_ptr
nfields = mxGetNumberOfFields(haar_ptr);
NStructElems = mxGetNumberOfElements(haar_ptr);
haarfeature = new matrix<double> * [NStructElems];
for(jstruct = 0; jstruct < NStructElems; jstruct ++)
haarfeature[jstruct] = new matrix<double>[nfields];
// haarfeature is the mxArray point the struct
// haarfeature[jstruct][ifield] means the i(th) field in j(th) struct
readHaarfeature(haarfeature, haar_ptr, NStructElems, nfields);
double * parameter = new double[MAX_NUMBER_PARAMETER];
readParameter(parameter, parameter_ptr);
int labelvalue = (int)label.data[0];
double importancevalue = importance.data[0];
update(&patches, &alpha, &selector, &haarfeature,&sumimagedata,
parameter, labelvalue, importancevalue);
for(jstruct = 0; jstruct < NStructElems; jstruct ++)
delete [] haarfeature[jstruct];
delete [] haarfeature;
delete [] parameter;
}
QSharedPointer<Filter> XMLizer::readFilter( QDomElement &element, bool audio, bool &readError, bool transition )
{
QDomNodeList nodes = element.childNodes();
QString name;
bool okName = false;
QSharedPointer<Filter> filter;
for ( int i = 0; i < nodes.count(); ++i ) {
QDomElement e = nodes.at( i ).toElement();
if ( e.isNull() )
continue;
if ( e.tagName() == "Name" ) {
name = e.text();
okName = true;
break;
}
}
if ( !okName ) {
readError = true;
return filter;
}
FilterCollection *fc = FilterCollection::getGlobalInstance();
if ( transition ) {
if ( audio ) {
for ( int i = 0; i < fc->audioTransitions.count(); ++i ) {
if ( fc->audioTransitions[ i ].identifier == name ) {
filter = fc->audioTransitions[ i ].create();
break;
}
}
}
else {
for ( int i = 0; i < fc->videoTransitions.count(); ++i ) {
if ( fc->videoTransitions[ i ].identifier == name ) {
filter = fc->videoTransitions[ i ].create();
break;
}
}
}
}
else {
if ( audio ) {
for ( int i = 0; i < fc->audioFilters.count(); ++i ) {
if ( fc->audioFilters[ i ].identifier == name ) {
filter = fc->audioFilters[ i ].create();
break;
}
}
}
else {
for ( int i = 0; i < fc->videoFilters.count(); ++i ) {
if ( fc->videoFilters[ i ].identifier == name ) {
filter = fc->videoFilters[ i ].create();
break;
}
}
}
}
if ( filter.isNull() ) {
readError = true;
return filter;
}
QString shader = "";
if ( filter->getIdentifier() == "GLCustom" ) {
for ( int i = 0; i < nodes.count(); ++i ) {
QDomElement e = nodes.at( i ).toElement();
if ( e.isNull() )
continue;
if ( e.tagName() == "Parameter" ) {
readParameter( e, filter );
}
}
QString shaderName = "";
QList<Parameter*> params = filter->getParameters();
Parameter *editor = NULL;
for ( int i = 0; i < params.count(); ++i ) {
if ( params[ i ]->id == "editor" ) {
editor = params[ i ];
// retrieve the shader name
shaderName = editor->value.toString();
break;
}
}
// get the shader
shader = ShaderCollection::getGlobalInstance()->getLocalShader( shaderName );
if ( editor && !shader.isEmpty() ) {
GLCustom *f = (GLCustom*)filter.data();
// set the shader so that parameters are constructed
// and will be reparsed in the following loop
f->setCustomParams( shader );
}
}
for ( int i = 0; i < nodes.count(); ++i ) {
QDomElement e = nodes.at( i ).toElement();
if ( e.isNull() )
continue;
if ( e.tagName() == "PosInTrack" ) {
filter->setPosition( e.text().toDouble() );
}
else if ( e.tagName() == "PosOffset" ) {
filter->setPositionOffset( e.text().toDouble() );
}
else if ( e.tagName() == "Length" ) {
filter->setLength( e.text().toDouble() );
}
else if ( e.tagName() == "SnapMode" ) {
filter->setSnap( e.text().toInt() );
}
else if ( e.tagName() == "Parameter" ) {
readParameter( e, filter );
}
}
if ( filter->getIdentifier() == "GLCustom" ) {
// restore the shader that has been overwritten
// by the preceding loop
QList<Parameter*> params = filter->getParameters();
for ( int i = 0; i < params.count(); ++i ) {
if ( params[ i ]->id == "editor" ) {
if ( !shader.isEmpty() )
params[ i ]->value = shader;
else {
params[ i ]->value = GLCustom::getDefaultShader();
}
break;
}
}
}
return filter;
}
