void getFileModeCallback(const std_msgs::String::ConstPtr& msg)
{
std::string temp = msg->data;
if( "write" == temp )
{
if( !tactileDataFile.is_open() && !jointsDataFile.is_open() )
{
std::cout << "\n\n ===== Creating files: " << tactileFileName << " and " << jointsFileName;
tactileDataFile.open(tactileFileName.c_str());
jointsDataFile.open(jointsFileName.c_str());
writeStatus = true;
}
}
else
{
if( tactileDataFile.is_open() && jointsDataFile.is_open() )
{
std::cout << "\n\n ===== Closing files: " << tactileFileName << " and " << jointsFileName;
tactileDataFile.close();
jointsDataFile.close();
writeStatus = false;
}
}
std::cout << "\n\n ===== mode: " << msg->data;
}
/* Flushes all ostreams used for debug messages. You need to call
this before forking. */
void flush_debug()
{
if (logfile_null.is_open())
logfile_null.flush();
if (logfile_file.is_open())
logfile_file.flush();
}
/*
Open the output file, initialize the output stream, and return the file's
length. If reload is true, first truncate any preexisting file
*/
unsigned long Download::openfile(char *url, bool reload, ofstream &fout, char *name)
{
char fname[MAX_FILENAME_SIZE];
if(!getfname(url, fname))
throw DLExc("File name error");
for(int i = 0; i < 5 && (!fout.is_open() || !fout); ++i)
{
if(!reload)
fout.open(fname, ios::binary | ios::out | ios::app | ios::ate);
else
fout.open(fname, ios::binary | ios::out | ios::trunc);
if(!fout.is_open() || !fout)
{
char buff[MAX_FILENAME_SIZE];
strcpy(buff, fname);
sprintf(fname, "%s-%u", buff, time(0)-i);
fout.clear();
}
}
if(!fout)
throw DLExc("Could not open TEMP file!");
strcpy(name, fname);
// get current file length
return fout.tellp();
}
virtual
void
close()
{
if(paramFile_.is_open()) paramFile_.close();
if(occFile_.is_open()) occFile_.close();
}
BOOL OpenLogFiles()
{
// Open import log file
if ( FileSize("./log/import.log") > MAXLOGSIZE )
// Truncate before writing
logfile.open("./log/import.log", ios::out);
else
// Append to existing
logfile.open("./log/import.log", ios::app);
if ( !logfile.is_open() )
{
cerr << "Could not open 'import.log'" << endl;
return FALSE;
}
// Open import error file
if ( FileSize("./log/import.err") > MAXERRSIZE )
// Truncate before writing
errfile.open("./log/import.err", ios::out);
else
// Append to existing
errfile.open("./log/import.err", ios::app);
if ( !errfile.is_open() )
{
cerr << "Could not open 'import.err'" << endl;
return FALSE;
}
return TRUE;
}
// Open the various files for output
bool DataScaling::openFiles(ifstream& kaggleFile, ofstream& nodeFile, ofstream& edgeFile, ofstream& adFile)
{
kaggleFile.open(this->kaggleFile);
if (!kaggleFile.is_open())
{
cout << "Failed to open input kaggle file:" << this->kaggleFile << endl;
return(false);
}
nodeFile.open(this->nodeFile);
if (!nodeFile.is_open())
{
cout << "Failed to open output node file:" << this->nodeFile << endl;
return(false);
}
edgeFile.open(this->edgeFile);
if (!edgeFile.is_open())
{
cout << "Failed to open output edge file:" << this->edgeFile << endl;
return(false);
}
adFile.open(this->adFile);
if (!adFile.is_open())
{
cout << "Failed to open output ad file:" << this->adFile << endl;
return(false);
}
return(true);
}
void incomingData(Stream *stream)
{
Message *message = Message::receive(stream);
UserMessage *userMessage = dynamic_cast<UserMessage *>(message);
if (userMessage)
{
if (userMessage->type == eventId)
{
double elapsedTime = (double)startingTime.msecsTo(QTime::currentTime()) / 1000.;
if (outputFile.is_open())
outputFile << elapsedTime;
timeStamps.push_back(elapsedTime);
for (size_t i = 0; i < values.size(); i++)
{
if (i < userMessage->data.size())
{
if (outputFile.is_open())
outputFile << " " << userMessage->data[i];
values[i].push_back(userMessage->data[i]);
}
else
{
if (outputFile.is_open())
outputFile << " " << 0;
values[i].push_back(0);
}
}
if (outputFile.is_open())
outputFile << endl;
replot();
}
}
delete message;
}
/**
* Output the energy/angular momentum.
*/
void output_converseved_quantities(double E1, double L1, ofstream& output_file_energy, ofstream& output_file_angular_momentum) {
if (output_file_energy.is_open()) {
output_file_energy << E1 << endl;
}
if (output_file_angular_momentum.is_open()) {
output_file_angular_momentum << L1 << endl;
}
}
/**
* Close the files in case they are open
* @param scores_file the scores file
* @param lattice_file the lattice file
*/
inline void close_lattice_files(ofstream & scores_file, ofstream & lattice_file) const {
if (scores_file.is_open()) {
scores_file.close();
}
if (lattice_file.is_open()) {
lattice_file.close();
}
}
~Disassembler(){
if (disassembly.is_open()){
disassembly.close();
}
if (simulation.is_open()){
simulation.close();
}
};
public: void Load(physics::ModelPtr _model, sdf::ElementPtr _sdf){
world = _model->GetWorld();
model = _model;
trunk = model->GetLink("trunk");
#if(PRINT_DEBUG)
cout << "Loading the velocity over time plugin" << endl;
#endif
connection = event::Events::ConnectWorldUpdateBegin(boost::bind(&VelocityOverTimePlugin::worldUpdate, this));
// Get the name of the folder to store the result in
const char* resultsFolder = std::getenv("RESULTS_FOLDER");
if(resultsFolder == nullptr){
cout << "Results folder not set. Using current directory." << endl;
resultsFolder = "./";
}
{
const string resultsXFileName = string(resultsFolder) + "/" + "velocities_x.csv";
bool exists = boost::filesystem::exists(resultsXFileName);
outputCSVX.open(resultsXFileName, ios::out | ios::app);
assert(outputCSVX.is_open());
if (!exists) {
writeHeader(outputCSVX);
}
}
{
const string resultsYFileName = string(resultsFolder) + "/" + "velocities_y.csv";
bool exists = boost::filesystem::exists(resultsYFileName);
outputCSVY.open(resultsYFileName, ios::out | ios::app);
assert(outputCSVY.is_open());
if (!exists) {
writeHeader(outputCSVY);
}
}
{
const string resultsZFileName = string(resultsFolder) + "/" + "velocities_z.csv";
bool exists = boost::filesystem::exists(resultsZFileName);
outputCSVZ.open(resultsZFileName, ios::out | ios::app);
assert(outputCSVZ.is_open());
if (!exists) {
writeHeader(outputCSVZ);
}
}
// Write out t0
outputCSVX << "Velocity X (m/s), " << trunk->GetWorldCoGLinearVel().x << ", ";
outputCSVY << "Velocity Y (m/s), " << trunk->GetWorldCoGLinearVel().y << ", ";
outputCSVZ << "Velocity Z (m/s), " << trunk->GetWorldCoGLinearVel().z << ", ";
}
/**
* Output the excentric/great half axis to a file.
*/
void output_orbital_parameters(double a1, double e1, ofstream& output_file_a, ofstream& output_file_e) {
if (output_file_a.is_open()) {
output_file_a << a1 << endl;
}
if (output_file_e.is_open()) {
output_file_e << e1 << endl;
}
}
void shared_print(string id, int value) {
if (!f.is_open()) { // lazy initialization -- A
std::unique_lock<mutex> locker(m_mutex);
if (!f.is_open()) {
f.open("log.txt"); // This must be synchronized -- B
}
}
f << "From " << id << ": " << value << endl; // I don't care this is not synchronized
}
void close_debug()
{
if (logfile_null.is_open())
logfile_null.close();
if (logfile_file.is_open())
logfile_file.close();
logfile_trace = logfile_info = logfile_warning = logfile_error = 0;
}
void OpenOutputFile(){
static string _FileNumber = "";
if (!OutputFile.is_open() || _FileNumber != FileNumber){
_FileNumber = FileNumber;
if (OutputFile.is_open()){
OutputFile.close();
}
string file = "output_" + FileNumber + ".txt";
cout << "Opening output file...";
OutputFile.open(file.c_str(), ios::ate | ios::app | ios::out);
if (!OutputFile){
TerminateError("Unable to open output file.");
}
}
}
int main(int argc, char **argv)
{
for(;;) {
int c;
int option_index = 0;
static struct option long_options[] = {
{"offset", 1, 0, 'o'},
{"help", 0, 0, 'h'},
{0, 0, 0, 0},
};
c = getopt_long(argc, argv, "ho:", long_options, &option_index);
if(c == -1)
break;
switch(c) {
case 'o':
fileoffset = strtoul(optarg, NULL, 0);
printf("offset %#zx\n", fileoffset);
break;
case 'h':
default:
usage(argc, argv);
break;
}
}
if (argc - optind < 2) {
printf("not enough arguments\n");
usage(argc, argv);
}
inputfile = argv[optind++];
outputfile = argv[optind++];
printf("input file %s\n", inputfile.c_str());
printf("output file %s\n", outputfile.c_str());
iHex hex;
if (hex.Open(inputfile) < 0) {
fprintf(stderr, "error opening input file\n");
return 1;
}
out.open(outputfile.c_str(), ios::out|ios::trunc|ios::binary);
if (!out.is_open()) {
fprintf(stderr, "error opening output file\n");
return 1;
}
hex.SetCallback(&ihexcallback);
hex.Parse();
hex.Close();
out.close();
return 0;
}
bool SaveOBJ(ofstream& fout, const double* const& points, const int* const& triangles, const unsigned int& nPoints,
const unsigned int& nTriangles, const Material& material, IVHACD::IUserLogger& logger, int convexPart, int vertexOffset)
{
if (fout.is_open()) {
fout.setf(std::ios::fixed, std::ios::floatfield);
fout.setf(std::ios::showpoint);
fout.precision(6);
size_t nV = nPoints * 3;
size_t nT = nTriangles * 3;
fout << "o convex_" << convexPart << std::endl;
if (nV > 0) {
for (size_t v = 0; v < nV; v += 3) {
fout << "v " << points[v + 0] << " " << points[v + 1] << " " << points[v + 2] << std::endl;
}
}
if (nT > 0) {
for (size_t f = 0; f < nT; f += 3) {
fout << "f "
<< triangles[f + 0]+vertexOffset << " "
<< triangles[f + 1]+vertexOffset << " "
<< triangles[f + 2]+vertexOffset << " " << std::endl;
}
}
return true;
}
else {
logger.Log("Can't open file\n");
return false;
}
}
long S_Rend::render(ifstream& in, ofstream& out) {
long bn;
long t;
if (!(in.is_open()))
{ return -1; }
else {
t = 300;
size=0;
for_each (std::istreambuf_iterator<char>(in), \
std::istreambuf_iterator<char>(), \
[&] (char x) {
t=s_nop(t,0);
cred.push_back(t);
alpha = static_cast<long>(cred[size]);
delta = static_cast<long>(x);
lambda ^= delta ^ alpha;
size++;
});
printf("*");
}
if (out.is_open())
{ out << lambda << endl;
out << delta << endl;
out << size << endl;
out << cred[size-1] << endl; }
else { return -1; }
in.close();
out.close();
return 0;
}
void WorkerThread::dumpPpm(ofstream& fout, const cv::Mat& frame) {
if (fout.is_open()) {
vector<uchar> buff;
cv::imencode(".pgm", frame, buff);
fout.write((char*)&buff.front(), buff.size());
}
}
void MQTTLogger::OnMessage(const struct mosquitto_message *message)
{
string topic = message->topic;
string payload = static_cast<const char*>(message->payload);
std::time_t tt = std::time(NULL);
char mbstr[100];
std::strftime(mbstr, sizeof(mbstr), "%Y-%m-%d %H:%M:%S:", std::localtime(&tt));
string time(mbstr);
Output << time + "\t" << topic + "\t" + payload << endl;
if (Output.tellp() > Max){
Output.close();
int i;
for (i = Number-1; i > 0; i--){
if (access((Path_To_Log + "." + to_string(i)).c_str(), F_OK) != -1){// check if old log file exists
if (rename((Path_To_Log + "." + to_string(i)).c_str(), (Path_To_Log + "." + to_string(i+1)).c_str()) != 0){
cerr << "can't create old log file \n";
exit(-1);
}
}
}
if (rename(Path_To_Log.c_str(), (Path_To_Log + ".1").c_str()) != 0){
cerr << "can't create old log file \n";
exit(-1);
}
Output.open(Path_To_Log);
if (!Output.is_open()){
cerr << "Cannot open log file for writting " << Path_To_Log << endl;
exit (-1);
}
mosquittopp::unsubscribe(NULL, Mask.c_str());// unsubscribe and subscribe to save all retained messages after rotate
Subscribe(NULL, Mask);
}
}
public: void Load(physics::ModelPtr _model, sdf::ElementPtr _sdf){
world = _model->GetWorld();
model = _model;
#if(PRINT_DEBUG)
cout << "Loading the angular momentum over time plugin" << endl;
#endif
connection = event::Events::ConnectWorldUpdateBegin(boost::bind(&AngularMomentumOverTimePlugin::worldUpdate, this));
// Get the name of the folder to store the result in
const char* resultsFolder = std::getenv("RESULTS_FOLDER");
if(resultsFolder == nullptr){
cout << "Results folder not set. Using current directory." << endl;
resultsFolder = "./";
}
const string resultsFileName = string(resultsFolder) + "/" + "angular_momentum.csv";
outputCSV.open(resultsFileName, ios::out);
assert(outputCSV.is_open());
writeHeader(outputCSV);
math::Vector3 angularMomentum;
for (unsigned int i = 0; i < boost::size(links); ++i) {
const physics::LinkPtr link = model->GetLink(links[i]);
angularMomentum += link->GetWorldInertiaMatrix() * link->GetWorldAngularVel();
}
// Write out t0
outputCSV << world->GetSimTime().Double() << ", " << angularMomentum.x / 10.0
<< ", " << angularMomentum.y / 10.0 << ", " << angularMomentum.z / 10.0 << endl;
}
int main(int argc, char * argv[])
{
if ( argc < 3 )
{
cout << "Provide the following details of file that contains the image names." << endl;
cout << "Expected command line arguments: <full path to directory> <filename>" << endl;
return -1;
}
string folder_path = argv[1];
string full_filename = folder_path + argv[2];
ifstream infile;
infile.open( full_filename.c_str() );
if ( !infile.is_open() )
{
cout << "Could not open file: " << full_filename << endl;
return -1;
}
// load flandmark model structure and initialize
model = flandmark_init("/home/teenarahul/RandD2/flandmark/flandmark/data/flandmark_model.dat");
if ( model == NULL )
{
cout << "Could not load flandmark model." << endl;
return -1;
}
string full_output_filename = folder_path + string( "Metadata_Flandmark.txt" );
outfile.open( full_output_filename.c_str(), ios::out );
if ( !outfile.is_open() )
{
cout << "Could not open file " << full_filename << " for writing." << endl;
return -1;
}
outfile << "** Format: <image file name> <left eye position: X> < left eye position: Y> <right eye position: X> < right eye position: Y> <expression label>";
bool success = false;
string image_name;
string full_imagename;
infile >> image_name; //Works even if the file is empty.
while ( infile.peek() != EOF )
{
success = false;
full_imagename = folder_path + image_name;
success = find_eye_positions_in_image( full_imagename, false, false );
if ( !success )
{
cout << "Eye positions not detected in image: " << image_name << "." << endl;
}
else
{
save_metadata( image_name );
}
infile >> image_name;
}
infile.close();
outfile.close();
}
void tbl_open(int tbl, ofstream& f) {
char prompt[256];
char fullpath[256];
struct stat fstats;
int retcode;
if (*tdefs[tbl].name == PATH_SEP)
strcpy(fullpath, tdefs[tbl].name);
else
sprintf(fullpath, "%s%c%s", env_config(PATH_TAG, PATH_DFLT), PATH_SEP,
tdefs[tbl].name);
retcode = stat(fullpath, &fstats);
if (retcode && (errno != ENOENT)) {
fprintf(stderr, "stat(%s) failed.\n", fullpath);
exit(-1);
}
if (S_ISREG(fstats.st_mode) && !force) {
sprintf(prompt, "Do you want to overwrite %s ?", fullpath);
if (!yes_no(prompt))
exit(0);
}
f.open(fullpath);
if (!f.is_open()) {
fprintf(stderr, "Open failed for %s at %s:%d\n",
fullpath, __FILE__, __LINE__);
exit(1);
}
}
static bool switch_log(ofstream &flog)
{
GenerateTime("pacs_log\\%Y\\%m\\%d\\%H%M%S_service_n.txt", buff, sizeof(buff));
if(flog.tellp() > 10 * 1024 * 1024 || strncmp(buff, current_log_path.c_str(), 20)) // 20 == strlen("pacs_log\\YYYY\\MM\\DD\\")
{
if(PrepareFileDir(buff))
{
if(flog.is_open())
{
time_header_out(flog) << "to be continued" << endl;
flog.close();
}
flog.open(buff);
if(flog.fail())
{
cerr << "watch_notify() switch log " << buff << " failed" << endl;
return false;
}
time_header_out(flog) << "continuation of " << current_log_path << endl;
current_log_path = buff;
}
else
{
DWORD gle = GetLastError();
cerr << "watch_notify() switch log failed, PrepareFileDir(" << buff << ") failed" << endl;
return false;
}
}
return true;
}
void DisabledInit() {
//Config loading
try {
cameraLight->Set(Relay::kOff);
if (!Config::LoadFromFile("config.txt")) {
cout << "Something happened during the load." << endl;
}
Config::Dump();
myDrive->DisablePID();
myDrive->ResetPID();
if(fout.is_open() && !freshStart && !ds->IsFMSAttached()){
fout.close();
myShooter->ResetShooterProcess();
lc->holdState(false);
}
} catch (exception ex) {
cout << "Disabled exception. Trying again." << endl;
cout << "Exception: " << ex.what() << endl;
}
//ResetShooterMotors();
/*
SmartDashboard::PutNumber("Target Info S",1741);
cout<<SmartDashboard::GetNumber("Target Info S");
*/
}
/**
* Open a log file for writing to.
* @return SUCCESS or FAIL
*/
int OpenLogFile(string path)
{
logFilePath = path;
//-------------------------------------------------------------------------
// Open file with append mode.
//-------------------------------------------------------------------------
logFileStream.open(path.c_str(), ios::app);
//-------------------------------------------------------------------------
// If the file successfully opened, then set the flag for the other
// functions to know that the file is open..
//-------------------------------------------------------------------------
if (logFileStream.is_open())
{
logOpen = TRUE;
}
//-------------------------------------------------------------------------
// .. Else return FAIL.
//-------------------------------------------------------------------------
else
{
return FAIL;
}
//-------------------------------------------------------------------------
// If flow reaches here, then everything is good.
//-------------------------------------------------------------------------
return SUCCESS;
}
// This method outputs the object's variables in the file 'fout'.
void SearchControl::showInput(ofstream & fout)
{
if (!fout.is_open())
return;
if ((initial_search == NULL) && (iterative_search == NULL) &&
(speculative_search == NULL))
fout << "\nNo search.\n----------\n";
else
{
if (initial_search != NULL)
{
fout << "\nInitial search type:\n--------------------\n";
initial_search->showInput(fout);
}
if (iterative_search != NULL)
{
fout << "\nIterative search type:\n----------------------\n";
iterative_search->showInput(fout);
}
if (speculative_search != NULL)
{
fout << "\nSpeculative search: Executed after a successful iteration.";
fout << "\n-------------\n";
}
}
}
int main()
{
LOGFILE.open("lab2_part1.log",ios::trunc);
if (LOGFILE.is_open())
LOGFILE << POS_IN_PROGRAM << "start of logging" << endl;
else
{
cout << "Unable to open file for logging.";
return 1;
}
// now all your regular stuff can go here
char c_array[5];
int i_array[5];
string intMsg = "Populate the int array with values.";
string charMsg = "Populate the char array with values.";
string dmpIntMsg = "Dump the data in the int array";
string dmpCharMsg = "Dump the data in the char array";
PromptForInt(intMsg, i_array);
PromptForChar(charMsg, c_array);
DumpInt(dmpIntMsg, i_array);
DumpChar(dmpCharMsg, c_array);
// close the logfile and exit
LOGFILE.close();
return 0;
}
void ask(istream& in, ofstream& log, Aeromatic::Param* param)
{
string input;
cout << param->name();
cout << " [" << param->get_units() << "]";
cout << " (" << param->get() << ")";
cout << ": ";
unsigned options = param->no_options();
for(unsigned j=0; j<options; ++j)
{
cout << endl;
cout << " " << j << ": ";
cout << param->get_option(j);
}
if (options) cout << endl;
getline(in, input);
if (!input.empty())
{
if (input == "?" || input == "h" || input == "help")
{
cout << param->help() << endl;
getline(in, input);
}
if (!input.empty()) {
param->set(input);
}
}
if (log.is_open()) {
log << input << endl;
}
}
int main(int argc, CHAR *argv[])
{
PIN_InitSymbols();
if( PIN_Init(argc,argv) )
{
return Usage();
}
string outFileName = KnobOutputFile.Value() + string("_") + decstr(PIN_GetPid());
Out.open(outFileName.c_str(), ios_base::app);
if (!Out.is_open())
{
cerr << "Can't open file " << outFileName << endl;
exit(-1);
}
cerr << "Open file " << outFileName << endl;
PIN_AddForkFunctionProbed(FPOINT_BEFORE, BeforeFork, 0);
PIN_AddForkFunctionProbed(FPOINT_AFTER_IN_CHILD, AfterForkInChild, 0);
PIN_AddForkFunctionProbed(FPOINT_AFTER_IN_PARENT, AfterForkInParent, 0);
PIN_AddFollowChildProcessFunction(FollowChild, 0);
PIN_StartProgramProbed();
return 0;
}
