comparison vamp-sdk/hostext/PluginSummarisingAdapter.cpp @ 194:27cfae2a4155

* Make summarising adapter debug optional
* Tidy up template generator output a bit
* Clarify an error message

 
 #include <map>
 #include <cmath>
 #include <climits>
 
+//#define DEBUG_PLUGIN_SUMMARISING_ADAPTER 1
+
 namespace Vamp {
 
 namespace HostExt {
 
 class PluginSummarisingAdapter::Impl

 
 void
 PluginSummarisingAdapter::Impl::setSummarySegmentBoundaries(const SegmentBoundaries &b)
 {
     m_boundaries = b;
+#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
     std::cerr << "PluginSummarisingAdapter::setSummarySegmentBoundaries: boundaries are:" << std::endl;
     for (SegmentBoundaries::const_iterator i = m_boundaries.begin();
          i != m_boundaries.end(); ++i) {
         std::cerr << *i << "  ";
     }
     std::cerr << std::endl;
+#endif
 }
 
 Plugin::FeatureList
 PluginSummarisingAdapter::Impl::getSummaryForOutput(int output,
                                                     SummaryType type,

 // need a separate phase to split the accumulator up into segments).
 // If features spanning a boundary should be counted only in the first
 // segment, with their full duration, then we should store them in a
 // single accumulator and distribute into segments only on reduce.
 
+#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
     std::cerr << "output " << output << ": timestamp " << timestamp << ", prev timestamp " << m_prevTimestamps[output] << ", final " << final << std::endl;
+#endif
 
     // At each process step, accumulate() is called once for each
     // feature on each output within that process's returned feature
     // list, and with the timestamp passed in being that of the start
     // of the process block.

         // will have to calculate the duration from the previous and
         // current timestamps.
 
         if (m_prevDurations[output] != INVALID_DURATION) {
             prevDuration = m_prevDurations[output];
+#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
             std::cerr << "Previous duration from previous feature: " << prevDuration << std::endl;
+#endif
         } else {
             prevDuration = timestamp - m_prevTimestamps[output];
+#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
             std::cerr << "Previous duration from diff: " << timestamp << " - "
                       << m_prevTimestamps[output] << std::endl;
+#endif
         }
 
+#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
         std::cerr << "output " << output << ": ";
-
         std::cerr << "Pushing previous duration as " << prevDuration << std::endl;
+#endif
         
         m_accumulators[output].results
             [m_accumulators[output].results.size() - 1]
             .duration = prevDuration;
     }

 
         if (acount == 0) continue;
 
         RealTime prevTimestamp = i->second;
 
+#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
         std::cerr << "output " << output << ": ";
+#endif
 
         if (m_prevDurations.find(output) != m_prevDurations.end() &&
             m_prevDurations[output] != INVALID_DURATION) {
 
+#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
             std::cerr << "Pushing final duration from feature as " << m_prevDurations[output] << std::endl;
+#endif
 
             m_accumulators[output].results[acount - 1].duration =
                 m_prevDurations[output];
 
         } else {
 
+#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
             std::cerr << "Pushing final duration from diff as " << m_lastTimestamp << " - " << m_prevTimestamps[output] << std::endl;
+#endif
 
             m_accumulators[output].results[acount - 1].duration =
                 m_lastTimestamp - m_prevTimestamps[output];
         }
         
+#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
         std::cerr << "so duration for result no " << acount-1 << " is "
                   << m_accumulators[output].results[acount-1].duration
                   << std::endl;
+#endif
     }
 }
 
 void
 PluginSummarisingAdapter::Impl::findSegmentBounds(RealTime t,
                                                   RealTime &start,
                                                   RealTime &end)
 {
+#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
     std::cerr << "findSegmentBounds: t = " << t <<  std::endl;
+#endif
 
     SegmentBoundaries::const_iterator i = std::upper_bound
         (m_boundaries.begin(), m_boundaries.end(), t);
 
     start = RealTime::zeroTime;

     }
 
     if (i != m_boundaries.begin()) {
         start = *--i;
     }
-    
+
+#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER    
     std::cerr << "findSegmentBounds: " << t << " is in segment " << start << " -> " << end << std::endl;
