Ejemplo n.º 1
0
 void initFlags(int *argcp, const char ***argvp, int ignoreargs) {
   int argc = *argcp;
   const char **argv = *argvp;
   
   map<string, LinkageData> &links = getLinkageSingleton();
   for(map<string, LinkageData>::iterator itr = links.begin(); itr != links.end(); itr++) {
     if(itr->second.type == LinkageData::LINKAGE_BOOL) {
       *itr->second.bool_link = itr->second.bool_def;
     } else if(itr->second.type == LinkageData::LINKAGE_INT) {
       *itr->second.int_link = itr->second.int_def;
     } else if(itr->second.type == LinkageData::LINKAGE_STRING) {
       *itr->second.str_link = itr->second.str_def;
     } else if(itr->second.type == LinkageData::LINKAGE_FLOAT) {
       *itr->second.float_link = itr->second.float_def;
     } else {
       CHECK(0);
     }
     *itr->second.source = FS_DEFAULT;
   }
   for(map<string, LinkageData>::iterator itr = links.begin(); itr != links.end(); itr++) {
     if(itr->second.type == LinkageData::LINKAGE_BOOL) {
       //dprintf("Initted bool %s to %d\n", itr->first.c_str(), *itr->second.bool_link);
     } else if(itr->second.type == LinkageData::LINKAGE_INT) {
       //dprintf("Initted int %s to %d\n", itr->first.c_str(), *itr->second.int_link);
     } else if(itr->second.type == LinkageData::LINKAGE_STRING) {
       //dprintf("Initted string %s to %s\n", itr->first.c_str(), itr->second.str_link->c_str());
     } else if(itr->second.type == LinkageData::LINKAGE_FLOAT) {
       //dprintf("Initted float %s to %f\n", itr->first.c_str(), *itr->second.float_link);
     } else {
       CHECK(0);
     }
   }
   
   vector<pair<string, FlagSource> > lines;
   
   {
     ifstream ifs("glorp/settings.local");
     string dt;
     while(getLineStripped(ifs, &dt))
       lines.push_back(make_pair(dt, FS_FILE));
   }
   
   vector<const char *> remains;
   for(int i = 0; i < ignoreargs + 1; i++)
     remains.push_back(argv[i]);
   
   for(int i = ignoreargs + 1; i < argc; i++) {
     if(argv[i][0] == '-' && argv[i][1] == '-') {
       lines.push_back(make_pair(argv[i] + 2, FS_CLI));
     } else {
       remains.push_back(argv[i]);
     }
   }
   
   remains.push_back(NULL);
   std::copy(remains.begin(), remains.end(), argv);
   
   for(int i = 0; i < lines.size(); i++) {
     const char *arg = lines[i].first.c_str();
     bool isBoolNo = false;
     if(strlen(arg) >= 2 && tolower(arg[0]) == 'n' && tolower(arg[1]) == 'o') {
       isBoolNo = true;
       arg += 2;
     }
     const char *eq = strchr(arg, '=');
     string realarg;
     if(eq) {
       realarg = string(arg, eq);
       eq++;
     } else {
       realarg = arg;
     }
     
     realarg = canonize(realarg);
     
     if(!links.count(realarg)) {
       dprintf("Invalid commandline argument %s\n", arg);
       CHECK(0);
       continue;
     }
     
     LinkageData &ld = links[realarg];
     if(ld.type == LinkageData::LINKAGE_BOOL) {
       CHECK(!eq || string(eq) == "true" || string(eq) == "false");
       CHECK(!eq || !isBoolNo);
       CHECK(ld.bool_link);
       if(isBoolNo || (eq && string(eq) == "false")) {
         *ld.bool_link = false;
       } else {
         *ld.bool_link = true;
       }
     } else if(ld.type == LinkageData::LINKAGE_STRING) {
       CHECK(!isBoolNo && eq);
       CHECK(ld.str_link);
       *ld.str_link = eq;
     } else if(ld.type == LinkageData::LINKAGE_INT) {
       CHECK(!isBoolNo && eq);
       CHECK(ld.int_link);
       *ld.int_link = atoi(eq);
     } else if(ld.type == LinkageData::LINKAGE_FLOAT) {
       CHECK(!isBoolNo && eq);
       CHECK(ld.float_link);
       *ld.float_link = atof(eq);
     } else {
       CHECK(0);
     }
     
     *ld.source = lines[i].second;
   }
   
   for(int i = 0; i < getMassageSingleton().size(); i++) {
     (*getMassageSingleton()[i])();
     delete getMassageSingleton()[i];
   }
   getMassageSingleton().clear();
   
   for(map<string, LinkageData>::iterator itr = links.begin(); itr != links.end(); itr++) {
     if(itr->second.type == LinkageData::LINKAGE_BOOL) {
       //dprintf("Set bool %s to %d\n", itr->first.c_str(), *itr->second.bool_link);
     } else if(itr->second.type == LinkageData::LINKAGE_INT) {
       //dprintf("Set int %s to %d\n", itr->first.c_str(), *itr->second.int_link);
     } else if(itr->second.type == LinkageData::LINKAGE_STRING) {
       //dprintf("Set string %s to %s\n", itr->first.c_str(), itr->second.str_link->c_str());
     } else if(itr->second.type == LinkageData::LINKAGE_FLOAT) {
       //dprintf("Set float %s to %f\n", itr->first.c_str(), *itr->second.float_link);
     } else {
       CHECK(0);
     }
   }
 }
Ejemplo n.º 2
0
void proxmap_t::init_opencl(){
  cerr<<"Initializing OpenCL...\n";
  if(run_gpu){
  // initialize the GPU if necessary
    //int platform_id = 0;
    int platform_id = config->platform_id;
    //int device_id = 0;
    int device_id = config->device_id;
    cerr<<"Initializing GPU with platform id "<<platform_id<<
    " and device id "<<device_id<<".\n";
    vector<cl::Platform> platforms;
    err = cl::Platform::get(&platforms);
    cerr<<"Platform ID "<<platform_id<<" has name "<<
    platforms[platform_id].getInfo<CL_PLATFORM_NAME>().c_str()<<endl;
    cl_context_properties cps[3] = {CL_CONTEXT_PLATFORM,
    (cl_context_properties)(platforms[platform_id])(),0};
    context = new cl::Context(CL_DEVICE_TYPE_GPU,cps);
    devices = context->getInfo<CL_CONTEXT_DEVICES>();
    cerr<<"There are "<<devices.size()<<" devices\n";
    cerr<<"Device ID "<<device_id<<" is a ";
    cl_device_type dtype = devices[device_id].getInfo<CL_DEVICE_TYPE>();
    switch(dtype){
      case CL_DEVICE_TYPE_GPU:
        cerr<<"GPU\n";
        break;
      case CL_DEVICE_TYPE_CPU:
        cerr<<"CPU\n";
        break;
    } 
    commandQueue = new cl::CommandQueue(*context,devices[device_id],0,&err);
    vector<string> sources;
    sources.push_back("cl_constants.h");
    sources.push_back("common.c");
    ostringstream full_source_str;
    for(uint j=0;j<sources.size();++j){
      ostringstream oss;
      oss<<config->kernel_base<<"/"<<sources[j];
      string full_path = oss.str();
      cerr<<"Opening "<<full_path<<endl;
      ifstream ifs(full_path.data());
      clSafe(ifs.is_open()?CL_SUCCESS:-1,"kernel_path not found");
      string source_str(istreambuf_iterator<char>(ifs),(istreambuf_iterator<char>()));
      full_source_str<<source_str;
    }
    string source_str = full_source_str.str();
    // create a program object from kernel source
    cerr<<"Creating source\n";
    cl::Program::Sources source(1,make_pair(source_str.c_str(),source_str.length()+1));
    cerr<<"Creating program\n";
    program = new cl::Program(*context,source);
    //const char * preproc;
//    if (geno_dim==PHASED_INPUT){
//      preproc = "-Dphased";
//    } else if(geno_dim==UNPHASED_INPUT){
//      preproc = "-Dunphased";
//    }
    err = program->build(devices);
    //err = program->build(devices,preproc);
    if(err!=CL_SUCCESS){
      cerr<<"Build failed:\n";
      string buffer;
      program->getBuildInfo(devices[0],CL_PROGRAM_BUILD_LOG,&buffer);
      cerr<<buffer<<endl;
      throw "Aborted from OpenCL build fail.";
    }
    cerr<<"GPU kernel arguments assigned.\n";
  }
}
Ejemplo n.º 3
0
void TMesh::Load(char *fname) {

  ifstream ifs(fname, ios::binary);
  if (ifs.fail()) {
    cerr << "INFO: cannot open file: " << fname << endl;
    return;
  }

  ifs.read((char*)&vertsN, sizeof(int));
  char yn;
  ifs.read(&yn, 1); // always xyz
  if (yn != 'y') {
    cerr << "INTERNAL ERROR: there should always be vertex xyz data" << endl;
    return;
  }
  if (verts)
    delete verts;
  verts = new Vector3D[vertsN];

  ifs.read(&yn, 1); // cols 3 floats
  if (cols)
    delete cols;
  cols = 0;
  if (yn == 'y') {
    cols = new Vector3D[vertsN];
  }

  ifs.read(&yn, 1); // normals 3 floats
  //Vector3D *normals = 0; // don't have normals for now
  if (normals)
    delete normals;
  normals = 0;
  if (yn == 'y') {
    normals = new Vector3D[vertsN];
  }

  ifs.read(&yn, 1); // texture coordinates 2 floats
  float *tcs = 0; // don't have texture coordinates for now
  if (tcs)
    delete tcs;
  tcs = 0;
  if (yn == 'y') {
    tcs = new float[vertsN*2];
  }

  ifs.read((char*)verts, vertsN*3*sizeof(float)); // load verts

  if (cols) {
    ifs.read((char*)cols, vertsN*3*sizeof(float)); // load cols
  }

  if (normals)
    ifs.read((char*)normals, vertsN*3*sizeof(float)); // load normals

  if (tcs)
    ifs.read((char*)tcs, vertsN*2*sizeof(float)); // load texture coordinates

  ifs.read((char*)&trisN, sizeof(int));
  if (tris)
    delete tris;
  tris = new unsigned int[trisN*3];
  ifs.read((char*)tris, trisN*3*sizeof(unsigned int)); // read tiangles

  ifs.close();

  cerr << "INFO: loaded " << vertsN << " verts, " << trisN << " tris from " << endl << "      " << fname << endl;
  cerr << "      xyz " << ((cols) ? "rgb " : "") << ((normals) ? "nxnynz " : "") << ((tcs) ? "tcstct " : "") << endl;

 /* float max_y = FLT_MIN;
  float min_y = FLT_MAX;
  float max_z = FLT_MIN;
  float min_z = FLT_MAX;

  for(int i = 0; i < vertsN; i++){
	if(verts[i].coords[1] < min_y){
		min_y = verts[i].coords[1];
	}else if(verts[i].coords[1] > max_y){
		max_y = verts[i].coords[1];
	}

	if(verts[i].coords[2] < min_z){
		min_z = verts[i].coords[2];
	}else if(verts[i].coords[2] > max_z){
		max_z = verts[i].coords[2];
	}
  }

  float range_y = max_y - min_y;
  float range_z = max_z - min_z;

  //cout << min_y << endl;

  for(int i = 0; i < vertsN; i++){
	float scale_y = (verts[i].coords[1]-min_y)/range_y;
	float scale_z = (verts[i].coords[2]-min_z)/range_z;
	cols[i] = Vector3D(0.0f, scale_y*scale_z, 0.0f);
  }*/
}
Ejemplo n.º 4
0
	std::string LoadMtl(
		std::map<std::string, material_t>& material_map,
		const char* filename,
		const char* mtl_basepath)
	{
		material_map.clear();
		std::stringstream err;

		std::string filepath;

		if (mtl_basepath) {
			filepath = std::string(mtl_basepath) + std::string(filename);
		}
		else {
			filepath = std::string(filename);
		}

		std::ifstream ifs(filepath.c_str());
		if (!ifs) {
			err << "Cannot open file [" << filepath << "]" << std::endl;
			return err.str();
		}

		material_t material;

		int maxchars = 8192;  // Alloc enough size.
		std::vector<char> buf(maxchars);  // Alloc enough size.
		while (ifs.peek() != -1) {
			ifs.getline(&buf[0], maxchars);

			std::string linebuf(&buf[0]);

			// Trim newline '\r\n' or '\r'
			if (linebuf.size() > 0) {
				if (linebuf[linebuf.size() - 1] == '\n') linebuf.erase(linebuf.size() - 1);
			}
			if (linebuf.size() > 0) {
				if (linebuf[linebuf.size() - 1] == '\n') linebuf.erase(linebuf.size() - 1);
			}

			// Skip if empty line.
			if (linebuf.empty()) {
				continue;
			}

			// Skip leading space.
			const char* token = linebuf.c_str();
			token += strspn(token, " \t");

			assert(token);
			if (token[0] == '\0') continue; // empty line

			if (token[0] == '#') continue;  // comment line

			// new mtl
			if ((0 == strncmp(token, "newmtl", 6)) && isSpace((token[6]))) {
				// flush previous material.
				material_map.insert(std::pair<std::string, material_t>(material.name, material));

				// initial temporary material
				InitMaterial(material);

				// set new mtl name
				char namebuf[4096];
				token += 7;
				sscanf(token, "%s", namebuf);
				material.name = namebuf;
				continue;
			}

			// ambient
			if (token[0] == 'K' && token[1] == 'a' && isSpace((token[2]))) {
				token += 2;
				float r, g, b;
				parseFloat3(r, g, b, token);
				material.ambient[0] = r;
				material.ambient[1] = g;
				material.ambient[2] = b;
				continue;
			}

			// diffuse
			if (token[0] == 'K' && token[1] == 'd' && isSpace((token[2]))) {
				token += 2;
				float r, g, b;
				parseFloat3(r, g, b, token);
				material.diffuse[0] = r;
				material.diffuse[1] = g;
				material.diffuse[2] = b;
				continue;
			}

			// specular
			if (token[0] == 'K' && token[1] == 's' && isSpace((token[2]))) {
				token += 2;
				float r, g, b;
				parseFloat3(r, g, b, token);
				material.specular[0] = r;
				material.specular[1] = g;
				material.specular[2] = b;
				continue;
			}

			// transmittance
			if (token[0] == 'K' && token[1] == 't' && isSpace((token[2]))) {
				token += 2;
				float r, g, b;
				parseFloat3(r, g, b, token);
				material.transmittance[0] = r;
				material.transmittance[1] = g;
				material.transmittance[2] = b;
				continue;
			}

			// ior(index of refraction)
			if (token[0] == 'N' && token[1] == 'i' && isSpace((token[2]))) {
				token += 2;
				material.ior = parseFloat(token);
				continue;
			}

			// emission
			if (token[0] == 'K' && token[1] == 'e' && isSpace(token[2])) {
				token += 2;
				float r, g, b;
				parseFloat3(r, g, b, token);
				material.emission[0] = r;
				material.emission[1] = g;
				material.emission[2] = b;
				continue;
			}

			// shininess
			if (token[0] == 'N' && token[1] == 's' && isSpace(token[2])) {
				token += 2;
				material.shininess = parseFloat(token);
				continue;
			}

			// illum model
			if (0 == strncmp(token, "illum", 5) && isSpace(token[5])) {
				token += 6;
				material.illum = parseInt(token);
				continue;
			}

			// dissolve
			if ((token[0] == 'd' && isSpace(token[1]))) {
				token += 1;
				material.dissolve = parseFloat(token);
				continue;
			}
			if (token[0] == 'T' && token[1] == 'r' && isSpace(token[2])) {
				token += 2;
				material.dissolve = parseFloat(token);
				continue;
			}

			// ambient texture
			if ((0 == strncmp(token, "map_Ka", 6)) && isSpace(token[6])) {
				token += 7;
				material.ambient_texname = token;
				continue;
			}

			// diffuse texture
			if ((0 == strncmp(token, "map_Kd", 6)) && isSpace(token[6])) {
				token += 7;
				material.diffuse_texname = token;
				continue;
			}

			// specular texture
			if ((0 == strncmp(token, "map_Ks", 6)) && isSpace(token[6])) {
				token += 7;
				material.specular_texname = token;
				continue;
			}

			// normal texture
			if (IsBumpMap(token)) {
				while (*token == '-') {
					// parse bump map options...
					if ((0 == strncmp(token, "-bm", 3)) && isSpace(token[3])) {
						token += 4;
						material.bump_scale = parseFloat(token);
					}
					else {
						ParseUnsupportedBumpModifier(token, err);
					}
					// skip space
					token += strspn(token, " \t");
				}
				material.normal_texname = token;
				continue;
			}

			// unknown parameter
			const char* _space = strchr(token, ' ');
			if (!_space) {
				_space = strchr(token, '\t');
			}
			if (_space) {
				int len = _space - token;
				std::string key(token, len);
				std::string value = _space + 1;
				material.unknown_parameter.insert(std::pair<std::string, std::string>(key, value));
			}
		}
		// flush last material.
		material_map.insert(std::pair<std::string, material_t>(material.name, material));

		return err.str();
	}
