changeset 69:696f6e7f2f31 refactors

distYSize no longer needed, and some tidying and checks

--- a/src/DistanceMetric.cpp	Tue Nov 18 10:33:03 2014 +0000
+++ b/src/DistanceMetric.cpp	Tue Nov 18 16:35:15 2014 +0000
@@ -32,6 +32,8 @@
     assert(int(f2.size()) == featureSize);
     
     for (int i = 0; i < featureSize; i++) {
+        assert(f1[i] >= 0);
+        assert(f2[i] >= 0);
         d += fabs(f1[i] - f2[i]);
         sum += f1[i] + f2[i];
     }

--- a/src/Finder.cpp	Tue Nov 18 10:33:03 2014 +0000
+++ b/src/Finder.cpp	Tue Nov 18 16:35:15 2014 +0000
@@ -51,11 +51,14 @@
 bool
 Finder::find(int i1, int i2)
 {
-    if (i1 >= 0) {
+    if ((i1 >= 0) && (i1 < (int)pm1->m_first.size()) &&
+        (i2 >= pm1->m_first[i1]) && (i2 < pm1->m_last[i1])) {
         index1 = i1;
         index2 = i2 - pm1->m_first[i1];
+        return true;
+    } else {
+        return false;
     }
-    return (i1 >= 0) && (i2 >= pm1->m_first[i1]) && (i2 < pm1->m_last[i1]);
 } // find()
 
 void
@@ -278,8 +281,15 @@
 int
 Finder::retrievePath(bool smooth, vector<int> &pathx, vector<int> &pathy)
 {
+    pathx.clear();
+    pathy.clear();
+
     int ex = pm2->getFrameCount() - 1;
     int ey = pm1->getFrameCount() - 1;
+
+    if (ex < 0 || ey < 0) {
+        return 0;
+    }
     
     int x = ex;
     int y = ey;
@@ -305,9 +315,6 @@
 
     recalculatePathCostMatrix(0, 0, y, x);
 
-    pathx.clear();
-    pathy.clear();
-
 //    cerr << "start: x = " << x << ", y = " << y << endl;
     
     while (find(y, x) && ((x > 0) || (y > 0))) {
@@ -332,7 +339,7 @@
             y--;
             break;
         case Matcher::AdvanceNone: // this would indicate a bug, but we wouldn't want to hang
-//            cerr << "WARNING: Neither matcher advanced in path backtrack at (" << x << "," << y << ")" << endl;
+            cerr << "WARNING: Neither matcher advanced in path backtrack at (" << x << "," << y << ")" << endl;
             if (x > y) {
                 x--;
             } else {

--- a/src/Matcher.cpp	Tue Nov 18 10:33:03 2014 +0000
+++ b/src/Matcher.cpp	Tue Nov 18 16:35:15 2014 +0000
@@ -86,7 +86,7 @@
     if (m_initialised) return;
 
     m_frames = vector<vector<double> >
-        (m_blockSize, vector<double>(m_featureSize, 0));
+        (m_blockSize, vector<double>(m_featureSize, -1.0));
 
     m_distXSize = m_blockSize * 2;
 
@@ -105,7 +105,6 @@
     m_bestPathCost.resize(m_distXSize, vector<double>(distSize, 0));
     m_distance.resize(m_distXSize, vector<float>(distSize, 0));
     m_advance.resize(m_distXSize, vector<Advance>(distSize, AdvanceNone));
-    m_distYSizes.resize(m_distXSize, distSize);
     m_first.resize(m_distXSize, 0);
     m_last.resize(m_distXSize, 0);
 }
@@ -153,22 +152,30 @@
         // distance[m_frameCount], and then truncate
         // distance[m_frameCount-m_blockSize] to its first len elements.
         // Same for bestPathCost.
-/*
-        std::cerr << "Matcher(" << this << "): moving " << distYSizes[m_frameCount - m_blockSize] << " from " << m_frameCount - m_blockSize << " to "
-                  << m_frameCount << ", allocating " << len << " for "
-                  << m_frameCount - m_blockSize << std::endl;
-*/
-        m_distance[m_frameCount] = m_distance[m_frameCount - m_blockSize];
-        m_distance[m_frameCount - m_blockSize].resize(len, 0);
 
-        m_bestPathCost[m_frameCount] = m_bestPathCost[m_frameCount - m_blockSize];
-        m_bestPathCost[m_frameCount - m_blockSize].resize(len, 0);
+        vector<float> dOld = m_distance[m_frameCount - m_blockSize];
+        vector<float> dNew(len, 0.f);
 
-        m_advance[m_frameCount] = m_advance[m_frameCount - m_blockSize];
-        m_advance[m_frameCount - m_blockSize].resize(len, AdvanceNone);
+        vector<double> bpcOld = m_bestPathCost[m_frameCount - m_blockSize];
+        vector<double> bpcNew(len, 0.0);
+
+        vector<Advance> adOld = m_advance[m_frameCount - m_blockSize];
+        vector<Advance> adNew(len, AdvanceNone);
+
+        for (int i = 0; i < len; ++i) {
+            dNew[i] = dOld[i];
+            bpcNew[i] = bpcOld[i];
+            adNew[i] = adOld[i];
+        }
         
-        m_distYSizes[m_frameCount] = m_distYSizes[m_frameCount - m_blockSize];
-        m_distYSizes[m_frameCount - m_blockSize] = len;
+        m_distance[m_frameCount] = dOld;
+        m_distance[m_frameCount - m_blockSize] = dNew;
+
+        m_bestPathCost[m_frameCount] = bpcOld;
+        m_bestPathCost[m_frameCount - m_blockSize] = bpcNew;
+
+        m_advance[m_frameCount] = adOld;
+        m_advance[m_frameCount - m_blockSize] = adNew;
     }
 
     int stop = m_otherMatcher->m_frameCount;
@@ -272,12 +279,11 @@
 
         int idx = i - m_otherMatcher->m_first[j];
         
-        if (idx == (int)m_otherMatcher->m_distYSizes[j]) {
+        if (idx == (int)m_otherMatcher->m_distance[j].size()) {
             // This should never happen, but if we allow arbitrary
             // pauses in either direction, and arbitrary lengths at
             // end, it is better than a segmentation fault.
             std::cerr << "Emergency resize: " << idx << " -> " << idx * 2 << std::endl;
-            m_otherMatcher->m_distYSizes[j] = idx * 2;
             m_otherMatcher->m_bestPathCost[j].resize(idx * 2, 0);
             m_otherMatcher->m_distance[j].resize(idx * 2, 0);
             m_otherMatcher->m_advance[j].resize(idx * 2, AdvanceNone);

--- a/src/Matcher.h	Tue Nov 18 10:33:03 2014 +0000
+++ b/src/Matcher.h	Tue Nov 18 16:35:15 2014 +0000
@@ -234,10 +234,6 @@
     vector<int> m_first;
     vector<int> m_last;
 
-    /** Height of each column in distance, path cost, and advance
-     * direction matrices. */
-    vector<int> m_distYSizes;
-
     /** Width of distance, path cost, and advance direction matrices
      * and first and last vectors */
     int m_distXSize;