+#endif
 }
 
 void
 PluginSummarisingAdapter::Impl::segment()
 {

          i != m_accumulators.end(); ++i) {
 
         int output = i->first;
         OutputAccumulator &source = i->second;
 
+#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
         std::cerr << "segment: total results for output " << output << " = "
                   << source.results.size() << std::endl;
+#endif
 
         //!!! This is basically nonsense if the results have no values
         //!!! (i.e. their times and counts are the only things of
         //!!! interest) but perhaps it's the user's problem if they
         //!!! ask for segmentation in that case

             // We need to dispose it into segments appropriately
 
             RealTime resultStart = source.results[n].time;
             RealTime resultEnd = resultStart + source.results[n].duration;
 
+#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
             std::cerr << "output: " << output << ", result start = " << resultStart << ", end = " << resultEnd << std::endl;
+#endif
 
             RealTime segmentStart = RealTime::zeroTime;
             RealTime segmentEnd = resultEnd - RealTime(1, 0);
             
             while (segmentEnd < resultEnd) {

                 Result chunk;
                 chunk.time = chunkStart;
                 chunk.duration = chunkEnd - chunkStart;
                 chunk.values = source.results[n].values;
 
+#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
                 std::cerr << "chunk for segment " << segmentStart << ": from " << chunk.time << ", duration " << chunk.duration << std::endl;
+#endif
 
                 m_segmentedAccumulators[output][segmentStart].results
                     .push_back(chunk);
 
                 resultStart = chunkEnd;

             RealTime segmentStart = j->first;
             OutputAccumulator &accumulator = j->second;
 
             int sz = accumulator.results.size();
 
+#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
             std::cerr << "reduce: segment starting at " << segmentStart
                       << " on output " << output << " has " << sz << " result(s)" << std::endl;
+#endif
 
             double totalDuration = 0.0;
             //!!! is this right?
             if (sz > 0) {
+#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
                 std::cerr << "last time = " << accumulator.results[sz-1].time 
                           << ", duration = " << accumulator.results[sz-1].duration
                           << std::endl;
+#endif
                 totalDuration = toSec((accumulator.results[sz-1].time +
                                        accumulator.results[sz-1].duration) -
                                       segmentStart);
             }
 

                 std::sort(valvec.begin(), valvec.end());
 
                 summary.minimum = valvec[0].value;
                 summary.maximum = valvec[sz-1].value;
 
+#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
                 std::cerr << "total duration = " << totalDuration << std::endl;
-
+#endif
+
+#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
                 std::cerr << "value vector for medians:" << std::endl;
                 for (int k = 0; k < sz; ++k) {
                     std::cerr << "(" << valvec[k].value << "," << valvec[k].duration << ") ";
                 }
                 std::cerr << std::endl;
+#endif
 
                 if (sz % 2 == 1) {
                     summary.median = valvec[sz/2].value;
                 } else {
                     summary.median = (valvec[sz/2].value + valvec[sz/2 + 1].value) / 2;

                         summary.median_c = valvec[k].value;
                         break;
                     }
                 }
 
+#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
                 std::cerr << "median_c = " << summary.median_c << std::endl;
                 std::cerr << "median = " << summary.median << std::endl;
+#endif
                 
                 std::map<float, int> distribution;
 
                 for (int k = 0; k < sz; ++k) {
                     summary.sum += accumulator.results[k].values[bin];

                         double value = accumulator.results[k].values[bin]
                             * toSec(accumulator.results[k].duration);
                         sum_c += value;
                     }
 
+#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
                     std::cerr << "mean_c = " << sum_c << " / " << totalDuration << " = "
                               << sum_c / totalDuration << " (sz = " << sz << ")" << std::endl;
+#endif
                 
                     summary.mean_c = sum_c / totalDuration;
 
                     for (int k = 0; k < sz; ++k) {
                         double value = accumulator.results[k].values[bin]

                     summary.variance_c /= summary.count;
                 }
 
                 float mean = summary.sum / summary.count;
 
+#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
                 std::cerr << "mean = " << summary.sum << " / " << summary.count << " = "
                           << summary.sum / summary.count << std::endl;
+#endif
 
                 for (int k = 0; k < sz; ++k) {
                     float value = accumulator.results[k].values[bin];
                     summary.variance += (value - mean) * (value - mean);
                 }