comparison data/fileio/CSVFileReader.cpp @ 1450:a12fd0456f0c streaming-csv-writer

Merge from default branch

 #include <QStringList>
 #include <QTextStream>
 
 #include <iostream>
 #include <map>
+#include <string>
 
 using namespace std;
 
 CSVFileReader::CSVFileReader(QString path, CSVFormat format,
                              sv_samplerate_t mainModelSampleRate) :

 {
     QFile *file = new QFile(path);
     bool good = false;
     
     if (!file->exists()) {
-	m_error = QFile::tr("File \"%1\" does not exist").arg(path);
+        m_error = QFile::tr("File \"%1\" does not exist").arg(path);
     } else if (!file->open(QIODevice::ReadOnly | QIODevice::Text)) {
-	m_error = QFile::tr("Failed to open file \"%1\"").arg(path);
+        m_error = QFile::tr("Failed to open file \"%1\"").arg(path);
     } else {
-	good = true;
+        good = true;
     }
 
     if (good) {
         m_device = file;
         m_filename = QFileInfo(path).fileName();
     } else {
-	delete file;
+        delete file;
     }
 }
 
 CSVFileReader::CSVFileReader(QIODevice *device, CSVFormat format,
                              sv_samplerate_t mainModelSampleRate) :

         }
     }
     
     if (!ok) {
         if (m_warnings < warnLimit) {
-            cerr << "WARNING: CSVFileReader::load: "
+            SVCERR << "WARNING: CSVFileReader::load: "
                       << "Bad time format (\"" << s
                       << "\") in data line "
                       << lineno+1 << endl;
         } else if (m_warnings == warnLimit) {
-            cerr << "WARNING: Too many warnings" << endl;
+            SVCERR << "WARNING: Too many warnings" << endl;
         }
         ++m_warnings;
     }
 
     return calculatedFrame;

             // that's likely to be visible
             windowSize = 1024;
         } else {
             windowSize = 1;
         }
-	if (timeUnits == CSVFormat::TimeSeconds ||
+        if (timeUnits == CSVFormat::TimeSeconds ||
             timeUnits == CSVFormat::TimeMilliseconds) {
-	    sampleRate = m_mainModelSampleRate;
-	}
+            sampleRate = m_mainModelSampleRate;
+        }
     }
 
     SparseOneDimensionalModel *model1 = 0;
     SparseTimeValueModel *model2 = 0;
     RegionModel *model2a = 0;

 
                 case CSVFormat::OneDimensionalModel:
                     model1 = new SparseOneDimensionalModel(sampleRate, windowSize);
                     model = model1;
                     break;
-		
+                
                 case CSVFormat::TwoDimensionalModel:
                     model2 = new SparseTimeValueModel(sampleRate, windowSize, false);
                     model = model2;
                     break;
-		
+                
                 case CSVFormat::TwoDimensionalModelWithDuration:
                     model2a = new RegionModel(sampleRate, windowSize, false);
                     model = model2a;
                     break;
-		
+                
                 case CSVFormat::TwoDimensionalModelWithDurationAndPitch:
                     model2b = new NoteModel(sampleRate, windowSize, false);
                     model = model2b;
                     break;
-		
+                
                 case CSVFormat::ThreeDimensionalModel:
                     model3 = new EditableDenseThreeDimensionalModel
                         (sampleRate,
                          windowSize,
                          valueColumns,

                     duration = endFrame - frameNo;
                 }
             }
 
             if (modelType == CSVFormat::OneDimensionalModel) {
-	    
+            
                 SparseOneDimensionalModel::Point point(frameNo, label);
                 model1->addPoint(point);
 
             } else if (modelType == CSVFormat::TwoDimensionalModel) {
 

 
                     bool ok = false;
                     float value = list[i].toFloat(&ok);
 
                     values.push_back(value);
-	    
+            
                     if (firstEverValue || value < min) min = value;
                     if (firstEverValue || value > max) max = value;
                     
                     if (firstEverValue) {
                         startFrame = frameNo;

                     
                     firstEverValue = false;
 
                     if (!ok) {
                         if (warnings < warnLimit) {
-                            cerr << "WARNING: CSVFileReader::load: "
+                            SVCERR << "WARNING: CSVFileReader::load: "
                                       << "Non-numeric value \""
                                       << list[i]
                                       << "\" in data line " << lineno+1
                                       << ":" << endl;
-                            cerr << line << endl;
+                            SVCERR << line << endl;
                             ++warnings;
                         } else if (warnings == warnLimit) {
-//                            cerr << "WARNING: Too many warnings" << endl;
+//                            SVCERR << "WARNING: Too many warnings" << endl;
                         }
                     }
                 }
-	
+        
 //                SVDEBUG << "Setting bin values for count " << lineno << ", frame "
 //                          << frameNo << ", time " << RealTime::frame2RealTime(frameNo, sampleRate) << endl;
 
                 model3->setColumn(lineno, values);
             }

 
             float v = 0.f;
             for (map<int, map<QString, float> >::iterator i =
                      countLabelValueMap.end(); i != countLabelValueMap.begin(); ) {
                 --i;
-                cerr << "count -> " << i->first << endl;
+                SVCERR << "count -> " << i->first << endl;
                 for (map<QString, float>::iterator j = i->second.begin();
                      j != i->second.end(); ++j) {
                     j->second = v;
-                    cerr << "label -> " << j->first << ", value " << v << endl;
+                    SVCERR << "label -> " << j->first << ", value " << v << endl;
                     v = v + 1.f;
                 }
             }
 
             map<RegionModel::Point, RegionModel::Point,

                      model2a->getPoints().begin();
                  i != model2a->getPoints().end(); ++i) {
                 RegionModel::Point p(*i);
                 int count = labelCountMap[p.label];
                 v = countLabelValueMap[count][p.label];
-                cerr << "mapping from label \"" << p.label << "\" (count " << count << ") to value " << v << endl;
+              //  SVCERR << "mapping from label \"" << p.label << "\" (count " << count << ") to value " << v << endl;
                 RegionModel::Point pp(p.frame, v, p.duration, p.label);
                 pointMap[p] = pp;
             }
 
             for (map<RegionModel::Point, RegionModel::Point>::iterator i = 

             model2b->setScaleUnits("Hz");
         }
     }
 
     if (model3) {
-	model3->setMinimumLevel(min);
-	model3->setMaximumLevel(max);
+        model3->setMinimumLevel(min);
+        model3->setMaximumLevel(max);
     }
 
     return model;
 }