comparison data/fileio/CSVFileReader.cpp @ 628:001db550bd48

* Add option to import time+duration (or time+endtime) from CSV files
  (importing to Region layers)
* Fix ffwd/rwd in Region layers so as to behave like time-value layers

 #include "model/Model.h"
 #include "base/RealTime.h"
 #include "model/SparseOneDimensionalModel.h"
 #include "model/SparseTimeValueModel.h"
 #include "model/EditableDenseThreeDimensionalModel.h"
+#include "model/RegionModel.h"
 #include "DataFileReaderFactory.h"
 
 #include <QFile>
 #include <QString>
 #include <QRegExp>
 #include <QStringList>
 #include <QTextStream>
 
 #include <iostream>
+#include <map>
 
 CSVFileReader::CSVFileReader(QString path, CSVFormat format,
                              size_t mainModelSampleRate) :
     m_format(format),
     m_file(0),

 	delete dialog;
         throw DataFileReaderFactory::ImportCancelled;
     }
 */
 
-    CSVFormat::ModelType   modelType = m_format.getModelType();
+    CSVFormat::ModelType modelType = m_format.getModelType();
     CSVFormat::TimingType timingType = m_format.getTimingType();
-    CSVFormat::TimeUnits   timeUnits = m_format.getTimeUnits();
+    CSVFormat::DurationType durationType = m_format.getDurationType();
+    CSVFormat::TimeUnits timeUnits = m_format.getTimeUnits();
     QString separator = m_format.getSeparator();
     QString::SplitBehavior behaviour = m_format.getSplitBehaviour();
     size_t sampleRate = m_format.getSampleRate();
     size_t windowSize = m_format.getWindowSize();
 

 	}
     }
 
     SparseOneDimensionalModel *model1 = 0;
     SparseTimeValueModel *model2 = 0;
+    RegionModel *model2a = 0;
     EditableDenseThreeDimensionalModel *model3 = 0;
     Model *model = 0;
 
     QTextStream in(m_file);
     in.seek(0);

     unsigned int lineno = 0;
 
     float min = 0.0, max = 0.0;
 
     size_t frameNo = 0;
+    size_t duration = 0;
     size_t startFrame = 0; // for calculation of dense model resolution
