// static bool PortablePixelMapIO::writeRGB( QString filename, ubyte* aubRGBArray, int width, int height, bool yAxisPointsUp ) { assert( aubRGBArray != NULL ); QFile outputFile( filename ); // try to open the file in write only mode if( !( outputFile.open( QIODevice::WriteOnly ) ) ) { return false; } QTextStream outputTextStream( &outputFile ); outputTextStream.setCodec( "ISO-8859-1" ); outputTextStream << "P6\n"; outputTextStream << width << " " << height << "\n"; outputTextStream << "255\n"; outputTextStream.flush(); QDataStream outputDataStream( &outputFile ); if( yAxisPointsUp ) { for( int y = 0; y < height; ++y ) { for( int x = 0; x < width; ++x ) { int yy = height - y - 1; int k = 3 * ( yy * width + x ); outputDataStream << aubRGBArray[ k ]; outputDataStream << aubRGBArray[ k + 1 ]; outputDataStream << aubRGBArray[ k + 2 ]; } } } else { for( int y = 0; y < height; ++y ) { for( int x = 0; x < width; ++x ) { int k = 3 * ( y * width + x ); outputDataStream << aubRGBArray[ k ]; outputDataStream << aubRGBArray[ k + 1 ]; outputDataStream << aubRGBArray[ k + 2 ]; } } } return true; }
void HHRImpl::write2Json() { string outFilename(outputFileLocation); outFilename += rootName; outFilename += "/HHR/"; outFilename += "hhr.json"; //cout << outFilename << endl; ofstream outputFile(outFilename.c_str()); outputFile << "{" << "\n"; for (int i = 0; i < hhrResultVector.size(); i++) { outputFile << "\"protein" << i << "\":{\n"; outputFile << "\t\"proteinName\":\"" << hhrResultVector[i].getProteinName() << "\",\n"; outputFile << "\t\"probab\":\"" << hhrResultVector[i].getProbab() << "\",\n"; outputFile << "\t\"OriginalSequenceLength\":\"" << proteinSeqLength << "\",\n"; outputFile << "\t\"eValue\":\"" << hhrResultVector[i].getExpect() << "\",\n"; outputFile << "\t\"score\":\"" << hhrResultVector[i].getScore() << "\",\n"; outputFile << "\t\"alignedCols\":\"" << hhrResultVector[i].getAlignedCols() << "\",\n"; outputFile << "\t\"identities\":\"" << hhrResultVector[i].getIdentities() << "\",\n"; outputFile << "\t\"QueryStart\":\"" << hhrResultVector[i].getQueryStart() << "\",\n"; outputFile << "\t\"Query\":\"" << hhrResultVector[i].getQuery() << "\",\n"; outputFile << "\t\"QueryEnd\":\"" << hhrResultVector[i].getQueryEnd() << "\",\n"; outputFile << "\t\"QueryConsensus\":\"" << hhrResultVector[i].getQueryConsensus() << "\",\n"; outputFile << "\t\"alignment\":\"" << hhrResultVector[i].getAlignment() << "\",\n"; outputFile << "\t\"TargetStart\":\"" << hhrResultVector[i].getTargetStart() << "\",\n"; outputFile << "\t\"TargetConsensus\":\"" << hhrResultVector[i].getTargetConsensus() << "\",\n"; outputFile << "\t\"TargetEnd\":\"" << hhrResultVector[i].getTargetEnd() << "\",\n"; outputFile << "\t\"target\":\"" << hhrResultVector[i].getTarget() << "\",\n"; outputFile << "\t\"targetConf\":\"" << hhrResultVector[i].getConfidence() << "\",\n"; outputFile << "\t\"tPred\":\"" << hhrResultVector[i].getTargetSsPred() << "\"\n"; outputFile << "},\n"; } outputFile << "\"finish\":\"end\"" << "\n"; outputFile << "}" << "\n"; outputFile.close(); }
void HelpWriterContext::writeOptionItem(const std::string &name, const std::string &value, const std::string &defaultValue, const std::string &info, const std::string &description) const { TextWriter &file = outputFile(); switch (outputFormat()) { case eHelpOutputFormat_Console: { TextTableFormatter &formatter(impl_->state_->consoleOptionsFormatter()); formatter.clear(); formatter.addColumnLine(0, name); formatter.addColumnLine(1, value); if (!defaultValue.empty()) { formatter.addColumnLine(2, "(" + defaultValue + ")"); } if (!info.empty()) { formatter.addColumnLine(3, "(" + info + ")"); } TextLineWrapperSettings settings; settings.setIndent(11); settings.setLineLength(78); std::string formattedDescription = substituteMarkupAndWrapToString(settings, description); file.writeLine(formatter.formatRow()); file.writeLine(formattedDescription); break; } case eHelpOutputFormat_Rst: { std::string args(value); if (!defaultValue.empty()) { args.append(" ("); args.append(defaultValue); args.append(")"); } if (!info.empty()) { args.append(" ("); args.append(info); args.append(")"); } file.writeLine(formatString("``%s`` %s", name.c_str(), args.c_str())); TextLineWrapperSettings settings; settings.setIndent(4); file.writeLine(substituteMarkupAndWrapToString(settings, description)); break; } default: GMX_THROW(NotImplementedError( "This output format is not implemented")); } }
void ResponseCurve::writeToFile(const std::string& fileName) const { ScopedStdIoFile outputFile(fopen(fileName.c_str(), "w")); responseSave(outputFile.data(), m_responses[RESPONSE_CHANNEL_RED].data(), m_responses[RESPONSE_CHANNEL_GREEN].data(), m_responses[RESPONSE_CHANNEL_BLUE].data(), NUM_BINS); }
bool QgsMeshCalculatorDialog::filePathValid() const { QString outputPath = outputFile(); if ( outputPath.isEmpty() ) return false; outputPath = QFileInfo( outputPath ).absolutePath(); return QFileInfo( outputPath ).isWritable(); }
int main() { std::ifstream inputFile(SOURCE_DIR "/input.txt"); std::ofstream outputFile(SOURCE_DIR "/output.txt" ); if ( inputFile && outputFile) { int countKey = 0; std::string countKeyString; std::vector < long long > keys; std::getline(inputFile, countKeyString); countKey = atoi(countKeyString.c_str()); for (int i = 0; i < countKey; ++i) { std::string key; if (!inputFile.eof()) { std::getline(inputFile, key); keys.push_back((long long)(atof(key.c_str()) * accuracy)); } else { break; } } while (!inputFile.eof()) { std::string passwordString; std::getline(inputFile, passwordString); if (passwordString.empty()) continue; long long password = (long long)(atof(passwordString.c_str()) * accuracy); for (int i = 0; i < countKey; ++i) { if (password == keys[i]) { outputFile << std::string("YES") << std::endl; break; } else { if (i + 1 == countKey) outputFile << std::string("NO") << std::endl; continue; } } } inputFile.close(); outputFile.close(); } return 0; }
void BLAPDBImpl::write2Json() { string outFilename(outputFileLocation); outFilename += rootName; outFilename += "/BLAPDB/"; outFilename += "blaPDB.json"; //cout<<outFilename<<endl; ofstream outputFile(outFilename.c_str()); outputFile << "{" << "\n"; for (int i = 0; i < blaPDBResultVector.size(); i++) { outputFile << "\"protein" << i << "\":{\n"; outputFile << "\t\"proteinName\":\"" << blaPDBResultVector[i].getProteinName() << "\",\n"; outputFile << "\t\"OriginalSequenceLength\":\"" << proteinSeqLength << "\",\n"; outputFile << "\t\"Length\":\"" << blaPDBResultVector[i].getLength() << "\",\n"; outputFile << "\t\"Score\":\"" << blaPDBResultVector[i].getScore() << "\",\n"; outputFile << "\t\"Expect\":\"" << blaPDBResultVector[i].getExpect() << "\",\n"; outputFile << "\t\"Identities\":\"" << blaPDBResultVector[i].getIdentities() << "%\",\n"; outputFile << "\t\"Positives\":\"" << blaPDBResultVector[i].getPositives() << "%\",\n"; outputFile << "\t\"Gaps\":\"" << blaPDBResultVector[i].getGaps() << "%\",\n"; outputFile << "\t\"CoveragePercentage\":\"" << double((blaPDBResultVector[i].getSubjectEnd() - blaPDBResultVector[i].getSubjectStart() + 1 - blaPDBResultVector[i].getGapNum())) / (proteinSeqLength) << "%\",\n"; outputFile << "\t\"QueyStart\":\"" << blaPDBResultVector[i].getQueryStart() << "\",\n"; outputFile << "\t\"Query\":\"" << blaPDBResultVector[i].getQuery() << "\",\n"; outputFile << "\t\"QueryEnd\":\"" << blaPDBResultVector[i].getQueryEnd() << "\",\n"; outputFile << "\t\"Alignment\":\"" << blaPDBResultVector[i].getAlignment() << "\",\n"; outputFile << "\t\"SubjectStart\":\"" << blaPDBResultVector[i].getSubjectStart() << "\",\n"; outputFile << "\t\"Subject\":\"" << blaPDBResultVector[i].getSubject() << "\",\n"; outputFile << "\t\"SubjectEnd\":\"" << blaPDBResultVector[i].getSubjectEnd() << "\"\n"; outputFile << "},\n"; } outputFile << "\"finish\":\"end\"" << "\n"; outputFile << "}" << "\n"; outputFile.close(); }
BEGIN_UGEN_NAMESPACE #include "ugen_DiskOut.h" #include "../ugen_JuceUtility.h" DiskOutUGenInternal::DiskOutUGenInternal(File const& file, UGen const& input, bool overwriteExisitingFile, int bitDepth) throw() : ProxyOwnerUGenInternal(NumInputs, input.getNumChannels()-1), audioFormatWriter(0), bufferData(0), numInputChannels(input.getNumChannels()) { ugen_assert(bitDepth >= 16); inputs[Input] = input; bufferData = new float*[numInputChannels]; memset(bufferData, 0, numInputChannels * sizeof(float*)); File outputFile(file); if(outputFile.getFileExtension().isEmpty()) outputFile = outputFile.withFileExtension("wav"); if(overwriteExisitingFile == true && outputFile.exists()) outputFile.deleteFile(); else if(outputFile.exists()) { ugen_assertfalse; return; } if(outputFile.hasFileExtension(".wav")) { WavAudioFormat wavAudioFormat; FileOutputStream* fileOutputStream = outputFile.createOutputStream(); if(fileOutputStream) audioFormatWriter = wavAudioFormat.createWriterFor(fileOutputStream, UGen::getSampleRate(), numInputChannels, bitDepth, 0, 0); } else if(outputFile.hasFileExtension(".aif") || outputFile.hasFileExtension(".aiff")) { AiffAudioFormat aiffAudioFormat; FileOutputStream* fileOutputStream = outputFile.createOutputStream(); if(fileOutputStream) audioFormatWriter = aiffAudioFormat.createWriterFor(fileOutputStream, UGen::getSampleRate(), numInputChannels, bitDepth, 0, 0); } }
void HelpWriterContext::writeTextBlock(const std::string &text) const { TextLineWrapperSettings settings; if (outputFormat() == eHelpOutputFormat_Console) { settings.setLineLength(78); } outputFile().writeLine(substituteMarkupAndWrapToString(settings, text)); }
void CLMBlockModel::saveStates(const std::string strTSVFilename) const { std::ofstream outputFile(strTSVFilename.c_str()); for(int i=0; i<(int)aAllSubcatchments.size(); i++) { if(!getSubcatchment(i)->getDownstreamCatchment()) getSubcatchment(i)->saveStates(outputFile); } }
bool LibSingleFileInterface::copyFiles(const QList<QVariant> & files, const QString & destinationDirectory, Kerfuffle::ExtractionOptions options) { Q_UNUSED(files) Q_UNUSED(options) QString outputFileName = destinationDirectory; if (!destinationDirectory.endsWith(QLatin1Char('/'))) { outputFileName += QLatin1Char('/'); } outputFileName += uncompressedFileName(); outputFileName = overwriteFileName(outputFileName); if (outputFileName.isEmpty()) { return true; } kDebug() << "Extracting to" << outputFileName; QFile outputFile(outputFileName); if (!outputFile.open(QIODevice::WriteOnly)) { kDebug() << "Failed to open output file" << outputFile.errorString(); emit error(i18nc("@info", "Ark could not extract <filename>%1</filename>.", outputFile.fileName())); return false; } QIODevice *device = KFilterDev::deviceForFile(filename(), m_mimeType, false); if (!device) { kDebug() << "Could not create KFilterDev"; emit error(i18nc("@info", "Ark could not open <filename>%1</filename> for extraction.", filename())); return false; } device->open(QIODevice::ReadOnly); qint64 bytesRead; QByteArray dataChunk(1024*16, '\0'); // 16Kb while (true) { bytesRead = device->read(dataChunk.data(), dataChunk.size()); if (bytesRead == -1) { emit error(i18nc("@info", "There was an error while reading <filename>%1</filename> during extraction.", filename())); break; } else if (bytesRead == 0) { break; } outputFile.write(dataChunk.data(), bytesRead); } delete device; return true; }
bool saveJson(const QString &filename, const QJsonDocument &document) { bool success = false; QFile outputFile(filename); if (outputFile.open(QIODevice::WriteOnly)) { outputFile.write(document.toJson(QJsonDocument::Indented)); success = true; } return success; }
void MainWindow::saveDirectory(const QString &dir) { QFile outputFile(LAST_FILE); outputFile.open(QIODevice::WriteOnly); if(outputFile.isOpen()){ QTextStream outStream(&outputFile); outStream << dir; outputFile.close(); } }
KoFilter::ConversionStatus WPGImport::convert(const QByteArray& from, const QByteArray& to) { if (from != "application/x-wpg") return KoFilter::NotImplemented; if (to != "image/svg+xml") return KoFilter::NotImplemented; #if LIBWPG_VERSION_MINOR<2 WPXInputStream* input = new libwpg::WPGFileStream(m_chain->inputFile().toLocal8Bit()); if (input->isOLEStream()) { WPXInputStream* olestream = input->getDocumentOLEStream(); if (olestream) { delete input; input = olestream; } } libwpg::WPGString output; #else WPXInputStream* input = new WPXFileStream(m_chain->inputFile().toLocal8Bit()); if (input->isOLEStream()) { WPXInputStream* olestream = input->getDocumentOLEStream("Anything"); if (olestream) { delete input; input = olestream; } } ::WPXString output; #endif if (!libwpg::WPGraphics::isSupported(input)) { kWarning() << "ERROR: Unsupported file format (unsupported version) or file is encrypted!"; delete input; return KoFilter::NotImplemented; } if (!libwpg::WPGraphics::generateSVG(input, output)) { kWarning() << "ERROR: SVG Generation failed!"; delete input; return KoFilter::ParsingError; } delete input; QFile outputFile(m_chain->outputFile()); if(!outputFile.open(QIODevice::WriteOnly | QIODevice::Text)) { kWarning() << "ERROR: Could not open output file" << m_chain->outputFile(); return KoFilter::InternalError; } outputFile.write(output.cstr()); outputFile.close(); return KoFilter::OK; }
bool ExportManager::localSave(const QUrl &url, const QString &mimetype) { QFile outputFile(url.toLocalFile()); outputFile.open(QFile::WriteOnly); if(!writeImage(&outputFile, mimetype.toLatin1())) { emit errorMessage(i18n("Cannot save screenshot. Error while writing file.")); return false; } return true; }
int main(int argc, char* argv[]) { //loadCalculatedValues(); parseFile("input.txt"); initMatrix(); calculateCurrentMoves(); runTestMoves(); outputFile("output.txt"); //std::cout << "p1 score is " << player1Score << " p2 score is " << player2Score << std::endl; return 0; }
void QgsRasterTerrainAnalysisDialog::on_mExportToCsvButton_clicked() { QString file = QFileDialog::getSaveFileName( 0, tr( "Export Frequency distribution as csv" ), QDir::homePath() ); if ( file.isEmpty() ) { return; } QgsRelief relief( inputFile(), outputFile(), outputFormat() ); relief.exportFrequencyDistributionToCsv( file ); }
static void SerializeToFileJustChunk( ColladaConversion::NascentChunkArray chunks, const char destinationFilename[], const ConsoleRig::LibVersionDesc& versionInfo) { BasicFile outputFile(destinationFilename, "wb"); for (unsigned i=0; i<(unsigned)chunks->size(); ++i) { auto& c = (*chunks)[i]; outputFile.Write(AsPointer(c._data.begin()), c._data.size(), 1); } }
std::string generateSentimenFile(std::string sentimentFile, int cutOff, string benchmarkNr){ std::string outputFile("sentiments/" + benchmarkNr + "-" + to_string(cutOff) + "-" + sentimentFile); if(!fileExists(outputFile)){ std::cout << "Parts for "<< outputFile << std::endl; std::string command(shufPath + " -o " + outputFile + " -n $( expr $( sed -n '$=' " + sentimentFile + " ) / 4 \\* " + to_string(cutOff) + " ) " + sentimentFile); //cout << command << endl; system(command.c_str()); } return outputFile; }
int _tmain(int argc, _TCHAR* argv[]) { CppUnit::TextUi::TestRunner runner; #ifdef _DEBUG std::ofstream outputFile("..\\output\\debug\\UnitTest_Results.xml"); #else std::ofstream outputFile("..\\output\\release\\UnitTest_Results.xml"); #endif CppUnit::Outputter *myoutputter; myoutputter = new CppUnit::XmlOutputter(&runner.result(), outputFile, "UTF-8"); runner.setOutputter(myoutputter); CppUnit::TestFactoryRegistry ®istry = CppUnit::TestFactoryRegistry::getRegistry("UCUnitTest"); runner.addTest( registry.makeTest() ); runner.run(); return 0; }
bool QgsRasterFileWriter::writeVRT( const QString& file ) { QFile outputFile( file ); if ( ! outputFile.open( QIODevice::WriteOnly | QIODevice::Truncate ) ) { return false; } QTextStream outStream( &outputFile ); mVRTDocument.save( outStream, 2 ); return true; }
void TaskSetWriter::writeJSON() { QJsonArray taskArray; QJsonArray vmArray; map<QString, PeriodicTaskData *> tasksData = TASKS_DATA; map<QString, PeriodicTaskData *>::iterator taskIter; PeriodicTaskData *tempPTask; QJsonObject task; for (taskIter=tasksData.begin(); taskIter != tasksData.end(); taskIter++){ tempPTask = taskIter->second; task["task_name"] = tempPTask->name(); task["phase"] = (int)tempPTask->phase(); task["period"] = (int)tempPTask->ti(); task["deadline"] = (int)tempPTask->di(); task["computation_time"] = (int)tempPTask->ci(); task["kernel"] = tempPTask->kernel(); taskArray.append(task); } map<QString, VMData *> vmData = VMS_DATA; map<QString, VMData *>::iterator vmIter; VMData *tempVM; QJsonObject vm; for (vmIter=vmData.begin(); vmIter != vmData.end(); vmIter++){ tempVM = vmIter->second; vm["VM_name"] = tempVM->name(); vm["budget"] = (int)tempVM->budget(); vm["period"] = (int)tempVM->period(); vmArray.append(vm); } QJsonObject obj; obj["tasks"] = taskArray; obj["VMs"] = vmArray; QFile outputFile(_filename); outputFile.open(QIODevice::WriteOnly); /* Point a QTextStream object at the file */ QTextStream outStream(&outputFile); /* Write the line to the file */ outStream << QJsonDocument(obj).toJson(QJsonDocument::Compact); /* Close the file */ outputFile.close(); }
int iCPApp::OnRun() { ReadDetectorConfig(); //read input project HuginBase::PanoramaMemento newPano; int ptoVersion = 0; wxFileName file(m_input); file.MakeAbsolute(); std::ifstream in((const char *)file.GetFullPath().mb_str(HUGIN_CONV_FILENAME)); if(!in.good()) { std::cerr << "could not open script : " << file.GetFullPath().char_str() << std::endl; return 1; } if(!newPano.loadPTScript(in, ptoVersion,(std::string)file.GetPath(wxPATH_GET_VOLUME | wxPATH_GET_SEPARATOR).mb_str(HUGIN_CONV_FILENAME))) { std::cerr << "could not parse script: " << file.GetFullPath().char_str() << std::endl; return 1; }; pano.setMemento(newPano); //match images AutoCtrlPointCreator matcher; HuginBase::UIntSet imgs; fill_set(imgs,0, pano.getNrOfImages()-1); //deactivate libpano messages PT_setProgressFcn(ptProgress); PT_setInfoDlgFcn(ptinfoDlg); HuginBase::CPVector cps = matcher.automatch(m_cpsetting,pano,imgs,m_matches,NULL); PT_setProgressFcn(NULL); PT_setInfoDlgFcn(NULL); if(cps.size()==0) { return 1; }; for(unsigned i=0;i<cps.size();i++) { pano.addCtrlPoint(cps[i]); }; //write output HuginBase::OptimizeVector optvec = pano.getOptimizeVector(); std::ofstream of((const char *)m_output.mb_str(HUGIN_CONV_FILENAME)); wxFileName outputFile(m_output); outputFile.MakeAbsolute(); std::string prefix(outputFile.GetPath(wxPATH_GET_SEPARATOR | wxPATH_GET_VOLUME).char_str()); pano.printPanoramaScript(of, optvec, pano.getOptions(), imgs, false, prefix); std::cout << std::endl << "Written output to " << m_output.char_str() << std::endl; return 0; };
void HHRNR2Json::writeAlignmentResults2JsonFile() { string outFilename(outputFileLocation); outFilename += outputJsonFilename; ofstream outputFile(outFilename.c_str()); outputFile << "{" << "\n"; for (int i = 0; i < HHRNRResultVector.size(); i++) { outputFile << "\"protein" << i << "\":{\n"; outputFile << "\t\"proteinName\":\"" << HHRNRResultVector[i].getProteinName() << "\",\n"; outputFile << "\t\"probab\":\"" << HHRNRResultVector[i].getProbab() << "\",\n"; outputFile << "\t\"eValue\":\"" << HHRNRResultVector[i].getExpect() << "\",\n"; outputFile << "\t\"score\":\"" << HHRNRResultVector[i].getScore() << "\",\n"; outputFile << "\t\"alignedCols\":\"" << HHRNRResultVector[i].getAlignedCols() << "\",\n"; outputFile << "\t\"identities\":\"" << HHRNRResultVector[i].getIdentities() << "\",\n"; outputFile << "\t\"similarity\":\"" << HHRNRResultVector[i].getSimilarities() << "\",\n"; outputFile << "\t\"sumProbs\":\"" << HHRNRResultVector[i].getSumProbs() << "\",\n"; outputFile << "\t\"QuerySSPred\":\"" << HHRNRResultVector[i].getQuerySsPred() << "\",\n"; outputFile << "\t\"QueryStart\":\"" << HHRNRResultVector[i].getQueryStart() << "\",\n"; outputFile << "\t\"Query\":\"" << HHRNRResultVector[i].getQuery() << "\",\n"; outputFile << "\t\"QueryEnd\":\"" << HHRNRResultVector[i].getQueryEnd() << "\",\n"; outputFile << "\t\"QueryConsensus\":\"" << HHRNRResultVector[i].getQueryConsensus() << "\",\n"; outputFile << "\t\"alignment\":\"" << HHRNRResultVector[i].getAlignment() << "\",\n"; outputFile << "\t\"TargetStart\":\"" << HHRNRResultVector[i].getTargetStart() << "\",\n"; outputFile << "\t\"TargetConsensus\":\"" << HHRNRResultVector[i].getTargetConsensus() << "\",\n"; outputFile << "\t\"TargetEnd\":\"" << HHRNRResultVector[i].getTargetEnd() << "\",\n"; outputFile << "\t\"target\":\"" << HHRNRResultVector[i].getTarget() << "\",\n"; outputFile << "\t\"tPred\":\"" << HHRNRResultVector[i].getTargetSsPred() << "\"\n"; outputFile << "},\n"; } outputFile << "\"finish\":\"end\"" << "\n"; outputFile << "}" << "\n"; outputFile.close(); }
void QtMorseCodeTranslator::on_m_saveResultButton_clicked() { //Creating output file and writing //the result into it QFile outputFile(QFileDialog::getSaveFileName(0, tr("Save result to file"), QDir::homePath(), "Text files (*.txt)") ); outputFile.open(QIODevice::WriteOnly); QTextStream text(&outputFile); text << ui->m_outputText->toPlainText(); }
int main(int argc, char* argv[]) { // Get the target directory const char* target = "headerfile.h"; if (argc > 1){ target = "/headerfile.h"; target = strcat(argv[1], target); } //Get the parsed code std::ofstream outputFile(target); outputFile << create_injection_header("/usr/include/GL/glx.h"); return 0; }
int main(int argc, char* argv[]) { bfs::path featureFile(argv[1]); bfs::path expressionFile(argv[2]); double estimatedReadLength = atod(argv[3]); double kmersPerRead = atod(argv[4]); uint64_t mappedKmers = atol(argv[5]); uint32_t mappedKmers = atoi(argv[6]); bfs::path outputFile(argv[7]); size_t numThreads = atoi(argv[8]); performBiasCorrection(featureFile, expressionFile, estimatedReadLength, kmersPerRead, mappedKmers, merLen, outputFile, numThreads); }
//____________________________________________________________________ void WriteBiasFixVoltage(const int biasVoltage, const char * txtFileName) { ofstream outputFile(txtFileName); for (int icol=0; icol<fgkEmCalCols; icol++) { for (int irow=0; irow<fgkEmCalRows; irow++) { outputFile << icol << " " << irow << " " << biasVoltage << endl; } } outputFile.close(); }
void writeResults(vector<ITrack*>* results, string fileLocation, string type) { ofstream outputFile((fileLocation + "/" + type + "DustinTracked.txt").c_str()); if (outputFile.is_open()) { int id = 1; for (vector< ITrack* >::iterator iter = results->begin(); iter != results->end(); iter++) { ITrack* track = iter.operator *(); vector<IEvent*>* events = track->getEvents(); for (vector<IEvent*>::iterator evIter = events->begin(); evIter != events->end(); evIter++) { ExtendedEvent* ev = (ExtendedEvent*)evIter.operator *(); string hgs_point_string = this->getPointString(ev->getHGSLocation()); string hgs_bbox_string = this->getPolyString(ev->getHGSBBox()); string hgs_polygon_string; if (ev->getHGSPoly() == NULL){ hgs_polygon_string = ""; } else{ hgs_polygon_string = this->getPolyString(ev->getHGSPoly()); } string hpc_point_string = this->getPointString(ev->getHPCLocation()); string hpc_bbox_string = this->getPolyString(ev->getHPCBBox()); string hpc_polygon_string; if (ev->getHPCPoly() == NULL){ hpc_polygon_string = ""; } else{ hpc_polygon_string = this->getPolyString(ev->getHPCPoly()); } string date_string = this->getDateString(ev->getTimePeriod().begin()); string next_date_string; if (ev->getNext() != NULL) { next_date_string = this->getDateString(ev->getNext()->getTimePeriod().begin()); } outputFile << id << "\t" << date_string << "\t" << next_date_string << "\t" << ev->getType() << "\t" << hpc_point_string << "\t" << hpc_bbox_string << "\t" << hpc_polygon_string << "\t" << hgs_point_string << "\t" << hgs_bbox_string << "\t" << hgs_polygon_string << "\t" << ev->getSpecificID() << endl; delete ev; } id++; delete events; delete track; } delete results; outputFile.flush(); outputFile.close(); } }
/** Applies polyphase FIR filter Coefficients create a 24 kHz low pass filter for a 192 kHz wave */ void AudioProcessing::TestSimpleConvolution( const juce::File & input ) { const int polyphase4Size = sizeof(filterPhase0) / sizeof(float); const int convolutionSize = 4 * polyphase4Size; juce::AudioSampleBuffer convolutionFilter( 1, convolutionSize ); float * data = convolutionFilter.getWritePointer( 0 ); for ( int i = 0 ; i < polyphase4Size ; ++ i ) { *data++ = filterPhase0[ i ]; *data++ = filterPhase1[ i ]; *data++ = filterPhase2[ i ]; *data++ = filterPhase3[ i ]; } juce::AudioFormatManager audioFormatManager; audioFormatManager.registerBasicFormats(); juce::AudioFormatReader * reader = audioFormatManager.createReaderFor( input ); if ( reader != nullptr ) { // read file juce::AudioSampleBuffer origin( (int)reader->numChannels, (int)reader->lengthInSamples ); reader->read( &origin, 0, (int)reader->lengthInSamples, 0, true, true ); // Convolve juce::AudioSampleBuffer output; convolution( origin, convolutionFilter, output ); output.applyGain(0.25f); // filter values use sample with 3 zeros per valid sample (1 / 4) juce::String outputName = input.getFullPathName().substring(0, input.getFullPathName().length() - 4); juce::File outputFile( outputName + "_convolution.wav" ); juce::FileOutputStream * outputStream = new juce::FileOutputStream( outputFile ); juce::WavAudioFormat wavAudioFormat; juce::StringPairArray emptyArray; juce::AudioFormatWriter * writer = wavAudioFormat.createWriterFor( outputStream, reader->sampleRate, reader->numChannels, 24, emptyArray, 0 ); if ( writer != nullptr ) { writer->writeFromAudioSampleBuffer( output, 0, output.getNumSamples() ); delete writer; } delete reader; } }