modified reverse.seqs and qualscores.cpp

diff --git a/qualityscores.cpp b/qualityscores.cpp
index 90412c62b6ae20705c0ba1c162c4c73c260d0171..6dee9862ec2c7582aa9a56dd2f5e8bd4f2ce9127 100644 (file)
--- a/qualityscores.cpp
+++ b/qualityscores.cpp
@@ -26,82 +26,42 @@ QualityScores::QualityScores(){
 
 /**************************************************************************************************/
 
-QualityScores::QualityScores(ifstream& qFile, int l){
+QualityScores::QualityScores(ifstream& qFile){
        try {
                
                m = MothurOut::getInstance();
-
+               
                seqName = "";
-               seqLength = l;
                int score;
                
                qFile >> seqName; 
-
-               while (!qFile.eof())    {       char c = qFile.get(); if (c == 10 || c == 13 || c == -1){       break;  }       } // get rest of line 
-               m->gobble(qFile);
-               if (seqName == "") { m->mothurOut("Error reading quality file, name blank at position, " + toString(qFile.tellg())); m->mothurOutEndLine(); }
-               else {
-                       seqName = seqName.substr(1); 
-               }
-               
-               //m->getline(qFile, line);
-               //istringstream qualStream(line);
-       
-               //while(qualStream){
-               //      qualStream >> score;
-               //      qScores.push_back(score);
-               //}
-               //qScores.pop_back();
-               
-               //seqLength = qScores.size();   
-               
-               /*while(!in.eof()){     
-                       string saveName = "";
-                       string name = "";
-                       string scores = "";
-                       
-                       in >> name; 
-                       //cout << name << endl;         
-                       if (name.length() != 0) { 
-                               saveName = name.substr(1);
-                               while (!in.eof())       {       
-                                       char c = in.get(); 
-                                       if (c == 10 || c == 13){        break;  }
-                                       else { name += c; }     
-                               } 
-                               m->gobble(in);
-                       }
-                       
-                       while(in){
-                               char letter= in.get();
-                               if(letter == '>'){      in.putback(letter);     break;  }
-                               else{ scores += letter; }
-                       }
-                       
-                //istringstream iss (scores,istringstream::in);
-                
-                //int count = 0; int tempScore;
-                //while (iss) { iss >> tempScore; count++; }
-                //cout << saveName << '\t' << count << endl;   
-                       
-                       m->gobble(in);
-               }*/             
+               m->getline(qFile);
                
+               if (seqName == "")      {
+                       m->mothurOut("Error reading quality file, name blank at position, " + toString(qFile.tellg()));
+                       m->mothurOutEndLine(); 
+               }
+               else{
+                       seqName = seqName.substr(1);
+               }
                
+               string qScoreString = m->getline(qFile);
                
-               for(int i=0;i<seqLength;i++){
-                       qFile >> score;
+               istringstream qScoreStringStream(qScoreString);
+               while(!qScoreStringStream.eof()){
+                       qScoreStringStream >> score;
                        qScores.push_back(score);
                }
-               m->gobble(qFile);
-
+               qScores.pop_back();
+               seqLength = qScores.size();
        }
        catch(exception& e) {
                m->errorOut(e, "QualityScores", "QualityScores");
                exit(1);
        }                                                       
-
+       
 }
+
 /**************************************************************************************************/
 
 string QualityScores::getName(){

diff --git a/qualityscores.h b/qualityscores.h
index 8f2105a1d095bfe94502d28ae387b89e8da9ed7c..5ae5e0ab754a9147106e859ce29e7046b37a32c0 100644 (file)
--- a/qualityscores.h
+++ b/qualityscores.h
@@ -20,7 +20,7 @@
 class QualityScores {
 public:
        QualityScores();
-       QualityScores(ifstream&, int);
+       QualityScores(ifstream&);
        string getName();
        void printQScores(ofstream&);
        void trimQScores(int, int);

diff --git a/reversecommand.cpp b/reversecommand.cpp
index d20f4af0acd4861cea64688e6e05460e42cbaf75..5eceb3049f0d6cbc41025c875843adce306a745c 100644 (file)
--- a/reversecommand.cpp
+++ b/reversecommand.cpp
@@ -9,11 +9,12 @@
 
 #include "reversecommand.h"
 #include "sequence.hpp"
+#include "qualityscores.h"
 
 //**********************************************************************************************************************
 vector<string> ReverseSeqsCommand::getValidParameters(){       
        try {
-               string Array[] =  {"fasta", "outputdir","inputdir"};
+               string Array[] =  {"fasta", "qfile", "outputdir", "inputdir"};
                vector<string> myArray (Array, Array+(sizeof(Array)/sizeof(string)));
                return myArray;
        }
@@ -28,6 +29,7 @@ ReverseSeqsCommand::ReverseSeqsCommand(){
                abort = true; calledHelp = true; 
                vector<string> tempOutNames;
                outputTypes["fasta"] = tempOutNames;
+               outputTypes["qfile"] = tempOutNames;
        }
        catch(exception& e) {
                m->errorOut(e, "ReverseSeqsCommand", "ReverseSeqsCommand");
@@ -35,9 +37,10 @@ ReverseSeqsCommand::ReverseSeqsCommand(){
        }
 }
 //**********************************************************************************************************************
+
 vector<string> ReverseSeqsCommand::getRequiredParameters(){    
        try {
-               string Array[] =  {"fasta"};
+               string Array[] =  {"fasta", "qfile"};
                vector<string> myArray (Array, Array+(sizeof(Array)/sizeof(string)));
                return myArray;
        }
@@ -46,7 +49,9 @@ vector<string> ReverseSeqsCommand::getRequiredParameters(){
                exit(1);
        }
 }
+
 //**********************************************************************************************************************
+
 vector<string> ReverseSeqsCommand::getRequiredFiles(){ 
        try {
                vector<string> myArray;
@@ -56,8 +61,7 @@ vector<string> ReverseSeqsCommand::getRequiredFiles(){
                m->errorOut(e, "ReverseSeqsCommand", "getRequiredFiles");
                exit(1);
        }
-}
-//***************************************************************************************************************
+}//***************************************************************************************************************
 
 ReverseSeqsCommand::ReverseSeqsCommand(string option)  {
        try {
@@ -68,7 +72,7 @@ ReverseSeqsCommand::ReverseSeqsCommand(string option)  {
                
                else {
                        //valid paramters for this command
-                       string Array[] =  {"fasta", "outputdir","inputdir"};
+                       string Array[] =  {"fasta", "qfile", "outputdir","inputdir"};
                        vector<string> myArray (Array, Array+(sizeof(Array)/sizeof(string)));
                        
                        OptionParser parser(option);
@@ -85,7 +89,8 @@ ReverseSeqsCommand::ReverseSeqsCommand(string option)  {
                        //initialize outputTypes
                        vector<string> tempOutNames;
                        outputTypes["fasta"] = tempOutNames;
-                       
+                       outputTypes["qfile"] = tempOutNames;
+
                        //if the user changes the input directory command factory will send this info to us in the output parameter 
                        string inputDir = validParameter.validFile(parameters, "inputdir", false);              
                        if (inputDir == "not found"){   inputDir = "";          }
@@ -101,14 +106,24 @@ ReverseSeqsCommand::ReverseSeqsCommand(string option)  {
                        }
 
                        //check for required parameters
-                       fasta = validParameter.validFile(parameters, "fasta", true);
-                       if (fasta == "not open") { abort = true; }
-                       else if (fasta == "not found") { fasta = ""; m->mothurOut("fasta is a required parameter for the reverse.seqs command."); m->mothurOutEndLine(); abort = true;  }       
+                       fastaFileName = validParameter.validFile(parameters, "fasta", true);
+                       if (fastaFileName == "not open") { abort = true; }
+                       else if (fastaFileName == "not found") { fastaFileName = "";}// m->mothurOut("fasta is a required parameter for the reverse.seqs command."); m->mothurOutEndLine(); abort = true;  }    
+                       
+                       qualFileName = validParameter.validFile(parameters, "qfile", true);
+                       if (qualFileName == "not open") { abort = true; }
+                       else if (qualFileName == "not found") { qualFileName = ""; }//m->mothurOut("fasta is a required parameter for the reverse.seqs command."); m->mothurOutEndLine(); abort = true;  }      
+
+                       if(fastaFileName == "not open" && qualFileName == "not open"){
+                               m->mothurOut("fasta or qfile is a required parameter for the reverse.seqs command.");
+                               m->mothurOutEndLine();
+                               abort = true;
+                       }
                        
                        //if the user changes the output directory command factory will send this info to us in the output parameter 
                        outputDir = validParameter.validFile(parameters, "outputdir", false);           if (outputDir == "not found"){  
                                outputDir = ""; 
-                               outputDir += m->hasPath(fasta); //if user entered a file with a path then preserve it   
+                               outputDir += m->hasPath(fastaFileName); //if user entered a file with a path then preserve it   
                        }
 
                }
@@ -123,7 +138,7 @@ ReverseSeqsCommand::ReverseSeqsCommand(string option)  {
 void ReverseSeqsCommand::help(){
        try {
                m->mothurOut("The reverse.seqs command reads a fastafile and outputs a fasta file containing the reverse compliment.\n");
-               m->mothurOut("The reverse.seqs command parameter is fasta and it is required.\n");
+               m->mothurOut("The reverse.seqs command parameters fasta or qfile are required.\n");
                m->mothurOut("The reverse.seqs command should be in the following format: \n");
                m->mothurOut("reverse.seqs(fasta=yourFastaFile) \n");   
        }
@@ -145,35 +160,61 @@ int ReverseSeqsCommand::execute(){
                
                if (abort == true) { if (calledHelp) { return 0; }  return 2;   }
                
-               ifstream inFASTA;
-               m->openInputFile(fasta, inFASTA);
-               
-               ofstream outFASTA;
-               string reverseFile = outputDir + m->getRootName(m->getSimpleName(fasta)) + "rc" + m->getExtension(fasta);
-               m->openOutputFile(reverseFile, outFASTA);
+               string fastaReverseFileName;
                
-               while(!inFASTA.eof()){
-                       if (m->control_pressed) {  inFASTA.close();  outFASTA.close(); remove(reverseFile.c_str()); return 0; }
-                        
-                       Sequence currSeq(inFASTA);  m->gobble(inFASTA);
-                       if (currSeq.getName() != "") {
-                               currSeq.reverseComplement();
-                               currSeq.printSequence(outFASTA);
+               if(fastaFileName != ""){
+                       ifstream inFASTA;
+                       m->openInputFile(fastaFileName, inFASTA);
+                       
+                       ofstream outFASTA;
+                       fastaReverseFileName = outputDir + m->getRootName(m->getSimpleName(fastaFileName)) + "rc" + m->getExtension(fastaFileName);
+                       m->openOutputFile(fastaReverseFileName, outFASTA);
+                       
+                       while(!inFASTA.eof()){
+                               if (m->control_pressed) {  inFASTA.close();  outFASTA.close(); remove(fastaReverseFileName.c_str()); return 0; }
+                                
+                               Sequence currSeq(inFASTA);  m->gobble(inFASTA);
+                               if (currSeq.getName() != "") {
+                                       currSeq.reverseComplement();
+                                       currSeq.printSequence(outFASTA);
+                               }
                        }
+                       inFASTA.close();
+                       outFASTA.close();
+                       outputNames.push_back(fastaReverseFileName);
                }
-               inFASTA.close();
-               outFASTA.close();
                
-               if (m->control_pressed) {  remove(reverseFile.c_str()); return 0; }
+               string qualReverseFileName;
+
+               if(qualFileName != ""){
+                       QualityScores currQual;
+
+                       ifstream inQual;
+                       m->openInputFile(qualFileName, inQual);
+                       
+                       ofstream outQual;
+                       string qualReverseFileName = outputDir + m->getRootName(m->getSimpleName(qualFileName)) + "rc" + m->getExtension(qualFileName);
+                       m->openOutputFile(qualReverseFileName, outQual);
+
+                       while(!inQual.eof()){
+                               if (m->control_pressed) {  inQual.close();  outQual.close(); remove(qualReverseFileName.c_str()); return 0; }
+                               currQual = QualityScores(inQual);  m->gobble(inQual);
+                               currQual.flipQScores(); 
+                               currQual.printQScores(outQual);
+                       }
+                       inQual.close();
+                       outQual.close();
+                       outputNames.push_back(qualReverseFileName);
+               }
                
                m->mothurOutEndLine();
                m->mothurOut("Output File Name: "); m->mothurOutEndLine();
-               m->mothurOut(reverseFile); m->mothurOutEndLine();       outputNames.push_back(reverseFile); outputTypes["fasta"].push_back(reverseFile);
-               m->mothurOutEndLine();
-
+               for(int i=0;i<outputNames.size();i++){
+                       m->mothurOut(outputNames[i]);
+                       m->mothurOutEndLine();
+               }
                
                return 0;
-               
        }
        catch(exception& e) {
                m->errorOut(e, "ReverseSeqsCommand", "execute");

diff --git a/reversecommand.h b/reversecommand.h
index 8b5bcd262528e36f756093a8236f8a1b3a447ce8..bd8d1194ff095fa5fecff1b51570520b849dbf9a 100644 (file)
--- a/reversecommand.h
+++ b/reversecommand.h
@@ -27,7 +27,7 @@ public:
 private:
 
        bool abort;
-       string fasta, outputDir;
+       string fastaFileName, qualFileName, outputDir;
        vector<string> outputNames;
        map<string, vector<string> > outputTypes;
        

diff --git a/seqerrorcommand.cpp b/seqerrorcommand.cpp
index 88794788a0472743665838721bb28b9b761f1765..b31c4e0d89ecdb7243e9f4e42d3dc0af1d903450 100644 (file)
--- a/seqerrorcommand.cpp
+++ b/seqerrorcommand.cpp
@@ -343,7 +343,7 @@ int SeqErrorCommand::execute(){
                                int startBase = report.getQueryStart();
                                int endBase = report.getQueryEnd();
 
-                               quality = QualityScores(qualFile, origLength);
+                               quality = QualityScores(qualFile);
 
                                if(!ignoreSeq){
                                        quality.updateQScoreErrorMap(qScoreErrorMap, minCompare.sequence, startBase, endBase, minCompare.weight);

diff --git a/trimseqscommand.cpp b/trimseqscommand.cpp
index 7f82366331830baf3ca6640b2af83073662ec9f6..53bdc7e28435d8fbe5b4379fd51f8ce23a909eb6 100644 (file)
--- a/trimseqscommand.cpp
+++ b/trimseqscommand.cpp
@@ -460,7 +460,7 @@ int TrimSeqsCommand::driverCreateTrim(string filename, string qFileName, string
 
                        QualityScores currQual;
                        if(qFileName != ""){
-                               currQual = QualityScores(qFile, currSeq.getNumBases());  m->gobble(qFile);
+                               currQual = QualityScores(qFile);  m->gobble(qFile);
                        }
 
                        string origSeq = currSeq.getUnaligned();