void initLogger(int networkId)
{
// Error file
if (gErrorFile.is_open())
{
gErrorFile.close();
gErrorFile.clear();
}
std::stringstream errorFile;
errorFile << "../error_log_" << networkId << ".txt";
gErrorFilePath = errorFile.str();
gErrorFile.open(gErrorFilePath.c_str());
// Debug message file
if (gDebugMessageFile.is_open())
{
gDebugMessageFile.close();
gDebugMessageFile.clear();
}
std::stringstream debugFile;
debugFile << "../debug_message_log_" << networkId << ".txt";
gDebugMessageFilePath = debugFile.str();
gDebugMessageFile.open(gDebugMessageFilePath.c_str());
}
void writeTrajectory(TrajectoryBasePtr ptraj){
mtx_.lock();
stringstream ss;
if (!!(ptraj)){
if ((ptraj->GetDuration() < timer)){
timer = ptraj->GetDuration();
//std::cout << "Storing Trajectory with following info" << std::endl;
//std::cout << timer << std::endl;
ptraj->serialize(ss);
traj.open("traj.xml");
traj.clear();
traj << ss.str();
traj.close();
}
else {
//std::cout << "Ignoring Trajectory Files" << std::endl;
}
}
else {
//std::cout << "Planning Failed : trajectory empty" << std::endl;
}
mtx_.unlock();
}
std::ostream& LoggerImpl::getAppender()
{
if (pipe)
return *pipe;
else if (!fname.empty())
{
if (!outfile.is_open())
{
outfile.clear();
outfile.open(fname.c_str(), std::ios::out | std::ios::app);
counter.resetCount(outfile.tellp());
}
if (maxfilesize > 0)
{
if (counter.getCount() > maxfilesize)
{
doRotate();
counter.resetCount();
}
return tee;
}
else
return outfile;
}
else if (loghost.isConnected())
return udpmessage;
else
return std::cerr;
}
void sotDebugTrace::openFile( const char * filename )
{
if( debugfile.good()&&debugfile.is_open() ) debugfile.close();
debugfile.clear();
debugfile.open( filename, std::ios::trunc&std::ios::out );
//std::cout << filename << debugfile.good() << debugfile.is_open() << std::endl;
}
void open(bool truncate)
{
if (open_filename == m_filename) return;
log_file.close();
log_file.clear();
log_file.open(m_filename.c_str(), truncate ? std::ios_base::trunc : std::ios_base::app);
open_filename = m_filename;
if (!log_file.good())
fprintf(stderr, "Failed to open logfile %s: %s\n", m_filename.c_str(), strerror(errno));
}
std::string promptUserForFile(std::ofstream &outFile, std::string prompt) {
while (true) {
std::cout << prompt;
std::string fileName;
getline(std::cin, fileName);
outFile.open(fileName.c_str());
if (!outFile.fail()) return fileName;
outFile.clear();
std::cout << "Unable to open that file. Try again." << std::endl;
if (prompt == "") prompt = "Output file: ";
}
}
bool FileSystem::rawopen
(
std::ofstream& out, // Output stream to open.
const string &fname, // May be converted to upper-case.
bool is_text // Should the file be opened in text mode
)
{
string name = fname;
if (!rewrite_virtual_path(name)) {
con.Print_err(MM_MAJOR_WARN, "Illegal file access\n");
return false;
}
#if defined(MACOS) || (__GNUG__ > 2)
std::ios_base::openmode mode = std::ios::out | std::ios::trunc;
if (!is_text) mode |= std::ios::binary;
#elif defined(UNIX)
int mode = std::ios::out | std::ios::trunc;
#else
int mode = std::ios::out | std::ios::trunc;
if (!is_text) mode |= std::ios::binary;
#endif
switch_slashes(name);
// We first "clear" the stream object. This is done to prevent
// problems when re-using stream objects
out.clear();
int uppercasecount = 0;
do {
out.open(name.c_str(), mode); // Try to open
if (out.good()) return true; // found it!
out.clear(); // Forget ye not
} while (base_to_uppercase(name, ++uppercasecount));
// file not found.
return false;
}
virtual void reset() {
DVLOG(5) << "resetting histogram";
if (!log_initialized) {
log_initialized = true;
char * jobid = getenv("SLURM_JOB_ID");
char fname[256]; sprintf(fname, "histogram.%s/%s.%d.out", jobid, name, mycore());
log.open(fname, std::ios::out | std::ios_base::binary);
DVLOG(5) << "opened " << fname;
}
if (log_initialized) {
log.clear();
log.seekp(0, std::ios::beg);
}
value_ = nil_value;
}
void parse_template(template_files_vector::iterator i, std::ifstream &input, std::ofstream &output, const symbol_map &symbols)
{
std::string line;
parser_vector parsers;
parsers.push_back(parser_object_ptr(new symbol_parser(symbols, parsers, input, output)));
input.open(i->first.c_str(), std::ios::in);
string_pair &out_file = i->second;
output.open(std::string(out_file.first + symbols.find("NAME_LOWER")->second + out_file.second).c_str(),
std::ios::out | std::ios::trunc);
if( !input.is_open() )
throw std::runtime_error("Failed to open template file");
if( !output.is_open() )
throw std::runtime_error("Failed to open output file");
std::string buff;
// read and write line by line
while(true)
{
symbol_parser::m_should_output = true;
std::getline(input, line);
buff = line;
if( input.eof() )
break;
if( !input.good() || !output.good() )
throw std::runtime_error("Input or Output error!");
for( parser_vector::reverse_iterator i = parsers.rbegin(), end = parsers.rend(); i != end; ++i )
if( (**i)(buff) )
break;
}
input.close();
output.close();
input.clear();
output.clear();
}
//--- Open an output file.
//
// Note not under unit test.
//
bool openOutputFile(std::ofstream& fileStream, const char *const fileName, std::ios_base::openmode mode,
std::string& errStr)
{
//
// Start with a clean slate.
if( fileStream.is_open() )
fileStream.close();
fileStream.clear(std::ios_base::goodbit);
//
// Open file.
fileStream.open(fileName, mode);
if( fileStream.fail() )
{
if( 0 != errStr.size() )
errStr.push_back('\n');
errStr.append("Failed to open file '").append(fileName).push_back('\'');
return( 0 );
}
//
return( 1 );
} // End fcn openOutputFile().
void LoggerImpl::doRotate()
{
outfile.clear();
outfile.close();
// ignore unlink- and rename-errors. In case of failure the
// original file is reopened
std::string newfilename = mkfilename(maxbackupindex);
::unlink(newfilename.c_str());
for (unsigned idx = maxbackupindex; idx > 0; --idx)
{
std::string oldfilename = mkfilename(idx - 1);
::rename(oldfilename.c_str(), newfilename.c_str());
newfilename = oldfilename;
}
::rename(fname.c_str(), newfilename.c_str());
outfile.open(fname.c_str(), std::ios::out | std::ios::app);
counter.resetCount(outfile.tellp());
}
std::string promptUserForFile(std::ofstream& stream,
const std::string& prompt,
const std::string& reprompt) {
std::string promptCopy = prompt;
std::string repromptCopy = reprompt;
if (reprompt == "") {
repromptCopy = "Unable to open that file. Try again.";
}
appendSpace(promptCopy);
while (true) {
std::cout << promptCopy;
std::string filename;
getline(std::cin, filename);
if (!filename.empty()) {
openFile(stream, filename);
if (!stream.fail()) return filename;
stream.clear();
}
std::cout << repromptCopy << std::endl;
if (promptCopy == "") promptCopy = "Output file: ";
}
}
// visit generate_ham_cycles_helper
void generate_ham_cycle(int m, int n, int v)
{
int size = m * n;
int column = n;
int** matrix;
generate_grid_matrix(matrix, m, n);
///////////////////////////////////////////////////////
fout.open("cuda/matrix.in");
fout << " " << size << std::endl;
for(int i = 0; i < size; ++i){
for(int j = 0; j < size; ++j){
fout << std::setw(3) << matrix[i][j];
}
fout << std::endl;
}
fout.close();
fout.clear();
///////////////////////////////////////////////////////
//print adjacency matrix for grid graph
//for(int i = 0; i < size; ++i){
// for(int j = 0; j < size; ++j){
// std::cout << matrix[i][j] << ' ';
// //std::cout << matrix[i][j] << ", ";
// }
// std::cout << std::endl;
//}
///////////////////////////////////////////////////////
bool* visit; // = {0,};
visit = new bool[size];
for(int i = 0; i < size; ++i){
visit[i] = false;
}
int w = v - 1; // starting node of hamiltonian cycle
std::vector<int> myvector;
myvector.push_back(w); // start of hamiltonian cycle
std::cout << std::endl;
generate_ham_cycle_helper(w, w, myvector, matrix, visit, size, column);
std::cout << " Count of HAMILTONIAN CYCLES " << cycles.size() << std::endl << std::endl;
//std::cout << "\nCount of HAMILTONIAN CYCLES = "
// << generate_ham_cycle_helper(w, w, myvector, matrix, visit, size, column)
// << std::endl << std::endl;
//print all hamiltonian cycles
//for(int i = 0; i < cycles.size(); ++i){
// print_vector(cycles[i]);
//}
int s = cycles.size();
if(s) {
int t,c1,c2;
int min = distance(0, 0);
long unsigned int sum1 = 0;
long unsigned int sum2 = 0;
std::vector<int> f1;
std::vector<int> f2;
c1 = 0;
c2 = 0;
//variables for non simetrical cycles
bool b = true;
unsigned int count = 0;
fout.open("octave/functions.in");
for(int i = 0; i < s; ++i){
//sum and f1 functions of C1 cycle
sum1 = charac_function(cycles[i], f1, column);
for(int j = i + 1; j < s; ++j){
//sum and f2 functions of C2 cycle
sum2 = charac_function(cycles[j], f2, column);
if(if_equal(f1, f2)){
b = false;
// print cycles, which function are equaly
// print_function(f1);
// print_vector_in_grid(cycles[i], column);
// print_vector_in_grid(cycles[j], column);
}
t = distance(i,j);
if(min > t){
min = t;
c1 = i;
c2 = j;
}
}
if(b) {
//print non charac. functions to file functions.in
print_function_to_file(f1);
++count;
}
b = true;
}
fout.close();
fout.clear();
std::cout << " Count of non simetrical HAMILTONIAN CYCLES "
<< count << std::endl << std::endl;
std::cout << " nm " << size << std::endl;
std::cout << " min distance " << min << std::endl;
std::cout << " max distance " << 2 * size - 2 * min << std::endl;
//print_vector(cycles[c1]);
//print_vector(cycles[c2]);
print_vector_in_grid(cycles[c1], column);
print_vector_in_grid(cycles[c2], column);
//for(int i = 0; i < s; ++i){
// for(int j = i + 1; j < s; ++j){
// t = distance(i,j);
// if(min == t){
// std::cout << "/////////////////////////////////////////////////////////////" << std::endl;
// print_vector_in_grid(cycles[i], column);
// print_vector_in_grid(cycles[j], column);
// }
// }
//}
}
///////////////////////////////////////////////////////
//std::vector<int> v1;
//std::vector<int> v2;
//std::vector<int> f1;
//std::vector<int> f2;
//v1.push_back(0);v1.push_back(1);v1.push_back(9);v1.push_back(17);v1.push_back(18);v1.push_back(10);v1.push_back(2);v1.push_back(3);v1.push_back(11);v1.push_back(12);v1.push_back(4);v1.push_back(5);v1.push_back(6);v1.push_back(7);v1.push_back(15);v1.push_back(23);v1.push_back(31);v1.push_back(30);v1.push_back(22);v1.push_back(14);v1.push_back(13);v1.push_back(21);v1.push_back(29);v1.push_back(28);v1.push_back(20);v1.push_back(19);v1.push_back(27);v1.push_back(26);v1.push_back(25);v1.push_back(24);v1.push_back(16);v1.push_back(8);
//v2.push_back(0);v2.push_back(1);v2.push_back(2);v2.push_back(3);v2.push_back(11);v2.push_back(12);v2.push_back(4);v2.push_back(5);v2.push_back(6);v2.push_back(7);v2.push_back(15);v2.push_back(23);v2.push_back(31);v2.push_back(30);v2.push_back(22);v2.push_back(14);v2.push_back(13);v2.push_back(21);v2.push_back(29);v2.push_back(28);v2.push_back(20);v2.push_back(19);v2.push_back(27);v2.push_back(26);v2.push_back(18);v2.push_back(10);v2.push_back(9);v2.push_back(17);v2.push_back(25);v2.push_back(24);v2.push_back(16);v2.push_back(8);
//int sum1 = charac_function(v1, f1, 8);
//int sum2 = charac_function(v2, f2, 8);
//print_function(f1);
//print_function(f2);
//std::cout << "sum1 = " << sum1 << std::endl;
//std::cout << "sum2 = " << sum2 << std::endl;
//print_vector_in_grid(v1, 8);
//print_vector_in_grid(v2, 8);
///////////////////////////////////////////////////////
std::cout << " Generated" << std::endl;
std::cout << " Adjacency matrix to file cuda/matrix.in" << std::endl;
std::cout << " Characteristic functions of loops to file octave/functions.in" << std::endl;
//generate Kirchhorff matrix
for(int i = 0; i < size; ++i){
for(int j = 0; j < size; ++j){
matrix[i][j] = -matrix[i][j];
}
}
matrix[0][n] = -1;
matrix[0][0] = 2;
matrix[n - 1][n - 1] = 2;
matrix[size - n][size - n] = 2;
matrix[size - 1][size - 1] = 2;
for(int i = 1; i < n-1; ++i){
matrix[i][i] = 3;
matrix[size - i - 1][size - i - 1] = 3;
}
for(int i = 1; i < m - 1; ++i){
matrix[i * n][i * n] = 3;
matrix[n + i * n - 1][n + i * n - 1] = 3;
}
for(int i = 1; i < m - 1; ++i){
for(int j = 1; j < n - 1; ++j){
matrix[i * n + j][i * n + j] = 4;
}
}
fout.open("octave/matrix.in");
for(int i = 0; i < size; ++i){
for(int j = 0; j < size; ++j){
fout << std::setw(3) << matrix[i][j];
}
fout << std::endl;
}
fout.close();
fout.clear();
std::cout << " Kirchhorff matrix to file octave/matrix.in" << std::endl << std::endl;
///////////////////////////////////////////////////////
for(int i = 0; i < size; ++i){
delete [] matrix[i];
}
delete [] matrix;
}
/** Open file stream to write in */
static void openTextFileStream(std::ofstream& fileStream,
const std::string& fileName) {
fileStream.open(fileName, std::ios::out);
assert_true(fileStream.is_open());
fileStream.clear();
}
void seekwriting(unsigned long int& seekpos) {
ofs_.clear();
ofs_.seekp(B_HEADERSIZE+seekpos);
}
void GLXOSD::stopFrameLogging() {
Lock lock(&frameLogMutex);
frameLoggingEnabled = false;
frameLogStream.close();
frameLogStream.clear();
}
int main()
{
traj.clear();
unsigned int mainthreadsleft = numThreads;
// boost::shared_ptr<boost::thread> ( new boost::thread(boost::bind( &track_threads )));
Ta.trans = transA;
Ta.rot = quatA;
Tb.trans = transB;
Tb.rot = quatB;
std::string scenefilename = "scenes/test6dof.mujin.zae";
std::string viewername = "qtcoin";
RaveInitialize(true); // start openrave core
EnvironmentBasePtr penv = RaveCreateEnvironment(); // create the main environment
Transform robot_t;
RaveVector< dReal > transR(c, d, 0);
robot_t.trans = transR;
//boost::thread thviewer(boost::bind(SetViewer,penv,viewername));
penv->Load(scenefilename);
RobotBasePtr probot = penv->GetRobot("RV-4F");
//removing floor for collision checking
EnvironmentBasePtr pclondedenv = penv->CloneSelf(Clone_Bodies);
pclondedenv->Remove( pclondedenv->GetKinBody("floor"));
RobotBasePtr probot_clone = pclondedenv->GetRobot("RV-4F");
unsigned int tot = ((( abs(a) + abs(c) )/discretization_x )+1) * (((( abs(b) + abs(d) )/discretization_y )+1) * (( abs( z )/discretization_z )+1));
unsigned int tot_o = tot;
for (unsigned int i = 0 ; i <= (( abs(a) + abs(c) )/discretization_x );i++) {
for (unsigned int j = 0 ; j <= (( abs(b) + abs(d) )/discretization_y ); j++) {
for (unsigned int k = 0 ; k <= ( abs( z )/discretization_z ) ; k++) {
////std::cout << transR[0] << ";" << transR[1] << ";" << transR[2] << std::endl;
//boost::this_thread::sleep(boost::posix_time::milliseconds(1000));
robot_t.trans = transR;
probot->SetTransform(robot_t);
probot_clone->SetTransform(robot_t);
if( pclondedenv->CheckCollision(RobotBaseConstPtr(probot_clone)) ){
//std::cout << "Robot in collision with the environment" << std::endl;
}
else {
do_task(Ta, Tb, penv,3);
}
tot -= 1;
std::cout << tot << "/" << tot_o << std::endl;
transR[2] = transR[2]+ discretization_z;
}
transR[2] = 0;
transR[1] = transR[1] + discretization_y;
robot_t.trans = transR;
}
transR[2] = 0;
transR[1] = c;
transR[0] = transR[0] + discretization_x;
robot_t.trans = transR;
}
//thviewer.join(); // wait for the viewer thread to exit
RaveDestroy(); // make sure to destroy the OpenRAVE runtime
penv->Destroy(); // destroy
return 0;
}
void CreateConfig(std::ofstream &file, Direct3DCap &cap)
{
file.clear();
//onderstaande code vraagt om scherm
int i = 1;
std::cout << "Choose one of the above screens" << std::endl;
scanf("%d", &i);
while (i >= cap.return_adapterCounnt() || i < 0)
{
std::cout << "Choice: " << i << " is invalid \nChoose one of the above screens" << std::endl;
scanf("%d", &i);
}
file << i << std::endl;
i = 0;
std::cout << "How many percent should be captured from the top/bottom (0-100)" << std::endl;
scanf("%d", &i);
while (i < 1 || i > 100)
{
std::cout << "Choice: " << i << " is invalid \n" << std::endl;
scanf("%d", &i);
}
file << i << std::endl;
i = 0;
std::cout << "How many percent should be captured from the left/right side (0-100)" << std::endl;
scanf("%d", &i);
while (i < 1 || i > 100)
{
std::cout << "Choice: " << i << " is invalid \n" << std::endl;
scanf("%d", &i);
}
file << i << std::endl;
int j = 0;
std::cout << "Which COM port is the arduino on" << std::endl;
scanf("%d", &j);
while (j < 0 || j > 60)
{
std::cout << "Choice: " << i << " is invalid \n" << std::endl;
scanf("%d", &j);
}
std::string String;
String = "\\\\.\\COM";
String += std::to_string(j);
char *temp = new char[String.size() + 1];
std::copy(String.begin(), String.end(), temp);
temp[String.size()] = '\0';
int *pointer = LedAmountTest(temp);
file << pointer[0] << std::endl;
file << pointer[1] << std::endl;
file << pointer[2] << std::endl;
file << pointer[3] << std::endl;
i = 0;
std::cout << "What is the minimum black treshold (0- 60)" << std::endl;
scanf("%d", &i);
while (i < 1 || i > 60)
{
std::cout << "Choice: " << i << " is invalid \n" << std::endl;
scanf("%d", &i);
}
file << i << std::endl;
i = 0;
file << j << std::endl;
}
bool openFile(std::ofstream& stream, const std::string& filename) {
stream.clear();
stream.open(expandPathname(filename).c_str());
return !stream.fail();
}
void PrintGMeshVTK(TPZGeoMesh * gmesh, std::ofstream &file)
{
file.clear();
int nelements = gmesh->NElements();
std::stringstream node, connectivity, type;
//Header
file << "# vtk DataFile Version 3.0" << std::endl;
file << "TPZGeoMesh VTK Visualization" << std::endl;
file << "ASCII" << std::endl << std::endl;
file << "DATASET UNSTRUCTURED_GRID" << std::endl;
file << "POINTS ";
int actualNode = -1, size = 0, nVALIDelements = 0;
for(int el = 0; el < nelements; el++)
{
if(gmesh->ElementVec()[el]->Type() == EPoint)//Exclude Lines and Arc3D
{
continue;
}
if(gmesh->ElementVec()[el]->Type() == EOned)//Exclude Lines and Arc3D
{
continue;
}
if(gmesh->ElementVec()[el]->HasSubElement())
{
continue;
}
int elNnodes = gmesh->ElementVec()[el]->NNodes();
size += (1+elNnodes);
connectivity << elNnodes;
for(int t = 0; t < elNnodes; t++)
{
for(int c = 0; c < 3; c++)
{
double coord = gmesh->NodeVec()[gmesh->ElementVec()[el]->NodeIndex(t)].Coord(c);
node << coord << " ";
}
node << std::endl;
actualNode++;
connectivity << " " << actualNode;
}
connectivity << std::endl;
int elType = -1;
switch (gmesh->ElementVec()[el]->Type())
{
case (ETriangle):
{
elType = 5;
break;
}
case (EQuadrilateral ):
{
elType = 9;
break;
}
case (ETetraedro):
{
elType = 10;
break;
}
case (EPiramide):
{
elType = 14;
break;
}
case (EPrisma):
{
elType = 13;
break;
}
case (ECube):
{
elType = 12;
break;
}
default:
{
//ElementType NOT Found!!!
DebugStop();
break;
}
}
type << elType << std::endl;
nVALIDelements++;
}
node << std::endl;
actualNode++;
file << actualNode << " float" << std::endl << node.str();
file << "CELLS " << nVALIDelements << " ";
file << size << std::endl;
file << connectivity.str() << std::endl;
file << "CELL_TYPES " << nVALIDelements << std::endl;
file << type.str();
file.close();
}