bool CScanner::getNextSection(const char name[])
{
do
{
getNextSection();
if (m_Section[0] == 0) return false;
}
while (strcmp(m_Section, name) != 0);
return true;
}
bool CScanner::getNextSection(const char name[], const char stop[])
{
if (strcmp(m_Section,stop) == 0) return strcmp(name,stop) == 0;
do
{
getNextSection();
if (m_Section[0] == 0) return false;
if (strcmp(m_Section,name) == 0) return true;
} while(strcmp(m_Section,stop) != 0);
return false;
}
bool CScanner::open(const char filename[])
{
if (m_logf.open(filename)) { getNextSection(); return true; }
return false;
}
bool CScanner::rewind()
{
if (m_logf.rewind()) { getNextSection(); return true; }
return false;
}
task autonomous(){
scoredSections = 0;
firstTime = true;
SensorValue[pneuVal] = 0;
if (SensorValue[disableSkyriseAut] == 1){ //12 Point Autonomous
/*
If on blue side, switch direction since preload is now on the other side
and we can use the same code.
*/
direction = (SensorValue[nextToSection] == 0) ? -1 : 1;
//Jerk the bot back and forth to release the preload onto the skyrise base
//driveEncoderVertical(-45);
//driveEncoderVertical(45);
//wait1Msec(350);
while(scoredSections < 2){
if (firstTime){
//Release the arm only on the first time
//For blue side, move the arm back so it does not hit the section
if (direction == -1){
motor[arm] = speedArmAuton;
wait1Msec(200);
motor[arm] = 0;
}
// ALTERNATE:
elevateLift(50);
SensorValue[pneuVal] = 1;
// // ORIGINAL:
// //Raise the lift slightly to expand arm
// liftMotors(1);
// wait1Msec(600);
// //Open the clamp
// SensorValue[pneuVal] = 1;
// stopLift();
/*
Since the arm is fast, we need to pulse it back in the
opposite direction so it does not knock into the preload.
*/
motor[arm] = -direction * speedArmAuton;
wait1Msec(175);
motor[arm] = 0;
}
//Move arm to pick up section
getNextSection();
//This needs to be our '0' spot so we come back to here
SensorValue[shaftEncoder] = 0;
int calculatedHeight =
(firstTime) ? FIRST_HEIGHT : HEIGHT;
elevateLift(calculatedHeight);
//Move to scoring side
moveArmToScore(-direction * speedArmAuton);
//Bring down to score
int nestValue =
(firstTime) ? FIRST_NEST_VAL : NEST_VAL;
elevateLift(nestValue);
wait1Msec(150);
//Open clamp
SensorValue[pneuVal] = 1;
//if (scoredSections == 1){
// driveEncoderVertical(45);
//}
// if (scoredSections == 1 && direction == 1){
// turnMotors(-1,250);
// }
//Raise lift to clear scored skyrise
int clearValue = (firstTime) ? FIRST_CLEAR_VAL : CLEAR_VAL;
elevateLift(clearValue);
//Return to starting position
returnToStart();
scoredSections++;
firstTime = false;
}
} else { //4 Point Autonomous
int waitTime = 2500;
// Robot positioned backwards with claw down
// Grab block
SensorValue[blockPicker] = !SensorValue[blockPicker];
// Raise lift partially to clear field
SensorValue[shaftEncoder] = 0;
elevateLift(250);
wait1Msec(waitTime);
// Strafe right
sideMotors(300)
wait1Msec(waitTime);
//Continue lifting
elevateLift(50);
wait1Msec(waitTime);
//Move forward a tad
driveEncoderVertical(75);
wait1Msec(waitTime);
// Nest block
elevateLift(-50);
wait1Msec(waitTime);
// Let go of block
SensorValue[blockPicker] = !SensorValue[blockPicker];
}
}
//Pick up next skyrise section after clearing the last one
void nextSkyrise(){
returnToStart();
getNextSection();
killSwitch = false;
}
int Stats::execute(int argc, char **argv)
{
// Extract command line arguments.
String inFile = "";
String indexFile = "";
bool basic = false;
bool noeof = false;
bool params = false;
bool qual = false;
bool phred = false;
int maxNumReads = -1;
bool unmapped = false;
String pBaseQC = "";
String cBaseQC = "";
String regionList = "";
int excludeFlags = 0;
int requiredFlags = 0;
bool withinRegion = false;
int minMapQual = 0;
String dbsnp = "";
PosList *dbsnpListPtr = NULL;
bool baseSum = false;
int bufferSize = PileupHelper::DEFAULT_WINDOW_SIZE;
ParameterList inputParameters;
BEGIN_LONG_PARAMETERS(longParameterList)
LONG_PARAMETER_GROUP("Required Parameters")
LONG_STRINGPARAMETER("in", &inFile)
LONG_PARAMETER_GROUP("Types of Statistics")
LONG_PARAMETER("basic", &basic)
LONG_PARAMETER("qual", &qual)
LONG_PARAMETER("phred", &phred)
LONG_STRINGPARAMETER("pBaseQC", &pBaseQC)
LONG_STRINGPARAMETER("cBaseQC", &cBaseQC)
LONG_PARAMETER_GROUP("Optional Parameters")
LONG_INTPARAMETER("maxNumReads", &maxNumReads)
LONG_PARAMETER("unmapped", &unmapped)
LONG_STRINGPARAMETER("bamIndex", &indexFile)
LONG_STRINGPARAMETER("regionList", ®ionList)
LONG_INTPARAMETER("excludeFlags", &excludeFlags)
LONG_INTPARAMETER("requiredFlags", &requiredFlags)
LONG_PARAMETER("noeof", &noeof)
LONG_PARAMETER("params", ¶ms)
LONG_PARAMETER_GROUP("Optional phred/qual Only Parameters")
LONG_PARAMETER("withinRegion", &withinRegion)
LONG_PARAMETER_GROUP("Optional BaseQC Only Parameters")
LONG_PARAMETER("baseSum", &baseSum)
LONG_INTPARAMETER("bufferSize", &bufferSize)
LONG_INTPARAMETER("minMapQual", &minMapQual)
LONG_STRINGPARAMETER("dbsnp", &dbsnp)
END_LONG_PARAMETERS();
inputParameters.Add(new LongParameters ("Input Parameters",
longParameterList));
inputParameters.Read(argc-1, &(argv[1]));
// If no eof block is required for a bgzf file, set the bgzf file type to
// not look for it.
if(noeof)
{
// Set that the eof block is not required.
BgzfFileType::setRequireEofBlock(false);
}
// Check to see if the in file was specified, if not, report an error.
if(inFile == "")
{
usage();
inputParameters.Status();
// In file was not specified but it is mandatory.
std::cerr << "--in is a mandatory argument for stats, "
<< "but was not specified" << std::endl;
return(-1);
}
// Use the index file if unmapped or regionList is not empty.
bool useIndex = (unmapped|| (!regionList.IsEmpty()));
// IndexFile is required, so check to see if it has been set.
if(useIndex && (indexFile == ""))
{
// In file was not specified, so set it to the in file
// + ".bai"
indexFile = inFile + ".bai";
}
////////////////////////////////////////
// Setup in case pileup is used.
Pileup<PileupElementBaseQCStats> pileup(bufferSize);
// Initialize start/end positions.
myStartPos = 0;
myEndPos = -1;
// Open the output qc file if applicable.
IFILE baseQCPtr = NULL;
if(!pBaseQC.IsEmpty() && !cBaseQC.IsEmpty())
{
usage();
inputParameters.Status();
// Cannot specify both types of baseQC.
std::cerr << "Cannot specify both --pBaseQC & --cBaseQC." << std::endl;
return(-1);
}
else if(!pBaseQC.IsEmpty())
{
baseQCPtr = ifopen(pBaseQC, "w");
PileupElementBaseQCStats::setPercentStats(true);
}
else if(!cBaseQC.IsEmpty())
{
baseQCPtr = ifopen(cBaseQC, "w");
PileupElementBaseQCStats::setPercentStats(false);
}
if(baseQCPtr != NULL)
{
PileupElementBaseQCStats::setOutputFile(baseQCPtr);
PileupElementBaseQCStats::printHeader();
}
if((baseQCPtr != NULL) || baseSum)
{
PileupElementBaseQCStats::setMapQualFilter(minMapQual);
PileupElementBaseQCStats::setBaseSum(baseSum);
}
if(params)
{
inputParameters.Status();
}
// Open the file for reading.
SamFile samIn;
if(!samIn.OpenForRead(inFile))
{
fprintf(stderr, "%s\n", samIn.GetStatusMessage());
return(samIn.GetStatus());
}
samIn.SetReadFlags(requiredFlags, excludeFlags);
// Set whether or not basic statistics should be generated.
samIn.GenerateStatistics(basic);
// Read the sam header.
SamFileHeader samHeader;
if(!samIn.ReadHeader(samHeader))
{
fprintf(stderr, "%s\n", samIn.GetStatusMessage());
return(samIn.GetStatus());
}
// Open the bam index file for reading if we are
// doing unmapped reads (also set the read section).
if(useIndex)
{
samIn.ReadBamIndex(indexFile);
if(unmapped)
{
samIn.SetReadSection(-1);
}
if(!regionList.IsEmpty())
{
myRegionList = ifopen(regionList, "r");
}
}
//////////////////////////
// Read dbsnp if specified and doing baseQC
if(((baseQCPtr != NULL) || baseSum) && (!dbsnp.IsEmpty()))
{
// Read the dbsnp file.
IFILE fdbSnp;
fdbSnp = ifopen(dbsnp,"r");
// Determine how many entries.
const SamReferenceInfo& refInfo = samHeader.getReferenceInfo();
int maxRefLen = 0;
for(int i = 0; i < refInfo.getNumEntries(); i++)
{
int refLen = refInfo.getReferenceLength(i);
if(refLen >= maxRefLen)
{
maxRefLen = refLen + 1;
}
}
dbsnpListPtr = new PosList(refInfo.getNumEntries(),maxRefLen);
if(fdbSnp==NULL)
{
std::cerr << "Open dbSNP file " << dbsnp.c_str() << " failed!\n";
}
else if(dbsnpListPtr == NULL)
{
std::cerr << "Failed to init the memory allocation for the dbsnpList.\n";
}
else
{
// Read the dbsnp file.
StringArray tokens;
String buffer;
int position = 0;
int refID = 0;
// Loop til the end of the file.
while (!ifeof(fdbSnp))
{
// Read the next line.
buffer.ReadLine(fdbSnp);
// If it does not have at least 2 columns,
// continue to the next line.
if (buffer.IsEmpty() || buffer[0] == '#') continue;
tokens.AddTokens(buffer);
if(tokens.Length() < 2) continue;
if(!tokens[1].AsInteger(position))
{
std::cerr << "Improperly formatted region line, start position "
<< "(2nd column) is not an integer: "
<< tokens[1]
<< "; Skipping to the next line.\n";
continue;
}
// Look up the reference name.
refID = samHeader.getReferenceID(tokens[0]);
if(refID != SamReferenceInfo::NO_REF_ID)
{
// Reference id was found, so add it to the dbsnp
dbsnpListPtr->addPosition(refID, position);
}
tokens.Clear();
buffer.Clear();
}
}
ifclose(fdbSnp);
}
// Read the sam records.
SamRecord samRecord;
int numReads = 0;
//////////////////////
// Setup in case doing a quality count.
// Quality histogram.
const int MAX_QUAL = 126;
const int START_QUAL = 33;
uint64_t qualCount[MAX_QUAL+1];
for(int i = 0; i <= MAX_QUAL; i++)
{
qualCount[i] = 0;
}
const int START_PHRED = 0;
const int PHRED_DIFF = START_QUAL - START_PHRED;
const int MAX_PHRED = MAX_QUAL - PHRED_DIFF;
uint64_t phredCount[MAX_PHRED+1];
for(int i = 0; i <= MAX_PHRED; i++)
{
phredCount[i] = 0;
}
int refPos = 0;
Cigar* cigarPtr = NULL;
char cigarChar = '?';
// Exclude clips from the qual/phred counts if unmapped reads are excluded.
bool qualExcludeClips = excludeFlags & SamFlag::UNMAPPED;
//////////////////////////////////
// When not reading by sections, getNextSection returns true
// the first time, then false the next time.
while(getNextSection(samIn))
{
// Keep reading records from the file until SamFile::ReadRecord
// indicates to stop (returns false).
while(((maxNumReads < 0) || (numReads < maxNumReads)) && samIn.ReadRecord(samHeader, samRecord))
{
// Another record was read, so increment the number of reads.
++numReads;
// See if the quality histogram should be genereated.
if(qual || phred)
{
// Get the quality.
const char* qual = samRecord.getQuality();
// Check for no quality ('*').
if((qual[0] == '*') && (qual[1] == 0))
{
// This record does not have a quality string, so no
// quality processing is necessary.
}
else
{
int index = 0;
cigarPtr = samRecord.getCigarInfo();
cigarChar = '?';
refPos = samRecord.get0BasedPosition();
if(!qualExcludeClips && (cigarPtr != NULL))
{
// Offset the reference position by any soft clips
// by subtracting the queryIndex of this start position.
// refPos is now the start position of the clips.
refPos -= cigarPtr->getQueryIndex(0);
}
while(qual[index] != 0)
{
// Skip this quality if it is clipped and we are skipping clips.
if(cigarPtr != NULL)
{
cigarChar = cigarPtr->getCigarCharOpFromQueryIndex(index);
}
if(qualExcludeClips && Cigar::isClip(cigarChar))
{
// Skip a clipped quality.
++index;
// Increment the position.
continue;
}
if(withinRegion && (myEndPos != -1) && (refPos >= myEndPos))
{
// We have hit the end of the region, stop processing this
// quality string.
break;
}
if(withinRegion && (refPos < myStartPos))
{
// This position is not in the target.
++index;
// Update the position if this is found in the reference or a clip.
if(Cigar::foundInReference(cigarChar) || Cigar::isClip(cigarChar))
{
++refPos;
}
continue;
}
// Check for valid quality.
if((qual[index] < START_QUAL) || (qual[index] > MAX_QUAL))
{
if(qual)
{
std::cerr << "Invalid Quality found: " << qual[index]
<< ". Must be between "
<< START_QUAL << " and " << MAX_QUAL << ".\n";
}
if(phred)
{
std::cerr << "Invalid Phred Quality found: " << qual[index] - PHRED_DIFF
<< ". Must be between "
<< START_QUAL << " and " << MAX_QUAL << ".\n";
}
// Skip an invalid quality.
++index;
// Update the position if this is found in the reference or a clip.
if(Cigar::foundInReference(cigarChar) || Cigar::isClip(cigarChar))
{
++refPos;
}
continue;
}
// Increment the count for this quality.
++(qualCount[(int)(qual[index])]);
++(phredCount[(int)(qual[index]) - PHRED_DIFF]);
// Update the position if this is found in the reference or a clip.
if(Cigar::foundInReference(cigarChar) || Cigar::isClip(cigarChar))
{
++refPos;
}
++index;
}
}
}
// Check the next thing to do for the read.
if((baseQCPtr != NULL) || baseSum)
{
// Pileup the bases for this read.
pileup.processAlignmentRegion(samRecord, myStartPos, myEndPos, dbsnpListPtr);
}
}
// Done with a section, move on to the next one.
// New section, so flush the pileup.
pileup.flushPileup();
}
// Flush the rest of the pileup.
if((baseQCPtr != NULL) || baseSum)
{
// Pileup the bases.
pileup.processAlignmentRegion(samRecord, myStartPos, myEndPos, dbsnpListPtr);
PileupElementBaseQCStats::printSummary();
ifclose(baseQCPtr);
}
std::cerr << "Number of records read = " <<
samIn.GetCurrentRecordCount() << std::endl;
if(basic)
{
std::cerr << std::endl;
samIn.PrintStatistics();
}
// Print the quality stats.
if(qual)
{
std::cerr << std::endl;
std::cerr << "Quality\tCount\n";
for(int i = START_QUAL; i <= MAX_QUAL; i++)
{
std::cerr << i << "\t" << qualCount[i] << std::endl;
}
}
// Print the phred quality stats.
if(phred)
{
std::cerr << std::endl;
std::cerr << "Phred\tCount\n";
for(int i = START_PHRED; i <= MAX_PHRED; i++)
{
std::cerr << i << "\t" << phredCount[i] << std::endl;
}
}
SamStatus::Status status = samIn.GetStatus();
if(status == SamStatus::NO_MORE_RECS)
{
// A status of NO_MORE_RECS means that all reads were successful.
status = SamStatus::SUCCESS;
}
return(status);
}
int WriteRegion::execute(int argc, char **argv)
{
// Extract command line arguments.
String inFile = "";
String outFile = "";
String indexFile = "";
String readName = "";
String bed = "";
myStart = UNSPECIFIED_INT;
myEnd = UNSPECIFIED_INT;
myPrevStart = UNSPECIFIED_INT;
myPrevEnd = UNSPECIFIED_INT;
myRefID = UNSET_REF;
myRefName.Clear();
myPrevRefName.Clear();
myBedRefID = SamReferenceInfo::NO_REF_ID;
bool lshift = false;
bool noeof = false;
bool params = false;
myWithinReg = false;
myWroteReg = false;
ParameterList inputParameters;
BEGIN_LONG_PARAMETERS(longParameterList)
LONG_PARAMETER_GROUP("Required Parameters")
LONG_STRINGPARAMETER("in", &inFile)
LONG_STRINGPARAMETER("out", &outFile)
LONG_PARAMETER_GROUP("Optional Region Parameters")
LONG_STRINGPARAMETER("bamIndex", &indexFile)
LONG_STRINGPARAMETER("refName", &myRefName)
LONG_INTPARAMETER("refID", &myRefID)
LONG_INTPARAMETER("start", &myStart)
LONG_INTPARAMETER("end", &myEnd)
LONG_STRINGPARAMETER("bed", &bed)
LONG_PARAMETER("withinReg", &myWithinReg)
LONG_STRINGPARAMETER("readName", &readName)
LONG_PARAMETER_GROUP("Optional Other Parameters")
LONG_PARAMETER("lshift", &lshift)
LONG_PARAMETER("noeof", &noeof)
LONG_PARAMETER("params", ¶ms)
END_LONG_PARAMETERS();
inputParameters.Add(new LongParameters ("Input Parameters",
longParameterList));
inputParameters.Read(argc-1, &(argv[1]));
// If no eof block is required for a bgzf file, set the bgzf file type to
// not look for it.
if(noeof)
{
// Set that the eof block is not required.
BgzfFileType::setRequireEofBlock(false);
}
// Check to see if the in file was specified, if not, report an error.
if(inFile == "")
{
usage();
// mandatory argument was not specified.
inputParameters.Status();
std::cerr << "Missing mandatory argument: --in" << std::endl;
return(-1);
}
if(outFile == "")
{
usage();
// mandatory argument was not specified.
inputParameters.Status();
std::cerr << "Missing mandatory argument: --out" << std::endl;
return(-1);
}
if(indexFile == "")
{
// In file was not specified, so set it to the in file
// + ".bai"
indexFile = inFile + ".bai";
}
if(myRefID != UNSET_REF && myRefName.Length() != 0)
{
std::cerr << "Can't specify both refID and refName" << std::endl;
inputParameters.Status();
return(-1);
}
if(myRefID != UNSET_REF && bed.Length() != 0)
{
std::cerr << "Can't specify both refID and bed" << std::endl;
inputParameters.Status();
return(-1);
}
if(myRefName.Length() != 0 && bed.Length() != 0)
{
std::cerr << "Can't specify both refName and bed" << std::endl;
inputParameters.Status();
return(-1);
}
if(!bed.IsEmpty())
{
myBedFile = ifopen(bed, "r");
}
if(params)
{
inputParameters.Status();
}
// Open the file for reading.
mySamIn.OpenForRead(inFile);
// Open the output file for writing.
SamFile samOut;
samOut.OpenForWrite(outFile);
// Open the bam index file for reading if a region was specified.
if((myRefName.Length() != 0) || (myRefID != UNSET_REF) || (myBedFile != NULL))
{
mySamIn.ReadBamIndex(indexFile);
}
// Read & write the sam header.
mySamIn.ReadHeader(mySamHeader);
samOut.WriteHeader(mySamHeader);
// Read the sam records.
SamRecord samRecord;
// Track the status.
int numSectionRecords = 0;
// Set returnStatus to success. It will be changed
// to the failure reason if any of the writes fail.
SamStatus::Status returnStatus = SamStatus::SUCCESS;
while(getNextSection())
{
// Keep reading records until they aren't anymore.
while(mySamIn.ReadRecord(mySamHeader, samRecord))
{
if(!readName.IsEmpty())
{
// Check for readname.
if(strcmp(samRecord.getReadName(), readName.c_str()) != 0)
{
// not a matching read name, so continue to the next record.
continue;
}
}
// Check to see if the read has already been processed.
if(myPrevEnd != UNSPECIFIED_INT)
{
// Because we already know that the bed was sorted,
// we know that the previous section started before
// this one, so if the previous end is greater than
// this record's end position we know that it
// was already written in the previous section.
// Note: can't be equal to the previous end since
// the end range was exclusive, while
// get0BasedAlignmentEnd is inclusive.
// myPrevEnd is reset by getNextSection when a new
// chromosome is hit.
if(samRecord.get0BasedAlignmentEnd() < myPrevEnd)
{
// This record was already written.
continue;
}
}
// Shift left if applicable.
if(lshift)
{
samRecord.shiftIndelsLeft();
}
// Successfully read a record from the file, so write it.
samOut.WriteRecord(mySamHeader, samRecord);
++numSectionRecords;
}
myWroteReg = true;
}
if(myBedFile != NULL)
{
ifclose(myBedFile);
}
std::cerr << "Wrote " << outFile << " with " << numSectionRecords
<< " records.\n";
return(returnStatus);
}
int sfccLex(parseUnion * lvalp, ParserControl * parm)
{
int i, rc;
char *next;
char *nextSection ;
for (;;) {
if(parm->econ) {
if(parm->econ->asynRCntl.escanInfo.getnew == 1 ){
nextSection = getNextSection(parm->econ) ;
if(nextSection != NULL) {
parm->xmb->base = nextSection ;
parm->xmb->cur = nextSection ;
parm->xmb->last = nextSection + (parm->econ->asynRCntl.escanInfo.sectlen) ;
} else {
printf(" sfccLex --- section is NULL !!!!!!!!!!!!!!!!! \n") ;
}
}
}
next = nextTag(parm->xmb);
if (next == NULL) {
return 0;
}
// fprintf(stderr,"--- token: %.32s\n",next); //usefull for debugging
if (parm->xmb->eTagFound) {
parm->xmb->eTagFound = 0;
return parm->xmb->etag;
}
if (*next == '/') {
for (i = 0; i < TAGS_NITEMS; i++) {
if (nextEquals(next + 1, tags[i].tag, tags[i].tagLen) == 1) {
skipTag(parm->xmb);
return tags[i].etag;
}
}
}
else {
if (strncmp(parm->xmb->cur, "<!--", 4) == 0) {
parm->xmb->cur = strstr(parm->xmb->cur, "-->") + 3;
continue;
} else
if (strncmp(parm->xmb->cur, "<EC>", 4) == 0) {
parm->econ->asynRCntl.escanInfo.getnew = 1 ;
parm->econ->asynRCntl.escanInfo.parsestate = PARSTATE_STARTED ;
continue;
}
for (i = 0; i < TAGS_NITEMS; i++) {
if (nextEquals(next, tags[i].tag, tags[i].tagLen) == 1) {
// printf("+++ %d\n",i);
rc=tags[i].process(lvalp, parm);
return rc;
}
}
}
break;
}
return 0;
}
