comparison data/model/AlignmentModel.cpp @ 376:ab24af1271e9

* just some debug stuff

 
 #include "AlignmentModel.h"
 
 #include "SparseTimeValueModel.h"
 
+//#define DEBUG_ALIGNMENT_MODEL 1
+
 AlignmentModel::AlignmentModel(Model *reference,
                                Model *aligned,
                                Model *inputModel,
 			       SparseTimeValueModel *path) :
     m_reference(reference),

 }
 
 size_t
 AlignmentModel::toReference(size_t frame) const
 {
-//    std::cerr << "AlignmentModel::toReference(" << frame << ")" << std::endl;
+#ifdef DEBUG_ALIGNMENT_MODEL
+    std::cerr << "AlignmentModel::toReference(" << frame << ")" << std::endl;
+#endif
     if (!m_path) {
         if (!m_rawPath) return frame;
         constructPath();
     }
     return align(m_path, frame);
 }
 
 size_t
 AlignmentModel::fromReference(size_t frame) const
 {
-//    std::cerr << "AlignmentModel::fromReference(" << frame << ")" << std::endl;
+#ifdef DEBUG_ALIGNMENT_MODEL
+    std::cerr << "AlignmentModel::fromReference(" << frame << ")" << std::endl;
+#endif
     if (!m_reversePath) {
         if (!m_rawPath) return frame;
         constructReversePath();
     }
     return align(m_reversePath, frame);

     if (!m_pathComplete) {
 
         int completion = 0;
         m_rawPath->isReady(&completion);
 
-//        std::cerr << "AlignmentModel::pathCompletionChanged: completion = "
-//                  << completion << std::endl;
+#ifdef DEBUG_ALIGNMENT_MODEL
+        std::cerr << "AlignmentModel::pathCompletionChanged: completion = "
+                  << completion << std::endl;
+#endif
 
         m_pathComplete = (completion == 100);
 
         if (m_pathComplete) {
 

         float value = i->value;
         long rframe = lrintf(value * m_aligned->getSampleRate());
         m_path->addPoint(PathPoint(frame, rframe));
     }
 
-//    std::cerr << "AlignmentModel::constructPath: " << m_path->getPointCount() << " points, at least " << (2 * m_path->getPointCount() * (3 * sizeof(void *) + sizeof(int) + sizeof(PathPoint))) << " bytes" << std::endl;
+#ifdef DEBUG_ALIGNMENT_MODEL
+    std::cerr << "AlignmentModel::constructPath: " << m_path->getPointCount() << " points, at least " << (2 * m_path->getPointCount() * (3 * sizeof(void *) + sizeof(int) + sizeof(PathPoint))) << " bytes" << std::endl;
+#endif
 }
 
 void
 AlignmentModel::constructReversePath() const
 {

         float value = i->value;
         long rframe = lrintf(value * m_aligned->getSampleRate());
         m_reversePath->addPoint(PathPoint(rframe, frame));
     }
 
-//    std::cerr << "AlignmentModel::constructReversePath: " << m_reversePath->getPointCount() << " points, at least " << (2 * m_reversePath->getPointCount() * (3 * sizeof(void *) + sizeof(int) + sizeof(PathPoint))) << " bytes" << std::endl;
+#ifdef DEBUG_ALIGNMENT_MODEL
+    std::cerr << "AlignmentModel::constructReversePath: " << m_reversePath->getPointCount() << " points, at least " << (2 * m_reversePath->getPointCount() * (3 * sizeof(void *) + sizeof(int) + sizeof(PathPoint))) << " bytes" << std::endl;
+#endif
 }
 
 size_t
 AlignmentModel::align(PathModel *path, size_t frame) const
 {

     // increasing.
 
     const PathModel::PointList &points = path->getPoints();
 
     if (points.empty()) {
-//        std::cerr << "AlignmentModel::align: No points" << std::endl;
+        std::cerr << "AlignmentModel::align: No points" << std::endl;
         return frame;
     }        
 
+#ifdef DEBUG_ALIGNMENT_MODEL
+    std::cerr << "AlignmentModel::align: frame " << frame << " requested" << std::endl;
+#endif
+
     PathModel::Point point(frame);
     PathModel::PointList::const_iterator i = points.lower_bound(point);
-    if (i == points.end()) --i;
+    if (i == points.end()) {
+#ifdef DEBUG_ALIGNMENT_MODEL
+        std::cerr << "Note: i == points.end()" << std::endl;
+#endif
+        --i;
+    }
     while (i != points.begin() && i->frame > long(frame)) --i;
 
     long foundFrame = i->frame;
     long foundMapFrame = i->mapframe;
 
     long followingFrame = foundFrame;
     long followingMapFrame = foundMapFrame;
 
     if (++i != points.end()) {
+#ifdef DEBUG_ALIGNMENT_MODEL
+        std::cerr << "another point available" << std::endl;
+#endif
         followingFrame = i->frame;
         followingMapFrame = i->mapframe;
-    }
+    } else {
+#ifdef DEBUG_ALIGNMENT_MODEL
+        std::cerr << "no other point available" << std::endl;
+#endif
+    }        
 
     if (foundMapFrame < 0) return 0;
 
     size_t resultFrame = foundMapFrame;
 

             float(frame - foundFrame) /
             float(followingFrame - foundFrame);
         resultFrame += lrintf((followingMapFrame - foundMapFrame) * interp);
     }
 
-//    std::cerr << "AlignmentModel::align: resultFrame = " << resultFrame << std::endl;
+#ifdef DEBUG_ALIGNMENT_MODEL
+    std::cerr << "AlignmentModel::align: resultFrame = " << resultFrame << std::endl;
+#endif
 
     return resultFrame;
 }