comparison src/Matcher.cpp @ 183:24ddab06aace re-minimise

Toward allowing types to be small again. Doesn't currently build

             cerr << "ERROR: Matcher::getDistance(" << i << ", " << j << "): "
                  << "Location is not in range" << endl;
             throw "Distance not available";
         }
         distance_t dist = m_distance[i][j - m_first[i]];
-        if (dist < 0) {
+        if (dist == InvalidDistance) {
             cerr << "ERROR: Matcher::getDistance(" << i << ", " << j << "): "
                  << "Location is in range, but distance ("
                  << dist << ") is invalid or has not been set" << endl;
             throw "Distance not available";
         }

 
 void
 Matcher::size()
 {
     int distSize = (m_params.maxRunCount + 1) * m_blockSize;
-    m_bestPathCost.resize(m_distXSize, pathcostvec_t(distSize, -1));
-    m_distance.resize(m_distXSize, distancevec_t(distSize, -1));
+    m_bestPathCost.resize(m_distXSize, pathcostvec_t(distSize, InvalidPathCost));
+    m_distance.resize(m_distXSize, distancevec_t(distSize, InvalidDistance));
     m_advance.resize(m_distXSize, advancevec_t(distSize, AdvanceNone));
     m_first.resize(m_distXSize, 0);
     m_last.resize(m_distXSize, 0);
 }
 

         // distance[m_frameCount], and then truncate
         // distance[m_frameCount-m_blockSize] to its first len elements.
         // Same for bestPathCost.
 
         distancevec_t dOld(m_distance[m_frameCount - m_blockSize]);
-        distancevec_t dNew(len, -1.f);
+        distancevec_t dNew(len, InvalidDistance);
 
         pathcostvec_t bpcOld(m_bestPathCost[m_frameCount - m_blockSize]);
-        pathcostvec_t bpcNew(len, -1.0);
+        pathcostvec_t bpcNew(len, InvalidPathCost);
 
         advancevec_t adOld(m_advance[m_frameCount - m_blockSize]);
         advancevec_t adNew(len, AdvanceNone);
 
         for (int i = 0; i < len; ++i) {

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

 void
 Matcher::updateValue(int i, int j, advance_t dir, pathcost_t value, distance_t distance)
 {
     distance_t weighted = distance;
     if (dir == AdvanceBoth) {
-        weighted *= m_params.diagonalWeight;
+        weighted = distance_t(weighted * m_params.diagonalWeight);
     }
     
     if (m_firstPM) {
 
         setDistance(i, j, distance);

         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.
             cerr << "Emergency resize: " << idx << " -> " << idx * 2 << endl;
-            m_otherMatcher->m_bestPathCost[j].resize(idx * 2, -1);
-            m_otherMatcher->m_distance[j].resize(idx * 2, -1);
+            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);