seqan::ArgumentParser::ParseResult
parseArgs(FxSamCoverageOptions & options,
int argc,
char const ** argv)
{
seqan::ArgumentParser parser("fx_sam_coverage");
setShortDescription(parser, "Read Coverage Computation.");
setVersion(parser, "0.1");
setDate(parser, "August 2012");
addUsageLine(parser, "[\\fIOPTIONS\\fP] \\fB-o\\fP \\fIOUT.tsv\\fP \\fIGENOME.fa\\fP \\fIMAPPING.sam\\fP");
addDescription(parser, "Compute read coverage and C+G content for a genome.");
// Two input files: Genome, and mapping.
addArgument(parser, seqan::ArgParseArgument(seqan::ArgParseArgument::INPUTFILE));
setValidValues(parser, 0, "fasta fa");
addArgument(parser, seqan::ArgParseArgument(seqan::ArgParseArgument::INPUTFILE));
setValidValues(parser, 1, "sam");
// TODO(holtgrew): I want a custom help text!
// addOption(parser, seqan::ArgParseOption("h", "help", "This helpful screen."));
addOption(parser, seqan::ArgParseOption("v", "verbose", "Verbose, log to STDERR."));
hideOption(parser, "verbose");
addOption(parser, seqan::ArgParseOption("vv", "very-verbose", "Very verbose, log to STDERR."));
hideOption(parser, "very-verbose");
addSection(parser, "Main Options");
addOption(parser, seqan::ArgParseOption("w", "window-size", "Set the size of the non-overlapping windows in base pairs.", seqan::ArgParseArgument::INTEGER, "NUM"));
setDefaultValue(parser, "window-size", "10000");
addSection(parser, "Output Options");
addOption(parser, seqan::ArgParseOption("o", "out-path", "Path to the resulting file. If omitted, result is printed to stdout.", seqan::ArgParseArgument::OUTPUTFILE, "TSV"));
setRequired(parser, "out-path");
setValidValues(parser, "out-path", "sam.coverage.tsv");
seqan::ArgumentParser::ParseResult res = parse(parser, argc, argv);
if (res == seqan::ArgumentParser::PARSE_OK)
{
getArgumentValue(options.inGenomePath, parser, 0);
getArgumentValue(options.inSamPath, parser, 1);
getOptionValue(options.outPath, parser, "out-path");
if (isSet(parser, "verbose"))
options.verbosity = 2;
if (isSet(parser, "very-verbose"))
options.verbosity = 3;
}
return res;
}
void getArgVals(
int argc,
char **argv,
std::string &procF,
std::string &partF){
bool isprocset = false;
bool ispartset = false;
for(int i = 0; i < argc; ++i){
string tmp = convert_to_string(argv[i]);
string identifier = "";
long long int value = -1; double fval = -1;
if(!getArgumentValue(identifier, fval, tmp)) continue;
value = (long long int) (fval);
if(identifier == "PROC"){
stringstream stream(stringstream::in | stringstream::out);
stream << tmp;
getline(stream, procF, '=');
stream >> procF;
isprocset = true;
}
else if(identifier == "PART"){
TrayWidget::TrayWidget(std::wstring cmdLine) {
strEx::splitList list = strEx::splitEx(cmdLine, _T(" "));
channel_id_ = getArgumentValue(_T("-channel"), list);
if (channel_id_.empty()) {
channel_id_ = _T("_solo_") + strEx::itos(GetCurrentProcessId()) + _T("_");
}
LOG_MESSAGE_TRAY(_T("Attempting to launch system tray module for ") + channel_id_);
gTrayInstance = this;
}
int main(int argc, char const ** argv)
{
//![object]
// Setup ArgumentParser.
seqan::ArgumentParser parser("modify_string");
//![object]
//![argument]
addArgument(parser, seqan::ArgParseArgument(
seqan::ArgParseArgument::STRING, "TEXT"));
//![argument]
//![option]
addOption(parser, seqan::ArgParseOption(
"i", "period", "Period to use for the index.",
seqan::ArgParseArgument::INTEGER, "INT"));
addOption(parser, seqan::ArgParseOption(
"U", "uppercase", "Select to-uppercase as operation."));
//![option]
//![parse]
// Parse command line.
seqan::ArgumentParser::ParseResult res = seqan::parse(parser, argc, argv);
//![parse]
// If parsing was not successful then exit with code 1 if there were errors.
// Otherwise, exit with code 0 (e.g. help was printed).
//![check]
if (res != seqan::ArgumentParser::PARSE_OK)
return res == seqan::ArgumentParser::PARSE_ERROR;
//![check]
//![print]
// Extract option values and print them.
unsigned period = 0;
getOptionValue(period, parser, "period");
bool toUppercase = isSet(parser, "uppercase");
seqan::CharString text;
getArgumentValue(text, parser, 0);
std::cout << "period \t" << period << '\n'
<< "uppercase\t" << toUppercase << '\n'
<< "text \t" << text << '\n';
//![print]
return 0;
}
int main(int argc, char const ** argv)
{
// Setup ArgumentParser.
seqan::ArgumentParser parser("modify_string");
addArgument(parser, seqan::ArgParseArgument(
seqan::ArgParseArgument::STRING, "TEXT"));
addOption(parser, seqan::ArgParseOption(
"i", "period", "Period to use for the index.",
seqan::ArgParseArgument::INTEGER, "INT"));
setDefaultValue(parser, "period", "1");
addOption(parser, seqan::ArgParseOption(
"U", "uppercase", "Select to-uppercase as operation."));
addOption(parser, seqan::ArgParseOption(
"L", "lowercase", "Select to-lowercase as operation."));
// Parse command line.
seqan::ArgumentParser::ParseResult res = seqan::parse(parser, argc, argv);
// If parsing was not successful then exit with code 1 if there were errors.
// Otherwise, exit with code 0 (e.g. help was printed).
if (res != seqan::ArgumentParser::PARSE_OK)
return res == seqan::ArgumentParser::PARSE_ERROR;
// Extract option values and print them.
ModifyStringOptions options;
getOptionValue(options.period, parser, "period");
options.toUppercase = isSet(parser, "uppercase");
options.toLowercase = isSet(parser, "lowercase");
getArgumentValue(options.text, parser, 0);
std::cout << "period \t" << options.period << '\n'
<< "uppercase\t" << options.toUppercase << '\n'
<< "lowercase\t" << options.toLowercase << '\n'
<< "text \t" << options.text << '\n';
return 0;
}
seqan::ArgumentParser::ParseResult
parseArgs(SakOptions & options,
int argc,
char ** argv)
{
seqan::ArgumentParser parser("sak");
setShortDescription(parser, "Slicing and dicing of FASTA/FASTQ files..");
setVersion(parser, SEQAN_APP_VERSION " [" SEQAN_REVISION "]");
setDate(parser, SEQAN_DATE);
setCategory(parser, "Utilities");
addUsageLine(parser, "[\\fIOPTIONS\\fP] [\\fB-o\\fP \\fIOUT.{fa,fq}\\fP] \\fIIN.{fa,fq}\\fP");
addDescription(parser, "\"It slices, it dices and it makes the laundry!\"");
addDescription(parser, "Original SAK tool by David Weese. Rewrite by Manuel Holtgrewe.");
// The only argument is the input file.
addArgument(parser, seqan::ArgParseArgument(seqan::ArgParseArgument::INPUT_FILE, "IN"));
// Only FASTA and FASTQ files are allowed as input.
setValidValues(parser, 0, seqan::SeqFileIn::getFileExtensions());
// TODO(holtgrew): I want a custom help text!
// addOption(parser, seqan::ArgParseOption("h", "help", "This helpful screen."));
addOption(parser, seqan::ArgParseOption("v", "verbose", "Verbose, log to STDERR."));
hideOption(parser, "verbose");
addOption(parser, seqan::ArgParseOption("vv", "very-verbose", "Very verbose, log to STDERR."));
hideOption(parser, "very-verbose");
addSection(parser, "Output Options");
addOption(parser, seqan::ArgParseOption("o", "out-path",
"Path to the resulting file. If omitted, result is printed to stdout in FastQ format.",
seqan::ArgParseOption::OUTPUT_FILE, "FASTX"));
setValidValues(parser, "out-path", seqan::SeqFileOut::getFileExtensions());
addOption(parser, seqan::ArgParseOption("rc", "revcomp", "Reverse-complement output."));
addOption(parser, seqan::ArgParseOption("l", "max-length", "Maximal number of sequence characters to write out.",
seqan::ArgParseOption::INTEGER, "LEN"));
addSection(parser, "Filter Options");
addOption(parser, seqan::ArgParseOption("s", "sequence", "Select the given sequence for extraction by 0-based index.",
seqan::ArgParseOption::INTEGER, "NUM", true));
addOption(parser, seqan::ArgParseOption("sn", "sequence-name", "Select sequence with name prefix being \\fINAME\\fP.",
seqan::ArgParseOption::STRING, "NAME", true));
addOption(parser, seqan::ArgParseOption("ss", "sequences",
"Select sequences \\fIfrom\\fP-\\fIto\\fP where \\fIfrom\\fP and \\fIto\\fP "
"are 0-based indices.",
seqan::ArgParseArgument::STRING, "RANGE", true));
addOption(parser, seqan::ArgParseOption("i", "infix",
"Select characters \\fIfrom\\fP-\\fIto\\fP where \\fIfrom\\fP and \\fIto\\fP "
"are 0-based indices.",
seqan::ArgParseArgument::STRING, "RANGE", true));
addOption(parser, seqan::ArgParseOption("ll", "line-length",
"Set line length in output file. See section \\fILine Length\\fP for details.",
seqan::ArgParseArgument::INTEGER, "LEN", false));
setMinValue(parser, "line-length", "-1");
addTextSection(parser, "Line Length");
addText(parser,
"You can use the setting \\fB--line-length\\fP for setting the resulting line length. By default, "
"sequences in FASTA files are written with at most 70 characters per line and sequences in FASTQ files are "
"written without any line breaks. The quality sequence in FASTQ file is written in the same way as the "
"residue sequence.");
addText(parser,
"The default is selected with a \\fB--line-length\\fP value of \\fI-1\\fP and line breaks can be disabled "
"with a value of \\fI0\\fP.");
addTextSection(parser, "Usage Examples");
addListItem(parser, "\\fBsak\\fP \\fB-s\\fP \\fI10\\fP \\fIIN.fa\\fP",
"Cut out 11th sequence from \\fIIN.fa\\fP and write to stdout as FASTA.");
addListItem(parser, "\\fBsak\\fP \\fB-ss\\fP \\fI10-12\\fP \\fB-ss\\fP \\fI100-200\\fP \\fIIN.fq\\fP",
"Cut out 11th up to and including 12th and 101th up to and including 199th sequence from \\fIIN.fq\\fP "
"and write to stdout as FASTA.");
seqan::ArgumentParser::ParseResult res = parse(parser, argc, argv);
if (res != seqan::ArgumentParser::PARSE_OK)
return res;
getArgumentValue(options.inFastxPath, parser, 0);
seqan::CharString tmp;
getOptionValue(tmp, parser, "out-path");
if (isSet(parser, "out-path"))
getOptionValue(options.outPath, parser, "out-path");
if (isSet(parser, "verbose"))
options.verbosity = 2;
if (isSet(parser, "very-verbose"))
options.verbosity = 3;
if (isSet(parser, "sequence"))
{
std::vector<std::string> sequenceIds = getOptionValues(parser, "sequence");
for (unsigned i = 0; i < seqan::length(sequenceIds); ++i)
{
unsigned idx = 0;
if (!seqan::lexicalCast(idx, sequenceIds[i]))
{
std::cerr << "ERROR: Invalid sequence index " << sequenceIds[i] << "\n";
return seqan::ArgumentParser::PARSE_ERROR;
}
appendValue(options.seqIndices, idx);
}
}
if (isSet(parser, "sequences"))
{
std::vector<std::string> sequenceRanges = getOptionValues(parser, "sequences");
seqan::CharString buffer;
for (unsigned i = 0; i < seqan::length(sequenceRanges); ++i)
{
seqan::Pair<uint64_t> range;
if (!parseRange(range.i1, range.i2, sequenceRanges[i]))
{
std::cerr << "ERROR: Invalid range " << sequenceRanges[i] << "\n";
return seqan::ArgumentParser::PARSE_ERROR;
}
appendValue(options.seqIndexRanges, range);
}
}
if (isSet(parser, "infix"))
{
seqan::CharString buffer;
getOptionValue(buffer, parser, "infix");
if (!parseRange(options.seqInfixBegin, options.seqInfixEnd, buffer))
{
std::cerr << "ERROR: Invalid range " << buffer << "\n";
return seqan::ArgumentParser::PARSE_ERROR;
}
}
options.reverseComplement = isSet(parser, "revcomp");
if (isSet(parser, "max-length"))
getOptionValue(options.maxLength, parser, "max-length");
if (isSet(parser, "sequence-name"))
getOptionValue(options.readPattern, parser, "sequence-name");
getOptionValue(options.seqOutOptions.lineLength, parser, "line-length");
return res;
}
void CEvaluator::visit ( CArgument* e )
{
result=getArgumentValue(e->getName());
}
int main(int argc, char const * argv[])
{
// Additional checks
seqan::ArgumentParser parser = buildParser();
seqan::ArgumentParser::ParseResult res = seqan::parse(parser, argc, argv);
// Check if input was successfully parsed.
if (res != seqan::ArgumentParser::PARSE_OK)
return res == seqan::ArgumentParser::PARSE_ERROR;
// Check if one or two input files (single or paired-end) were given.
int fileCount = getArgumentValueCount(parser, 0);
if (fileCount < 1) {
printShortHelp(parser);
return 1;
}
unsigned int radius = 1;
getOptionValue(radius, parser, "r");
seqan::CharString readsFileName;
getOptionValue(readsFileName, parser, "i");
// Open input file, BamFileIn can read SAM and BAM files.
seqan::BamFileIn bamFileIn(seqan::toCString(readsFileName));
seqan::CharString _filterChromosomes;
seqan::getOptionValue(_filterChromosomes, parser, "fc");
std::string filterChromosomes = seqan::toCString(_filterChromosomes);
OccurenceMap occurenceMap;
Statistics stats;
std::cout << "read bam file... ";
auto t1 = std::chrono::steady_clock::now();
seqan::BamAlignmentRecord record;
seqan::BamHeader header;
readHeader(header, bamFileIn);
const auto chromosomeFilterSet = calculateChromosomeFilter(filterChromosomes, contigNames(context(bamFileIn)));
const auto chromosomes = contigNames(context(bamFileIn));
processBamFile(bamFileIn, chromosomeFilterSet, occurenceMap, stats);
auto t2 = std::chrono::steady_clock::now();
std::cout << std::chrono::duration_cast<std::chrono::duration<float>>(t2 - t1).count() << "s" << std::endl;
std::vector<std::pair<unsigned int, unsigned int>> hits(radius * 2 + 1);
t1 = std::chrono::steady_clock::now();
std::cout << "calculating 5'-ends around peaks... ";
for (unsigned int fileIndex = 0;fileIndex < static_cast<unsigned int>(fileCount); ++fileIndex)
{
seqan::CharString fileName_;
getArgumentValue(fileName_, parser, fileIndex, 0);
const std::string fileName = seqan::toCString(fileName_);
std::ifstream infile(fileName);
std::string chromosome, dummy;
unsigned int start, end;
while (infile >> chromosome >> start >> end >> dummy)
{
int rID = -1;
for (unsigned int i = 0;i < length(chromosomes);++i)
if (chromosomes[i] == chromosome)
{
rID = i;
break;
}
if (rID == -1)
{
std::cout << "invalid chromosome name: " << chromosome << " in file " << fileName << std::endl;
return -1;
}
seqan::BamAlignmentRecord record;
record.beginPos = std::max<int>(start - radius, 0);
record.rID = rID;
record.flag = 0;
unsigned int index = 0;
if (start < radius)
index += radius - start;
while (record.beginPos <= static_cast<__int32>(start + radius))
{
BamRecordKey<NoBarcode> pos(record);
auto el = occurenceMap.find(pos);
if(el != occurenceMap.end())
hits[index].first += el->second;
pos.init(pos.getRID(), pos.get5EndPosition(), true);
el = occurenceMap.find(pos);
if (el != occurenceMap.end())
hits[index].second += el->second;
++record.beginPos;
++index;
}
}
std::string outFilename = getFilePrefix(fileName) + std::string("_5PrimeEnds.tab");
if (seqan::isSet(parser, "o"))
{
seqan::CharString outFileName_;
getOptionValue(outFileName_, parser, "o");
outFilename = seqan::toCString(outFileName_);
}
std::fstream fs;
std::cout << "writing " << outFilename << std::endl;
#ifdef _MSC_VER
fs.open(outFilename, std::fstream::out, _SH_DENYNO);
#else
fs.open(outFilename, std::fstream::out);
#endif
int i = - static_cast<int>(radius);
for (const auto& hit : hits)
fs << i++ << "\t" << hit.first << "\t" << hit.second << std::endl;
fs.close();
}
t2 = std::chrono::steady_clock::now();
std::cout << std::chrono::duration_cast<std::chrono::duration<float>>(t2 - t1).count() << "s" << std::endl;
return 0;
}
