fix trim.seqs / qualscores bug

[mothur.git] / qualityscores.cpp

diff --git a/qualityscores.cpp b/qualityscores.cpp
index fa78b69d653cb841c33833d6249bab6b6ecaf18c..0641d3b7bf4ed8abc588467b946d0678766c5fb0 100644 (file)
--- a/qualityscores.cpp
+++ b/qualityscores.cpp
@@ -16,6 +16,7 @@ QualityScores::QualityScores(){
                m = MothurOut::getInstance();
                seqName = "";
                seqLength = -1;
+               
        }
        catch(exception& e) {
                m->errorOut(e, "QualityScores", "QualityScores");
@@ -25,50 +26,91 @@ QualityScores::QualityScores(){
 
 /**************************************************************************************************/
 
-QualityScores::QualityScores(ifstream& qFile, int l){
+QualityScores::QualityScores(ifstream& qFile){
        try {
                
                m = MothurOut::getInstance();
-
+               
                seqName = "";
-               seqLength = l;
                int score;
                
-               //string line;
-               //m->getline(qFile, line); 
-               //istringstream nameStream(line);
-       
                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();
+               m->getline(qFile);
                
-               //seqLength = qScores.size();   
+               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);
+               while(qFile.peek() != '>' && qFile.peek() != EOF){
+                       qScoreString += ' ' + m->getline(qFile);
+               }
                
-               for(int i=0;i<seqLength;i++){
-                       qFile >> score;
+               istringstream qScoreStringStream(qScoreString);
+               int count = 0;
+               while(!qScoreStringStream.eof()){
+                       if (m->control_pressed) { break; }
+                       qScoreStringStream >> score;
                        qScores.push_back(score);
+                       count++;
                }
-               m->gobble(qFile);
+               qScores.pop_back();
+               
+//             string scores = "";
+//             
+//             while(!qFile.eof()){    
+//                     
+//                     qFile >> seqName; 
+//                     
+//                     //get name
+//                     if (seqName.length() != 0) { 
+//                             seqName = seqName.substr(1);
+//                             while (!qFile.eof())    {       
+//                                     char c = qFile.get(); 
+//                                     //gobble junk on line
+//                                     if (c == 10 || c == 13){        break;  }
+//                             } 
+//                             m->gobble(qFile);
+//                     }
+//                     
+//                     //get scores
+//                     while(qFile){
+//                             char letter=qFile.get();
+//                             if((letter == '>')){    qFile.putback(letter);  break;  }
+//                             else if (isprint(letter)) { scores += letter; }
+//                     }
+//                     cout << scores << endl;
+//                     m->gobble(qFile);
+//                     
+//                     break;
+//             }
+//             
+//             //convert scores string to qScores
+//             istringstream qScoreStringStream(scores);
+//             
+//             int score;
+//             while(!qScoreStringStream.eof()){
+//                     
+//                     if (m->control_pressed) { break; }
+//                     
+//                     qScoreStringStream >> score;
+//                     qScores.push_back(score);
+//             }
+//             
+//             qScores.pop_back();
 
+               seqLength = qScores.size();
+               
+               
        }
        catch(exception& e) {
                m->errorOut(e, "QualityScores", "QualityScores");
                exit(1);
        }                                                       
-
+       
 }
 
 /**************************************************************************************************/
@@ -76,6 +118,7 @@ QualityScores::QualityScores(ifstream& qFile, int l){
 string QualityScores::getName(){
        
        try {
+               cout << qScores.size() << '\t';
                return seqName;
        }
        catch(exception& e) {
@@ -111,13 +154,17 @@ void QualityScores::trimQScores(int start, int end){
        try {
                vector<int> hold;
                
+               cout << seqName << '\t' << qScores.size() << '\t' << start << '\t' << end << endl;
+               
                if(end == -1){          
                        hold = vector<int>(qScores.begin()+start, qScores.end());
                        qScores = hold;         
                }
                if(start == -1){
-                       hold = vector<int>(qScores.begin(), qScores.begin()+end);       //not sure if indexing is correct
-                       qScores = hold;         
+                       if(qScores.size() > end){
+                               hold = vector<int>(qScores.begin(), qScores.begin()+end);
+                               qScores = hold;         
+                       }
                }
 
                seqLength = qScores.size();
@@ -165,9 +212,12 @@ bool QualityScores::stripQualThreshold(Sequence& sequence, double qThreshold){
                        }
                }
                
+               //every score passed
+               if (end == (seqLength-1)) { end = seqLength; }
+               
                sequence.setUnaligned(rawSequence.substr(0,end));
                trimQScores(-1, end);
-       
+               
                return 1;
        }
        catch(exception& e) {
@@ -198,16 +248,17 @@ bool QualityScores::stripQualRollingAverage(Sequence& sequence, double qThreshol
                        
                        if(rollingSum / (double)(i+1) < qThreshold){
                                end = i;
-//                             cout << i+1 << '\t' << seqName << '\t' << rollingSum / (double)(i+1) << endl;
                                break;
                        }
                }
                
                if(end == -1){  end = seqLength;        }
                
+               
                sequence.setUnaligned(rawSequence.substr(0,end));
                trimQScores(-1, end);
                
+               
                return 1;
        }
        catch(exception& e) {
@@ -232,12 +283,13 @@ bool QualityScores::stripQualWindowAverage(Sequence& sequence, int stepSize, int
                int end = windowSize;
                int start = 0;
                
-
+               if(seqLength < windowSize) {    return 0;       }
+                       
                while(start < seqLength){
                        double windowSum = 0.0000;
 
                        for(int i=start;i<end;i++){
-                               windowSum += qScores[i];                                
+                               windowSum += qScores[i];
                        }
                        double windowAverage = windowSum / (double)(end-start);
                        
@@ -250,7 +302,6 @@ bool QualityScores::stripQualWindowAverage(Sequence& sequence, int stepSize, int
                        if(end >= seqLength){   end = seqLength - 1;    }
                }
                
-               
                if(end == -1){  end = seqLength;        }
                
                sequence.setUnaligned(rawSequence.substr(0,end));
@@ -299,7 +350,68 @@ bool QualityScores::cullQualAverage(Sequence& sequence, double qAverage){
                return success;
        }
        catch(exception& e) {
-               m->errorOut(e, "TrimSeqsCommand", "cullQualAverage");
+               m->errorOut(e, "QualityScores", "cullQualAverage");
+               exit(1);
+       }
+}
+
+/**************************************************************************************************/
+
+void QualityScores::updateQScoreErrorMap(map<char, vector<int> >& qualErrorMap, string errorSeq, int start, int stop, int weight){
+       try {
+
+               int seqLength = errorSeq.size();
+               
+               int qIndex = start - 1;
+
+               for(int i=0;i<seqLength;i++){
+                       
+                       if(errorSeq[i] == 'm')          {       qualErrorMap['m'][qScores[qIndex]] += weight;   }
+                       else if(errorSeq[i] == 's')     {       qualErrorMap['s'][qScores[qIndex]] += weight;   }
+                       else if(errorSeq[i] == 'i')     {       qualErrorMap['i'][qScores[qIndex]] += weight;   }
+                       else if(errorSeq[i] == 'a')     {       qualErrorMap['a'][qScores[qIndex]] += weight;   }
+                       else if(errorSeq[i] == 'd')     {       /*      there are no qScores for deletions      */              }
+
+                       if(errorSeq[i] != 'd')          {       qIndex++;       }
+                       if(qIndex > stop){      break;  }
+               }       
+       }
+       catch(exception& e) {
+               m->errorOut(e, "QualityScores", "updateQScoreErrorMap");
+               exit(1);
+       }
+}
+
+/**************************************************************************************************/
+
+void QualityScores::updateForwardMap(vector<vector<int> >& forwardMap, int start, int stop, int weight){
+       try {
+               
+               int index = 0;
+               for(int i=start-1;i<stop;i++){
+                       forwardMap[index++][qScores[i]] += weight;
+               }
+               
+       }
+       catch(exception& e) {
+               m->errorOut(e, "QualityScores", "updateForwardMap");
+               exit(1);
+       }
+}
+
+/**************************************************************************************************/
+
+void QualityScores::updateReverseMap(vector<vector<int> >& reverseMap, int start, int stop, int weight){
+       try {
+               
+               int index = 0;
+               for(int i=stop-1;i>=start;i--){
+                       reverseMap[index++][qScores[i]] += weight;
+               }
+               
+       }       
+       catch(exception& e) {
+               m->errorOut(e, "QualityScores", "updateForwardMap");
                exit(1);
        }
 }