// Read edgelist input file
inline void readFile(char* filePath, nodeCollection* ncp){
inputFileStream1.open(filePath);
std::string line;
std::string x, y, del;
int maxValue, a, b;
char oneLine[256];
maxValue = 0;
//To find max Value (to make dynamic array)
if(inputFileStream1.is_open()){
int lineNumber = 0;
while(getline(inputFileStream1, line)){
strcpy(oneLine,line.c_str());
del = strtok(oneLine,"\t ");
x = del;
y = strtok(NULL,"\t ");
lineNumber++;
a = atoi(x.c_str());
b = atoi(y.c_str());
if ( a > b){
if(a > maxValue){
maxValue = a;}
}
else{
if(b > maxValue){
maxValue = b;}
}
}
}
else{
std::cout<<"Error Occured!"<<std::endl;
}
//ncp->setAdjMat(maxValue); //Make matrix
ncp->setDegMat(maxValue); //Make degMatrix
inputFileStream1.seekg(0, inputFileStream1.beg); //to read again
inputFileStream1.close();
inputFileStream2.open(filePath);
if(inputFileStream2.is_open()){
while(getline(inputFileStream2, line)){
strcpy(oneLine,line.c_str());
del = strtok(oneLine,"\t ");
x = del;
y = strtok(NULL,"\t ");
a = atoi(x.c_str());
b = atoi(y.c_str());
ncp->putNode(a, b);
ncp->putNode(b, a);
}
}
else{
std::cout<<"Error Occured!"<<std::endl;
}
std::cout<<"#### FILE READ & SETUP FINISHED####"<<std::endl;
inputFileStream2.close();
}
std::string MiscUtil::OpenFile(std::string name, std::ifstream& f)
{
#ifndef ABS_TOP_SRCDIR
#error ABS_TOP_SRCDIR not defined!
#endif
#ifndef DATADIR
#error ABS_TOP_SRCDIR not defined!
#endif
std::string programDirFile;
std::string absFile;
std::string dataFile;
# if defined(BOOST_FILESYSTEM_VERSION)
BenzeneAssert (BOOST_FILESYSTEM_VERSION == 2 || BOOST_FILESYSTEM_VERSION == 3);
#endif
{
path p = programDir / name;
p.normalize();
#if (defined (BOOST_FILESYSTEM_VERSION) && (BOOST_FILESYSTEM_VERSION == 3))
programDirFile = p.string();
#else
programDirFile = p.native_file_string();
#endif
f.open(programDirFile.c_str());
if (f.is_open())
return programDirFile;
}
{
path p = boost::filesystem::path(ABS_TOP_SRCDIR) / "share" / name;
p.normalize();
#if (defined (BOOST_FILESYSTEM_VERSION) && (BOOST_FILESYSTEM_VERSION == 3))
absFile = p.string();
#else
absFile = p.native_file_string();
#endif
f.open(absFile.c_str());
if (f.is_open())
return absFile;
}
{
path p = boost::filesystem::path(DATADIR) / name;
p.normalize();
#if (defined (BOOST_FILESYSTEM_VERSION) && (BOOST_FILESYSTEM_VERSION == 3))
dataFile = p.string();
#else
dataFile = p.native_file_string();
#endif
f.open(dataFile.c_str());
if (f.is_open())
return dataFile;
}
throw BenzeneException() << "Could not find '" << name << "'. Tried \n"
<< "\t'" << programDirFile << "' and\n"
<< "\t'" << absFile << "' and\n"
<< "\t'" << dataFile << "'.";
}
//-------------------------------------------------------------------------//
bool Material::Load(std::ifstream& ifs)
{
//-----------------------------------------------------------------------//
// Throw assertion is file streams is not open.
assert(ifs.is_open() && ifs.good());
//-----------------------------------------------------------------------//
//-----------------------------------------------------------------------//
// If the file stream is not open return false.
if(!ifs.is_open() || !ifs.good())
return false;
//-----------------------------------------------------------------------//
//-----------------------------------------------------------------------//
// This string will hold the label that describes some camera parameter.
string strLabel;
//-----------------------------------------------------------------------//
//-----------------------------------------------------------------------//
// This unsigned short will count the number of camera parameters read in
// and will be used to verify that the correct number of parameters have
// been initialized.
unsigned short usParameterCount = 0;
//-----------------------------------------------------------------------//
//-----------------------------------------------------------------------//
// The for loop will read in data from the file stream and will set
// the objects data members accordingly.
for(unsigned short i = 0; i < NUMBER_OF_MATERIAL_PARAMETERS; i++)
{
//---------------------------------------------------------------------//
// Read in the label
ifs >> strLabel;
//---------------------------------------------------------------------//
//---------------------------------------------------------------------//
// Match the label to some predefined token and set the proper data member.
float fR, fG, fB, fA;
if(strLabel == DIFFUSE_COLOR_LABEL)
{
ifs >> fR;
ifs >> fG;
ifs >> fB;
ifs >> fA;
this->SetDiffuse(fR, fG, fB);
usParameterCount++;
}
else if(strLabel == AMBIENT_FACTOR_LABEL)
/**
* @brief Configures the block: defines the input file.
* @param n The configuration parameters
*/
virtual void _configure(const xml_node& n)
{
xml_node source = n.child("source");
xml_node gates_node = n.child("gates");
if( (!source) || (!gates_node) )
throw std::runtime_error("TweetReader: missing parameter");
std::string gates_s = gates_node.attribute("number").value();
std::string type = source.attribute("type").value();
std::string ip = source.attribute("ip").value();
file_name = source.attribute("name").value();
if(!type.length() || !file_name.length() || !gates_s.length())
throw std::runtime_error("TweetReader: missing attribute");
if(type.compare("offline") != 0)
throw std::runtime_error("TweetReader: invalid type parameter");
num_gates = atoi(gates_s.c_str());
file.open(file_name);
if(!file.is_open()) {
throw std::runtime_error("TweetReader: cannot open source file");
}
// Create and register the output gates
m_outgate_ids = new int[num_gates];
for(int i=0; i<num_gates; i++){
std::string ogate = outgate_basename + boost::lexical_cast<std::string>(i);
m_outgate_ids[i] = register_output_gate(ogate.c_str());
}
}
/*Name: fOpen
//Purpose: Opens file with given filename
//Parameters: ifstream object, string filename, bool fail bit
//Returns: null
*/
void fOpen(std::ifstream& fin, string filename, bool& fail){
fin.open(filename.c_str());
if(!fin.is_open()){
fail = 1;
cerr << "File failed to open";
}
}
// Unit test.
bool test_reverse_word(std::ifstream &file)
{
if(!file.is_open())
{
throw; //file not open
}
std::string line;
while(getline(file,line))
{
//make a deep copy...
std::string expected = line + "";
char* exp = &expected[0];
char* actual = &line[0];
reverse_words_quick_and_dirty(exp);
reverse_words(actual);
if(strcmp(actual,exp) != 0)
{
std::cout << "expected: " << exp << std::endl;
std::cout << "actual : " << actual << std::endl;
std::cout << "Test Failed!" << std::endl;
return false;
}
}
std::cout << "Test Passed!" << std::endl;
return true;
}
void Constants::setConstantsFromFile(std::ifstream & infile)
{
if(infile.is_open())
{
std::string input;
while(std::getline(infile,input))
{
std::vector<float> params;
if(input[0] == '#') continue;
std::string commandName = input.substr(0,input.find_first_of(" "));
input = input.substr(input.find_first_of(" ")+1,input.length());
while(input.length() > 0)
{
int spaceloc = input.find_first_of(" \n\0");
std::string param = input.substr(0,(spaceloc>=0)?spaceloc:input.length());
if(input[0] == '#') ;
if(spaceloc == -1)
input = "";
else
input = input.substr(spaceloc+1,input.length());
char * charParam = new char[input.size()+1];
strcpy(charParam,param.c_str());
float parameter = (float)atof(charParam);
params.push_back(parameter);
}
if(commandName == "G_ACCEL")
{
Constants::getInstance()->gravity = params[0];
}
}
}
}
bool closeEdgeFile(int iter_counter) {
if (fin.is_open()) {
fin.close();
//logstream(LOG_INFO) << "close edge block-" << block_id << std::endl;
}
return true;
}
/*--------------------------------------------------------------------
m_load_matches_from_stream
----------------------------------------------------------------------*/
bool CStereoOdometryEstimator::m_load_matches_from_stream(
std::ifstream & stream,
vector<cv::DMatch> & matches,
vector<size_t> & matches_ids )
{
/* FORMAT
- # of matches
- match id
- queryIdx
- trainIdx
- distance
*/
if( !stream.is_open() )
return false;
size_t num_matches, num_matches_id;
stream.read( (char*)&num_matches, sizeof(size_t) );
stream.read( (char*)&num_matches_id, sizeof(size_t) );
matches.resize( num_matches );
matches_ids.resize( num_matches_id );
const bool add_ids = num_matches == num_matches_id;
for( size_t m = 0; m < matches.size(); ++m )
{
if( add_ids ) stream.read( (char*)&(matches_ids[m]), sizeof(size_t) );
stream.read( (char*)&(matches[m].queryIdx), sizeof(matches[m].queryIdx) );
stream.read( (char*)&(matches[m].trainIdx), sizeof(matches[m].trainIdx) );
stream.read( (char*)&(matches[m].distance), sizeof(matches[m].distance) );
stream.read( (char*)&(matches[m].imgIdx), sizeof(matches[m].imgIdx) );
} // end-for-matches
return true;
} // end-loadMatchesFromStream
void RigidBodyScene::deserialize( std::ifstream& inputstream )
{
assert( inputstream.is_open() );
// Load the state of each rigid body
for( std::vector<RigidBody>::size_type i = 0; i < m_rbs.size(); ++i ) m_rbs[i].deserialize( inputstream );
}
//----------------------------------------------------------------------
bool KeyboardProfile::VInitialize( std::ifstream& fin, WkActionTranslatorPtr pActionTransl )
{
auto pActiontranslator = pActionTransl.lock();
auto pDevice = m_pKeyboard.lock();
if( fin.is_open() && pActiontranslator && pDevice )
{
string temp;
if( !InitializeGOID(fin) )
{
return false;
}
// Mapping button/action
fin >> temp;
while( temp != ";" )
{
if( StringUtilities::ToLower(temp) == "b" )
{
temp = MapButtonToAction( pDevice, pActiontranslator, fin );
}
else // Skip
{
do
{
fin >> temp;
}
while( temp != "b" && temp != ";" );
return false;
}
}
return true;
}
/** \brief Hide a file (or some other ifstream) in the loaded picture
* It loads the streamsize to this->hundredPercentValue and the amount of finished bytes to this->doneBytes
* \param &toHideFileStream std::ifstream the filestream whose contents should be hidden in the picture (should be opened binary)
* \param &password const std::string the password (not used yet)
* \throw SteganoException::ImgNotLoaded if no container file is loaded.
* \throw SteganoException::Img2Small if the loaded image is too small to hide the given phrase
* \throw SteganoException::FileStreamClosed if the specified fileStream is not opened
*/
void SteganoHide::hideFile(std::ifstream &toHideFileStream, const std::string &password) {
if(!this->steganoImage.isValid()) {
throw SteganoException::ImgNotLoaded();
}
// we need to divide it by 2 because in worst case every byte takes 2 pixel
if(getFileStreamSizeInBytes(toHideFileStream) > (this->xResolution * this->yResolution) / 2) {
throw SteganoException::Img2Small();
}
if(!toHideFileStream.is_open()) {
throw SteganoException::FileStreamClosed();
}
this->origImageBackup = this->steganoImage;
this->doneBytes = 0;
// 2 * |imagePixel| because we normalize all pixels first and afterwards we reset it.
this->hundredPercentValue = getFileStreamSizeInBytes(toHideFileStream) + 2 * this->pixelAmount;
normalizeImage();
unsigned int loopCount = 0;
while(toHideFileStream.good()) {
Pixel hidingPixel = calculateHidingPosition(loopCount);
hideByteAtPixel(toHideFileStream.get(), hidingPixel);
loopCount++;
this->doneBytes++;
// std::cout << "byte" << std::endl;
}
drawFinishPixel(calculateHidingPosition(loopCount));
resetNormalizedImage();
}
void openfile(const char *filename, std::ifstream &infile){
infile.open(filename);
if (! infile.is_open()) {
std::cout << "Error opening file:" << filename << std::endl;
exit(1);
}
}
bool InpNativeInfo::read_file(const std::string& file_name)
{
if(already_read)
std::cout << "Warning: trying to substitute ninfo for already initiated object."
<< std::endl;
already_read = true;
if(inpfile.is_open())
{
std::cout << "Warning: trying to re-open file named " << file_name
<< std::endl;
}
inpfile.open(file_name);
bool read(false);
while(!inpfile.eof())
{
std::string line;
std::getline(inpfile, line);
if(line.empty()) continue;
if(line[0] == '\x2a') continue;
if(eq_ignorecase(line.substr(0,20), "<<<< native_info_sim"))
{
read = true;
std::string temp(line, 20);
simN = std::stoi(temp);
read_block(inpfile);
}
}
return read;
}
void open(std::ifstream& stream) const {
stream.open(m_path.c_str(), std::ios::in|std::ios::binary);
if (!stream.is_open()) {
LOG4CXX_ERROR(m_logger, "Couldn't open file [" << m_path << "]");
MR4C_THROW(std::logic_error, "Couldn't open file [" << m_path << "]");
}
stream.exceptions(std::ifstream::badbit);
}
// Ensure a filehandle is open
void assertFileOpen(std::ifstream& fh, const std::string& fn)
{
if(!fh.is_open())
{
std::cerr << "Error: could not open " << fn << " for read\n";
exit(EXIT_FAILURE);
}
}
void
close ()
{
if (file_in_.is_open ())
{
file_in_.close ();
}
}
bool OpenFile(std::ifstream & fileStream, const String & fileName
, const char * _possibleLocations[])
{
fileStream.open(fileName.c_str());
int i=0;
while (!fileStream.is_open()
&& _possibleLocations != NULL && _possibleLocations[ i ] != NULL)
{
fileStream.clear();
fileStream.open((String(_possibleLocations[ i ]) + "/" + fileName).c_str());
++i;
}
return fileStream.is_open();
}
bool openInputFile(std::ifstream& _inFile, std::string _path){
_inFile.open(_path);
if(!_inFile.is_open() || !_inFile.good())
return false;
return true;
}
void printFileOpen(std::ifstream &fileStream) {
if ( ! fileStream.is_open() ) {
std::cout <<" Failed to open" << std::endl;
}
else {
std::cout <<"Opened OK" << std::endl;
}
}
bool openInFile(const std::string &filename, std::ifstream &file){
file.open(filename.c_str(),std::ifstream::in);
if(!file.is_open()) {
printf("Could not open input file %s", filename.c_str());
return false;
}
return true;
}
TimeIntegrator::TimeIntegrator(Eigen::VectorXd &napp, std::ifstream &dyn_id, double &mass)
{
_napp = napp;
std::string line;
if (dyn_id.is_open())
{
std::vector<double> F_std, T_std;
while (dyn_id.good())
{
while(std::getline(dyn_id,line,'\n'))
{
// Ignore blank lines in the begining of the file (if any)
if(line.empty()) continue;
// Trim white space from the beginning of the string
line.erase(line.begin(), std::find_if(line.begin(), line.end(), std::not1(std::ptr_fun<int, int>(isspace))));
// If line starts with /, //, #, * and %, ignore it
if(line[0] == '#' || line[0]=='/' || line[0]=='%' || line[0]=='*') continue;
// Read data
// Note: automatically rules out strings and does not convert them. No need for checking
std::vector<double> inputs;
std::istringstream sline(line);
std::copy( std::istream_iterator<double>(sline),std::istream_iterator<double>(),std::back_inserter(inputs));
// Build Piezoelectric Matrix
if (inputs.size()==2)
{
T_std.push_back(inputs[0]);
F_std.push_back(inputs[1]);
}
}
}
// Determine nstep, dt, F1
// Map F1 using temp
Eigen::Map<Eigen::VectorXd> Acc_temp(F_std.data(),F_std.size());
F1=Acc_temp*mass; // accecelaration into mass
_nstep = T_std.size();
for (unsigned int i=0; i<T_std.size(); ++i)
{
if (T_std[i+1]>T_std[i])
{
_dt = T_std[i+1]-T_std[i];
break;
}
else
{
// Turn this off for GUI mode
// throw std::invalid_argument("Could not determine time-step size");
}
}
}
else
{
// Turn this off for GUI mode
// throw std::invalid_argument("Could not open the file!");
}
}
//-------------------------------------------------------------------------//
bool Mesh::Load(std::ifstream& ifs)
{
bool bReturnValue = false;
//-----------------------------------------------------------------------//
// Ensure the file stream passed into this method is open
assert(ifs.is_open());
if(ifs.is_open())
{
ifs >> mulNumberOfFaces;
ifs >> mulNumberOfVertices;
ifs >> mulNumberOfIndices;
unsigned long ulArrayIndex = 0UL;
unsigned long ulIndicesIndex = 0UL;
//---------------------------------------------------------------------//
if(this->mpIndexArray != NULL)
delete [] this->mpIndexArray;
this->mpIndexArray = new unsigned long[mulNumberOfIndices];
//---------------------------------------------------------------------//
//---------------------------------------------------------------------//
// Clear vertex data is any exist and create a new buffer for this mesh
if(this->mpVertexArray != NULL)
delete [] this->mpVertexArray;
this->mpVertexArray = new Vertex[mulNumberOfVertices];
//---------------------------------------------------------------------//
//---------------------------------------------------------------------//
while(!ifs.eof() && ((ulIndicesIndex < mulNumberOfIndices) || (ulArrayIndex < mulNumberOfVertices)))
{
string strLabel;
ifs >> strLabel;
if(strLabel == "Loc")
{
float fX, fY, fZ;
ifs >> fX;
ifs >> fY;
ifs >> fZ;
Object::Position(fX, fY, fZ);
}
else if(strLabel == "v")
// This closes the file which was being parsed, if there is one open.
inline void RestrictedXmlParser::CloseFile()
{
if( xmlFileStream.is_open() )
{
xmlFileStream.close();
}
xmlFileStream.clear();
xmlStream = &xmlStringStream;
}
bool IsFileNameCorrect(const std::ifstream & inputFile)
{
if (inputFile.is_open())
{
return true;
}
std::cout << "inputFile name is incorrect" << std::endl;
return false;
}
inline lf_file::lf_file(std::string fname):
post_header_pos(0)
{
f.open(fname.c_str(), std::ifstream::in);
if (!f.is_open()) {
throw std::runtime_error("Could not open file.\n ");
}
parse_header();
}
inline bool
hash_commented_file_reader::file_is_open()
const
// this returns true if the file to be read was successfully opened.
{
return input_file.is_open();
}
bool const
file_handler<
std::string,
std::ifstream>::get_data(
std::string const &key,
std::ifstream &value) const
{
value.open(key.c_str(), std::ios_base::binary);
return value.is_open();
}
void
OpenIFile(std::ifstream& fs, const char* filenm)
{
using namespace std;
fs.open(filenm, ios::in);
if (!fs.is_open() || fs.fail()) {
DIAG_Throw("Cannot open file '" << filenm << "'");
}
}
void initializeInstructionMemory(std::ifstream &fp) {
std::string line;
std::string text;
if (fp.is_open()) {
while ( getline(fp,line) ) {
text << line << '\n';
}
fp.close();
}
}
