comparison src/Matcher.cpp @ 182:a67663dc698d types

Start using properly-named types

 void
 Matcher::init()
 {
     if (m_initialised) return;
 
-    m_frames = vector<vector<double> >(m_blockSize);
+    m_features = featureseq_t(m_blockSize);
 
     m_distXSize = m_blockSize * 2;
 
     size();
 

 Matcher::getRowRange(int i)
 {
     return m_otherMatcher->getColRange(i);
 }
 
-float
+distance_t
 Matcher::getDistance(int i, int j)
 {
     if (m_firstPM) {
         if (!isInRange(i, j)) {
             cerr << "ERROR: Matcher::getDistance(" << i << ", " << j << "): "
                  << "Location is not in range" << endl;
             throw "Distance not available";
         }
-        float dist = m_distance[i][j - m_first[i]];
+        distance_t dist = m_distance[i][j - m_first[i]];
         if (dist < 0) {
             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";

         return m_otherMatcher->getDistance(j, i);
     }
 }
                 
 void
-Matcher::setDistance(int i, int j, float distance)
+Matcher::setDistance(int i, int j, distance_t distance)
 {
     if (m_firstPM) {
         if (!isInRange(i, j)) {
             cerr << "ERROR: Matcher::setDistance(" << i << ", " << j << ", "
                  << distance << "): Location is out of range" << endl;

     } else {
         m_otherMatcher->setDistance(j, i, distance);
     }
 }
 
-double
+pathcost_t
 Matcher::getNormalisedPathCost(int i, int j)
 {
     // normalised for path length. 1+ prevents division by zero here
     return getPathCost(i, j) / (1 + i + j);
 }
 
-double
+pathcost_t
 Matcher::getPathCost(int i, int j)
 {
     if (m_firstPM) {
         if (!isAvailable(i, j)) {
             if (!isInRange(i, j)) {

         return m_otherMatcher->getPathCost(j, i);
     }
 }
                 
 void
-Matcher::setPathCost(int i, int j, advance_t dir, double pathCost)
+Matcher::setPathCost(int i, int j, advance_t dir, pathcost_t pathCost)
 {
     if (m_firstPM) {
         if (!isInRange(i, j)) {
             cerr << "ERROR: Matcher::setPathCost(" << i << ", " << j << ", "
                  << dir << ", " << pathCost

 
 void
 Matcher::size()
 {
     int distSize = (m_params.maxRunCount + 1) * m_blockSize;
-    m_bestPathCost.resize(m_distXSize, vector<double>(distSize, -1));
-    m_distance.resize(m_distXSize, vector<float>(distSize, -1));
-    m_advance.resize(m_distXSize, vector<advance_t>(distSize, AdvanceNone));
+    m_bestPathCost.resize(m_distXSize, pathcostvec_t(distSize, -1));
+    m_distance.resize(m_distXSize, distancevec_t(distSize, -1));
+    m_advance.resize(m_distXSize, advancevec_t(distSize, AdvanceNone));
     m_first.resize(m_distXSize, 0);
     m_last.resize(m_distXSize, 0);
 }
 
 void
-Matcher::consumeFeatureVector(vector<double> feature)
+Matcher::consumeFeatureVector(const feature_t &feature)
 {
     if (!m_initialised) init();
     int frameIndex = m_frameCount % m_blockSize; 
-    m_frames[frameIndex] = feature;
+    m_features[frameIndex] = feature;
     calcAdvance();
 }
 
 void
 Matcher::calcAdvance()

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

     m_first[m_frameCount] = index;
     m_last[m_frameCount] = stop;
 
     for ( ; index < stop; index++) {
 
-        float distance = (float) m_metric.calcDistance
-            (m_frames[frameIndex],
-             m_otherMatcher->m_frames[index % m_blockSize]);
-
-        float diagDistance = distance * m_params.diagonalWeight;
+        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;
 
         if ((m_frameCount == 0) && (index == 0)) { // first element
 
             updateValue(0, 0, AdvanceNone,
                         0,

             
             // missing value(s) due to cutoff
             //  - no previous value in current row (resp. column)
             //  - no diagonal value if prev. dir. == curr. dirn
             
-            double min2 = getPathCost(m_frameCount - 1, index);
+            pathcost_t min2 = getPathCost(m_frameCount - 1, index);
 
 //            cerr << "NOTE: missing value at i = " << m_frameCount << ", j = "
 //                 << index << " (first = " << m_firstPM << ")" << endl;
                 
             //	if ((m_firstPM && (first[m_frameCount - 1] == index)) ||

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

                 }
             }
 
         } else {
 
-            double min1 = getPathCost(m_frameCount, index - 1);
-            double min2 = getPathCost(m_frameCount - 1, index);
-            double min3 = getPathCost(m_frameCount - 1, index - 1);
-
-            double cost1 = min1 + distance;
-            double cost2 = min2 + distance;
-            double cost3 = min3 + diagDistance;
+            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;
 
             // 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

 
     m_otherMatcher->m_runCount = 0;
 }
 
 void
-Matcher::updateValue(int i, int j, advance_t dir, double value, float distance)
-{
-    float weighted = distance;
+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;
     }
     
     if (m_firstPM) {