+
+    std::map<QString, float> labelValueMap;
+    float syntheticMax = 0.f;
 
     while (!in.atEnd()) {
 
         // QTextStream's readLine doesn't cope with old-style Mac
         // CR-only line endings.  Why did they bother making the class

                 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::ThreeDimensionalModel:
                     model3 = new EditableDenseThreeDimensionalModel
                         (sampleRate,
                          windowSize,
                          list.size(),

             }
 
             QStringList tidyList;
             QRegExp nonNumericRx("[^0-9eE.,+-]");
 
+            float value = 0.f;
+
             for (int i = 0; i < list.size(); ++i) {
 	    
                 QString s(list[i].trimmed());
 
                 if (s.length() >= 2 && s.startsWith("\"") && s.endsWith("\"")) {
                     s = s.mid(1, s.length() - 2);
                 } else if (s.length() >= 2 && s.startsWith("'") && s.endsWith("'")) {
                     s = s.mid(1, s.length() - 2);
                 }
 
-                if (i == 0 && timingType == CSVFormat::ExplicitTiming) {
-
+                if (timingType == CSVFormat::ExplicitTiming) {
+
+                    size_t calculatedFrame = 0;
+
+                    if (i == 0 ||
+                        (i == 1 &&
+                         modelType == CSVFormat::TwoDimensionalModelWithDuration)) {
+
+                        bool ok = false;
+                        QString numeric = s;
+                        numeric.remove(nonNumericRx);
+
+                        if (timeUnits == CSVFormat::TimeSeconds) {
+
+                            double time = numeric.toDouble(&ok);
+                            calculatedFrame = int(time * sampleRate + 0.5);
+
+                        } else {
+
+                            calculatedFrame = numeric.toInt(&ok);
+
+                            if (timeUnits == CSVFormat::TimeWindows) {
+                                calculatedFrame *= windowSize;
+                            }
+                        }
+			       
+                        if (!ok) {
+                            if (warnings < warnLimit) {
+                                std::cerr << "WARNING: CSVFileReader::load: "
+                                          << "Bad time format (\"" << s.toStdString()
+                                          << "\") in data line "
+                                          << lineno+1 << ":" << std::endl;
+                                std::cerr << line.toStdString() << std::endl;
+                            } else if (warnings == warnLimit) {
+                                std::cerr << "WARNING: Too many warnings" << std::endl;
+                            }
+                            ++warnings;
+                        }
+
+                        if (i == 0) frameNo = calculatedFrame;
+                        else {
+                            if (durationType == CSVFormat::EndTimes) {
+                                duration = calculatedFrame - frameNo;
+                            } else {
+                                duration = calculatedFrame;
+                            }
+                        }
+
+                        continue;
+                    }
+                }
+
+                if ((i == 1 &&
+                     modelType == CSVFormat::TwoDimensionalModel) ||
+                    (i == 2 &&
+                     modelType == CSVFormat::TwoDimensionalModelWithDuration)) {
                     bool ok = false;
-                    QString numeric = s;
-                    numeric.remove(nonNumericRx);
-
-                    if (timeUnits == CSVFormat::TimeSeconds) {
-
-                        double time = numeric.toDouble(&ok);
-                        frameNo = int(time * sampleRate + 0.5);
-
+                    value = s.toFloat(&ok);
+                    if (!ok) {
+                        // cf. RDFImporter::fillModel
+                        if (labelValueMap.find(s) == labelValueMap.end()) {
+                            syntheticMax = syntheticMax + 1.f;
+                            labelValueMap[s] = syntheticMax;
+                        }
+                        value = labelValueMap[s];
                     } else {
-
-                        frameNo = numeric.toInt(&ok);
-
-                        if (timeUnits == CSVFormat::TimeWindows) {
-                            frameNo *= windowSize;
-                        }
-                    }
-			       
-                    if (!ok) {
-                        if (warnings < warnLimit) {
-                            std::cerr << "WARNING: CSVFileReader::load: "
-                                      << "Bad time format (\"" << s.toStdString()
-                                      << "\") in data line "
-                                      << lineno+1 << ":" << std::endl;
-                            std::cerr << line.toStdString() << std::endl;
-                        } else if (warnings == warnLimit) {
-                            std::cerr << "WARNING: Too many warnings" << std::endl;
-                        }
-                        ++warnings;
-                    }
-                } else {
-                    tidyList.push_back(s);
-                }
+                        if (value > syntheticMax) syntheticMax = value;
+                    }
+                    if (i + 1 == list.size()) {
+                        // keep text around for use as label (none other given)
+                        tidyList.push_back(s);
+                    }
+                    continue;
+                }
+
+                tidyList.push_back(s);
             }
 
             if (modelType == CSVFormat::OneDimensionalModel) {
 	    
                 SparseOneDimensionalModel::Point point

 
             } else if (modelType == CSVFormat::TwoDimensionalModel) {
 
                 SparseTimeValueModel::Point point
                     (frameNo,
-                     tidyList.size() > 0 ? tidyList[0].toFloat() : 0.0,
-                     tidyList.size() > 1 ? tidyList[1] : QString("%1").arg(lineno+1));
+                     value,
+                     tidyList.size() > 0 ? tidyList[0] : QString("%1").arg(lineno+1));
 
                 model2->addPoint(point);
+
+            } else if (modelType == CSVFormat::TwoDimensionalModelWithDuration) {
+
+                RegionModel::Point point
+                    (frameNo,
+                     value,
+                     duration,
+                     tidyList.size() > 0 ? tidyList[0] : QString("%1").arg(lineno+1));
+
+                model2a->addPoint(point);
 
             } else if (modelType == CSVFormat::ThreeDimensionalModel) {
 
                 DenseThreeDimensionalModel::Column values;