Ejemplo n.º 5
0
bool
Consistency::check(Variable &dataVar, std::string entryID)
{
  // return value is true, when there is not a project table, yet.

  // Search the project table for an entry
  // matching the varname and frequency (account also rotated).

  // Open project table. Mode:  read
  std::string str0(projectTableFile.getFile());

  std::ifstream ifs(str0.c_str(), std::ios::in);
  if( !ifs.is_open() )  // file does not exist
     return true;  // causes writing of a new entry

  size_t sz_PV = entryID.size();

  std::string t_md;
  bool notFound=true;

  while( getline(ifs, str0) )
  {
    if( str0.substr(0,sz_PV) != entryID )
      continue;

    // found a valid entry
    notFound=false;
    t_md = hdhC::stripSides(str0) ;

    // read aux-lines
    while( getline(ifs, str0) )
    {
      str0 = hdhC::stripSides(str0) ;
      if( str0.substr(0,4) != "aux=" )
        goto BREAK ;  // found the end of the entry

      t_md += '\n';
      t_md += str0 ;
    }
  }

  if(notFound)
    return true;  // entry not found

BREAK:

  // close the project table
  ifs.close();

  // get meta data info from the file
  std::string f_md;
  getMetaData(dataVar, entryID, f_md);

  // Comparison of meta-data from the project table and the file, respectively.
  // Note that the direct comparison fails because of different spaces.

  // Deviating distribution of auxiliaries and attributes is tolerated.
  // Use index-vector for book-keeping.
  // Meaning: x=split, t=file, t=table, a=attribute, eq=(att-name,att-value)

  Split splt_xt(t_md, '\n');
  Split splt_xf(f_md, '\n');
  size_t xt_sz=splt_xt.size();
  size_t xf_sz=splt_xf.size();

  std::vector<std::string> xf;
  for( size_t i=0 ; i < xf_sz ; ++i )
    xf.push_back( hdhC::stripSides(splt_xf[i]) );

  std::vector<std::string> xt;
  for( size_t i=0 ; i < xt_sz ; ++i )
    xt.push_back( hdhC::stripSides(splt_xt[i]) );

  // simple test for identity
  if( xt_sz == xf_sz )
  {
    bool is=true;
    for( size_t i=0 ; i < xt_sz ; ++i )
    {
       if( xt[i] != xf[i] )
       {
         is=false ;
         break;
       }
    }

    if( is )
       return false;
  }

  // store indexes
  std::vector<int> xf_ix;
  for( size_t i=0 ; i < xf_sz ; ++i )
    xf_ix.push_back( i );

  std::vector<int> xt_ix;
  for( size_t i=0 ; i < xt_sz ; ++i )
    xt_ix.push_back( i );

  // At first, test whether total auxiliary entries are identical.
  for( size_t i=0 ; i < xt_sz ; ++i )
  {
    for( size_t j=0 ; j < xf_sz ; ++j )
    {
       // only test strings for indexes still to be checked
       if( xt_ix[i] > -1 && xf_ix[i] > -1 && xf[j] == xt[i] )
       {
         xt_ix[i] = -1;
         xf_ix[j] = -1;
         break;
       }
    }
  }

  Split xf_a;  // meta-data from file
  xf_a.setSeparator(',');
  Split xt_a;  // from the table
  xt_a.setSeparator(',');

  Split xf_eq;
  xf_eq.setSeparator('=');
  Split xt_eq;
  xt_eq.setSeparator('=');

  bool isMissAux;
  for( size_t ixt=0 ; ixt < xt_ix.size() ; ++ixt )
  {
    int jt=xt_ix[ixt];

    if( jt < 0 )
      continue;  // passed already a check

    isMissAux=true;

    //split at comma
    xt_a = xt[jt] ;

    for( size_t ixf=0 ; ixf < xf_ix.size() ; ++ixf )
    {
      int jf=xf_ix[ixf];

      if( jf < 0 )
        continue;  // passed already a check

      //split at comma
      xf_a = xf[jf] ;

      // compare the names of the auxiliaries
      if( xf_a[0] != xt_a[0] )
        continue;

      isMissAux=false;

      // scan the attributes
      for( size_t ita=1 ; ita < xt_a.size() ; ++ita )
      {
        // split at '='
        xt_eq = xt_a[ita] ;

        bool isAttMissing=true;

        for( size_t ifa=1 ; ifa < xf_a.size() ; ++ifa )
        {
          // split at '='
          xf_eq = xf_a[ifa] ;

          if( xt_eq[0] == xf_eq[0] ) // found identical attribute names
          {
            isAttMissing=false;
            if( xt_eq[1] == xf_eq[1] )  // found identical values
              break;  // try the next attribute

            // this is a very special one for time: one wit separator T and/or Z
            // the other one without
            std::string auxName;
            if( xt_a[0].substr(0,4) == "aux=" )
              auxName = xt_a[0].substr(4) ;
            else
              auxName = xt_a[0] ;

            if( auxName == "time" )
            {
               Split x_tt(xt_eq[1]," TZ",true) ;
               Split x_ff(xf_eq[1]," TZ",true) ;

               if( x_tt.size() == x_ff.size() )
               {
                 bool is=true;
                 for(size_t c=0 ; c < x_tt.size()  ; ++c )
                   if( x_tt[c] != x_ff[c] )
                     is=false;

                 if(is)
                   break;
               }
            }

            // different values --> annotation
            status=true;

            std::string key("8_8");
            if( notes->inq( key, dataVar.name ) )
            {
              std::string capt;
              if( xt_a[0].substr(0,4) == "aux=" )
              {
                capt = "auxiliary ";
                capt += hdhC::tf_var(auxName, hdhC::colon) ;
              }
              else
                capt += hdhC::tf_var(xt_a[0], hdhC::colon) ;

              if( xt_eq[0] == "values" )
                capt += "data has changed";
              else
              {
                capt += xt_eq[0] ;
                capt += " has changed from";
                capt += hdhC::tf_val(xt_eq[1]) ;
                capt += " to";
                capt += hdhC::tf_val(xf_eq[1]) ;
              }
              capt += " across experiment or sub-temporal files";

              (void) notes->operate(capt) ;
              notes->setCheckMetaStr( "FAIL" );
            }

            break;  // try next
          }
        }

        if( isAttMissing )
        {
          status=true;

          std::string key("8_7");
          if( notes->inq( key, dataVar.name ) )
          {
            std::string capt;
            if( xt_a[0].substr(0,4) == "aux=" )
            {
              capt = "auxiliary ";
              capt += hdhC::tf_var(xt_a[0].substr(4), hdhC::colon) ;
            }
            else
              capt += hdhC::tf_var(xt_a[0], hdhC::colon) ;

            if( xt_eq[0] == "values" )
              capt += "no data";
            else
            {
              capt += hdhC::tf_att(xt_eq[0]);
              capt += "is missing " ;
            }

            if( qa->currQARec )
              capt += "across sub-temporal files";
            else
              capt += "across experiments";

            (void) notes->operate(capt) ;
            notes->setCheckMetaStr( "FAIL" );
          }
        }
      }
    }

    if( isMissAux )
    {
      status=true;

      std::string key("8_4");
      if( notes->inq( key, dataVar.name ) )
      {
        std::string capt;
        if( xt_a[0].substr(0,4) == "aux=" )
        {
          capt = "auxiliary ";
          capt += hdhC::tf_var(xt_a[0].substr(4), hdhC::colon) ;
        }
        else
          capt += hdhC::tf_var(xt_a[0], hdhC::colon) ;

        capt += "missing across experiments or sub-temporal files";

        (void) notes->operate(capt) ;
        notes->setCheckMetaStr( "FAIL" );
      }
    }
  }


  // test for missing attributes in the table (reversed for-loops)
  bool isAddAux=true;
  for( size_t ixf=0 ; ixf < xf_ix.size() ; ++ixf )
  {
    int jf=xf_ix[ixf];

    if( jf < 0 )
      continue;  // passed already a check

    isAddAux=true;

    //split at comma
    xf_a = xf[jf] ;

    for( size_t ixt=0 ; ixt < xt_ix.size() ; ++ixt )
    {
      int jt=xt_ix[ixt];

      if( jt < 0 )
        continue;  // passed already a check

      //split at comma
      xt_a = xt[jt] ;

      // compare the names of the auxiliaries
      if( xf_a[0] != xt_a[0] )
        continue;

      // found identical auxiliaries
      isAddAux=false;

      // scan the attributes
      for( size_t ifa=1 ; ifa < xf_a.size() ; ++ifa )
      {
        // split at '='
        xf_eq = xf_a[ifa] ;
        bool isAddAtt=true;

        for( size_t ita=1 ; ita < xt_a.size() ; ++ita )
        {
          // split at '='
          xt_eq = xt_a[ita] ;

          if( xt_eq[0] == xf_eq[0] ) // found identical attribute names
          {
            isAddAtt=false;
            break;
          }
        }

        if( isAddAtt )
        {
          status=true;

          // additional attribute of auxiliary in the file
          std::string key("8_6");
          if( notes->inq( key, dataVar.name ) )
          {
            std::string capt;
            if( xt_a[0].substr(0,4) == "aux=" )
            {
              capt = "auxiliary ";
              capt += hdhC::tf_var(xf_a[0].substr(4), hdhC::colon) ;
            }
            else
              capt += hdhC::tf_var(xf_a[0], hdhC::colon) ;

            if( xt_eq[0] == "values" )
            {
              capt += "additional data across experiments or sub-temporal files";
            }
            else
            {
              capt += hdhC::tf_att(xf_eq[0]);
              capt += "is new across experiments or sub-temporal files";
            }

            (void) notes->operate(capt) ;
            notes->setCheckMetaStr( "FAIL" );
          }
        }
      }
    }

    if( isAddAux )
    {
      status=true;

      std::string key("8_5");
      if( notes->inq( key, dataVar.name) )
      {
        std::string capt("additional auxiliary ");
        if( xf_a[0].size() > 4 )
          capt += hdhC::tf_var(xf_a[0].substr(4)) ;
        else
          capt += hdhC::tf_var(xf_a[0]) ;
        capt += "across experiments or sub-temporal files";

        (void) notes->operate(capt) ;
        notes->setCheckMetaStr( "FAIL" );
      }
    }
  }

  return false;
}
Ejemplo n.º 6
0
string DU_File::load2str(const string &sFullFileName)
{
    ifstream ifs(sFullFileName.c_str());

    return string(istreambuf_iterator<char>(ifs), istreambuf_iterator<char>());
}
Ejemplo n.º 7
0
void AircraftProperties::load(){

  rotor.load();
  
  std::ifstream ifs("/home/ken/UAVdata.csv");
  if(!ifs){
    std::cout<<"READ ERROR"<<std::endl;
    return;
  }

  std::string str;
  std::vector<double> aircraft_data;
  while(getline(ifs,str)){
    std::istringstream stream(str);
    double val;
    stream >> val;
    aircraft_data.push_back(val);
  }


  I.xx = 0.008445;
  I.yy = 0.01011;
  I.zz = 0.004132;
  
  C.L0 = aircraft_data[0];
  C.D0 = aircraft_data[1];
  C.m0 = aircraft_data[2];

  C.L.a = aircraft_data[3];
  C.D.a = aircraft_data[4];
  C.C.a = aircraft_data[5];
  C.l.a = aircraft_data[6];
  C.m.a = aircraft_data[7];
  C.n.a = aircraft_data[8];

  C.L.b = aircraft_data[9];
  C.D.b = aircraft_data[10];
  C.C.b = aircraft_data[11];
  C.l.b = -aircraft_data[12];
  C.m.b = aircraft_data[13];
  C.n.b = -aircraft_data[14];

  C.L.p = aircraft_data[15];
  C.D.p = aircraft_data[16];
  C.C.p = -aircraft_data[17];
  C.l.p = aircraft_data[18];
  C.m.p = aircraft_data[19];
  C.n.p = -aircraft_data[20];

  C.L.q = aircraft_data[21];
  C.D.q = aircraft_data[22];
  C.C.q = aircraft_data[23];
  C.l.q = aircraft_data[24];
  C.m.q = aircraft_data[25];
  C.n.q = aircraft_data[26];
  
  C.L.r = aircraft_data[27];
  C.D.r = aircraft_data[28];
  C.C.r = -aircraft_data[29];
  C.l.r = aircraft_data[30];
  C.m.r = aircraft_data[31];
  C.n.r = aircraft_data[32];

  C.L.de = aircraft_data[33];
  C.D.de = aircraft_data[34]; 
  C.C.de = aircraft_data[35];
  C.l.de = aircraft_data[36];
  C.m.de = aircraft_data[37];
  C.n.de = aircraft_data[38];

  C.L.da = aircraft_data[39];
  C.D.da = aircraft_data[40];
  C.C.da = aircraft_data[41];
  C.l.da = aircraft_data[42];
  C.m.da = aircraft_data[43];
  C.n.da = aircraft_data[44];

  C.L.dr = aircraft_data[45];
  C.D.dr = aircraft_data[46];
  C.C.dr = aircraft_data[47];
  C.l.dr = aircraft_data[48];
  C.m.dr = aircraft_data[49];
  C.n.dr = aircraft_data[50];

  T_arm = aircraft_data[51];

  mass = aircraft_data[52];

  Sref = aircraft_data[53];
  Bref = aircraft_data[54];  
  Cref = aircraft_data[55];
  Uref = aircraft_data[56];
}
Ejemplo n.º 8
0
Archivo: qm.hpp Proyecto: bindung/utils
	IfStatement if_(const BoolExpression &exp) {
		IfStatement ifs(this);
		ifs.condition(exp);
		return ifs;
	}
