comparison align/TransformDTWAligner.cpp @ 773:699b5b130ea2 pitch-align

Fixes to aligner destruction sequence when re-aligning during alignment; hide debug output behind a flag

         SVCERR << "Align::alignModel: ERROR: Failed to create reference output model (no plugin?)" << endl;
         emit failed(m_toAlign, message);
         return;
     }
 
+#ifdef DEBUG_TRANSFORM_DTW_ALIGNER
     SVCERR << "TransformDTWAligner[" << this << "]: begin(): transform id "
            << m_transform.getIdentifier()
            << " is running on reference model" << endl;
+#endif
 
     message = "";
 
     m_toAlignOutputModel = mtf->transform(m_transform, m_toAlign, message);
     auto toAlignOutputModel = ModelById::get(m_toAlignOutputModel);

         SVCERR << "Align::alignModel: ERROR: Failed to create toAlign output model (no plugin?)" << endl;
         emit failed(m_toAlign, message);
         return;
     }
 
+#ifdef DEBUG_TRANSFORM_DTW_ALIGNER
     SVCERR << "TransformDTWAligner[" << this << "]: begin(): transform id "
            << m_transform.getIdentifier()
            << " is running on toAlign model" << endl;
+#endif
 
     connect(referenceOutputModel.get(), SIGNAL(completionChanged(ModelId)),
             this, SLOT(completionChanged(ModelId)));
     connect(toAlignOutputModel.get(), SIGNAL(completionChanged(ModelId)),
             this, SLOT(completionChanged(ModelId)));

 TransformDTWAligner::completionChanged(ModelId id)
 {
     if (!m_incomplete) {
         return;
     }
-/*
+#ifdef DEBUG_TRANSFORM_DTW_ALIGNER
     SVCERR << "TransformDTWAligner[" << this << "]: completionChanged: "
            << "model " << id << endl;
-*/
+#endif
+    
     auto referenceOutputModel = ModelById::get(m_referenceOutputModel);
     auto toAlignOutputModel = ModelById::get(m_toAlignOutputModel);
     auto alignmentModel = ModelById::getAs<AlignmentModel>(m_alignmentModel);
 
     if (!referenceOutputModel || !toAlignOutputModel || !alignmentModel) {

         } else {
             emit failed(m_toAlign, tr("Alignment of transform outputs failed"));
         }
 
     } else {
-/*
+#ifdef DEBUG_TRANSFORM_DTW_ALIGNER
         SVCERR << "TransformDTWAligner[" << this << "]: completionChanged: "
                << "not ready yet: reference completion " << referenceCompletion
                << ", toAlign completion " << toAlignCompletion << endl;
-*/
+#endif
+        
         int completion = std::min(referenceCompletion,
                                   toAlignCompletion);
         completion = (completion * 94) / 100;
         alignmentModel->setCompletion(completion);
     }

                               sv_samplerate_t sampleRate,
                               sv_frame_t resolution)
 {
     Path path(sampleRate, resolution);
 
+    path.add(PathPoint(0, 0));
+    
     for (int i = 0; in_range_for(alignment, i); ++i) {
 
         // DTW returns "the index into s2 for each element in s1"
         sv_frame_t refFrame = refFrames[i];
 

     }
     for (double v: otherValues) {
         s2.push_back(m_magnitudePreprocessor(v));
     }
 
+#ifdef DEBUG_TRANSFORM_DTW_ALIGNER
     SVCERR << "TransformDTWAligner[" << this << "]: performAlignmentMagnitude: "
            << "Have " << s1.size() << " events from reference, "
            << s2.size() << " from toAlign" << endl;
+#endif
     
     MagnitudeDTW dtw;
     vector<size_t> alignment;
 
     {
+#ifdef DEBUG_TRANSFORM_DTW_ALIGNER
         SVCERR << "TransformDTWAligner[" << this
                << "]: serialising DTW to avoid over-allocation" << endl;
+#endif
         QMutexLocker locker(&m_dtwMutex);
         alignment = dtw.alignSeries(s1, s2);
     }
 
+#ifdef DEBUG_TRANSFORM_DTW_ALIGNER
     SVCERR << "TransformDTWAligner[" << this << "]: performAlignmentMagnitude: "
            << "DTW produced " << alignment.size() << " points:" << endl;
     for (int i = 0; in_range_for(alignment, i) && i < 100; ++i) {
         SVCERR << alignment[i] << " ";
     }
     SVCERR << endl;
+#endif
 
     alignmentModel->setPath(makePath(alignment,
                                      refFrames,
                                      otherFrames,
                                      alignmentModel->getSampleRate(),

         }; 
     
     vector<RiseFallDTW::Value> s1 = preprocess(refValues);
     vector<RiseFallDTW::Value> s2 = preprocess(otherValues);
 
+#ifdef DEBUG_TRANSFORM_DTW_ALIGNER
     SVCERR << "TransformDTWAligner[" << this << "]: performAlignmentRiseFall: "
            << "Have " << s1.size() << " events from reference, "
            << s2.size() << " from toAlign" << endl;
 
     SVCERR << "Reference:" << endl;

     SVCERR << "toAlign:" << endl;
     for (int i = 0; in_range_for(s2, i) && i < 100; ++i) {
         SVCERR << s2[i] << " ";
     }
     SVCERR << endl;
-
+#endif
+    
     RiseFallDTW dtw;
     vector<size_t> alignment;
 
     {
+#ifdef DEBUG_TRANSFORM_DTW_ALIGNER
         SVCERR << "TransformDTWAligner[" << this
                << "]: serialising DTW to avoid over-allocation" << endl;
+#endif
         QMutexLocker locker(&m_dtwMutex);
         alignment = dtw.alignSeries(s1, s2);
     }
 
+#ifdef DEBUG_TRANSFORM_DTW_ALIGNER
     SVCERR << "TransformDTWAligner[" << this << "]: performAlignmentRiseFall: "
            << "DTW produced " << alignment.size() << " points:" << endl;
     for (int i = 0; i < alignment.size() && i < 100; ++i) {
         SVCERR << alignment[i] << " ";
     }
     SVCERR << endl;
+#endif
 
     alignmentModel->setPath(makePath(alignment,
                                      refFrames,
                                      otherFrames,
                                      alignmentModel->getSampleRate(),
                                      resolution));
 
     alignmentModel->setCompletion(100);
 
-    SVCERR << "TransformDTWAligner[" << this << "]: performAlignmentRiseFall: Done"
-           << endl;
+    SVCERR << "TransformDTWAligner[" << this
+           << "]: performAlignmentRiseFall: Done" << endl;
 
     m_incomplete = false;
     return true;
 }