comparison transform/FeatureExtractionModelTransformer.cpp @ 558:1d7ebc05157e

* Some fairly simplistic code to set up layer type properties based on
  RDF data about feature types (both when running transforms and when
  importing features from RDF files).

 #include "data/model/DenseTimeValueModel.h"
 #include "data/model/NoteModel.h"
 #include "data/model/RegionModel.h"
 #include "data/model/FFTModel.h"
 #include "data/model/WaveFileModel.h"
+#include "rdf/PluginRDFDescription.h"
 
 #include "TransformFactory.h"
 
 #include <iostream>
 

             .arg(pluginId)
             .arg(m_transform.getOutput());
 	return;
     }
 
+    createOutputModel();
+}
+
+void
+FeatureExtractionModelTransformer::createOutputModel()
+{
+    DenseTimeValueModel *input = getConformingInput();
+
 //    std::cerr << "FeatureExtractionModelTransformer: output sample type "
 //	      << m_descriptor->sampleType << std::endl;
+
+    PluginRDFDescription description(m_transform.getPluginIdentifier());
+    QString outputId = m_transform.getOutput();
 
     int binCount = 1;
     float minValue = 0.0, maxValue = 0.0;
     bool haveExtents = false;
     

         // Anything with no value and no duration is an instant
 
 	m_output = new SparseOneDimensionalModel(modelRate, modelResolution,
 						 false);
 
+        QString outputEventTypeURI = description.getOutputEventTypeURI(outputId);
+        m_output->setRDFTypeURI(outputEventTypeURI);
+
     } else if ((preDurationPlugin && binCount > 1 &&
                 (m_descriptor->sampleType ==
                  Vamp::Plugin::OutputDescriptor::VariableSampleRate)) ||
                (!preDurationPlugin && m_descriptor->hasDuration)) {
 

             }
             model->setScaleUnits(m_descriptor->unit.c_str());
             m_output = model;
         }
 
+        QString outputEventTypeURI = description.getOutputEventTypeURI(outputId);
+        m_output->setRDFTypeURI(outputEventTypeURI);
+
     } else if (binCount == 1 ||
                (m_descriptor->sampleType == 
                 Vamp::Plugin::OutputDescriptor::VariableSampleRate)) {
 
         // Anything that is not a 1D, note, or interval model and that

                 (modelRate, modelResolution, minValue, maxValue, false);
         } else {
             model = new SparseTimeValueModel
                 (modelRate, modelResolution, false);
         }
+
+        Vamp::Plugin::OutputList outputs = m_plugin->getOutputDescriptors();
         model->setScaleUnits(outputs[m_outputFeatureNo].unit.c_str());
 
         m_output = model;
+
+        QString outputEventTypeURI = description.getOutputEventTypeURI(outputId);
+        m_output->setRDFTypeURI(outputEventTypeURI);
 
     } else {
 
         // Anything that is not a 1D, note, or interval model and that
         // has a fixed sample rate and more than one value per result

 	    }
 	    model->setBinNames(names);
 	}
         
         m_output = model;
+
+        QString outputSignalTypeURI = description.getOutputSignalTypeURI(outputId);
+        m_output->setRDFTypeURI(outputSignalTypeURI);
     }
 
     if (m_output) m_output->setSourceModel(input);
 }