Ejemplo n.º 9
0
void talk(const std::string& filename = "data.dat",
          const std::string& title = "CMSSM spectrum generator run-time")
{
   std::ifstream ifs(filename.c_str());
   std::string line;

   if (!ifs.good()) {
      cout << "Error: could not open file: " << filename << endl;
      return;
   }

   const int NSG = 5;
   const double range_start = 0., range_stop = 0.7;
   TH1D* combined[NSG];
   TH1D* valid[NSG];
   TH1D* invalid[NSG];

   ULong64_t integral_valid[NSG];
   ULong64_t integral_invalid[NSG];
   ULong64_t integral_combined[NSG];

   combined[0] = new TH1D("combined[0]", "Softsusy 3.6.2"        , 20, range_start, range_stop);
   combined[1] = new TH1D("combined[1]", "FlexibleSUSY-CMSSM"    , 20, range_start, range_stop);
   combined[2] = new TH1D("combined[2]", "SPheno 3.3.7"          , 20, range_start, range_stop);
   combined[3] = new TH1D("combined[3]", "SPhenoMSSM"            , 20, range_start, range_stop);
   combined[4] = new TH1D("combined[4]", "FlexibleSUSY-CMSSMNoFV", 20, range_start, range_stop);

   valid[0] = new TH1D("valid[0]", "Softsusy 3.6.2"              , 20, range_start, range_stop);
   valid[1] = new TH1D("valid[1]", "FlexibleSUSY-CMSSM 1.2.0"    , 20, range_start, range_stop);
   valid[2] = new TH1D("valid[2]", "SPheno 3.3.7"                , 20, range_start, range_stop);
   valid[3] = new TH1D("valid[3]", "SPhenoMSSM 3.3.7/4.5.8"      , 20, range_start, range_stop);
   valid[4] = new TH1D("valid[4]", "FlexibleSUSY-CMSSMNoFV 1.2.0", 20, range_start, range_stop);

   invalid[0] = new TH1D("invalid[0]", "Softsusy"              , 20, range_start, range_stop);
   invalid[1] = new TH1D("invalid[1]", "FlexibleSUSY-CMSSM"    , 20, range_start, range_stop);
   invalid[2] = new TH1D("invalid[2]", "SPheno"                , 20, range_start, range_stop);
   invalid[3] = new TH1D("invalid[3]", "SPhenoMSSM"            , 20, range_start, range_stop);
   invalid[4] = new TH1D("invalid[4]", "FlexibleSUSY-CMSSMNoFV", 20, range_start, range_stop);

   for (int i = 0; i < NSG; i++) {
      combined[i]->SetStats(0);
      valid[i]->SetStats(0);
      invalid[i]->SetStats(0);
   }

   // initialize integrals
   for (int i = 0; i < NSG; i++) {
      integral_valid[i] = 0;
      integral_invalid[i] = 0;
      integral_combined[i] = 0;
   }

   while (getline(ifs,line)) {
      std::istringstream input(line);
      std::string word;
      input >> word;
      if (word != "" && word[0] != '#') {
         std::istringstream kk(line);
         double m0, m12, tanb, sgnmu, a0;
         double time[NSG];
         int error[NSG];

         kk >> m0 >> m12 >> tanb >> sgnmu >> a0;
         for (int i = 0; i < NSG; i++) {
            try {
               kk >> time[i] >> error[i];
            } catch (...) {
               cout << "Error: time and error are not convertible for"
                  " spectrum generator " << i << endl;
            }
         }

         for (int i = 0; i < NSG; i++) {
            combined[i]->Fill(time[i]);
            integral_combined[i]++;
            if (error[i] == 0) {
               valid[i]->Fill(time[i]);
               integral_valid[i]++;
            } else {
               invalid[i]->Fill(time[i]);
               integral_invalid[i]++;
            }
         }
      }
   }
Ejemplo n.º 10
0
/*********************************************************************
*
*  chkpt_m::backward_scan_log(lock_heap)
*
*  Scans the log backwards, starting from _lsn until the t_chkpt_begin log record
*  corresponding to the latest completed checkpoint.
*
*********************************************************************/
void chkpt_t::scan_log()
{
    init();

    lsn_t scan_start = smlevel_0::log->durable_lsn();
    if (scan_start == lsn_t(1,0)) { return; }

    log_i scan(*smlevel_0::log, scan_start, false); // false == backward scan
    logrec_t r;
    lsn_t lsn = lsn_t::max;   // LSN of the retrieved log record

    // Set when scan finds begin of previous checkpoint
    lsn_t scan_stop = lsn_t(1,0);

    // CS TODO: not needed with file serialization
    // bool insideChkpt = false;
    while (lsn > scan_stop && scan.xct_next(lsn, r))
    {
        if (r.is_skip() || r.type() == logrec_t::t_comment) {
            continue;
        }

        if (!r.tid().is_null()) {
            if (r.tid() > get_highest_tid()) {
                set_highest_tid(r.tid());
            }

            if (r.is_page_update() || r.is_cpsn()) {
                mark_xct_active(r.tid(), lsn, lsn);

                if (is_xct_active(r.tid())) {
                    if (!r.is_cpsn()) { acquire_lock(r); }
                }
                else if (r.xid_prev().is_null()) {
                    // We won't see this xct again -- delete it
                    delete_xct(r.tid());
                }
            }
        }

        if (r.is_page_update()) {
            w_assert0(r.is_redo());
            mark_page_dirty(r.pid(), lsn, lsn);

            if (r.is_multi_page()) {
                w_assert0(r.pid2() != 0);
                mark_page_dirty(r.pid2(), lsn, lsn);
            }
        }

        switch (r.type())
        {
            case logrec_t::t_chkpt_begin:
                // CS TODO: not needed with file serialization
                // if (insideChkpt) {
                //     // Signal to stop backward log scan loop now
                //     scan_stop = lsn;
                // }
                {
                    fs::path fpath = smlevel_0::log->get_storage()->make_chkpt_path(lsn);
                    if (fs::exists(fpath)) {
                        ifstream ifs(fpath.string(), ios::binary);
                        deserialize_binary(ifs);
                        ifs.close();
                        scan_stop = lsn;
                    }
                }

                break;

            case logrec_t::t_chkpt_bf_tab:
                // CS TODO: not needed with file serialization
                // if (insideChkpt) {
                //     const chkpt_bf_tab_t* dp = (chkpt_bf_tab_t*) r.data();
                //     for (uint i = 0; i < dp->count; i++) {
                //         mark_page_dirty(dp->brec[i].pid, dp->brec[i].page_lsn,
                //                 dp->brec[i].rec_lsn);
                //     }
                // }
                break;


            case logrec_t::t_chkpt_xct_lock:
                // CS TODO: not needed with file serialization
                // if (insideChkpt) {
                //     const chkpt_xct_lock_t* dp = (chkpt_xct_lock_t*) r.data();
                //     if (is_xct_active(dp->tid)) {
                //         for (uint i = 0; i < dp->count; i++) {
                //             add_lock(dp->tid, dp->xrec[i].lock_mode,
                //                     dp->xrec[i].lock_hash);
                //         }
                //     }
                // }
                break;

            case logrec_t::t_chkpt_xct_tab:
                // CS TODO: not needed with file serialization
                // if (insideChkpt) {
                //     const chkpt_xct_tab_t* dp = (chkpt_xct_tab_t*) r.data();
                //     for (size_t i = 0; i < dp->count; ++i) {
                //         tid_t tid = dp->xrec[i].tid;
                //         w_assert1(!tid.is_null());
                //         mark_xct_active(tid, dp->xrec[i].first_lsn,
                //                 dp->xrec[i].last_lsn);
                //     }
                // }
                break;


                // CS TODO: not needed with file serialization
            // case logrec_t::t_chkpt_end:
                // checkpoints should not run concurrently
                // w_assert0(!insideChkpt);
                // insideChkpt = true;
                break;

            // CS TODO: why do we need this? Isn't it related to 2PC?
            // case logrec_t::t_xct_freeing_space:
            case logrec_t::t_xct_end:
            case logrec_t::t_xct_abort:
                mark_xct_ended(r.tid());
                break;

            case logrec_t::t_xct_end_group:
                {
                    // CS TODO: is this type of group commit still used?
                    w_assert0(false);
                    const xct_list_t* list = (xct_list_t*) r.data();
                    uint listlen = list->count;
                    for(uint i=0; i<listlen; i++) {
                        tid_t tid = list->xrec[i].tid;
                        mark_xct_ended(tid);
                    }
                }
                break;

            case logrec_t::t_page_write:
                {
                    char* pos = r.data();

                    PageID pid = *((PageID*) pos);
                    pos += sizeof(PageID);

                    lsn_t clean_lsn = *((lsn_t*) pos);
                    pos += sizeof(lsn_t);

                    uint32_t count = *((uint32_t*) pos);
                    PageID end = pid + count;

                    while (pid < end) {
                        mark_page_clean(pid, clean_lsn);
                        pid++;
                    }
                }
                break;

            case logrec_t::t_add_backup:
                {
                    const char* dev = (const char*)(r.data_ssx());
                    add_backup(dev);
                }
                break;

            case logrec_t::t_chkpt_backup_tab:
                // CS TODO
                break;

            case logrec_t::t_restore_begin:
            case logrec_t::t_restore_end:
            case logrec_t::t_restore_segment:
            case logrec_t::t_chkpt_restore_tab:
                // CS TODO - IMPLEMENT!
                break;

            default:
                break;

        } //switch
    } //while

    w_assert0(lsn == scan_stop);

    cleanup();
}
    void TestArchiveAlarcon2004OxygenBasedCellCycleModels()
    {
        OutputFileHandler handler("archive", false);
        std::string archive_filename = handler.GetOutputDirectoryFullPath() + "Alarcon2004OxygenBasedCellCycleModel.arch";

        // Set up oxygen_concentration
        double oxygen_concentration = 1.0;

        {
            // We must set up SimulationTime to avoid memory leaks
            SimulationTime::Instance()->SetEndTimeAndNumberOfTimeSteps(1.0, 1);

            // As usual, we archive via a pointer to the most abstract class possible
            AbstractCellCycleModel* const p_model = new Alarcon2004OxygenBasedCellCycleModel;

            p_model->SetDimension(1);
            p_model->SetBirthTime(-1.5);
            static_cast<Alarcon2004OxygenBasedCellCycleModel*>(p_model)->SetDt(0.085);

            // We must create a cell to be able to initialise the cell cycle model's ODE system
            MAKE_PTR(WildTypeCellMutationState, p_healthy_state);
            MAKE_PTR(StemCellProliferativeType, p_stem_type);
            CellPtr p_cell(new Cell(p_healthy_state, p_model));
            p_cell->SetCellProliferativeType(p_stem_type);
            p_cell->GetCellData()->SetItem("oxygen", oxygen_concentration);
            p_cell->InitialiseCellCycleModel();

            std::ofstream ofs(archive_filename.c_str());
            boost::archive::text_oarchive output_arch(ofs);

            output_arch << p_model;

            // Note that here, deletion of the cell-cycle model is handled by the cell destructor
            SimulationTime::Destroy();
        }

        {
            // We must set SimulationTime::mStartTime here to avoid tripping an assertion
            SimulationTime::Instance()->SetStartTime(0.0);

            AbstractCellCycleModel* p_model2;

            std::ifstream ifs(archive_filename.c_str(), std::ios::binary);
            boost::archive::text_iarchive input_arch(ifs);

            input_arch >> p_model2;

            TS_ASSERT_EQUALS(p_model2->GetDimension(), 1u);
            TS_ASSERT_DELTA(p_model2->GetBirthTime(), -1.5, 1e-12);
            TS_ASSERT_DELTA(static_cast<Alarcon2004OxygenBasedCellCycleModel*>(p_model2)->GetDt(), 0.085, 1e-3);

            Alarcon2004OxygenBasedCellCycleModel* p_static_cast_model =
                static_cast<Alarcon2004OxygenBasedCellCycleModel*>(p_model2);

            Alarcon2004OxygenBasedCellCycleOdeSystem* p_ode_system =
                static_cast<Alarcon2004OxygenBasedCellCycleOdeSystem*>(p_static_cast_model->GetOdeSystem());

            TS_ASSERT(p_ode_system != NULL);
            TS_ASSERT_EQUALS(p_ode_system->IsLabelled(), false);

            // Avoid memory leaks
            delete p_model2;
        }
    }
Ejemplo n.º 12
0
bool INI::load(string sFile) {
	ifstream ifs(sFile.c_str());
	if(!ifs.is_open()) {
		cout << "error: cannot load ini file:" << sFile << endl;
		return false;
	}
	string line;
	string section;
	while(getline(ifs,line)) {
		// empty line.
		if(line.size() == 0) {
			INISortedEntry* se = new INISortedEntry("", INI_NEW_LINE);
			sorted_entries.push_back(se);
			continue;
		}
			
		// get key
		string key;
		int key_end = 0;
		for(int i = 0; i < line.size(); ++i) {
			if(line[i] == '=') {
				key_end = i+1;
				break;
			}
			else {
				if(line[i] != ' ') {
					key.push_back(line[i]);
				}
			}
		}
		
		// is it a comment?
		if(key.at(0) == '#') {
			INISortedEntry* sorted_entry = new INISortedEntry(line, INI_COMMENT);
			sorted_entries.push_back(sorted_entry);
			continue;
		}
		
		// is key a section?
		if(key.at(0) == '[') {
			section = "";
			for(int i = 0; i < key.size(); ++i) {
				if(key[i] != '[' && key[i] != ']' && key[i] != 0x0D && key[i] != 0x0A)  {
					section.push_back(key[i]);
				}
			}
			continue;
		}
		
		// get value.
		string val;
		for(int i = key_end; i < line.size(); ++i) {
			if(line[i] == '\r' || line[i] == '\n') {
				break;
			}
			val.push_back(line[i]);
		}
			

		// trim 
		string key_copy = key;
		if(section != "") {
			key = "." +key;
		}
		
		string dict_key = section + key;
		INIEntry* entry = new INIEntry(key_copy, val, section);
		dict.insert(pair<string,INIEntry*>(dict_key,entry));
		INISortedEntry* sorted_entry = new INISortedEntry(dict_key, INI_ENTRY);
		sorted_entries.push_back(sorted_entry);
	}
	return true;
}
Ejemplo n.º 13
0
/*
XWinManaged xwin(Dims(WIDTH,HEIGHT*2), 1, 1, "Test SIFT");


rutz::shared_ptr<VisualObject> objTop, objBottom;

void showObjs(rutz::shared_ptr<VisualObject> obj1, rutz::shared_ptr<VisualObject> obj2){
        //return ;

        Image<PixRGB<byte> > keyIma = rescale(obj1->getKeypointImage(),
                        WIDTH, HEIGHT);
        objTop = obj1;

        if (obj2.is_valid()){
                keyIma = concatY(keyIma, rescale(obj2->getKeypointImage(),
                                        WIDTH, HEIGHT));
                objBottom = obj2;
        }

        xwin.drawImage(keyIma);
}

void showKeypoint(rutz::shared_ptr<VisualObject> obj, int keypi,
                Keypoint::CHANNEL channel = Keypoint::ORI){

        char winTitle[255];
        switch(channel){
                case Keypoint::ORI:
                        sprintf(winTitle, "Keypoint view (Channel ORI)");
                        break;
                case Keypoint::COL:
                        sprintf(winTitle, "Keypoint view (Channel COL)");
         break;
                default:
                        sprintf(winTitle, "Keypoint view (Channel   )");
                        break;
        }


        rutz::shared_ptr<Keypoint> keyp = obj->getKeypoint(keypi);
        float x = keyp->getX();
        float y = keyp->getY();
        float s = keyp->getS();
        float o = keyp->getO();
        float m = keyp->getM();

        uint FVlength = keyp->getFVlength(channel);
        if (FVlength<=0) return; //dont show the Keypoint if we dont have a FV

        XWinManaged *xwinKey = new XWinManaged(Dims(WIDTH*2,HEIGHT), -1, -1, winTitle);


        //draw the circle around the keypoint
        const float sigma = 1.6F * powf(2.0F, s / float(6 - 3));
        const float sig = 1.5F * sigma;
        const int rad = int(3.0F * sig);

        Image<PixRGB<byte> > img = obj->getImage();
        Point2D<int> loc(int(x + 0.5F), int(y + 0.5F));
        drawCircle(img, loc, rad, PixRGB<byte>(255, 0, 0));
        drawDisk(img, loc, 2, PixRGB<byte>(255,0,0));

        s=s*5.0F; //mag for scale
        if (s > 0.0f) drawLine(img, loc,
                        Point2D<int>(int(x + s * cosf(o)  + 0.5F),
                                int(y + s * sinf(o) + 0.5F)),
                        PixRGB<byte>(255, 0, 0));

        char info[255];
        sprintf(info, "(%0.2f,%0.2f) s=%0.2f o=%0.2f m=%0.2f", x, y, s, o, m);

        writeText(img, Point2D<int>(0, HEIGHT-20), info,
                        PixRGB<byte>(255), PixRGB<byte>(127));


        //draw the vectors from the features vectors

        Image<PixRGB<byte> > fvDisp(WIDTH, HEIGHT, NO_INIT);
        fvDisp.clear(PixRGB<byte>(255, 255, 255));
        int xBins = int((float)WIDTH/4);
        int yBins = int((float)HEIGHT/4);

        drawGrid(fvDisp, xBins, yBins, 1, 1, PixRGB<byte>(0, 0, 0));



        switch (channel){
                case Keypoint::ORI:
                        for (int xx=0; xx<4; xx++){
                                for (int yy=0; yy<4; yy++){
                                        for (int oo=0; oo<8; oo++){
                                                Point2D<int> loc(xBins/2+(xBins*xx), yBins/2+(yBins*yy));
                                                byte mag = keyp->getFVelement(xx*32+yy*8+oo, channel);
                                                mag = mag/4;
                                                drawDisk(fvDisp, loc, 2, PixRGB<byte>(255, 0, 0));
                                                drawLine(fvDisp, loc,
                                                                Point2D<int>(int(loc.i + mag*cosf(oo*M_PI/4)),
                                                                        int(loc.j + mag*sinf(oo*M_PI/4))),
                                                                PixRGB<byte>(255, 0, 0));
                                        }
                                }
                        }
                        break;

                case Keypoint::COL:
                        for (int xx=0; xx<4; xx++){
                                for (int yy=0; yy<4; yy++){
                                        for (int cc=0; cc<3; cc++){
                                                Point2D<int> loc(xBins/2+(xBins*xx), yBins/2+(yBins*yy));
                                                byte mag = keyp->getFVelement(xx*12+yy*3+cc, channel);
                                                mag = mag/4;
                                                drawDisk(fvDisp, loc, 2, PixRGB<byte>(255, 0, 0));
                                                drawLine(fvDisp, loc,
                                                                Point2D<int>(int(loc.i + mag*cosf(-1*cc*M_PI/2)),
                                                                        int(loc.j + mag*sinf(-1*cc*M_PI/2))),
                                                                PixRGB<byte>(255, 0, 0));
                                        }
                                }
                        }
                        break;
                default:
                        break;
        }



        Image<PixRGB<byte> > disp = img;
        disp = concatX(disp, fvDisp);


        xwinKey->drawImage(disp);

        while(!xwinKey->pressedCloseButton()){
                usleep(100);
        }
        delete xwinKey;

}



void analizeImage(){
   int key = -1;

        while(key != 24){ // q to quit window
                key = xwin.getLastKeyPress();
                Point2D<int>  point = xwin.getLastMouseClick();
                if (point.i > -1 && point.j > -1){

                        //get the right object
                        rutz::shared_ptr<VisualObject> obj;
                        if (point.j < HEIGHT){
                                obj = objTop;
                        } else {
                                obj = objBottom;
                                point.j = point.j - HEIGHT;
                        }
                        LINFO("ClickInfo: key = %i, p=%i,%i", key, point.i, point.j);

                        //find the keypoint
                        for(uint i=0; i<obj->numKeypoints(); i++){
                                rutz::shared_ptr<Keypoint> keyp = obj->getKeypoint(i);
                                float x = keyp->getX();
                                float y = keyp->getY();

                                if ( (point.i < (int)x + 5 && point.i > (int)x - 5) &&
                                          (point.j < (int)y + 5 && point.j > (int)y - 5)){
                                        showKeypoint(obj, i, Keypoint::ORI);
                                        showKeypoint(obj, i, Keypoint::COL);
                                }

                        }

                }
        }

}
*/
int main(const int argc, const char **argv)
{

  MYLOGVERB = LOG_INFO;
  ModelManager manager("Test SIFT");



  nub::ref<InputFrameSeries> ifs(new InputFrameSeries(manager));
  manager.addSubComponent(ifs);

  nub::ref<OutputFrameSeries> ofs(new OutputFrameSeries(manager));
  manager.addSubComponent(ofs);



  if (manager.parseCommandLine(
        (const int)argc, (const char**)argv, "<database file> <trainingLabel>", 2, 2) == false)
    return 0;

  manager.start();

  Timer masterclock;                // master clock for simulations
  Timer timer;

  const char *vdbFile = manager.getExtraArg(0).c_str();
  const char *trainingLabel = manager.getExtraArg(1).c_str();

  int numMatches = 0; //the number of correct matches
  int totalObjects = 0; //the number of objects presented to the network
  int uObjId = 0; //a unique obj id for sift

  bool train = false;
  //load the database file
 // if (!train)
  vdb.loadFrom(std::string(vdbFile));

  while(1)
  {
    Image< PixRGB<byte> > inputImg;
    const FrameState is = ifs->updateNext();
    if (is == FRAME_COMPLETE)
      break;

    //grab the images
    GenericFrame input = ifs->readFrame();
    if (!input.initialized())
      break;
    inputImg = input.asRgb();
    totalObjects++;

    ofs->writeRGB(inputImg, "Input", FrameInfo("Input", SRC_POS));


    if (train)
    {
      //add the object to the database
      char objName[255]; sprintf(objName, "%s_%i", trainingLabel, uObjId);
      uObjId++;
      rutz::shared_ptr<VisualObject>
        vo(new VisualObject(objName, "NULL", inputImg,
              Point2D<int>(-1,-1),
              std::vector<float>(),
              std::vector< rutz::shared_ptr<Keypoint> >(),
              USECOLOR));

      vdb.addObject(vo);
    } else {

      //get the object classification
      std::string objName;
      std::string tmpName = matchObject(inputImg);
      int i = tmpName.find("_");
      objName.assign(tmpName, 0, i);
      LINFO("Object name %s", objName.c_str());
      printf("%i %s\n", ifs->frame(), objName.c_str());

      if (objName == trainingLabel)
        numMatches++;

      //printf("objid %i:class %i:rate=%0.2f\n",
      //    objData.description.c_str(), objData.id, cls,
      //    (float)numMatches/(float)totalObjects);
    }
  }

  if (train)
  {
    printf("Trained on %i objects\n", totalObjects);
    printf("Object in db %i\n" , vdb.numObjects());
    vdb.saveTo(std::string(vdbFile));
  } else {
    printf("Classification Rate: %i/%i %0.2f\n",
        numMatches, totalObjects,
        (float)numMatches/(float)totalObjects);
  }


}
Ejemplo n.º 14
0
bool VehicleParam::loadFromFile(std::string fileName)
{
	std::ifstream ifs(fileName.c_str());
	if (ifs.bad())
		return false;

	//std paramer

	if (!readLine(ifs, "LinearDamping", m_sVehicleParam.LinearDamping))
		return false;
	if (!readLine(ifs, "AngularDamping", m_sVehicleParam.AngularDamping))
		return false;;
	if (!readLine(ifs, "MotorTorque", m_sVehicleParam.MotorTorque))
		return false;;
	if (!readLine(ifs, "SteerAngleRange", m_sVehicleParam.SteerAngleRange))
		return false;;
	if (!readLine(ifs, "SteerSpeed", m_sVehicleParam.SteerSpeed))
		return false;;

	std::string str;
	for (int i=0;i<2;i++)
	{
		str = i==0 ? "Front" : "Rear";
		for (int j=0;j<2;j++)
		{
			for (int k=0;k<5;k++)
			{
				std::string ttfStr = j==0 ? "LNG" : "LAT";
				switch(k)
				{
				case 0:
					ttfStr += "extremumSlip";
					break;
				case 1:
					ttfStr += "extremumValue";
					break;
				case 2:
					ttfStr += "asymptoteSlip";
					break;
				case 3:
					ttfStr += "asymptoteValue";
					break;
				case 4:
					ttfStr += "stiffnessFactor";
				}
				if ( !readLine(ifs, str + ttfStr, getTTF(i, j, k)))
					return false;
			}
		}

		//deal with suspension

		NxSpringDesc& sup = i == 0 ? m_sVehicleParam.FrontSuspension:
									m_sVehicleParam.RearSuspension;
		if (!readLine(ifs, str+"SuspensionSpring", sup.spring))
			return false;
		if (!readLine(ifs, str+"SuspensionDamping", sup.damper))
			return false;
		if (!readLine(ifs, str+"SuspensionTargetValue", sup.targetValue))
			return false;

		float& supTra = i==0 ? m_sVehicleParam.FrontSuspensionTravel:
								m_sVehicleParam.RearSuspensionTravel;
		if (!readLine(ifs, str+"SuspensionTravel", supTra))
			return false;
	}

	ifs.close();

	return true;
}
Ejemplo n.º 15
0
void RunHardwareDetection()
{
	TIMER(L"RunHardwareDetection");

	ScriptInterface scriptInterface("Engine", "HWDetect", g_ScriptRuntime);
	JSContext* cx = scriptInterface.GetContext();
	JSAutoRequest rq(cx);

	scriptInterface.RegisterFunction<void, bool, &SetDisableAudio>("SetDisableAudio");
	scriptInterface.RegisterFunction<void, bool, &SetDisableS3TC>("SetDisableS3TC");
	scriptInterface.RegisterFunction<void, bool, &SetDisableShadows>("SetDisableShadows");
	scriptInterface.RegisterFunction<void, bool, &SetDisableShadowPCF>("SetDisableShadowPCF");
	scriptInterface.RegisterFunction<void, bool, &SetDisableAllWater>("SetDisableAllWater");
	scriptInterface.RegisterFunction<void, bool, &SetDisableFancyWater>("SetDisableFancyWater");
	scriptInterface.RegisterFunction<void, bool, &SetEnableGLSL>("SetEnableGLSL");
	scriptInterface.RegisterFunction<void, bool, &SetEnablePostProc>("SetEnablePostProc");
	scriptInterface.RegisterFunction<void, bool, &SetEnableSmoothLOS>("SetEnableSmoothLOS");
	scriptInterface.RegisterFunction<void, std::string, &SetRenderPath>("SetRenderPath");

	// Load the detection script:

	const wchar_t* scriptName = L"hwdetect/hwdetect.js";
	CVFSFile file;
	if (file.Load(g_VFS, scriptName) != PSRETURN_OK)
	{
		LOGERROR("Failed to load hardware detection script");
		return;
	}

	std::string code = file.DecodeUTF8(); // assume it's UTF-8
	scriptInterface.LoadScript(scriptName, code);

	// Collect all the settings we'll pass to the script:
	// (We'll use this same data for the opt-in online reporting system, so it
	// includes some fields that aren't directly useful for the hwdetect script)

	JS::RootedValue settings(cx);
	scriptInterface.Eval("({})", &settings);

	scriptInterface.SetProperty(settings, "os_unix", OS_UNIX);
	scriptInterface.SetProperty(settings, "os_bsd", OS_BSD);
	scriptInterface.SetProperty(settings, "os_linux", OS_LINUX);
	scriptInterface.SetProperty(settings, "os_android", OS_ANDROID);
	scriptInterface.SetProperty(settings, "os_macosx", OS_MACOSX);
	scriptInterface.SetProperty(settings, "os_win", OS_WIN);

	scriptInterface.SetProperty(settings, "arch_ia32", ARCH_IA32);
	scriptInterface.SetProperty(settings, "arch_amd64", ARCH_AMD64);
	scriptInterface.SetProperty(settings, "arch_arm", ARCH_ARM);
	scriptInterface.SetProperty(settings, "arch_aarch64", ARCH_AARCH64);

#ifdef NDEBUG
	scriptInterface.SetProperty(settings, "build_debug", 0);
#else
	scriptInterface.SetProperty(settings, "build_debug", 1);
#endif
	scriptInterface.SetProperty(settings, "build_opengles", CONFIG2_GLES);

	scriptInterface.SetProperty(settings, "build_datetime", std::string(__DATE__ " " __TIME__));
	scriptInterface.SetProperty(settings, "build_revision", std::wstring(svn_revision));

	scriptInterface.SetProperty(settings, "build_msc", (int)MSC_VERSION);
	scriptInterface.SetProperty(settings, "build_icc", (int)ICC_VERSION);
	scriptInterface.SetProperty(settings, "build_gcc", (int)GCC_VERSION);
	scriptInterface.SetProperty(settings, "build_clang", (int)CLANG_VERSION);

	scriptInterface.SetProperty(settings, "gfx_card", gfx::CardName());
	scriptInterface.SetProperty(settings, "gfx_drv_ver", gfx::DriverInfo());

	scriptInterface.SetProperty(settings, "snd_card", std::wstring(snd_card));
	scriptInterface.SetProperty(settings, "snd_drv_ver", std::wstring(snd_drv_ver));

	ReportGLLimits(scriptInterface, settings);

	scriptInterface.SetProperty(settings, "video_xres", g_VideoMode.GetXRes());
	scriptInterface.SetProperty(settings, "video_yres", g_VideoMode.GetYRes());
	scriptInterface.SetProperty(settings, "video_bpp", g_VideoMode.GetBPP());

	scriptInterface.SetProperty(settings, "video_desktop_xres", g_VideoMode.GetDesktopXRes());
	scriptInterface.SetProperty(settings, "video_desktop_yres", g_VideoMode.GetDesktopYRes());
	scriptInterface.SetProperty(settings, "video_desktop_bpp", g_VideoMode.GetDesktopBPP());
	scriptInterface.SetProperty(settings, "video_desktop_freq", g_VideoMode.GetDesktopFreq());

	struct utsname un;
	uname(&un);
	scriptInterface.SetProperty(settings, "uname_sysname", std::string(un.sysname));
	scriptInterface.SetProperty(settings, "uname_release", std::string(un.release));
	scriptInterface.SetProperty(settings, "uname_version", std::string(un.version));
	scriptInterface.SetProperty(settings, "uname_machine", std::string(un.machine));

#if OS_LINUX
	{
		std::ifstream ifs("/etc/lsb-release");
		if (ifs.good())
		{
			std::string str((std::istreambuf_iterator<char>(ifs)), std::istreambuf_iterator<char>());
			scriptInterface.SetProperty(settings, "linux_release", str);
		}
	}
#endif

	scriptInterface.SetProperty(settings, "cpu_identifier", std::string(cpu_IdentifierString()));
	scriptInterface.SetProperty(settings, "cpu_frequency", os_cpu_ClockFrequency());
	scriptInterface.SetProperty(settings, "cpu_pagesize", (u32)os_cpu_PageSize());
	scriptInterface.SetProperty(settings, "cpu_largepagesize", (u32)os_cpu_LargePageSize());
	scriptInterface.SetProperty(settings, "cpu_numprocs", (u32)os_cpu_NumProcessors());
#if ARCH_X86_X64
	scriptInterface.SetProperty(settings, "cpu_numpackages", (u32)topology::NumPackages());
	scriptInterface.SetProperty(settings, "cpu_coresperpackage", (u32)topology::CoresPerPackage());
	scriptInterface.SetProperty(settings, "cpu_logicalpercore", (u32)topology::LogicalPerCore());
	scriptInterface.SetProperty(settings, "cpu_numcaches", (u32)topology::NumCaches());
#endif

	scriptInterface.SetProperty(settings, "numa_numnodes", (u32)numa_NumNodes());
	scriptInterface.SetProperty(settings, "numa_factor", numa_Factor());
	scriptInterface.SetProperty(settings, "numa_interleaved", numa_IsMemoryInterleaved());

	scriptInterface.SetProperty(settings, "ram_total", (u32)os_cpu_MemorySize());
	scriptInterface.SetProperty(settings, "ram_total_os", (u32)os_cpu_QueryMemorySize());
	scriptInterface.SetProperty(settings, "ram_free", (u32)os_cpu_MemoryAvailable());

#if ARCH_X86_X64
	scriptInterface.SetProperty(settings, "x86_frequency", x86_x64::ClockFrequency());

	scriptInterface.SetProperty(settings, "x86_vendor", (u32)x86_x64::Vendor());
	scriptInterface.SetProperty(settings, "x86_model", (u32)x86_x64::Model());
	scriptInterface.SetProperty(settings, "x86_family", (u32)x86_x64::Family());

	u32 caps0, caps1, caps2, caps3;
	x86_x64::GetCapBits(&caps0, &caps1, &caps2, &caps3);
	scriptInterface.SetProperty(settings, "x86_caps[0]", caps0);
	scriptInterface.SetProperty(settings, "x86_caps[1]", caps1);
	scriptInterface.SetProperty(settings, "x86_caps[2]", caps2);
	scriptInterface.SetProperty(settings, "x86_caps[3]", caps3);

	JS::RootedValue tmpVal(cx);
	ConvertCaches(scriptInterface, x86_x64::L1I, &tmpVal);
	scriptInterface.SetProperty(settings, "x86_icaches", tmpVal);
	ConvertCaches(scriptInterface, x86_x64::L1D, &tmpVal);
	scriptInterface.SetProperty(settings, "x86_dcaches", tmpVal);
	ConvertTLBs(scriptInterface, &tmpVal);
	scriptInterface.SetProperty(settings, "x86_tlbs", tmpVal);
#endif

	scriptInterface.SetProperty(settings, "timer_resolution", timer_Resolution());

	// Send the same data to the reporting system
	g_UserReporter.SubmitReport("hwdetect", 11, scriptInterface.StringifyJSON(&settings, false));

	// Run the detection script:
	JS::RootedValue global(cx, scriptInterface.GetGlobalObject());
	scriptInterface.CallFunctionVoid(global, "RunHardwareDetection", settings);
}
Ejemplo n.º 16
0
bool PhaseEstimator::LoadPhaseEstimationTrainSubset(const string& phase_file_name)
{
    Json::Value json, temp_value;
    ifstream ifs(phase_file_name.c_str());

    if (ifs.fail()) {
        cerr << "PhaseEstimator ERROR: Unable to load phase estimates from file: " << phase_file_name << endl;
        return false;
    }

    ifs >> json;
    ifs.close();

    if (json["TrainSubset"].isNull()) {
    	cerr << "PhaseEstimator WARNING: No TrainSubset available in file: " << phase_file_name << endl;
        return false;
    }

    train_subset_count_ = json["TrainSubset"]["TrainSubsetCount"].asInt();
    if(train_subset_count_ < 1) {
        cerr << "PhaseEstimator ERROR: TrainSubsetCount in file " << phase_file_name << " is less than 1." << endl;
        return false;
    } else if ((int)json["TrainSubset"]["CFbyRegion"].size() != train_subset_count_ or
               (int)json["TrainSubset"]["IEbyRegion"].size() != train_subset_count_ or
               (int)json["TrainSubset"]["CFbyRegion"].size() != train_subset_count_){
    	cerr << "PhaseEstimator ERROR: Number of array elements in regions in does not match TrainSubsetCount." << endl;
    	train_subset_count_ = 0;
        return false;
    }

    train_subset_cf_.resize(train_subset_count_);
    train_subset_ie_.resize(train_subset_count_);
    train_subset_dr_.resize(train_subset_count_);
    train_subset_regions_y_.resize(train_subset_count_);
    train_subset_regions_x_.resize(train_subset_count_);

    for(int i = 0; i < train_subset_count_; ++i)
    {
        train_subset_regions_y_[i] = json["TrainSubset"]["RegionRows"][i].asInt();
        train_subset_regions_x_[i] = json["TrainSubset"]["RegionCols"][i].asInt();
        int n = train_subset_regions_y_[i] * train_subset_regions_x_[i];

        if (n==0 or (int)json["TrainSubset"]["CFbyRegion"][i].size() != n or
                    (int)json["TrainSubset"]["IEbyRegion"][i].size() != n or
                    (int)json["TrainSubset"]["DRbyRegion"][i].size() != n ){
        	cerr << "PhaseEstimator ERROR: Unexpected number of array elements for TrainSubset "<< i <<"." << endl;
        	train_subset_count_ = 0;
            return false;
        }

        vector<float> cf;
        vector<float> ie;
        vector<float> dr;

		for(int j = 0; j < n; ++j)
        {
            cf.push_back(json["TrainSubset"]["CFbyRegion"][i][j].asFloat());
            ie.push_back(json["TrainSubset"]["IEbyRegion"][i][j].asFloat());
            dr.push_back(json["TrainSubset"]["DRbyRegion"][i][j].asFloat());
        }

        train_subset_cf_[i] = cf;
        train_subset_ie_[i] = ie;
        train_subset_dr_[i] = dr;
    }

    // Transfer one of the train subsets to the results structure
    result_regions_y_ = train_subset_regions_y_[train_subset_count_ - 1];
    result_regions_x_ = train_subset_regions_x_[train_subset_count_ - 1];

    result_cf_ = train_subset_cf_[train_subset_count_ - 1];
    result_ie_ = train_subset_ie_[train_subset_count_ - 1];
    result_dr_ = train_subset_dr_[train_subset_count_ - 1];
    average_cf_ = 0;
    average_ie_ = 0;
    average_dr_ = 0;
    int count = 0;

    for (int r = 0; r < result_regions_x_*result_regions_y_; r++) {
        if (result_cf_[r] || result_ie_[r] || result_dr_[r]) {
            average_cf_ += result_cf_[r];
            average_ie_ += result_ie_[r];
            average_dr_ += result_dr_[r];
        count++;
        }
    }
    if (count > 0) {
        average_cf_ /= count;
        average_ie_ /= count;
        average_dr_ /= count;
    }
		
    cout << "PhaseEstimator: Successfully loaded phase estimates from file: " << phase_file_name << endl;
    return true;
}
Ejemplo n.º 17
0
bool Sketch::loadVect(const char *path)
{
    for (unsigned int i = 0; i < strokes_.size(); ++i)
        delete strokes_[i];
    strokes_.clear();

    delete active_polyline_;
    active_polyline_ = NULL;

    std::ifstream ifs(path);

    if (!ifs)
    {
        std::cerr << "Error: could not open sketch file for reading at " << path
                  << "\n" << std::flush;
        return false;
    } else
    {
        bool succeded = false;
        std::string buffer;

        ifs >> buffer;
        if (buffer.compare("VECT") != 0)
        {
            std::cerr << "Error: This VECT is invalid since it does not starts with VECT"
                      << "\n" << std::flush;
            succeded = false;
        } else
        {
            int num_strokes, total_num_points, num_colors;
            ifs >> num_strokes >> total_num_points >> num_colors;

            std::vector<int> stroke_point_counts(num_strokes, 0);
            for (int i = 0; i < num_strokes; ++i)
                ifs >> stroke_point_counts[i];

            int color_count;
            for (int i = 0; i < num_strokes; ++i)
                ifs >> color_count;

            for (int i = 0; i < num_strokes; ++i)
            {
                Stroke *new_stroke = new Stroke ();
                new_stroke->read_text(ifs, stroke_point_counts[i]);
                addStroke(new_stroke);
            }

            //get colors
            int color[4];
            for (int i = 0; i < num_colors; ++i)
                ifs >> color[0] >> color[1] >> color[2] >> color[3];

            //get view frame
            camera_info_.read_text(ifs);
//            ifs >> view_position_[0] >> view_position_[1] >> view_position_[2];
//            ifs >> view_direction_[0] >> view_direction_[1] >> view_direction_[2];

            succeded = true;
        }

        ifs.close();
        return succeded;
    }

}
Ejemplo n.º 18
0
int main(int argc, char *argv[])
{
    setbuf(stdout, NULL);

    uint16_t nfiles = 0;

    uint8_t filter_systemid = 0xFF, filter_tmtype = 0xFF;
    bool filter_events = false;

    bool save_packets = false;
    char outfile[256];

    for(int i = 1; i < argc; i++) {
        if(argv[i][0] == '-') {
            for(int j = 1; argv[i][j] != 0; j++) {
                switch(argv[i][j]) {
                    case 'e':
                        filter_events = true;
                        j = strlen(&argv[i][0]) - 1;
                        break;
                    case 'f':
                        if(argv[i][j+1] == 's') filter_systemid = atoi(&argv[i][j+2]);
                        if(argv[i][j+1] == 't') filter_tmtype = atoi(&argv[i][j+2]);
                        j = strlen(&argv[i][0]) - 1;
                        break;
                    case 'o':
                        save_packets = true;
                        strncpy(outfile, &argv[i][j+1], 256);
                        outfile[255] = 0;
                        j = strlen(&argv[i][0]) - 1;
                        break;
                    case '?':
                        help_message(argv[0]);
                        return -1;
                    default:
                        std::cerr << "Unknown option, use -? to list options\n";
                        return -1;
                }
            }
        } else {
            nfiles++;
        }
    }

    if(nfiles == 0) {
        help_message(argv[0]);
        return -1;
    }

    std::streampos cur;

    uint8_t buffer[TELEMETRY_PACKET_MAX_SIZE];
    buffer[0] = 0x90;

    uint16_t length;

    uint32_t count[256][256];
    uint32_t bad_checksum[256][256];
    uint64_t amount[256][256];
    uint16_t previous_frame_counter[256][256];
    uint32_t gaps[256][256];
    Clock first_systemtime = 0, last_systemtime = 0;
    bool not_coincident[16];

    std::ofstream log;
    if (save_packets) {
        log.open(outfile, std::ofstream::binary);
    }

    TelemetryPacket tp(NULL);

    for(int i = 1; i < argc; i++) {
        memset(count, 0, sizeof(count));
        memset(bad_checksum, 0, sizeof(bad_checksum));
        memset(amount, 0, sizeof(amount));
        memset(previous_frame_counter, 0xFF, sizeof(previous_frame_counter));
        memset(gaps, 0, sizeof(gaps));
        first_systemtime = last_systemtime = 0;
        memset(not_coincident, 0, sizeof(not_coincident));

        if(argv[i][0] != '-') {
            std::cout << "Inspecting " << argv[i] << std::endl;

            uint8_t percent_completed = 0;

            std::ifstream ifs(argv[i]);

            if(ifs.good()) {
                ifs.seekg(0, ifs.end);
                std::streampos size = ifs.tellg();
                ifs.seekg(0, ifs.beg);

                std::cout << size << " bytes: ";
                std::cout.flush();

                while (ifs.good()) {
                    if(ifs.get() == 0x90) {
                        if(ifs.peek() == 0xeb) {
                            cur = ifs.tellg(); // points one byte into sync word
                            ifs.seekg(5, std::ios::cur);
                            ifs.read((char *)&length, 2);

                            if(length > TELEMETRY_PACKET_MAX_SIZE-16) continue; //invalid payload size

                            ifs.seekg(cur);

                            ifs.read((char *)buffer+1, length+15);

                            tp = TelemetryPacket(buffer, length+16);
                            uint8_t this_systemid = tp.getSystemID();
                            uint8_t this_tmtype = tp.getTmType();

                            if(((!filter_events) || (((this_systemid & 0xF0) == 0x80) && (this_tmtype == 0xF3))) &&
                               ((filter_systemid == 0xFF) || (this_systemid == filter_systemid)) &&
                               ((filter_tmtype == 0xFF) || (this_tmtype == filter_tmtype))) {
                                if(tp.valid()) {
                                    cur += length+15;

                                    count[this_systemid][this_tmtype]++;
                                    amount[this_systemid][this_tmtype] += length+16;
                                    uint16_t this_frame_counter = tp.getCounter();
                                    int16_t frame_counter_difference = this_frame_counter -
                                                                       previous_frame_counter[this_systemid][this_tmtype];
                                    if((previous_frame_counter[this_systemid][this_tmtype] != 0xFFFF) &&
                                       (frame_counter_difference > 1)) {
                                        // Make an exception for quicklook spectrum packets
                                        if(!((frame_counter_difference == 6) && (this_systemid == 0x10) && ((this_tmtype & 0xF0) == 0x10))) {
                                            gaps[this_systemid][this_tmtype]++;
                                        }
                                    }
                                    previous_frame_counter[this_systemid][this_tmtype] = this_frame_counter;

                                    if(((this_systemid & 0xF0) == 0x80) && (this_tmtype == 0xF3)) {
                                        if(((buffer[19] == 0) && (buffer[20] == 0) && (buffer[21] == 0)) ||
                                           ((buffer[22] == 0) && (buffer[23] == 0) && (buffer[24] == 0))) {
                                            not_coincident[this_systemid & 0x0F] = true;
                                        }
                                    }

                                    if(first_systemtime == 0) first_systemtime = tp.getSystemTime();
                                    last_systemtime = tp.getSystemTime();

                                    if(save_packets && log.is_open()) {
                                        log.write((char *)buffer, length+16);
                                    }
                                } else {
                                    bad_checksum[this_systemid][tp.getTmType()]++;
                                }
                            }

                            if((((uint64_t)ifs.tellg())*100/size) > percent_completed) {
                                percent_completed++;
                                printf("%3u%%\b\b\b\b", percent_completed);
                            }

                            ifs.seekg(cur);
                        }
                    }
                }

                ifs.close();

                std::cout << "\nPacket breakdown:\n";
                for(int j = 0; j < 256; j++) {
                    for(int k = 0; k < 256; k++) {
                        if(count[j][k] > 0) {
                            printf("  0x%02x 0x%02x : [%4.1f%%] %lu", j, k, 100. * amount[j][k] / size, count[j][k]);
                            if(((j & 0xF0) == 0x80) && (k == 0xF3) && not_coincident[j & 0x0F]) {
                                printf(" (includes non-coincident data!)");
                            }
                            if(bad_checksum[j][k] > 0) {
                                printf(", plus %lu with bad checksums", bad_checksum[j][k]);
                            }
                            if(gaps[j][k] > 0) {
                                printf(", plus %lu gaps", gaps[j][k]);
                            }
                            printf("\n");
                        }
                    }
                }

                printf("Elapsed gondola time: %llu (%f minutes)\n\n", last_systemtime - first_systemtime, (last_systemtime - first_systemtime) * 1e-7 / 60);
            }
        }
    }

    if(save_packets && log.is_open()) {
        log.close();
    }

    return 0;
}
Ejemplo n.º 19
0
ifstream::pos_type DU_File::getFileSize(const string &sFullFileName)
{
    ifstream ifs(sFullFileName.c_str());
    ifs.seekg(0, ios_base::end);
    return ifs.tellg();
}
Ejemplo n.º 20
0
    static bool HandleDebugSendOpcodeCommand(ChatHandler* handler, char const* /*args*/)
    {
        Unit* unit = handler->getSelectedUnit();
        Player* player = NULL;
        if (!unit || (unit->GetTypeId() != TYPEID_PLAYER))
            player = handler->GetSession()->GetPlayer();
        else
            player = (Player*)unit;

        if (!unit)
            unit = player;

        std::ifstream ifs("opcode.txt");
        if (ifs.bad())
            return false;

        // remove comments from file
        std::stringstream parsedStream;
        while (!ifs.eof())
        {
            char commentToken[2];
            ifs.get(commentToken[0]);
            if (commentToken[0] == '/' && !ifs.eof())
            {
                ifs.get(commentToken[1]);
                // /* comment
                if (commentToken[1] == '*')
                {
                    while (!ifs.eof())
                    {
                        ifs.get(commentToken[0]);
                        if (commentToken[0] == '*' && !ifs.eof())
                        {
                            ifs.get(commentToken[1]);
                            if (commentToken[1] == '/')
                                break;
                            else
                                ifs.putback(commentToken[1]);
                        }
                    }
                    continue;
                }
                // line comment
                else if (commentToken[1] == '/')
                {
                    std::string str;
                    getline(ifs, str);
                    continue;
                }
                // regular data
                else
                    ifs.putback(commentToken[1]);
            }
            parsedStream.put(commentToken[0]);
        }
        ifs.close();

        uint32 opcode;
        parsedStream >> opcode;

        WorldPacket data(opcode, 0);

        while (!parsedStream.eof())
        {
            std::string type;
            parsedStream >> type;

            if (type == "")
                break;

            if (type == "uint8")
            {
                uint16 val1;
                parsedStream >> val1;
                data << uint8(val1);
            }
            else if (type == "uint16")
Ejemplo n.º 21
0
errcode DSA1Intro::a_create(Config* config) {
    std::ofstream ofs_dir(config->archive_name.c_str(), std::ios::binary);
    if (!ofs_dir.good()) {
	cerror << "could not write archive directory '" << config->archive_name << "'" << std::endl;
	exit(1);
    }
    
    // Dateigrößen feststellen
    CmdlineList::iterator f = config->fileList.begin();
    while (f != config->fileList.end()) {
	std::ifstream ifs(f->second.name.c_str(), std::ios::binary);
	if (ifs.good()) {
	    f->second.size = filesize(ifs);
	    f++;
	} else {
	    std::cerr << "Warning: Could not open "<< f->second.name << std::endl;
	    CmdlineList::iterator temp = f; temp++;
	    config->fileList.erase(f);
	    f = temp;
	}
	ifs.close();
    }

    // Header schreiben
    readMaster(config->archive_name);
    synchronize(config->fileList);
    write(ofs_dir);
    ofs_dir.close();
    
    // Dateien schreiben
    for(FileList::iterator f = entries.begin(); f != entries.end(); f++) {
	DSA1Intro_Entry* entry = dynamic_cast<DSA1Intro_Entry*>(*f);
	assert(entry != 0);
	Cmdline_Entry cmde = config->fileList.find(entry->name)->second;

	std::ifstream ifs(cmde.name.c_str(), std::ios::binary);
	std::fstream ofs;
	string volname = "";
	if (ifs.good()) {
	    /*if (volname != entry->volname) {
		if (ofs.is_open()) ofs.close();
		ofs.open(entry->volname.c_str(), std::ios::binary);
		if (!ofs.good()) {
		    cerror << "could not write archive volume '" << config->archive_name << "'" << std::endl;
		    exit(-1);
		}
		}*/
	    // TODO: Dieser Modus (app) bereitet Schwierigkeiten beim Überschreiben.
	    ofs.open(entry->volname.c_str(), std::ios::binary | std::ios::out | std::ios::in);
		if (!ofs.good()) {
		    cerror << "could not write archive volume '" << config->archive_name << "'" << std::endl;
		    exit(-1);
		}
	    ifs.seekg(0);
	    ofs.seekp(entry->offset, std::ios::beg);
	    std::cout << "writing from " << cmde.name << ":"<<ifs.tellg()<< " to "
		      << entry->volname << ":"<<entry->offset<<" ["<<entry->size <<"]"<< std::endl;
	    copy(ifs, ofs, entry->size);
	    ofs.close();
	} else {
	    std::cerr << "Error reading file »" << cmde.name <<"«"<< std::endl;
	    exit(0);
	}
	ofs.close();
	ifs.close();
    }
    return ERR_OK;
}
Ejemplo n.º 22
0
// ------------------------------------------------------------------------------------------
Config_V GetConfigVal(string filename,string name,bool dbg) {
  char t_str[SIZE];
  char did[10];
  char moduleType[10];
  int mod,channel;
  int  pre,post;
  int threshold,sampleRate,sampleSize,streamNumber,detectorChannel,
			fullscale,delay,thresholdSign,used;
  float offset;


  // calculate a crate number
  char crateString[25];
  strcpy(crateString,name.c_str());
  if (dbg) cout << "crate name: " << crateString;
  int length=strlen(crateString);
  if (crateString[length-1]==':') { // delete ':'
      crateString[length-1]=0;
      length--;
      }
  if (crateString[length-1]=='g') { // the hosts may have the ending 'g', e.g. 'pcntof19g' g=gigabit
      crateString[length-1]=0;
      length--;
      }
  int crate;
  crate=atoi(&crateString[length-2]);
  if ((crateString[length-4]!='p') && (crateString[length-4]!='P')) crate+=100;
  if (dbg) cout << " number: " << crate << endl;


	Channel_Config	readoutConfig;
	Config_V rconf_v;

	ifstream ifs(filename.c_str());

	if( !ifs ) { // open failed
		cerr << "cannot open file " << filename << endl;
		exit(-1);
		}

	string nameOff,detectoridOff;
   	string::size_type pos;

	while ( ifs.getline(t_str,SIZE)) {
		if(dbg) cout << "-->" << t_str << endl;
		string line = t_str;
		if (line.find_first_of("#") != (string::size_type)0 ) {
			if((pos = line.find(name)) != string::npos ) {	// fist we hunt the name identifier
				nameOff = line.substr(pos + name.size(),line.size());
				sscanf(nameOff.c_str(),"%s%d%d%d%d%d%d%d%d%s%d%d%d%d%f%d",
          did,&streamNumber,&mod,&channel,&pre,&post,
	  &threshold,&sampleRate,&sampleSize,moduleType,
          &fullscale,&detectorChannel,&delay,
          &thresholdSign,&offset,&used );
				if(dbg) printf("nameOff %s\n",nameOff.c_str());
				if(dbg) printf("got %s m: %d ch: %d pre: %d post: %d thr: %d dch: %d\n",did,mod,channel,pre,post,threshold,detectorChannel);
				memcpy(&readoutConfig.id,did,4);
				memcpy(&readoutConfig.moduleType,moduleType,4);
				readoutConfig.clockState=(readoutConfig.moduleType==ACQD_as_int) ? INTC_as_int : EXTC_as_int;
				readoutConfig.str_crate_mod_ch 	= (streamNumber<<24) + (crate<<16) + (mod << 8) + channel;
				readoutConfig.detectorChannel = detectorChannel;
				readoutConfig.fullScale =  fullscale;
				readoutConfig.threshold = threshold;
				readoutConfig.thresholdSign = thresholdSign;
				readoutConfig.delayTime = delay;
				readoutConfig.offset= offset;
				readoutConfig.pre 	= pre;
				readoutConfig.post 	= post;
 				readoutConfig.sampleRate = sampleRate;
				readoutConfig.sampleSize = sampleSize;
				if ((readoutConfig.moduleType!=NONE_as_int) &&
				    (strcmp(did,"*NO*")) &&
				    (used>0))   rconf_v.push_back( readoutConfig );
				}
      } // if
		} // while
  if (rconf_v.size()==0)
	cout << "No config data found for pc " << name.c_str() << endl;
  return rconf_v;
}
Ejemplo n.º 23
0
	std::string
		LoadObj(
		std::vector<shape_t>& shapes,
		const char* filename,
		const char* mtl_basepath)
	{

		shapes.clear();

		std::stringstream err;

		std::ifstream ifs(filename);
		if (!ifs) {
			err << "Cannot open file [" << filename << "]" << std::endl;
			return err.str();
		}

		std::vector<float> v;
		std::vector<float> vn;
		std::vector<float> vt;
		std::vector<std::vector<vertex_index> > faceGroup;
		std::string name;

		// material
		std::map<std::string, material_t> material_map;
		material_t material;

		int maxchars = 8192;  // Alloc enough size.
		std::vector<char> buf(maxchars);  // Alloc enough size.
		while (ifs.peek() != -1) {
			ifs.getline(&buf[0], maxchars);

			std::string linebuf(&buf[0]);

			// Trim newline '\r\n' or '\r'
			if (linebuf.size() > 0) {
				if (linebuf[linebuf.size() - 1] == '\n') linebuf.erase(linebuf.size() - 1);
			}
			if (linebuf.size() > 0) {
				if (linebuf[linebuf.size() - 1] == '\n') linebuf.erase(linebuf.size() - 1);
			}

			// Skip if empty line.
			if (linebuf.empty()) {
				continue;
			}

			// Skip leading space.
			const char* token = linebuf.c_str();
			token += strspn(token, " \t");

			assert(token);
			if (token[0] == '\0') continue; // empty line

			if (token[0] == '#') continue;  // comment line

			// vertex
			if (token[0] == 'v' && isSpace((token[1]))) {
				token += 2;
				float x, y, z;
				parseFloat3(x, y, z, token);
				v.push_back(x);
				v.push_back(y);
				v.push_back(z);
				continue;
			}

			// normal
			if (token[0] == 'v' && token[1] == 'n' && isSpace((token[2]))) {
				token += 3;
				float x, y, z;
				parseFloat3(x, y, z, token);
				vn.push_back(x);
				vn.push_back(y);
				vn.push_back(z);
				continue;
			}

			// texcoord
			if (token[0] == 'v' && token[1] == 't' && isSpace((token[2]))) {
				token += 3;
				float x, y;
				parseFloat2(x, y, token);
				vt.push_back(x);
				vt.push_back(y);
				continue;
			}

			// face
			if (token[0] == 'f' && isSpace((token[1]))) {
				token += 2;
				token += strspn(token, " \t");

				std::vector<vertex_index> face;
				while (!isNewLine(token[0])) {
					vertex_index vi = parseTriple(token, v.size() / 3, vn.size() / 3, vt.size() / 2);
					face.push_back(vi);
					int n = strspn(token, " \t\r");
					token += n;
				}

				faceGroup.push_back(face);

				continue;
			}

			// use mtl
			if ((0 == strncmp(token, "usemtl", 6)) && isSpace((token[6]))) {

				char namebuf[4096];
				token += 7;
				sscanf(token, "%s", namebuf);

				if (material_map.find(namebuf) != material_map.end()) {
					material = material_map[namebuf];
				}
				else {
					// { error!! material not found }
					InitMaterial(material);
				}
				continue;

			}

			// load mtl
			if ((0 == strncmp(token, "mtllib", 6)) && isSpace((token[6]))) {
				char namebuf[4096];
				token += 7;
				sscanf(token, "%s", namebuf);

				std::string err_mtl = LoadMtl(material_map, namebuf, mtl_basepath);
				if (!err_mtl.empty()) {
					faceGroup.clear();  // for safety
					return err_mtl;
				}
				continue;
			}

			// group name
			if (token[0] == 'g' && isSpace((token[1]))) {

				// flush previous face group.
				shape_t shape;
				bool ret = exportFaceGroupToShape(shape, v, vn, vt, faceGroup, material, name);
				if (ret) {
					shapes.push_back(shape);
				}

				faceGroup.clear();

				std::vector<std::string> names;
				while (!isNewLine(token[0])) {
					std::string str = parseString(token);
					names.push_back(str);
					token += strspn(token, " \t\r"); // skip tag
				}

				assert(names.size() > 0);

				// names[0] must be 'g', so skipt 0th element.
				if (names.size() > 1) {
					name = names[1];
				}
				else {
					name = "";
				}

				continue;
			}

			// object name
			if (token[0] == 'o' && isSpace((token[1]))) {

				// flush previous face group.
				shape_t shape;
				bool ret = exportFaceGroupToShape(shape, v, vn, vt, faceGroup, material, name);
				if (ret) {
					shapes.push_back(shape);
				}

				faceGroup.clear();

				// @todo { multiple object name? }
				char namebuf[4096];
				token += 2;
				sscanf(token, "%s", namebuf);
				name = std::string(namebuf);


				continue;
			}

			// Ignore unknown command.
		}

		shape_t shape;
		bool ret = exportFaceGroupToShape(shape, v, vn, vt, faceGroup, material, name);
		if (ret) {
			shapes.push_back(shape);
		}
		faceGroup.clear();  // for safety

		return err.str();
	}
Ejemplo n.º 24
0
int main( int argc, char *argv[] )
{
//    try {

        time_t programStartTime(time(NULL) );
        boost::filesystem::path workingDir( boost::filesystem::current_path() );


        // ========== PROGRAM PARAMETERS ==========

        std::string progName( "buildctree" );
        std::string configFilename( "/home/raid2/moreno/Code/hClustering/config/"+progName+".cfg" );

        // program parameters
        std::string roiFilename, inputFolder, outputFolder, tempFolder;
        float memory( 0.5 ), maxNbDist( 1 ), relativeThreshold( 0 );
        unsigned int nbLevel( 26 ), threads( 0 );
        bool keepDiscarded( false ), niftiMode( true ), debug( false ), noLog( false );
        TC_GROWTYPE growType( TC_GROWOFF );
        size_t baseSize( 0 );

        // Declare a group of options that will be allowed only on command line
        boost::program_options::options_description genericOptions( "Generic options" );
        genericOptions.add_options()
                ( "version", "Program version" )
                ( "help,h", "Produce extended program help message" )
                ( "roi-file,r", boost::program_options::value< std::string >(&roiFilename), "file with the seed voxels coordinates." )
                ( "inputf,I",  boost::program_options::value< std::string >(&inputFolder), "input data folder (seed tractograms)." )
                ( "tempf,T",  boost::program_options::value< std::string >(&tempFolder), "temporal folder (for mean tractogram storage)." )
                ( "outputf,O",  boost::program_options::value< std::string >(&outputFolder), "output folder" )
                ( "threshold,t", boost::program_options::value< float >(&relativeThreshold)->implicit_value(0), "[opt] noise threshold for the tractograms relative to number of streamlines per tract. [0,1)." )
                ( "maxnbdist,d",  boost::program_options::value< float >(&maxNbDist)->implicit_value(1), "[opt] maximum dissimilarity a seed voxel tract must have to its most similar neighbor not be discarded. (0,1]." )
                ( "cnbhood,c",  boost::program_options::value< unsigned int >(&nbLevel)->implicit_value(26), "[opt] centroid method neighborhood level. Valid values: 6, 18, 26(default), 32, 96, 124." )
                ( "basesize,S",  boost::program_options::value< size_t >(&baseSize), "[opt] grow homogeneous base nodes (meta-leaves) of size S. (>=2)." )
                ( "basenum,N",  boost::program_options::value< size_t >(&baseSize), "[opt] grow N homogeneous base nodes (meta-leaves). (>=10)." )
                ( "nolog", "use only linear normalization (input tracts must be also linearly normalized)" )
                ;

        // Declare a group of options that will be allowed both on command line and in config file
        boost::program_options::options_description configOptions( "Configuration" );
        configOptions.add_options()
                ( "verbose,v", "[opt] verbose output." )
                ( "vista", "[opt] use vista file format (default is nifti)." )
                ( "cache-mem,m",  boost::program_options::value< float >(&memory)->implicit_value(0.5), "[opt] maximum of memory (in GBytes) to use for tractogram cache memory. Default: 0.5." )
                ( "keep-disc,k", "[opt] keep discarded voxels data in a section of the tree file." )
                ( "debugout", "[opt] write additional detailed outputs meant for debug." )
                ( "pthreads,p",  boost::program_options::value< unsigned int >(&threads), "[opt] number of processing cores to run the program in. Default: all available." )
                ;

        // Hidden options, will be allowed both on command line and in config file, but will not be shown to the user.
        boost::program_options::options_description hiddenOptions( "Hidden options" );
        //hiddenOptions.add_options() ;

        boost::program_options::options_description cmdlineOptions;
        cmdlineOptions.add(genericOptions).add(configOptions).add(hiddenOptions);
        boost::program_options::options_description configFileOptions;
        configFileOptions.add(configOptions).add(hiddenOptions);
        boost::program_options::options_description visibleOptions( "Allowed options" );
        visibleOptions.add(genericOptions).add(configOptions);
        boost::program_options::positional_options_description posOpt; //this arguments do not need to specify the option descriptor when typed in
        //posOpt.add( "roi-file", -1);

        boost::program_options::variables_map variableMap;
        store(boost::program_options::command_line_parser(argc, argv).options(cmdlineOptions).positional(posOpt).run(), variableMap);

        std::ifstream ifs(configFilename.c_str() );
        store(parse_config_file(ifs, configFileOptions), variableMap);
        notify( variableMap);



        if ( variableMap.count( "help" ) )
        {
            std::cout << "---------------------------------------------------------------------------" << std::endl;
            std::cout << std::endl;
            std::cout << " Project: hClustering" << std::endl;
            std::cout << std::endl;
            std::cout << " Whole-Brain Connectivity-Based Hierarchical Parcellation Project" << std::endl;
            std::cout << " David Moreno-Dominguez" << std::endl;
            std::cout << " [email protected]" << std::endl;
            std::cout << " [email protected]" << std::endl;
            std::cout << " www.cbs.mpg.de/~moreno" << std::endl;
            std::cout << std::endl;
            std::cout << " For more reference on the underlying algorithm and research they have been used for refer to:" << std::endl;
            std::cout << " - Moreno-Dominguez, D., Anwander, A., & Knösche, T. R. (2014)." << std::endl;
            std::cout << "   A hierarchical method for whole-brain connectivity-based parcellation." << std::endl;
            std::cout << "   Human Brain Mapping, 35(10), 5000-5025. doi: http://dx.doi.org/10.1002/hbm.22528" << std::endl;
            std::cout << " - Moreno-Dominguez, D. (2014)." << std::endl;
            std::cout << "   Whole-brain cortical parcellation: A hierarchical method based on dMRI tractography." << std::endl;
            std::cout << "   PhD Thesis, Max Planck Institute for Human Cognitive and Brain Sciences, Leipzig." << std::endl;
            std::cout << "   ISBN 978-3-941504-45-5" << std::endl;
            std::cout << std::endl;
            std::cout << " hClustering is free software: you can redistribute it and/or modify" << std::endl;
            std::cout << " it under the terms of the GNU Lesser General Public License as published by" << std::endl;
            std::cout << " the Free Software Foundation, either version 3 of the License, or" << std::endl;
            std::cout << " (at your option) any later version." << std::endl;
            std::cout << " http://creativecommons.org/licenses/by-nc/3.0" << std::endl;
            std::cout << std::endl;
            std::cout << " hClustering is distributed in the hope that it will be useful," << std::endl;
            std::cout << " but WITHOUT ANY WARRANTY; without even the implied warranty of" << std::endl;
            std::cout << " MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the" << std::endl;
            std::cout << " GNU Lesser General Public License for more details." << std::endl;
            std::cout << std::endl;
            std::cout << "---------------------------------------------------------------------------" << std::endl << std::endl;
            std::cout << "buildctree" << std::endl << std::endl;
            std::cout << "Build a centroid hierarchical tree from a set of seed voxels and their corresponding tractograms." << std::endl << std::endl;
            std::cout << "* Arguments:" << std::endl << std::endl;
            std::cout << " --version:       Program version." << std::endl << std::endl;
            std::cout << " -h --help:       produce extended program help message." << std::endl << std::endl;
            std::cout << " -r --roi-file:   a text file with the seed voxel coordinates and the corresponding tractogram index (if tractogram naming is based on index rather than coordinates)." << std::endl << std::endl;
            std::cout << " -I --inputf:     input data folder (containing the compact tractograms)." << std::endl << std::endl;
            std::cout << " -T --tempf:	    mean tractogram folder location for centroid method. Will be used as temporary storage for intermediate tractogram results." << std::endl << std::endl;
            std::cout << " -O --outputf:    output folder where tree files will be written." << std::endl << std::endl;
            std::cout << "[-t --threshold]: number of streamlines relative to the total generated that must pass through a tract voxel to be considered for tract similarity" << std::endl;
            std::cout << "                   (i.e.: minimum value of a normalized probabilistic tract in natural units to be considered above noise)." << std::endl;
            std::cout << "                   Valid values: [0,1) Use a value of 0 (default) if no thresholding is desired." << std::endl << std::endl;
            std::cout << "[-d --maxnbdist]: maximum dissimilarity a seed voxel tract must have to its most similar neighbor not be discarded." << std::endl;
            std::cout << "                   Valid values: (0,1] Use a value of 1 (default) if no discarding is desired." << std::endl << std::endl;
            std::cout << "[-c --cnbhood]:   use centroid method with C neighborhood level. Valid values: 6, 18, 24(default), 32, 96, 124." << std::endl << std::endl;
            std::cout << "[-S --basesize]:  merge homogeneous base nodes of size S. (mutually exclusive with -N option). Default: 0 (no homogeneous merging)." << std::endl << std::endl;
            std::cout << "[-N --basenum]:   grow N homogeneous base nodes. (mutually exclusive with -S option). Default: 0 (no homogeneous merging)." << std::endl << std::endl;
            std::cout << "[--nolog]:        Use linear normalization. Use if input tracts are only linearly normalized instead of logarithmically normalized (assumed by default)." << std::endl << std::endl;
            std::cout << "[-v --verbose]:   verbose output (recommended)." << std::endl << std::endl;
            std::cout << "[--vista]: 	     read/write vista (.v) files [default is nifti (.nii) and compact (.cmpct) files]." << std::endl << std::endl;
            std::cout << "[-m --cache-mem]: maximum amount of RAM memory (in GBytes) to use for temporal tractogram cache storing. Valid values [0.1,50]. Default: 0.5." << std::endl << std::endl;
            std::cout << "[-k --keep-disc]: keep discarded voxel information in a specialiced section of the tree." << std::endl << std::endl;
            std::cout << "[--debugout]:     write additional detailed outputs meant to be used for debugging." << std::endl << std::endl;
            std::cout << "[-p --pthreads]:  number of processing threads to run the program in parallel. Default: use all available processors." << std::endl << std::endl;
            std::cout << std::endl;
            std::cout << "* Usage example:" << std::endl << std::endl;
            std::cout << " buildctree -r roi_lh.txt -I tractograms/ -T /tmp/tracts -O results/ -t 0.001 -d 0.1 -c 26 -N 1000 -k -m 2 -v " << std::endl << std::endl;
            std::cout << std::endl;
            std::cout << "* Outputs (in output folder defined at option -O):" << std::endl << std::endl;
            std::cout << " - 'cX.txt' - (where X is the neighborhood level defined at option -c) Contains the output hierarchical tree." << std::endl;
            std::cout << " - 'baselist.txt' - Contains the IDs of the nodes corresponding to meta-leaves (and forming the maximum granularity level)." << std::endl;
            std::cout << " - 'success.txt' - An empty file created when the program has sucessfully exited after completion (to help for automatic re-running scripting after failure)." << std::endl;
            std::cout << " - 'buildctree_log.txt' - A text log file containing the parameter details and in-run and completion information of the program." << std::endl;
            std::cout << std::endl;
            std::cout << " [extra outputs when using --debugout option)" << std::endl << std::endl;
            std::cout << " - 'cX_bin_nmt.txt' - non-monotonic binary-branching hierarchical tree before tree processing." << std::endl;
            std::cout << " - 'baselist_bin.txt' - meta-leaves (base nodes) list with IDs corresponding to the binary tree files." << std::endl;
            std::cout << " - 'cX_bin_nmt_granlimit.txt' - non-monotonic hierarchical after granularity limitation (and meta-leaf formation)." << std::endl;
            std::cout << " - 'cX_bin.txt' -binary tree after granularity and monotonicity correction." << std::endl;
            std::cout << " - 'cX_Down.txt' - processed hierarchical tree but using a lower-limit monotonicity correction algorithm rather than the standard weighetd one." << std::endl;
            std::cout << " - 'cX_Up.txt' - processed hierarchical tree but using a Higher-limit monotonicity correction algorithm rather than the standard weighetd one." << std::endl;
            std::cout << " - 'cX_[*]debug.txt' - versions of the counterpart files without suffix with redundant information for debugging purposes." << std::endl;
            std::cout << " - 'baselist_bin_10k.txt' - IDs of the peak nodes at the building point where only 10k active node remained." << std::endl;
            std::cout << " - 'compact_[ID/COORD].nii(.v)' - compact tractogram corresponding to the tree root node (mean tractogram of all seeds included in the final tree)." << std::endl;
            std::cout << std::endl;
            exit(0);
        }

        if ( variableMap.count( "verbose" ) )
        {
            std::cout << "verbose output" << std::endl;
            verbose=true;
        }

        if ( variableMap.count( "pthreads" ) )
        {
            if ( threads == 1 )
            {
                std::cout << "Using a single processor" << std::endl;
            }
            else if( threads == 0 || threads >= omp_get_num_procs() )
            {
                threads = omp_get_num_procs();
                std::cout << "Using all available processors ( " << threads << " )." << std::endl;
            }
            else
            {
                std::cout << "Using a maximum of " << threads << " processors " << std::endl;
            }
            omp_set_num_threads( threads );
        }
        else
        {
            threads = omp_get_num_procs();
            omp_set_num_threads( threads );
            std::cout << "Using all available processors ( " << threads << " )." << std::endl;
        }

        if ( variableMap.count( "vista" ) )
        {
            if( verbose )
            {
                std::cout << "Using vista format" << std::endl;
            }
            fileManagerFactory fmf;
            fmf.setVista();
            niftiMode = false;
        }
        else
        {
            if( verbose )
            {
                std::cout << "Using nifti format" << std::endl;
            }
            fileManagerFactory fmf;
            fmf.setNifti();
            niftiMode = true;
        }

        if ( variableMap.count( "debugout" ) )
        {
            if( verbose )
            {
                std::cout << "Debug output files activated" << std::endl;
            }
            debug = true;
        }

        if ( variableMap.count( "version" ) )
        {
            std::cout << progName << ", version 2.0" << std::endl;
            exit(0);
        }

        if ( variableMap.count( "roi-file" ) )
        {
            if( !boost::filesystem::is_regular_file( boost::filesystem::path( roiFilename ) ) )
            {
                std::cerr << "ERROR: roi file \"" <<roiFilename<< "\" is not a regular file" << std::endl;
                std::cerr << visibleOptions << std::endl;
                exit(-1);
            }
            else if( verbose )
            {
                std::cout << "Seed voxels roi file: " << roiFilename << std::endl;
            }
        }
        else
        {
            std::cerr << "ERROR: no seed voxels roi file stated" << std::endl;
            std::cerr << visibleOptions << std::endl;
            exit(-1);
        }

        if( verbose )
        {
            std::cout << "Tractogram relative threshold value: " << relativeThreshold << std::endl;
        }
        if ( relativeThreshold < 0 || relativeThreshold >= 1 )
        {
            std::cerr << "ERROR: Threshold value used is out of bounds please use a value within [0,1)" << std::endl;
            std::cerr << visibleOptions << std::endl;
            exit(-1);
        }
        else if ( relativeThreshold == 0 )
        {
            std::cout << "No tractogram thresholding will be applied" << std::endl;
        }
        else if( verbose )
        {
            std::cout << "Tractogram voxels visited by less than " << relativeThreshold * 100 << " % of the streamlines generated will be set to 0 before dissimilarity computation" << std::endl;
        }

        if( verbose )
        {
            std::cout << "Maximum distance to most similar neighbor: " << maxNbDist << std::endl;
        }

        if ( maxNbDist <= 0 || maxNbDist > 1 )
        {
            std::cerr << "ERROR: distance value used is out of bounds please use a value within (0,1]" << std::endl;
            std::cerr << visibleOptions << std::endl;
            exit(-1);
        }
        else if ( maxNbDist == 1 && verbose )
        {
            std::cout << "No neighbor distance restrictions will be applied" << std::endl;
        }
        else if( verbose )
        {
            std::cout << "Seed voxels with no neighbors with tract dissimilarity lower than " << maxNbDist << " will be discarded as outliers" << std::endl;
        }

        if( verbose )
        {
            std::cout << "Centroid neighborhood level: " << nbLevel << std::endl;
        }

        if ( ( nbLevel != 6 ) && ( nbLevel != 18 ) && ( nbLevel != 26 ) && ( nbLevel != 32 ) && ( nbLevel != 92 ) && ( nbLevel != 124 ) )
        {
            std::cerr << "ERROR: invalid nbhood level, only (6,18,26,32,92,124) are accepted" << std::endl;
            std::cerr << visibleOptions << std::endl;
            exit(-1);
        }

        if ( ( variableMap.count( "basesize" ) && variableMap.count( "basenum" ) ) )
        {
            std::cerr << "ERROR: options --basesize (-S) and --basenum (-N) are mutually exclusive" << std::endl;
            std::cerr << visibleOptions << std::endl;
            exit(-1);
        }
        if ( variableMap.count( "basesize" ) )
        {
            if( baseSize <= 1 )
            {
                std::cerr << "ERROR: base node (meta-leaf) size must be greater than 1" << std::endl;
                std::cerr << visibleOptions << std::endl;
                exit(-1);
            }
            else
            {
                if( verbose )
                {
                    std::cout << "Initial merging stage up to homogeneous base nodes of size: " << baseSize << std::endl;
                }
                growType = TC_GROWSIZE;
            }
        }
        if ( variableMap.count( "basenum" ) )
        {
            if( baseSize < 10 )
            {
                std::cerr << "ERROR: base node (meta-leaf) number must be equal or greater than 10" << std::endl;
                std::cerr << visibleOptions << std::endl;
                exit(-1);
            }
            else
            {
                if( verbose )
                {
                    std::cout << "Initial merging stage up to " << baseSize << " homogeneous base nodes (meta-leaves)" << std::endl;
                }
                growType = TC_GROWNUM;
            }
        }

        if( growType == TC_GROWOFF && verbose )
        {
            std::cout << "No homogeneous merging stage" << std::endl;
        }

        if ( variableMap.count( "nolog" ) )
        {
            std::cout << "Using only linear tract normalization:" <<  std::endl;
            noLog = true;

        }


        if ( variableMap.count( "keep-disc" ) )
        {
            if( verbose )
            {
                std::cout << "Discarded voxel coordinates will be saved in an special section fo the tree file" << std::endl;
            }
            keepDiscarded = true;
        }
        else
        {
            if( verbose )
            {
                std::cout << "Discarded voxel coordinates will not be saved" << std::endl;
            }
            keepDiscarded = false;
        }

        if ( variableMap.count( "inputf" ) )
        {
            if( !boost::filesystem::is_directory( boost::filesystem::path( inputFolder ) ) )
            {
                std::cerr << "ERROR: input seed tractogram folder \"" <<inputFolder<< "\" is not a directory" << std::endl;
                std::cerr << visibleOptions << std::endl;
                exit(-1);

            }
            else if( verbose )
            {
                std::cout << "Input seed tractogram folder: " << inputFolder << std::endl;
            }
        }
        else
        {
            std::cerr << "ERROR: no input seed tractogram stated" << std::endl;
            std::cerr << visibleOptions << std::endl;
            exit(-1);
        }

        if ( variableMap.count( "outputf" ) )
        {
            if( !boost::filesystem::is_directory( boost::filesystem::path( outputFolder ) ) )
            {
                std::cerr << "ERROR: output folder \"" <<outputFolder<< "\" is not a directory" << std::endl;
                std::cerr << visibleOptions << std::endl;
                exit(-1);

            }
            else if( verbose )
            {
                std::cout << "Output folder: " << outputFolder << std::endl;
            }
        }
        else
        {
            std::cerr << "ERROR: no output folder stated" << std::endl;
            std::cerr << visibleOptions << std::endl;
            exit(-1);
        }

        if ( variableMap.count( "tempf" ) )
        {
            if( !boost::filesystem::is_directory(boost::filesystem::path( tempFolder ) ) )
            {
                std::cerr << "ERROR: temporal folder \"" <<tempFolder<< "\" is not a directory" << std::endl;
                std::cerr << visibleOptions << std::endl;
                exit(-1);

            }
            if( verbose )
            {
                std::cout << "temporal folder: " << tempFolder << std::endl;
            }
        }
        else
        {
            std::cerr << "ERROR: no temporal folder stated" << std::endl;
            std::cerr << visibleOptions << std::endl;
            exit(-1);
        }

        if ( memory < 0.1 || memory > 50)
        {
            std::cerr << "ERROR: cache size must be a positive float between 0.1 and 50 (GB)" << std::endl;
            std::cerr << visibleOptions << std::endl;
            exit(-1);
        }
        else if( verbose )
        {
            std::cout << "Tractogram cache memory: " << memory << " GBytes" << std::endl;
        }


        std::string logFilename(outputFolder+"/"+progName+"_log.txt" );
        std::ofstream logFile(logFilename.c_str() );
        if(!logFile)
        {
            std::cerr << "ERROR: unable to open log file: \"" <<logFilename<< "\"" << std::endl;
            exit(-1);
        }


        logFile << "Start Time:\t" << ctime(&programStartTime) << std::endl;
        logFile << "Working directory:\t" << workingDir.string() << std::endl;
        logFile << "Verbose:\t" << verbose << std::endl;
        logFile << "Processors used:\t" << threads << std::endl;
        if( niftiMode )
        {
            logFile << "Using nifti file format" << std::endl;
        }
        else
        {
            logFile << "Using vista file format" << std::endl;
        }
        logFile << "Roi file:\t" << roiFilename << std::endl;
        if( noLog )
        {
            logFile << "Using only linear tract normalization" << std::endl;
        }
        logFile << "Relative threshold:\t" << relativeThreshold << std::endl;
        logFile << "Max nb distance:\t" << maxNbDist << std::endl;
        logFile << "Nbhood restriction level:\t" <<nbLevel<< std::endl;
        switch(growType)
        {
        case TC_GROWOFF:
            logFile << "Region growing: None" << std::endl;
            break;
        case TC_GROWSIZE:
            logFile << "Region growing: Size: " << baseSize << std::endl;
            break;
        case TC_GROWNUM:
            logFile << "Region growing: Number: " << baseSize << std::endl;
            break;
        }
        logFile << "Input seed tract folder:\t" << inputFolder << std::endl;
        logFile << "Output folder:\t" << outputFolder << std::endl;
        logFile << "Temp folder:\t" << tempFolder << std::endl;
        logFile << "Memory cache size:\t" << memory << " GB" << std::endl;
        logFile << "Debug outputr:\t" << debug << std::endl;
        logFile << "-------------" << std::endl;


        /////////////////////////////////////////////////////////////////


        CnbTreeBuilder builder( roiFilename, relativeThreshold, maxNbDist, verbose, noLog );
        logFile << "Roi size:\t" << builder.roiSize() << std::endl;

        builder.log( &logFile );
        builder.setInputFolder( inputFolder );
        builder.setOutputFolder( outputFolder );
        builder.setTempFolder( tempFolder );
        builder.setDebugOutput( debug );
        builder.buildCentroid( nbLevel, memory, growType, baseSize, keepDiscarded );


        /////////////////////////////////////////////////////////////////


        // save and print total time
        time_t programEndTime(time(NULL) );
        int totalTime( difftime(programEndTime,programStartTime) );
        std::cout << "Program Finished, total time: " << totalTime/3600 << "h " <<  (totalTime%3600)/60 << "' " << ((totalTime%3600)%60) << "\"   " << std::endl;
        logFile << "-------------" << std::endl;
        logFile << "Finish Time:\t" << ctime(&programEndTime) << std::endl;
        logFile << "Elapsed time : " << totalTime/3600 << "h " <<  (totalTime%3600)/60 << "' " << ((totalTime%3600)%60) << "\"" << std::endl;


        // create file that indicates process was finished successfully
        std::string successFilename(outputFolder+"/success.txt" );
        std::ofstream successFile(successFilename.c_str() );
        if(!successFile)
        {
            std::cerr << "ERROR: unable to create success file: \"" <<successFile<< "\"" << std::endl;
            exit(-1);
        }
        successFile << "success";


//    }
//    catch(std::exception& e)
//    {
//        std::cout << e.what() << std::endl;
//        return 1;
//    }
    return 0;
}
Ejemplo n.º 25
0
//=============================================================================
//コンストラクタ
//=============================================================================
//[input]
//	name:データ名
//	vPos:設定する座標
//	filename:敵の動きのファイル名
//=============================================================================
CEnemyAmeus::CEnemyAmeus( string name, Math::Vector3D vPos, string filename )  
{
	m_DataName = name;
	m_eType = OBJ_ENEMY;
	
	m_IsVisible = true;
	m_IsStop	= false;	
	m_IsSetFlag = false;
	
	m_IsHit = false;
	
	float Scale = 1.0f;
	
	m_vPos = vPos;
	m_vOldPos = vPos;
	m_vRot.Set( 0, -DEG_TO_ANGLE(60), 0 );
	m_vScale.Set( Scale, Scale, Scale );
	
	m_pModel = NULL;
	
	for( int numActor = 0;numActor < S_MAX;++numActor )
	{
		m_pActorModel[numActor] = NULL;
	}
	
	m_ActorIndex = 0;
	
	for( int Anim = 0;Anim < ANIM_MAX;++Anim )
	{
		m_fAnimTime[Anim] = 0.0f;
		m_AnimID[Anim] = 0;
	} 

	m_fKeyTime = 0.0f;
	
	m_fSpeed = 2.0f;
	
	std::ifstream ifs(filename.c_str());
	
	vector< float > vecKeyX;
	vector< float > vecKeyZ;
	vector< float > vecKeyRotX;
	
	while( !ifs.eof() )
	{
		float KeyTime = 0.0f;
		float KeyX = 0;
		float KeyZ = 0;
		float KeyRotX = 0;
		float fKeySpeed = 0;
		
		ifs >> fKeySpeed >> KeyX >> KeyZ >> KeyRotX;
		
		vecKeyX.push_back( KeyX );
		vecKeyZ.push_back( KeyZ );
		vecKeyRotX.push_back( KeyRotX );
		m_vKeySpeed.push_back( fKeySpeed );
				
	}
	
	Sint32 MaxKey = vecKeyX.size(); 
	
	m_pAnimX = new Math::Animation(MaxKey);
	m_pAnimZ = new Math::Animation(MaxKey);
	m_pAnimRotX = new Math::Animation(MaxKey);
	m_pAnimSpeed = new Math::Animation(MaxKey);
	
	/*キー時間の最初を0に設定しておく*/
	m_vDeltaKey.push_back( 0.0f );
	
	/*キーの差分時間を求める*/
	for( Sint32 i = 0;i < MaxKey - 1;++i )
	{
		float Delta = Abs( vecKeyZ.at( i + 1 ) - vecKeyZ.at( i ) );
		
		if( Delta <= 1.0f )
		{
			Delta = 3.0f;
		}
		
		float KeyTime = Delta / m_fSpeed;
		
		m_vDeltaKey.push_back( KeyTime );
		
		//float Delta = m_vKeyTime.at( i + 1 ) - m_vKeyTime.at( i );
		//
		//m_vDeltaKey.push_back( Delta );
	}
	
	/*キーをセット*/
	for( int Key = 0;Key < MaxKey; ++Key )
	{	
		static float KeyTime = 0.0f;
		
		KeyTime += m_vDeltaKey.at(Key);
		
		m_vKeyTime.push_back( KeyTime );

		m_pAnimX->SetKey( Key, KeyTime, vecKeyX.at(Key) );
		m_pAnimZ->SetKey( Key, KeyTime, vecKeyZ.at(Key) );
		m_pAnimRotX->SetKey( Key, KeyTime, vecKeyRotX.at(Key) );
		m_pAnimSpeed->SetKey( Key, KeyTime, m_vKeySpeed.at(Key) );
		
		if( Key == MaxKey - 1 )
		{
			m_fMaxKeyTime = KeyTime;
		}
		
	} 
	
	m_fWeight = 0.0f;
	
	m_KeyIndex = 0;
	
	m_IsChangeKeyTime = false;
	
	m_IsStopKeyTime = false;
	
	//m_pAnim->SetKey
	
}
Ejemplo n.º 26
0
bool GitCommitLog::parseCommit(RCommit& commit) {

    std::string line;
    char filesizeBuf[256];

    commit.username = "";

    while(logf->getNextLine(line) && line.size()) {

        if(line.find("commit_id:") == 0) {
           commit.commit_id = line.substr(10); 

           if(!logf->getNextLine(line)) return false;

            //username follows user prefix
            commit.username = line.substr(5);

            if(!logf->getNextLine(line)) return false;

            commit.timestamp = atol(line.c_str());

            //this isnt a commit we are parsing, abort
            if(commit.timestamp == 0) return false;

            continue;
        }

        //should see username before files
        if(commit.username.empty()) return false;

        size_t tab = line.find('\t');

        //incorrect log format
        if(tab == std::string::npos || tab == 0 || tab == line.size()-1) continue;

        std::string status = line.substr(tab - 1, 1);
        std::string file   = line.substr(tab + 1);

        if(file.empty()) continue;

        //check for and remove double quotes
        if(file.find('"') == 0 && file.rfind('"') == file.size()-1) {
            if(file.size()<=2) continue;

            file = file.substr(1,file.size()-2);
        }


        std::string size_temp_file = temp_file + "_filesize";

        memset(filesizeBuf, 0, sizeof(char) * 256);
        snprintf(filesizeBuf, sizeof(char) * 256, GitGetFileSizeCommand.c_str(), commit.commit_id.c_str(), file.c_str(), size_temp_file.c_str());

        systemCommand(filesizeBuf);

        std::ifstream ifs ( size_temp_file );
        std::string filesize_str;
        ifs >> filesize_str;

        size_t filesize = 0;
        if(!filesize_str.empty()) {
            filesize = std::stoi(filesize_str);
        }

        commit.addFile(file, status, filesize);
    }

    //check we at least got a username
    if(commit.username.empty()) return false;

    return true;
}
Ejemplo n.º 27
0
void Raw::read(const std::string& fn) {
    if(mBuffer)
        delete[] mBuffer;
    mBuffer = NULL;

    // Read file into buffer.
    std::cout << "Reading " << fn << std::endl;
    std::ifstream ifs(fn.data(), std::ifstream::binary);

    if(ifs) {
        ifs.seekg(0, std::ifstream::end);
        std::size_t mSize = ifs.tellg();
        ifs.seekg(0, std::ifstream::beg);

        mBuffer = new uint8_t[mSize];
        ifs.read((char*) mBuffer, mSize);

        ifs.close();
    } else {
        std::cerr << "Error reading " << fn << std::endl;
        ifs.close();
        return;
    }

    // Get total number of blocks.
    int blocks = (mWidth / 4) * (mHeight / 4);
    std::cout << "Reading in " << blocks << " blocks" << std::flush;

    for(int i = 0; i < blocks; ++i) {
        if(i % (int)((blocks * 0.05) + 1) == 0)
            std::cout << "." << std::flush;

        Block<double> block;

        // We find the x- and y-offset of the block.
        int xOff = (i % (mWidth / 4)) * 4;
        int yOff = (i / (mWidth / 4)) * 4;

        // We find the locations in the buffer of the "left side" of the block.
        int l0 = (xOff % mWidth) + (yOff * mWidth);
        int l1 = l0 + mWidth;
        int l2 = l1 + mWidth;
        int l3 = l2 + mWidth;

        // Set the data.
        double newData[4][4] = {
            {(double)mBuffer[l0], (double)mBuffer[l0 + 1],
                (double)mBuffer[l0 + 2], (double)mBuffer[l0 + 3]},
            {(double)mBuffer[l1], (double)mBuffer[l1 + 1],
                (double)mBuffer[l1 + 2], (double)mBuffer[l1 + 3]},
            {(double)mBuffer[l2], (double)mBuffer[l2 + 1],
                (double)mBuffer[l2 + 2], (double)mBuffer[l2 + 3]},
            {(double)mBuffer[l3], (double)mBuffer[l3 + 1],
                (double)mBuffer[l3 + 2], (double)mBuffer[l3 + 3]}
        };
        block.data(newData);

        // balance around 0
        for(int i = 0; i < 4; ++i)
            for(int j = 0; j < 4; ++j)
                block.data(i, j, block.data(i, j) - 128);

        mData.push_back(block);
    }

    delete[] mBuffer;
    mBuffer = NULL;

    std::cout << std::endl;
}
Ejemplo n.º 28
0
bool Inventory::readRecipe(std::string recipeFile)
{
  std::ifstream ifs(recipeFile.c_str());

  if (ifs.fail())
  {
    std::cerr <<  "Could not find: " <<  recipeFile << std::endl;
    ifs.close();
    return false;
  }

  //LOG(INFO, "Inventory", "Reading: " + recipeFile);

  std::string temp;

  int height = 0, width = 0, outCount = 0;
  int16_t outType = 0, outHealth = 0;

  // Reading row at a time
  int del;
  bool readingRecipe = false;
  std::vector<std::string> line;
  std::vector<Item*> recipetable;
  std::string text;
  while (getline(ifs, temp))
  {
    //If empty line
    if (temp.size() == 0)
    {
      continue;
    }

    // If commentline -> skip to next
    if (temp[0] == COMMENTPREFIX)
    {
      continue;
    }

    // Init vars
    del = 0;
    line.clear();

    // Process line
    while (temp.length() > 0)
    {
      // Remove white spaces
      while (temp[0] == ' ')
      {
        temp = temp.substr(1);
      }

      // Split words
      del = temp.find(' ');
      if (del > -1)
      {
        line.push_back(temp.substr(0, del));
        temp = temp.substr(del + 1);
      }
      else
      {
        line.push_back(temp);
        break;
      }
    }

    // Begin recipe
    if (line.size() == 1 && line[0] == "<-")
    {
      readingRecipe = true;
      continue;
    }
    // Begin recipe
    if (line.size() == 1 && line[0] == "->")
    {
      readingRecipe = false;
      continue;
    }

    if (readingRecipe)
    {
      for (unsigned int i = 0; i < line.size(); i++)
      {
        std::string data(line[i]);
        Item* item = new Item();
        item->setCount(1);
        item->setHealth(-1);
        int location = data.find("x");
        if (location > -1)
        {
          // Quantity before ID
          item->setCount(atoi(data.substr(0, location).c_str()));
          data = data.substr(location + 1, std::string::npos);
        }
        location = data.find(":");
        if (location > -1)
        {
          // Meta after ID
          item->setHealth(atoi(data.substr(location + 1, std::string::npos).c_str()));
          data = data.substr(0, location);
        }
        item->setType(atoi(data.c_str()));
        recipetable.push_back(item);
      }
      continue;
    }
    else
    {
      // Keywords
      if (line[0] == "width")
      {
        width = atoi(line[1].c_str());
      }
      if (line[0] == "height")
      {
        height = atoi(line[1].c_str());
      }
      if (line[0] == "outputcount")
      {
        outCount = atoi(line[1].c_str());
      }
      if (line[0] == "outputtype")
      {
        outType = atoi(line[1].c_str());
      }
      if (line[0] == "outputhealth")
      {
        outHealth = atoi(line[1].c_str());
      }
    }
  }
  ifs.close();

  addRecipe(width, height, recipetable, outCount, outType, outHealth);

  //  delete [] inrecipe;

  return true;
}
void VDPMLoader::openVDPM_ServerRendering(const char *_filename)
{
    unsigned int                    i;
    unsigned int                    value;
    unsigned int                    fvi[3];
    char                            fileformat[16];
    Vec3f                           p, normal;
    float                           radius, sin_square, mue_square, sigma_square;
    VHierarchyNodeHandleContainer   roots;
    VertexHandle                    vertex_handle;
    VHierarchyNodeIndex             node_index;
    VHierarchyNodeIndex             lchild_node_index, rchild_node_index;
    VHierarchyNodeIndex             fund_lcut_index, fund_rcut_index;
    VHierarchyNodeHandle            node_handle;
    VHierarchyNodeHandle            lchild_node_handle, rchild_node_handle;
    
    
    
    std::ifstream ifs(_filename, std::ios::binary);
    
    if (!ifs)
    {
        std::cerr << "read error\n";
        exit(1);
    }
    
    //
    bool swap = Endian::local() != Endian::LSB;
    
    // read header
    ifs.read(fileformat, 10); fileformat[10] = '\0';
    if (std::string(fileformat) != std::string("VDProgMesh"))
    {
        std::cerr << "Wrong file format.\n";
        ifs.close();
        exit(1);
    }
    
    IO::restore(ifs, n_base_vertices_, swap);
    IO::restore(ifs, n_base_faces_, swap);
    IO::restore(ifs, n_details_, swap);
    
    mesh_.clear();
    vfront_.clear();
    vhierarchy_.clear();
    
    vhierarchy_.set_num_roots(n_base_vertices_);
    
    
    // load base mesh
    for (i=0; i<n_base_vertices_; ++i)
    {
        IO::restore(ifs, p, swap);
        IO::restore(ifs, radius, swap);
        IO::restore(ifs, normal, swap);
        IO::restore(ifs, sin_square, swap);
        IO::restore(ifs, mue_square, swap);
        IO::restore(ifs, sigma_square, swap);
        
        vertex_handle = mesh_.add_vertex(p);
        node_index    = vhierarchy_.generate_node_index(i, 1);
        node_handle   = vhierarchy_.add_node();
        
        VHierarchyNode &node = vhierarchy_.node(node_handle);
        
        node.set_index(node_index);
        node.set_vertex_handle(vertex_handle);
        mesh_.data(vertex_handle).set_vhierarchy_node_handle(node_handle);
        
        node.set_radius(radius);
        node.set_normal(normal);
        node.set_sin_square(sin_square);
        node.set_mue_square(mue_square);
        node.set_sigma_square(sigma_square);
        mesh_.set_normal(vertex_handle, normal);
        
        index2handle_map[node_index] = node_handle;
        roots.push_back(node_handle);
    }
    vfront_.init(roots, n_details_);
    
    for (i=0; i<n_base_faces_; ++i)
    {
        IO::restore(ifs, fvi[0], swap);
        IO::restore(ifs, fvi[1], swap);
        IO::restore(ifs, fvi[2], swap);
        
        mesh_.add_face(mesh_.vertex_handle(fvi[0]),
                       mesh_.vertex_handle(fvi[1]),
                       mesh_.vertex_handle(fvi[2]));
    }
    
    vsplit_loaded.clear();
    
    // load details
    for (i=0; i<n_details_; ++i)
    {
        Vsplit avs;
        // position of v0
        IO::restore(ifs, p, swap);
        
        avs.v0 = p;
        
        // vsplit info.
        IO::restore(ifs, value, swap);
        node_index = VHierarchyNodeIndex(value);
        
        avs.node_index = value;
        
        IO::restore(ifs, value, swap);
        fund_lcut_index = VHierarchyNodeIndex(value);
        
        avs.fund_lcut_index = value;
        
        IO::restore(ifs, value, swap);
        fund_rcut_index = VHierarchyNodeIndex(value);
        
        avs.fund_rcut_index = value;
        
        node_handle = index2handle_map[node_index];
        vhierarchy_.make_children(node_handle);
        
        VHierarchyNode &node   = vhierarchy_.node(node_handle);
        VHierarchyNode &lchild = vhierarchy_.node(node.lchild_handle());
        VHierarchyNode &rchild = vhierarchy_.node(node.rchild_handle());
        
        node.set_fund_lcut(fund_lcut_index);
        node.set_fund_rcut(fund_rcut_index);
        
        vertex_handle = mesh_.add_vertex(p);
        lchild.set_vertex_handle(vertex_handle);
        rchild.set_vertex_handle(node.vertex_handle());
        
        index2handle_map[lchild.node_index()] = node.lchild_handle();
        index2handle_map[rchild.node_index()] = node.rchild_handle();
        
        // view-dependent parameters
        IO::restore(ifs, radius, swap);
        IO::restore(ifs, normal, swap);
        IO::restore(ifs, sin_square, swap);
        IO::restore(ifs, mue_square, swap);
        IO::restore(ifs, sigma_square, swap);
        lchild.set_radius(radius);
        lchild.set_normal(normal);
        lchild.set_sin_square(sin_square);
        lchild.set_mue_square(mue_square);
        lchild.set_sigma_square(sigma_square);
        
        avs.l_radius = radius;
        avs.l_normal = normal;
        avs.l_mue_square = mue_square;
        avs.l_sigma_square = sigma_square;
        avs.l_sin_square = sin_square;
        
        IO::restore(ifs, radius, swap);
        IO::restore(ifs, normal, swap);
        IO::restore(ifs, sin_square, swap);
        IO::restore(ifs, mue_square, swap);
        IO::restore(ifs, sigma_square, swap);
        rchild.set_radius(radius);
        rchild.set_normal(normal);
        rchild.set_sin_square(sin_square);
        rchild.set_mue_square(mue_square);
        rchild.set_sigma_square(sigma_square);
        
        avs.r_radius = radius;
        avs.r_normal = normal;
        avs.r_mue_square = mue_square;
        avs.r_sigma_square = sigma_square;
        avs.r_sin_square = sin_square;
        
        vsplit_loaded.push_back(avs);
        
    }
    
    ifs.close();
    
    //refine 100 vsplits
    int cc = 0;
    for ( vfront_.begin(); !vfront_.end() && cc < 100; ++cc)
    {
        VHierarchyNodeHandle
        node_handle   = vfront_.node_handle();
        
        if (vhierarchy_.is_leaf_node(node_handle) != true)
        {
            force_vsplit(node_handle, vsplits_to_send);
        }
        vfront_.next();
        std::cout << "vfront_ size " << vfront_.size() <<std::endl;
    }
    
    //**********//

    
    // update face and vertex normals
    mesh_.update_face_normals();
    
    // bounding box
    VDPMMesh::ConstVertexIter
    vIt(mesh_.vertices_begin()),
    vEnd(mesh_.vertices_end());
    
    VDPMMesh::Point bbMin, bbMax;
    
    bbMin = bbMax = mesh_.point(vIt);
    for (; vIt!=vEnd; ++vIt)
    {
        bbMin.minimize(mesh_.point(vIt));
        bbMax.maximize(mesh_.point(vIt));
    }
    
    // set center and radius
    VDPMMesh::Point center = 0.5f * (bbMin + bbMax);
    set_scene_pos(0.5f*(bbMin + bbMax), 0.5*(bbMin - bbMax).norm());
    
    
    
    // info
    std::cerr << mesh_.n_vertices() << " vertices, "
    << mesh_.n_edges()    << " edge, "
    << mesh_.n_faces()    << " faces, "
    << n_details_ << " detail vertices\n";
    
    mesh_loaded = true;
}
Ejemplo n.º 30
0
source::source()
{
	ifstream ifs(getenv("idock_cl"));
	insert(begin(), istreambuf_iterator<char>(ifs), istreambuf_iterator<char>());
}