comparison rdf/RDFImporter.cpp @ 510:af7b6e55895b

* Ensure text models are exported with text properties in RDF, and
  imported back into text models again (instead of time/value models)

 
 #include "data/model/SparseOneDimensionalModel.h"
 #include "data/model/SparseTimeValueModel.h"
 #include "data/model/EditableDenseThreeDimensionalModel.h"
 #include "data/model/NoteModel.h"
+#include "data/model/TextModel.h"
 #include "data/model/RegionModel.h"
 #include "data/model/WaveFileModel.h"
 
 #include "data/fileio/FileSource.h"
 

         "   <%2> rdfs:label ?label . "
         " } "
 
         ).arg(m_uristring);
 
+    QString textQueryString = prefixes + QString(
+        
+        " SELECT ?label FROM <%1> "
+        " WHERE { "
+        "   <%2> af:text ?label . "
+        " } "
+
+        ).arg(m_uristring);
+
     SimpleSPARQLQuery query(s, queryString);
     query.setProgressReporter(reporter);
 
 //    cerr << "Query will be: " << queryString.toStdString() << endl;
 

         RealTime duration;
 
         bool haveTime = false;
         bool haveDuration = false;
 
-        QString label = SimpleSPARQLQuery::singleResultQuery
-            (s, labelQueryString.arg(thinguri), "label").value;
+        QString label = "";
+        bool text = (type.contains("Text") || type.contains("text")); // Ha, ha
+
+        if (text) {
+            label = SimpleSPARQLQuery::singleResultQuery
+                (s, textQueryString.arg(thinguri), "label").value;
+        }
+
+        if (label == "") {
+            label = SimpleSPARQLQuery::singleResultQuery
+                (s, labelQueryString.arg(thinguri), "label").value;
+        }
 
         SimpleSPARQLQuery rangeQuery(s, rangeQueryString.arg(thinguri));
         SimpleSPARQLQuery::ResultList rangeResults = rangeQuery.execute();
         if (!rangeResults.empty()) {
 //                std::cerr << rangeResults.size() << " range results" << std::endl;

             
             if (!haveDuration) {
 
                 if (dimensions == 1) {
 
-//                    std::cerr << "SparseOneDimensionalModel" << std::endl;
-                    model = new SparseOneDimensionalModel(m_sampleRate, 1, false);
+                    if (text) {
+                        
+                        model = new TextModel(m_sampleRate, 1, false);
+
+                    } else {
+
+                        model = new SparseOneDimensionalModel(m_sampleRate, 1, false);
+                    }
 
                 } else if (dimensions == 2) {
 
-//                    std::cerr << "SparseTimeValueModel" << std::endl;
-                    model = new SparseTimeValueModel(m_sampleRate, 1, false);
+                    if (text) {
+
+                        model = new TextModel(m_sampleRate, 1, false);
+
+                    } else {
+
+                        model = new SparseTimeValueModel(m_sampleRate, 1, false);
+                    }
 
                 } else {
 
                     // We don't have a three-dimensional sparse model,
                     // so use a note model.  We do have some logic (in
                     // extractStructure below) for guessing whether
                     // this should after all have been a dense model,
                     // but it's hard to apply it because we don't have
                     // all the necessary timing data yet... hmm
 
-//                    std::cerr << "NoteModel" << std::endl;
                     model = new NoteModel(m_sampleRate, 1, false);
                 }
 
             } else { // haveDuration
 
                 if (dimensions == 1 || dimensions == 2) {
 
                     // If our units are frequency or midi pitch, we
                     // should be using a note model... hm
                     
-//                    std::cerr << "RegionModel" << std::endl;
                     model = new RegionModel(m_sampleRate, 1, false);
 
                 } else {
 
                     // We don't have a three-dimensional sparse model,

                     // extractStructure below) for guessing whether
                     // this should after all have been a dense model,
                     // but it's hard to apply it because we don't have
                     // all the necessary timing data yet... hmm
 
-//                    std::cerr << "NoteModel" << std::endl;
                     model = new NoteModel(m_sampleRate, 1, false);
                 }
             }
 
             if (m_audioModelMap.find(source) != m_audioModelMap.end()) {

     SparseOneDimensionalModel *sodm =
         dynamic_cast<SparseOneDimensionalModel *>(model);
     if (sodm) {
         SparseOneDimensionalModel::Point point(ftime, label);
         sodm->addPoint(point);
+        return;
+    }
+
+    TextModel *tm =
+        dynamic_cast<TextModel *>(model);
+    if (tm) {
+        TextModel::Point point
+            (ftime,
+             values.empty() ? 0.5f : values[0] < 0.f ? 0.f : values[0] > 1.f ? 1.f : values[0], // I was young and feckless once too
+             label);
+        tm->addPoint(point);
         return;
     }
 
     SparseTimeValueModel *stvm =
         dynamic_cast<SparseTimeValueModel *>(model);