comparison rdf/RDFImporter.cpp @ 616:3a61a4df6d53

* RDF importer: Features that are on different timeline URIs should go
  into separate models (_not_ just on separate signal URIs as there may
  not be any meaningful signal URIs)
* FileSource: if a file is not found, try again assuming its name is
  encoded (not just in tolerant mode)

     std::vector<Model *> models;
 
     getDataModelsAudio(models, reporter);
 
     if (m_sampleRate == 0) {
-        std::cerr << "RDFImporter::getDataModels: invalid sample rate from audio" << std::endl;
+        m_errorString = QString("Invalid audio data model (is audio file format supported?)");
+        std::cerr << m_errorString.toStdString() << std::endl;
         return models;
     }
 
     QString error;
 

     for (int i = 0; i < results.size(); ++i) {
 
         QString signal = results[i]["signal"].value;
         QString source = results[i]["source"].value;
 
+        std::cerr << "NOTE: Seeking signal source \"" << source.toStdString()
+                  << "\"..." << std::endl;
+
         FileSource *fs = new FileSource(source, reporter);
+        if (fs->isAvailable()) {
+            std::cerr << "NOTE: Source is available: Local filename is \""
+                      << fs->getLocalFilename().toStdString()
+                      << "\"..." << std::endl;
+        }
+            
 #ifdef NO_SV_GUI
         if (!fs->isAvailable()) {
             m_errorString = QString("Signal source \"%1\" is not available").arg(source);
             delete fs;
             continue;
         }
 #else
         if (!fs->isAvailable()) {
+            std::cerr << "NOTE: Signal source \"" << source.toStdString()
+                      << "\" is not available, using file finder..." << std::endl;
             FileFinder *ff = FileFinder::getInstance();
             if (ff) {
                 QString path = ff->find(FileFinder::AudioFile,
                                         fs->getLocation(),
                                         m_uristring);

         " PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>"
         );
 
     QString queryString = prefixes + QString(
 
-        " SELECT ?signal ?timed_thing ?event_type ?value"
+        " SELECT ?signal ?timed_thing ?timeline ?event_type ?value"
         " FROM <%1>"
 
         " WHERE {"
 
         "   ?signal a mo:Signal ."
 
         "   ?signal mo:time ?interval ."
-        "   ?interval tl:onTimeLine ?tl ."
-        "   ?time tl:onTimeLine ?tl ."
+        "   ?interval tl:onTimeLine ?timeline ."
+        "   ?time tl:onTimeLine ?timeline ."
         "   ?timed_thing event:time ?time ."
         "   ?timed_thing a ?event_type ."
 
         "   OPTIONAL {"
         "     ?timed_thing af:feature ?value"
         "   }"
         " }"
 
         ).arg(m_uristring);
+
+    //!!! NB we're using rather old terminology for these things, apparently:
+    // beginsAt -> start
+    // onTimeLine -> timeline
 
     QString timeQueryString = prefixes + QString(
         
         " SELECT ?time FROM <%1> "
         " WHERE { "        

       start, for each of the source+type keys, and then push each
       feature into the relevant model depending on what we find out
       about it.  Then return only non-empty models.
     */
 
-    // Map from signal source to event type to dimensionality to
+    // Map from timeline uri to event type to dimensionality to
     // presence of duration to model ptr.  Whee!
     std::map<QString, std::map<QString, std::map<int, std::map<bool, Model *> > > >
         modelMap;
 
     for (int i = 0; i < results.size(); ++i) {

         if (i % 4 == 0) {
             if (reporter) reporter->setProgress(i/4);
         }
 
         QString source = results[i]["signal"].value;
+        QString timeline = results[i]["timeline"].value;
         QString type = results[i]["event_type"].value;
         QString thinguri = results[i]["timed_thing"].value;
         
         RealTime time;
         RealTime duration;

         if (values.size() == 1) dimensions = 2;
         else if (values.size() > 1) dimensions = 3;
 
         Model *model = 0;
 
-        if (modelMap[source][type][dimensions].find(haveDuration) ==
-            modelMap[source][type][dimensions].end()) {
+        if (modelMap[timeline][type][dimensions].find(haveDuration) ==
+            modelMap[timeline][type][dimensions].end()) {
 
 /*
             std::cerr << "Creating new model: source = " << source.toStdString()
                       << ", type = " << type.toStdString() << ", dimensions = "
                       << dimensions << ", haveDuration = " << haveDuration

                     ).arg(m_uristring).arg(type);
             QString title = SimpleSPARQLQuery::singleResultQuery
                 (s, titleQuery, "title").value;
             if (title != "") model->setObjectName(title);
 
-            modelMap[source][type][dimensions][haveDuration] = model;
+            modelMap[timeline][type][dimensions][haveDuration] = model;
             models.push_back(model);
         }
 
-        model = modelMap[source][type][dimensions][haveDuration];
+        model = modelMap[timeline][type][dimensions][haveDuration];
 
         if (model) {
             long ftime = RealTime::realTime2Frame(time, m_sampleRate);
             long fduration = RealTime::realTime2Frame(duration, m_sampleRate);
             fillModel(model, ftime, fduration, haveDuration, values, label);

         if (value.type == SimpleSPARQLQuery::URIValue) {
             haveAudio = true;
         }
     }
 
+    std::cerr << "NOTE: RDFImporter::identifyDocumentType: haveAudio = "
+              << haveAudio << std::endl;
+
     value =
         SimpleSPARQLQuery::singleResultQuery
         (SimpleSPARQLQuery::QueryFromSingleSource,
          QString
          (" PREFIX event: <http://purl.org/NET/c4dm/event.owl#> "

         
         if (value.type == SimpleSPARQLQuery::URIValue) {
             haveAnnotations = true;
         }
     }
+
+    std::cerr << "NOTE: RDFImporter::identifyDocumentType: haveAnnotations = "
+              << haveAnnotations << std::endl;
 
     SimpleSPARQLQuery::closeSingleSource(url);
 
     if (haveAudio) {
         if (haveAnnotations) {