comparison transform/FeatureExtractionModelTransformer.cpp @ 1713:978c143c767f

Merge from branch single-point

 #include "data/model/SparseOneDimensionalModel.h"
 #include "data/model/SparseTimeValueModel.h"
 #include "data/model/EditableDenseThreeDimensionalModel.h"
 #include "data/model/DenseTimeValueModel.h"
 #include "data/model/NoteModel.h"
-#include "data/model/FlexiNoteModel.h"
 #include "data/model/RegionModel.h"
 #include "data/model/FFTModel.h"
 #include "data/model/WaveFileModel.h"
 #include "rdf/PluginRDFDescription.h"
 

         // If we had a "sparse 3D model", we would have the additional
         // problem of determining whether to use that here (if bin
         // count > 1).  But we don't.
 
         QSettings settings;
-        settings.beginGroup("Transformer");
-        bool flexi = settings.value("use-flexi-note-model", false).toBool();
-        settings.endGroup();
-
-        cerr << "flexi = " << flexi << endl;
-
-        if (isNoteModel && !flexi) {
+
+        if (isNoteModel) {
 
             NoteModel *model;
             if (haveExtents) {
                 model = new NoteModel
                     (modelRate, modelResolution, minValue, maxValue, false);
             } else {
                 model = new NoteModel
-                    (modelRate, modelResolution, false);
-            }
-            model->setScaleUnits(m_descriptors[n]->unit.c_str());
-            out = model;
-
-        } else if (isNoteModel && flexi) {
-
-            FlexiNoteModel *model;
-            if (haveExtents) {
-                model = new FlexiNoteModel
-                    (modelRate, modelResolution, minValue, maxValue, false);
-            } else {
-                model = new FlexiNoteModel
                     (modelRate, modelResolution, false);
             }
             model->setScaleUnits(m_descriptors[n]->unit.c_str());
             out = model;
 

 
         SparseOneDimensionalModel *model =
             getConformingOutput<SparseOneDimensionalModel>(n);
         if (!model) return;
 
-        model->addPoint(SparseOneDimensionalModel::Point
-                       (frame, feature.label.c_str()));
+        model->add(Event(frame, feature.label.c_str()));
         
     } else if (isOutput<SparseTimeValueModel>(n)) {
 
         SparseTimeValueModel *model =
             getConformingOutput<SparseTimeValueModel>(n);

                 if (!targetModel) targetModel = model;
 //                std::cerr << "adding point to model " << targetModel
 //                          << " for output " << n << " bin " << i << std::endl;
             }
 
-            targetModel->addPoint
-                (SparseTimeValueModel::Point(frame, value, label));
-        }
-
-    } else if (isOutput<FlexiNoteModel>(n) || isOutput<NoteModel>(n) || isOutput<RegionModel>(n)) { //GF: Added Note Model
+            targetModel->add(Event(frame, value, label));
+        }
+
+    } else if (isOutput<NoteModel>(n) || isOutput<RegionModel>(n)) {
 
         int index = 0;
 
         float value = 0.0;
         if ((int)feature.values.size() > index) {

             if (in_range_for(feature.values, index)) {
                 duration = lrintf(feature.values[index++]);
             }
         }
 
-        if (isOutput<FlexiNoteModel>(n)) { // GF: added for flexi note model
+        if (isOutput<NoteModel>(n)) {
 
             float velocity = 100;
             if ((int)feature.values.size() > index) {
                 velocity = feature.values[index++];
             }
             if (velocity < 0) velocity = 127;
             if (velocity > 127) velocity = 127;
 
-            FlexiNoteModel *model = getConformingOutput<FlexiNoteModel>(n);
-            if (!model) return;
-            model->addPoint(FlexiNoteModel::Point(frame,
-                                                  value, // value is pitch
-                                                  duration,
-                                                  velocity / 127.f,
-                                                  feature.label.c_str()));
-                        // GF: end -- added for flexi note model
-        } else  if (isOutput<NoteModel>(n)) {
-
-            float velocity = 100;
-            if ((int)feature.values.size() > index) {
-                velocity = feature.values[index++];
-            }
-            if (velocity < 0) velocity = 127;
-            if (velocity > 127) velocity = 127;
-
             NoteModel *model = getConformingOutput<NoteModel>(n);
             if (!model) return;
-            model->addPoint(NoteModel::Point(frame, value, // value is pitch
-                                             duration,
-                                             velocity / 127.f,
-                                             feature.label.c_str()));
+            model->add(Event(frame, value, // value is pitch
+                             duration,
+                             velocity / 127.f,
+                             feature.label.c_str()));
         } else {
 
             RegionModel *model = getConformingOutput<RegionModel>(n);
             if (!model) return;
 

                     QString label = feature.label.c_str();
                     if (feature.values.size() > 1) {
                         label = QString("[%1] %2").arg(i+1).arg(label);
                     }
 
-                    model->addPoint(RegionModel::Point(frame,
-                                                       value,
-                                                       duration,
-                                                       label));
+                    model->add(Event(frame,
+                                     value,
+                                     duration,
+                                     label));
                 }
             } else {
             
-                model->addPoint(RegionModel::Point(frame,
-                                                   value,
-                                                   duration,
-                                                   feature.label.c_str()));
+                model->add(Event(frame,
+                                 value,
+                                 duration,
+                                 feature.label.c_str()));
             }
         }
         
     } else if (isOutput<EditableDenseThreeDimensionalModel>(n)) {
         

         NoteModel *model = getConformingOutput<NoteModel>(n);
         if (!model) return;
         if (model->isAbandoning()) abandon();
         model->setCompletion(completion, true);
         
-    } else if (isOutput<FlexiNoteModel>(n)) {
-
-        FlexiNoteModel *model = getConformingOutput<FlexiNoteModel>(n);
-        if (!model) return;
-        if (model->isAbandoning()) abandon();
-        model->setCompletion(completion, true);
-
     } else if (isOutput<RegionModel>(n)) {
 
         RegionModel *model = getConformingOutput<RegionModel>(n);
         if (!model) return;
         if (model->isAbandoning()) abandon();