comparison src/Matcher.cpp @ 188:487261a22b18 re-minimise

distance_t * diagonalWeight might not fit in distance_t; use pathcost_t for it. Also remove C-style casts.

         } else if (dir == AdvanceOther) {
             dir = AdvanceThis;
         }
         m_otherMatcher->setPathCost(j, i, dir, pathCost);
     }
-
 }
 
 void
 Matcher::size()
 {

     m_first[m_frameCount] = index;
     m_last[m_frameCount] = stop;
 
     for ( ; index < stop; index++) {
 
-        distance_t distance = (distance_t) m_metric.calcDistance
+        distance_t distance = m_metric.calcDistance
             (m_features[frameIndex],
              m_otherMatcher->m_features[index % m_blockSize]);
 
-        distance_t diagDistance = distance_t(distance * m_params.diagonalWeight);
+        pathcost_t straightIncrement(distance);
+        pathcost_t diagIncrement = pathcost_t(distance * m_params.diagonalWeight);
 
         if ((m_frameCount == 0) && (index == 0)) { // first element
 
             updateValue(0, 0, AdvanceNone,
                         0,

                             min2, distance);
                 
             } else {
 
                 pathcost_t min1 = getPathCost(m_frameCount - 1, index - 1);
-                if (min1 + diagDistance <= min2 + distance) {
+                if (min1 + diagIncrement <= min2 + straightIncrement) {
                     updateValue(m_frameCount, index, AdvanceBoth,
                                 min1, distance);
                 } else {
                     updateValue(m_frameCount, index, AdvanceThis,
                                 min2, distance);

 
             pathcost_t min1 = getPathCost(m_frameCount, index - 1);
             pathcost_t min2 = getPathCost(m_frameCount - 1, index);
             pathcost_t min3 = getPathCost(m_frameCount - 1, index - 1);
 
-            pathcost_t cost1 = min1 + distance;
-            pathcost_t cost2 = min2 + distance;
-            pathcost_t cost3 = min3 + diagDistance;
+            pathcost_t cost1 = min1 + straightIncrement;
+            pathcost_t cost2 = min2 + straightIncrement;
+            pathcost_t cost3 = min3 + diagIncrement;
 
             // Choosing is easy if there is a strict cheapest of the
             // three. If two or more share the lowest cost, we choose
             // in order of preference: cost3 (AdvanceBoth), cost2
             // (AdvanceThis), cost1 (AdvanceOther) if we are the first

 }
 
 void
 Matcher::updateValue(int i, int j, advance_t dir, pathcost_t value, distance_t distance)
 {
-    distance_t weighted = distance;
+    pathcost_t increment = distance;
     if (dir == AdvanceBoth) {
-        weighted = distance_t(weighted * m_params.diagonalWeight);
+        increment = pathcost_t(increment * m_params.diagonalWeight);
+    }
+
+    pathcost_t newValue = value + increment;
+    if (MaxPathCost - increment < value) {
+        cerr << "ERROR: Path cost overflow at i=" << i << ", j=" << j << ": "
+             << value << " + " << increment << " > " << MaxPathCost << endl;
+        newValue = MaxPathCost;
     }
     
     if (m_firstPM) {
 
         setDistance(i, j, distance);
-        setPathCost(i, j, dir, value + weighted);
+        setPathCost(i, j, dir, newValue);
 
     } else {
 
         if (dir == AdvanceThis) dir = AdvanceOther;
         else if (dir == AdvanceOther) dir = AdvanceThis;
 
         int idx = i - m_otherMatcher->m_first[j];
         
-        if (idx == (int)m_otherMatcher->m_distance[j].size()) {
+        if (idx < 0 || size_t(idx) == 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.
             cerr << "Emergency resize: " << idx << " -> " << idx * 2 << endl;
             m_otherMatcher->m_bestPathCost[j].resize(idx * 2, InvalidPathCost);
             m_otherMatcher->m_distance[j].resize(idx * 2, InvalidDistance);
             m_otherMatcher->m_advance[j].resize(idx * 2, AdvanceNone);
         }
 
         m_otherMatcher->setDistance(j, i, distance);
-        m_otherMatcher->setPathCost(j, i, dir, value + weighted);
+        m_otherMatcher->setPathCost(j, i, dir, newValue);
     }
 }
 
 advance_t
 Matcher::getAdvance(int i, int j)