// 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;
}
}
