cl::Program KernelLoader::loadProgram( const std::string &sourcePath, const cl::Context &context, const std::string &buildOptions) { std::ifstream sourceStream(sourcePath); if (sourceStream.fail()) { throw std::ifstream::failure("unable to open file"); } sourceStream.exceptions(std::ifstream::failbit | std::ifstream::badbit); std::string sourceText { std::istreambuf_iterator<char>(sourceStream), std::istreambuf_iterator<char>() }; cl::Program prog(context, sourceText); try { prog.build(buildOptions.c_str()); } catch (const cl::Error &err) { std::cerr << "ERROR: Failed to build program!" << std::endl; for (cl::Device &device : context.getInfo<CL_CONTEXT_DEVICES>()) { std::string buildLog = prog.getBuildInfo<CL_PROGRAM_BUILD_LOG>(device); if (!buildLog.empty()) { std::cerr << "INFO: Build log from device '" << device.getInfo<CL_DEVICE_NAME>() << "':" << std::endl; std::cerr << buildLog << std::endl; } } throw; } return prog; }
void QProtobufModel::checkSourceChange() { if (m_metadata.isEmpty()) return; if (m_message.isEmpty()) return; if (m_source.isEmpty()) return; QProtobufModelErrorCollector errorCollector(this); QProtobufModelSourceTree sourceTree(m_metadata, this); ::pb::compiler::Importer importer(&sourceTree, &errorCollector); auto fileDescriptor = importer.Import(m_metadata.toString().toStdString()); auto descriptor = fileDescriptor->FindMessageTypeByName(m_message.toStdString()); m_prototype = m_messageFactory.GetPrototype(descriptor); m_rootItem = m_prototype->New(); LocalFileStream sourceStream(m_source); m_rootItem->ParseFromZeroCopyStream(&sourceStream); }
void FileSystem::copyFile(const Path& source, const Path& destination) { std::ifstream sourceStream(source.toString().c_str(), std::ios::binary); std::ofstream destinationStream(destination.toString().c_str(), std::ios::binary); destinationStream << sourceStream.rdbuf(); sourceStream.close(); destinationStream.close(); }
bool SkCLImageDiffer::loadKernelFile(const char file[], const char name[], cl_kernel* kernel) { // Open the kernel source file SkFILEStream sourceStream(file); if (!sourceStream.isValid()) { SkDebugf("Failed to open kernel source file"); return false; } return loadKernelStream(&sourceStream, name, kernel); }
void ShaderFile::_parseShader(std::string& shader, std::vector<std::string> includeList) { // Copy source std::string source = shader; shader.clear(); std::stringstream sourceStream(source); std::string line, token; while (!sourceStream.eof()) { std::getline(sourceStream, line, '\n'); std::stringstream lineStream(line); std::getline(lineStream, token, ' '); if (token == "#include") { std::getline(lineStream, token, '"'); std::getline(lineStream, token, '"'); if (!token.empty()) { bool found = false; for (auto iter : includeList) { if (iter == token) found = true; } if (!found) { includeList.push_back(token); std::string incldeFile; if (!Utilities::fileToString(mDirectory + token, incldeFile)) Log::error("Cannot include file '%s' in '%s'", token.c_str(), (mDirectory + mFileName).c_str()); else { _parseShader(incldeFile, includeList); shader += incldeFile; } } } } else { shader += line + '\n'; } } }
// FOR NOW THIS HAS THE FOLLOWING LIMITATIONS: // - Blocks can only be lighting related (easily fixable) << Quickly // - There's no explicit support to arrays. // FIX ASAP void ShaderProgram::fillUniformTable(){ for(unsigned int i=0; i<m_shaders.size(); i++){ std::string currSource = m_shaders.at(i).getSource(); std::string line,s, type; std::istringstream sourceStream(currSource); while(std::getline(sourceStream,line)){ std::istringstream iss(line); iss >> s; if(s=="layout(std140)"){ iss >> s; // skip keyword "uniform" iss >> s; m_lightUBO = glGetUniformBlockIndex(m_ID, s.c_str()); glUniformBlockBinding(m_ID, m_lightUBO, LIGHT_UBO_BINDING_POINT); } else if(s=="uniform"){ iss >> type; // skip type iss >> s; s = s.substr(0, s.size()-1); // Remove ; addUniform(s); }
ShaderProgram::Shader* ResourceManager::LoadShaderSource(std::string path) { ShaderProgram::Shader* shader = shaderMap[path]; if (shader == nullptr) { shader = new ShaderProgram::Shader(); shader->path = path; std::string extension = path.substr(path.find_last_of('.') + 1); if (extension == ShaderProgram::VERT_EXTENSION) { shader->type = GL_VERTEX_SHADER; } else if (extension == ShaderProgram::FRAG_EXTENSION) { shader->type = GL_FRAGMENT_SHADER; } else if (extension == ShaderProgram::GEOM_EXTENSION) { shader->type = GL_GEOMETRY_SHADER; } std::ifstream sourceStream(path, std::ios::ate | std::ios::binary); size_t size = sourceStream.tellg(); shader->source = new GLchar[size + 1]; sourceStream.seekg(0); sourceStream.read(shader->source, size); shader->source[size] = '\0'; shaderMap[path] = shader; } return shader; }
void DataInterface::writeEdgeList( const QString sourceSelection, const QString targetSelection, const bool directedRelationships, const QString relationsType, const std::string filename, const std::string sepOne, const std::string sepTwo ) { // We point to the InputTable and we get all the stuff out that we need from the input table and the function arguments. std::string sourceString = sourceSelection.toStdString(); std::string targetString = targetSelection.toStdString(); std::string relationshipType = "Undirected"; if (directedRelationships) { relationshipType = "Directed"; } std::string relationshipLabel = relationsType.toStdString(); std::istringstream convertSepOne(sepOne.c_str()); char sepOneChar; convertSepOne >> sepOneChar; std::istringstream convertSepTwo(sepTwo.c_str()); char sepTwoChar; convertSepTwo >> sepTwoChar; // We need to know in which part of the data vector the source and target node reside. // We create and set an index to achieve that. int sourceIndex = 0; int targetIndex = 0; for (std::vector<std::string>::size_type i = 0; i != header.size(); i++) { std::string currentString = header[i]; if (currentString == sourceString) { sourceIndex = i; } if (currentString == targetString) { targetIndex = i; } } // Then we prepare the file for writing. std::ofstream fileOut(filename.c_str()); if (!fileOut.is_open()) { QPointer<QMessageBox> errorBox = new QMessageBox; errorBox->setText(tr("<b>ERROR: Could not write file</b>")); errorBox->setInformativeText("The program had problems trying to open the file in which to write data"); errorBox->exec(); return; } // First we write the header of the file. if (relationshipLabel.length() > 0) { fileOut << "Source" << sepOne << "Target" << sepOne << "Weight" << sepOne << "Type" << sepOne << "Type_User_Defined"; } else { fileOut << "Source" << sepOne << "Target" << sepOne << "Weight" << sepOne << "Type"; } fileOut << '\n'; // We make a vector to store our lines for the output file. std::vector <std::string> fileVector; // Then we iterate through the data vector, find the appropriate entries, and write them to our file vector. std::vector <std::vector <std::string> >::iterator itData; for (itData = rowData.begin(); itData != rowData.end(); itData++) { std::vector <std::string> currentData = *itData; std::string currentSource = currentData[sourceIndex]; std::string currentTarget = currentData[targetIndex]; std::vector <std::string> sepSources; std::vector <std::string> sepTargets; // Some of the entries may have multiple values in one string. We need to separate these now. std::istringstream sourceStream(currentSource); while (sourceStream) { std::string s; if (!getline(sourceStream, s, sepTwoChar)) break; while (s[0] == ' ') { s = s.substr(1, s.length()); } sepSources.push_back(s); } std::istringstream targetStream(currentTarget); while (targetStream) { std::string s; if (!getline(targetStream, s, sepTwoChar)) break; while (s[0] == ' ') { s = s.substr(1, s.length()); } sepTargets.push_back(s); } std::vector <std::string>::iterator itSepSources; std::vector <std::string>::iterator itSepTargets; // After making sures that the values have been separated where necessary, we can write the bulk of our file. for (itSepSources = sepSources.begin(); itSepSources != sepSources.end(); itSepSources++) { std::string currentSepSource = *itSepSources; for (itSepTargets = sepTargets.begin(); itSepTargets != sepTargets.end(); itSepTargets++) { std::string currentSepTarget = *itSepTargets; if (currentSepSource != currentSepTarget) { std::vector <std::string> tempVector; tempVector.push_back(currentSepSource); tempVector.push_back(currentSepTarget); if (sourceSelection == targetSelection) { std::sort(tempVector.begin(), tempVector.end()); } std::string sourceTarget = tempVector[0] + sepOne + tempVector[1]; if (relationshipLabel.size() > 0) { fileVector.push_back(sourceTarget + sepOne + "1" + sepOne + relationshipType + sepOne + relationshipLabel + '\n'); } else { fileVector.push_back(sourceTarget + sepOne + "1" + sepOne + relationshipType + '\n'); } } } } } if (fileVector.empty()) { QPointer<QMessageBox> errorBox = new QMessageBox; errorBox->setText("<b>WARNING</b>"); errorBox->setInformativeText("The Edge list is empty. Check your settings."); errorBox->exec(); } // We remove all doubles from the edge list here. std::sort(fileVector.begin(), fileVector.end()); fileVector.erase(std::unique(fileVector.begin(), fileVector.end()), fileVector.end()); // Then we iterate through our file vector and write everything to our file. std::vector <std::string>::iterator lineReader; for (lineReader = fileVector.begin(); lineReader != fileVector.end(); lineReader++) { fileOut << *lineReader; } // And after that we can close the file and end the function. fileOut.close(); return; }
QMimeData* toResultModel::mimeData(const QModelIndexList &indexes) const { QMimeData *mimeData = new QMimeData(); QByteArray encodedData; QDataStream stream(&encodedData, QIODevice::WriteOnly); QByteArray stringData; QDataStream ss(&stringData, QIODevice::WriteOnly); int valid = 0; QModelIndex validIndex; QString text; // qt sends list by column (all indexes from column 1, then column // column2). Need to figure out the number of columns and // rows. It'd be awesome if we could get the selection but there's // no good way to do that from the model. int rows = 0; int columns = 0; int currentRow = -1; int currentCol = -1; foreach (QModelIndex index, indexes) { if (index.isValid()) { if (index.row() > currentRow) { currentRow = index.row(); rows++; } if (currentCol != index.column()) { currentCol = index.column(); columns++; } valid++; validIndex = index; text = data(index, Qt::DisplayRole).toString(); ss << text; } } if (valid < 1) return 0; if (valid == 1) { mimeData->setText(text); // set row and column in data so we can try to preserve the // columns, if needed QByteArray sourceData; QDataStream sourceStream(&sourceData, QIODevice::WriteOnly); sourceStream << validIndex.row(); sourceStream << validIndex.column(); mimeData->setData("application/vnd.int.list", sourceData); } else { // serialize selection shape stream << rows; stream << columns; mimeData->setData("application/vnd.tomodel.list", encodedData + stringData); } return mimeData; }
void TestRunner::compile() { // Check when is the last time that the test source has been modified const QString filePath = inDir_.filePath(fileName_); const QFileInfo fileInfo(filePath); const QDateTime lastModified = fileInfo.lastModified(); // Compile if necessary Status s = status(); bool notCompiledYet = (s == Status::NotCompiledYet) || (s == Status::CompileError); bool modified = (lastCompiled_ < lastModified); bool processing = (s == Status::Compiling) || (s == Status::Running); if (notCompiledYet || (modified && !processing)) { setStatus_(Status::Compiling); compileOutput_.clear(); lastCompiled_ = lastModified; // -------- Go to folder where to compile test -------- QString compileDirPath = outDir_.absoluteFilePath(testName_); compileDir_ = outDir_; if (!compileDir_.cd(testName_)) { // Create folder since it doesn't exist if (!outDir_.mkdir(testName_)) { failCompilation_("Can't create build folder " + compileDirPath); return; } // Go to folder where to compile test // This is hard to reach (if we manage to create the folder, surely // we can cd to it), but doesn't hurt to check. if (!compileDir_.cd(testName_)) { failCompilation_("Can't create build folder " + compileDirPath); return; } } // -------- Open all files for reading or writing -------- const QString hFileName = testName_ + ".gen.h"; const QString cppFileName = testName_ + ".gen.cpp"; const QString proFileName = testName_ + ".gen.pro"; const QString hFilePath = compileDir_.filePath(hFileName); const QString cppFilePath = compileDir_.filePath(cppFileName); const QString proFilePath = compileDir_.filePath(proFileName); QFile sourceFile(filePath); QFile hFile(hFilePath); QFile cppFile(cppFilePath); QFile proFile(proFilePath); if (!sourceFile.open(QFile::ReadOnly | QFile::Text)) { failCompilation_("Can't open " + filePath); return; } if (!hFile.open(QFile::WriteOnly | QFile::Text)) { failCompilation_("Can't write " + hFilePath); return; } if (!cppFile.open(QFile::WriteOnly | QFile::Text)) { failCompilation_("Can't write " + cppFilePath); return; } if (!proFile.open(QFile::WriteOnly | QFile::Text)) { failCompilation_("Can't write " + proFilePath); return; } // -------- Read source file -------- QTextStream sourceStream(&sourceFile); const QString testSource = sourceStream.readAll(); // -------- Generate and write test gen files -------- QTextStream hStream(&hFile); QTextStream cppStream(&cppFile); QTextStream proStream(&proFile); hStream << generateH(testName_, testSource); cppStream << generateCpp(testName_, testSource); proStream << generatePro(testName_, testSource); // -------- Run qmake -------- QString program = QMAKE_QMAKE_QMAKE; QStringList arguments; arguments << "-spec" << QMAKE_QMAKESPEC << proFilePath; compileOutput_ += getCurrentTime() + ": Starting: \"" + program + "\" " + arguments.join(' ') + "\n"; process_->setWorkingDirectory(compileDirPath); connect(process_, static_cast<void (QProcess::*)(int, QProcess::ExitStatus)>(&QProcess::finished), this, &TestRunner::compile_onQmakeFinished_); emit outputChanged(); process_->start(program, arguments); // -> go read qMakeFinished_(int exitCode) now. } else { emit compileFinished(true); } }
int ExtractGHKM::Main(int argc, char *argv[]) { // Process command-line options. Options options; ProcessOptions(argc, argv, options); // Open input files. InputFileStream targetStream(options.targetFile); InputFileStream sourceStream(options.sourceFile); InputFileStream alignmentStream(options.alignmentFile); // Open output files. OutputFileStream fwdExtractStream; OutputFileStream invExtractStream; std::ofstream glueGrammarStream; std::ofstream unknownWordStream; std::string fwdFileName = options.extractFile; std::string invFileName = options.extractFile + std::string(".inv"); if (options.gzOutput) { fwdFileName += ".gz"; invFileName += ".gz"; } OpenOutputFileOrDie(fwdFileName, fwdExtractStream); OpenOutputFileOrDie(invFileName, invExtractStream); if (!options.glueGrammarFile.empty()) { OpenOutputFileOrDie(options.glueGrammarFile, glueGrammarStream); } if (!options.unknownWordFile.empty()) { OpenOutputFileOrDie(options.unknownWordFile, unknownWordStream); } // Target label sets for producing glue grammar. std::set<std::string> labelSet; std::map<std::string, int> topLabelSet; // Word count statistics for producing unknown word labels. std::map<std::string, int> wordCount; std::map<std::string, std::string> wordLabel; std::string targetLine; std::string sourceLine; std::string alignmentLine; XmlTreeParser xmlTreeParser(labelSet, topLabelSet); ScfgRuleWriter writer(fwdExtractStream, invExtractStream, options); size_t lineNum = options.sentenceOffset; while (true) { std::getline(targetStream, targetLine); std::getline(sourceStream, sourceLine); std::getline(alignmentStream, alignmentLine); if (targetStream.eof() && sourceStream.eof() && alignmentStream.eof()) { break; } if (targetStream.eof() || sourceStream.eof() || alignmentStream.eof()) { Error("Files must contain same number of lines"); } ++lineNum; // Parse target tree. if (targetLine.size() == 0) { std::cerr << "skipping line " << lineNum << " with empty target tree\n"; continue; } std::auto_ptr<ParseTree> t; try { t = xmlTreeParser.Parse(targetLine); assert(t.get()); } catch (const Exception &e) { std::ostringstream s; s << "Failed to parse XML tree at line " << lineNum; if (!e.GetMsg().empty()) { s << ": " << e.GetMsg(); } Error(s.str()); } // Read source tokens. std::vector<std::string> sourceTokens(ReadTokens(sourceLine)); // Read word alignments. Alignment alignment; try { alignment = ReadAlignment(alignmentLine); } catch (const Exception &e) { std::ostringstream s; s << "Failed to read alignment at line " << lineNum << ": "; s << e.GetMsg(); Error(s.str()); } if (alignment.size() == 0) { std::cerr << "skipping line " << lineNum << " without alignment points\n"; continue; } // Record word counts. if (!options.unknownWordFile.empty()) { CollectWordLabelCounts(*t, options, wordCount, wordLabel); } // Form an alignment graph from the target tree, source words, and // alignment. AlignmentGraph graph(t.get(), sourceTokens, alignment); // Extract minimal rules, adding each rule to its root node's rule set. graph.ExtractMinimalRules(options); // Extract composed rules. if (!options.minimal) { graph.ExtractComposedRules(options); } // Write the rules, subject to scope pruning. const std::vector<Node *> &targetNodes = graph.GetTargetNodes(); for (std::vector<Node *>::const_iterator p = targetNodes.begin(); p != targetNodes.end(); ++p) { const std::vector<const Subgraph *> &rules = (*p)->GetRules(); for (std::vector<const Subgraph *>::const_iterator q = rules.begin(); q != rules.end(); ++q) { ScfgRule r(**q); // TODO Can scope pruning be done earlier? if (r.Scope() <= options.maxScope) { writer.Write(r); } } } } if (!options.glueGrammarFile.empty()) { WriteGlueGrammar(labelSet, topLabelSet, glueGrammarStream); } if (!options.unknownWordFile.empty()) { WriteUnknownWordLabel(wordCount, wordLabel, options, unknownWordStream); } return 0; }
int CBIR::buildClustersIndex(){ if(clustersMat.data == NULL) exit(1); //Creo el índice. // cv::flann::KDTreeIndexParams kdtiParams(1); // cv::Mat savedIndexMat(1, 1, CV_32F); // cv::flann::Index clustersIndex = cv::flann::Index(savedIndexMat, kdtiParams); cv::flann::Index *clustersIndex; qDebug() << "Declaro el indice."; QFile indexFile("cbir\\flann\\index\\index.hdf5"); if(indexFile.exists()){ cv::flann::SavedIndexParams siParams("cbir\\flann\\index\\index.hdf5"); clustersIndex = new cv::flann::Index(clustersMat, siParams); qDebug() << "Creo el indice a partir del archivo."; }else{ cv::flann::KDTreeIndexParams kdtiParams(8); clustersIndex = new cv::flann::Index(clustersMat, kdtiParams); clustersIndex->save("cbir\\flann\\index\\index.hdf5"); qDebug() << "Creo el indice a partir de la matriz."; } cv::Mat indices(descriptorsMat.rows, 1, CV_32S); cv::Mat dists(descriptorsMat.rows, 1, CV_32F); //cv::Mat_<float> indices(descriptorsMat.rows, 1); //cv::Mat_<int> dists(descriptorsMat.rows, 1); //Ubica cada feature en un determinado cluster basándose en Knn-Search clustersIndex->knnSearch(descriptorsMat, indices, dists, 1, cv::flann::SearchParams(1024)); qDebug() << endl << "Indices:" << indices.rows << endl; //DOCUMENTO int totalFeatures = 0; QFile sourceFile("cbir/lemur/index/index_source"); sourceFile.open(QIODevice::WriteOnly | QIODevice::Text); QTextStream sourceStream(&sourceFile); QFile trecFile; QTextStream trecStream(&trecFile); //Itero sobre las imágenes. for(int i=0; i<featuresCount.count() && totalFeatures < descriptorsMat.rows; i++){ trecFile.setFileName("cbir/lemur/files/" + featuresCount[i].first + ".trec"); if (!trecFile.open(QIODevice::WriteOnly | QIODevice::Text)) return 1; trecStream.flush(); trecStream << "<DOC>" << endl << "<DOCNO>" << featuresCount[i].first << "</DOCNO>" << endl << "<TEXT>" << endl; // Itero sobre todos los features de la imagen. for(int j=0; j<featuresCount[i].second && totalFeatures < descriptorsMat.rows; j++, totalFeatures++){ trecStream << indices.at<int>(totalFeatures, 0) << endl; } trecStream << "</TEXT>" << endl << "</DOC>" << endl; trecFile.close(); qDebug() << "Archivo guardado:" << trecFile.fileName(); //Agrego la imagen al archivo index_source sourceStream << "e:\\Proyectos\\Git\\keepc\\release\\cbir\\lemur\\files\\" << featuresCount[i].first + ".trec" << endl; } sourceFile.close(); }
GLShader::GLShader(EGLShaderType type, const string &filename) :m_ID(GL_NONE), m_type(type) { // Check if file exists if(!fileExists(filename)) { cerr << "Shader source file '" << filename << "' does not exist." << endl; } // File exists else { // Create shader m_ID = glCreateShader(getShaderTypeConstant(type)); if(m_ID == GL_NONE) { cerr << "Could not create OpenGL shader." << endl; } // Successfully created shader else { cout << "Created OpenGL shader: " << m_ID << endl; // Load shader source string line, source; ifstream sourceStream(filename); while(sourceStream.good() && !sourceStream.eof()) { getline(sourceStream, line); source.append(line + "\n"); } // Compile shader const char *sourceCString = source.c_str(); glShaderSource(m_ID, 1, &sourceCString, nullptr); glCompileShader(m_ID); // Check compilation GLint compileResult; glGetShaderiv(m_ID, GL_COMPILE_STATUS, &compileResult); if(compileResult != GL_TRUE) { cerr << "Shader compilation of file '" << filename << "' failed." << endl; GLsizei logLength; GLchar log[1024]; glGetShaderInfoLog( m_ID, sizeof(log), &logLength, log); cerr << "Shader info log: " << endl << log << endl; } // Compilation worked else { cout << "Successfully compiled shader '" << filename << "'" << endl; } } } }