comparison src/Finder.cpp @ 181:8e7f96432570 types

Introduce (though don't use properly) types header; get to build

             bestRow = row;
         }
     }
 }
 
-Matcher::Advance
+advance_t
 Finder::getExpandDirection()
 {
     return getExpandDirection(m_m->getFrameCount() - 1,
                               m_m->getOtherFrameCount() - 1);
 }
 
-Matcher::Advance
+advance_t
 Finder::getExpandDirection(int row, int col)
 {
     // To determine which direction to expand the search area in, we
     // look at the path costs along the leading edges of the search
     // area (the final row and column within the area). We find the

 
 //    cerr << "at [" << row << "," << col << "] (cost " << m_m->getPathCost(row, col) << ") blocksize = " << m_m->getBlockSize() << " best is [" << bestRow << "," << bestCol << "] (cost " << bestCost << ")" << endl;
     
     if (bestRow == row) {
         if (bestCol == col) {
-            return Matcher::AdvanceBoth;
+            return AdvanceBoth;
         } else {
-            return Matcher::AdvanceThis;
+            return AdvanceThis;
         }
     } else if (bestCol == col) {
-        return Matcher::AdvanceOther;
+        return AdvanceOther;
     } else {
-        return Matcher::AdvanceNone;
+        return AdvanceNone;
     }
 }
 
 void
 Finder::recalculatePathCostMatrix(int r1, int c1, int r2, int c2) 

         int rowStop = min(c2 + 1, colRange.second);
         
         for (int c = rowStart; c < rowStop; c++) {
 
             float newCost = m_m->getDistance(r, c);
-            Matcher::Advance dir = Matcher::AdvanceNone;
+            advance_t dir = AdvanceNone;
 
             if (r > r1) {	// not first row
                 double min = -1;
                 if ((c > prevRowStart) && (c <= prevRowStop)) {
                     // diagonal from (r-1,c-1)
                     min = m_m->getPathCost(r-1, c-1) + newCost * diagonalWeight;
-                    dir = Matcher::AdvanceBoth;
+                    dir = AdvanceBoth;
                 }
                 if ((c >= prevRowStart) && (c < prevRowStop)) {
                     // vertical from (r-1,c)
                     double cost = m_m->getPathCost(r-1, c) + newCost;
                     if ((min < 0) || (cost < min)) {
                         min = cost;
-                        dir = Matcher::AdvanceThis;
+                        dir = AdvanceThis;
                     }
                 }
                 if (c > rowStart) {
                     // horizontal from (r,c-1)
                     double cost = m_m->getPathCost(r, c-1) + newCost;
                     if ((min < 0) || (cost < min)) {
                         min = cost;
-                        dir = Matcher::AdvanceOther;
+                        dir = AdvanceOther;
                     }
                 }
                 
                 m_m->setPathCost(r, c, dir, min);
 
             } else if (c > rowStart) {	// first row
                 // horizontal from (r,c-1)
-                m_m->setPathCost(r, c, Matcher::AdvanceOther,
+                m_m->setPathCost(r, c, AdvanceOther,
                                    m_m->getPathCost(r, c-1) + newCost);
             }
         }
 
         prevRowStart = rowStart;

         
         for (int c = rowStart; c < rowStop; c++) {
 
             float newCost = m_m->getDistance(r, c);
             double updateTo = -1.0;
-            Matcher::Advance dir = Matcher::AdvanceNone;
+            advance_t dir = AdvanceNone;
 
             if (r > r1) { // not first row
                 double min = -1;
                 if ((c > prevRowStart) && (c <= prevRowStop)) {
                     // diagonal from (r-1,c-1)
                     min = m_m->getPathCost(r-1, c-1) + newCost * diagonalWeight;
                     err.prevCost = m_m->getPathCost(r-1, c-1);
                     err.distance = newCost * diagonalWeight;
-                    dir = Matcher::AdvanceBoth;
+                    dir = AdvanceBoth;
                 }
                 if ((c >= prevRowStart) && (c < prevRowStop)) {
                     // vertical from (r-1,c)
                     double cost = m_m->getPathCost(r-1, c) + newCost;
                     if ((min < 0) || (cost < min)) {
                         min = cost;
                         err.prevCost = m_m->getPathCost(r-1, c);
                         err.distance = newCost;
-                        dir = Matcher::AdvanceThis;
+                        dir = AdvanceThis;
                     }
                 }
                 if (c > rowStart) {
                     // horizontal from (r,c-1)
                     double cost = m_m->getPathCost(r, c-1) + newCost;
                     if ((min < 0) || (cost < min)) {
                         min = cost;
                         err.prevCost = m_m->getPathCost(r, c-1);
                         err.distance = newCost;
-                        dir = Matcher::AdvanceOther;
+                        dir = AdvanceOther;
                     }
                 }
 
                 updateTo = min;
 

                 if (c > rowStart) {
                     // horizontal from (r,c-1)
                     updateTo = m_m->getPathCost(r, c-1) + newCost;
                     err.prevCost = m_m->getPathCost(r, c-1);
                     err.distance = newCost;
-                    dir = Matcher::AdvanceOther;
+                    dir = AdvanceOther;
                 }
             }
 
-            if (dir != Matcher::AdvanceNone) {
+            if (dir != AdvanceNone) {
                 if (m_m->getAdvance(r, c) != dir) {
                     err.type = ErrorPosition::WrongAdvance;
                     err.r = r;
                     err.c = c;
                     err.costWas = m_m->getPathCost(r, c);

         
         pathx.push_back(x);
         pathy.push_back(y);
 
         switch (m_m->getAdvance(y, x)) {
-        case Matcher::AdvanceThis:
+        case AdvanceThis:
 //            cerr << ", going down (dist = " << getDistance() << ")" << endl;
             y--;
             break;
-        case Matcher::AdvanceOther:
+        case AdvanceOther:
 //            cerr << ", going left (dist = " << getDistance() << ")" << endl;
             x--;
             break;
-        case Matcher::AdvanceBoth:
+        case AdvanceBoth:
 //            cerr << ", going diag (dist = " << getDistance() << ")" << endl;
             x--;
             y--;
             break;
-        case Matcher::AdvanceNone: // this would indicate a bug, but we wouldn't want to hang
+        case 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;
             if (x > y) {
                 x--;
             } else {
                 y--;