Fixed compiler warnings (signed/unsigned comparisons, unused variables)

2025-10-06 07:06:54 +08:00 · 2014-08-28 21:57:10 -04:00
parent 5903e5fb8c
commit 1801733061
19 changed files with 133 additions and 131 deletions
--- a/src/openalpr/alpr_impl.cpp
+++ b/src/openalpr/alpr_impl.cpp
@@ -103,7 +103,7 @@ AlprFullDetails AlprImpl::recognizeFullDetails(cv::Mat img, std::vector<cv::Rect
  response.plateRegions = plateDetector->detect(img, regionsOfInterest);

  // Get the number of threads specified and make sure the value is sane (cannot be greater than CPU cores or less than 1)
-  int numThreads = config->multithreading_cores;
+  uint numThreads = config->multithreading_cores;
  if (numThreads > tthread::thread::hardware_concurrency())
    numThreads = tthread::thread::hardware_concurrency();
  if (numThreads <= 0)
@@ -116,7 +116,7 @@ AlprFullDetails AlprImpl::recognizeFullDetails(cv::Mat img, std::vector<cv::Rect
    
  // Spawn n threads to process all of the candidate regions and recognize
  list<tthread::thread*> threads;
-  for (int i = 0; i < numThreads; i++)
+  for (uint i = 0; i < numThreads; i++)
  {
    tthread::thread * t = new tthread::thread(plateAnalysisThread, (void *) &dispatcher);
    threads.push_back(t);
@@ -139,12 +139,12 @@ AlprFullDetails AlprImpl::recognizeFullDetails(cv::Mat img, std::vector<cv::Rect
  
  if (config->debugGeneral && config->debugShowImages)
  {
-    for (int i = 0; i < response.plateRegions.size(); i++)
+    for (uint i = 0; i < response.plateRegions.size(); i++)
    {
      rectangle(img, response.plateRegions[i].rect, Scalar(0, 0, 255), 2);
    }
    
-    for (int i = 0; i < dispatcher.getRecognitionResults().size(); i++)
+    for (uint i = 0; i < dispatcher.getRecognitionResults().size(); i++)
    {
      for (int z = 0; z < 4; z++)
      {
@@ -228,7 +228,7 @@ void plateAnalysisThread(void* arg)
    {
      // Not a valid plate
      // Check if this plate has any children, if so, send them back up to the dispatcher for processing
-      for (int childidx = 0; childidx < plateRegion.children.size(); childidx++)
+      for (uint childidx = 0; childidx < plateRegion.children.size(); childidx++)
      {
 	dispatcher->appendPlate(plateRegion.children[childidx]);
      }
@@ -265,7 +265,7 @@ void plateAnalysisThread(void* arg)
      
      int bestPlateIndex = 0;
      
-      for (int pp = 0; pp < ppResults.size(); pp++)
+      for (uint pp = 0; pp < ppResults.size(); pp++)
      {
 	if (pp >= dispatcher->topN)
 	  break;
@@ -321,7 +321,7 @@ void plateAnalysisThread(void* arg)
 std::vector<cv::Rect> AlprImpl::convertRects(std::vector<AlprRegionOfInterest> regionsOfInterest)
 {
   std::vector<cv::Rect> rectRegions;
-   for (int i = 0; i < regionsOfInterest.size(); i++)
+   for (uint i = 0; i < regionsOfInterest.size(); i++)
   {
     rectRegions.push_back(cv::Rect(regionsOfInterest[i].x, regionsOfInterest[i].y, regionsOfInterest[i].width, regionsOfInterest[i].height));
   }
@@ -341,7 +341,7 @@ string AlprImpl::toJson(const vector< AlprResult > results, double processing_ti
  }
  
  cJSON_AddItemToObject(root, "results", 		jsonResults=cJSON_CreateArray());
-  for (int i = 0; i < results.size(); i++)
+  for (uint i = 0; i < results.size(); i++)
  {
    cJSON *resultObj = createJsonObj( &results[i] );
    cJSON_AddItemToArray(jsonResults, resultObj);
@@ -389,7 +389,7 @@ cJSON* AlprImpl::createJsonObj(const AlprResult* result)
  
  
  cJSON_AddItemToObject(root, "candidates", 		candidates=cJSON_CreateArray());
-  for (int i = 0; i < result->topNPlates.size(); i++)
+  for (uint i = 0; i < result->topNPlates.size(); i++)
  {
    cJSON *candidate_object;
    candidate_object = cJSON_CreateObject();
--- a/src/openalpr/alpr_impl.h
+++ b/src/openalpr/alpr_impl.h
@@ -167,7 +167,7 @@ class PlateDispatcher
    OCR* ocr;
    Config* config;
  
-    int topN;
+    uint topN;
    bool detectRegion;
    std::string defaultRegion;
    
--- a/src/openalpr/binarize_wolf.cpp
+++ b/src/openalpr/binarize_wolf.cpp
@@ -122,7 +122,6 @@ void NiblackSauvolaWolfJolion (Mat im, Mat output, NiblackVersion version,
  int x_lastth = im.cols-wxh-1;
  int y_lastth = im.rows-wyh-1;
  int y_firstth= wyh;
-  int mx, my;

  // Create local statistics and store them in a float matrices
  Mat map_m = Mat::zeros (im.rows, im.cols, CV_32F);
--- a/src/openalpr/characteranalysis.cpp
+++ b/src/openalpr/characteranalysis.cpp
@@ -49,7 +49,7 @@ void CharacterAnalysis::analyze()
  timespec startTime;
  getTime(&startTime);

-  for (int i = 0; i < pipeline_data->thresholds.size(); i++)
+  for (uint i = 0; i < pipeline_data->thresholds.size(); i++)
  {
    vector<vector<Point> > contours;
    vector<Vec4i> hierarchy;
@@ -76,7 +76,7 @@ void CharacterAnalysis::analyze()

  getTime(&startTime);

-  for (int i = 0; i < pipeline_data->thresholds.size(); i++)
+  for (uint i = 0; i < pipeline_data->thresholds.size(); i++)
  {
    vector<bool> goodIndices = this->filter(pipeline_data->thresholds[i], allContours[i], allHierarchy[i]);
    charSegments.push_back(goodIndices);
@@ -97,7 +97,7 @@ void CharacterAnalysis::analyze()
  if (hasPlateMask)
  {
    // Filter out bad contours now that we have an outer box mask...
-    for (int i = 0; i < pipeline_data->thresholds.size(); i++)
+    for (uint i = 0; i < pipeline_data->thresholds.size(); i++)
    {
      charSegments[i] = filterByOuterMask(allContours[i], allHierarchy[i], charSegments[i]);
    }
@@ -105,7 +105,7 @@ void CharacterAnalysis::analyze()

  int bestFitScore = -1;
  int bestFitIndex = -1;
-  for (int i = 0; i < pipeline_data->thresholds.size(); i++)
+  for (uint i = 0; i < pipeline_data->thresholds.size(); i++)
  {
    //vector<bool> goodIndices = this->filter(thresholds[i], allContours[i], allHierarchy[i]);
    //charSegments.push_back(goodIndices);
@@ -139,7 +139,7 @@ void CharacterAnalysis::analyze()
    cvtColor(img_contours, img_contours, CV_GRAY2RGB);

    vector<vector<Point> > allowedContours;
-    for (int i = 0; i < bestContours.size(); i++)
+    for (uint i = 0; i < bestContours.size(); i++)
    {
      if (bestCharSegments[i])
        allowedContours.push_back(bestContours[i]);
@@ -186,7 +186,7 @@ void CharacterAnalysis::analyze()
 int CharacterAnalysis::getGoodIndicesCount(vector<bool> goodIndices)
 {
  int count = 0;
-  for (int i = 0; i < goodIndices.size(); i++)
+  for (uint i = 0; i < goodIndices.size(); i++)
  {
    if (goodIndices[i])
      count++;
@@ -207,14 +207,14 @@ Mat CharacterAnalysis::findOuterBoxMask()
  if (this->config->debugCharAnalysis)
    cout << "CharacterAnalysis::findOuterBoxMask" << endl;

-  for (int imgIndex = 0; imgIndex < allContours.size(); imgIndex++)
+  for (uint imgIndex = 0; imgIndex < allContours.size(); imgIndex++)
  {
    //vector<bool> charContours = filter(thresholds[imgIndex], allContours[imgIndex], allHierarchy[imgIndex]);

    int charsRecognized = 0;
    int parentId = -1;
    bool hasParent = false;
-    for (int i = 0; i < charSegments[imgIndex].size(); i++)
+    for (uint i = 0; i < charSegments[imgIndex].size(); i++)
    {
      if (charSegments[imgIndex][i]) charsRecognized++;
      if (charSegments[imgIndex][i] && allHierarchy[imgIndex][i][3] != -1)
@@ -253,9 +253,9 @@ Mat CharacterAnalysis::findOuterBoxMask()
    int longestChildIndex = -1;
    double longestChildLength = 0;
    // Find the child with the longest permiter/arc length ( just for kicks)
-    for (int i = 0; i < allContours[winningIndex].size(); i++)
+    for (uint i = 0; i < allContours[winningIndex].size(); i++)
    {
-      for (int j = 0; j < allContours[winningIndex].size(); j++)
+      for (uint j = 0; j < allContours[winningIndex].size(); j++)
      {
        if (allHierarchy[winningIndex][j][3] == winningParentId)
        {
@@ -301,7 +301,7 @@ Mat CharacterAnalysis::findOuterBoxMask()
    findContours(mask, contoursSecondRound, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE);
    int biggestContourIndex = -1;
    double largestArea = 0;
-    for (int c = 0; c < contoursSecondRound.size(); c++)
+    for (uint c = 0; c < contoursSecondRound.size(); c++)
    {
      double area = contourArea(contoursSecondRound[c]);
      if (area > largestArea)
@@ -360,7 +360,7 @@ Mat CharacterAnalysis::getCharacterMask()
 {
  Mat charMask = Mat::zeros(bestThreshold.size(), CV_8U);

-  for (int i = 0; i < bestContours.size(); i++)
+  for (uint i = 0; i < bestContours.size(); i++)
  {
    if (bestCharSegments[i] == false)
      continue;
@@ -389,7 +389,7 @@ vector<Point> CharacterAnalysis::getBestVotedLines(Mat img, vector<vector<Point>

  vector<Rect> charRegions;

-  for (int i = 0; i < contours.size(); i++)
+  for (uint i = 0; i < contours.size(); i++)
  {
    if (goodIndices[i])
      charRegions.push_back(boundingRect(contours[i]));
@@ -405,9 +405,9 @@ vector<Point> CharacterAnalysis::getBestVotedLines(Mat img, vector<vector<Point>
    vector<LineSegment> topLines;
    vector<LineSegment> bottomLines;
    // Iterate through each possible char and find all possible lines for the top and bottom of each char segment
-    for (int i = 0; i < charRegions.size() - 1; i++)
+    for (uint i = 0; i < charRegions.size() - 1; i++)
    {
-      for (int k = i+1; k < charRegions.size(); k++)
+      for (uint k = i+1; k < charRegions.size(); k++)
      {
        //Mat tempImg;
        //result.copyTo(tempImg);
@@ -471,13 +471,13 @@ vector<Point> CharacterAnalysis::getBestVotedLines(Mat img, vector<vector<Point>
    int bestScoreDistance = -1; // Line segment distance is used as a tie breaker

    // Now, among all possible lines, find the one that is the best fit
-    for (int i = 0; i < topLines.size(); i++)
+    for (uint i = 0; i < topLines.size(); i++)
    {
      float SCORING_MIN_THRESHOLD = 0.97;
      float SCORING_MAX_THRESHOLD = 1.03;

      int curScore = 0;
-      for (int charidx = 0; charidx < charRegions.size(); charidx++)
+      for (uint charidx = 0; charidx < charRegions.size(); charidx++)
      {
        float topYPos = topLines[i].getPointAt(charRegions[charidx].x);
        float botYPos = bottomLines[i].getPointAt(charRegions[charidx].x);
@@ -550,7 +550,7 @@ vector<bool> CharacterAnalysis::filter(Mat img, vector<vector<Point> > contours,
    int goodIndicesCount;

    vector<bool> goodIndices(contours.size());
-    for (int z = 0; z < goodIndices.size(); z++) goodIndices[z] = true;
+    for (uint z = 0; z < goodIndices.size(); z++) goodIndices[z] = true;

    goodIndices = this->filterByBoxSize(contours, goodIndices, STARTING_MIN_HEIGHT + (i * HEIGHT_STEP), STARTING_MAX_HEIGHT + (i * HEIGHT_STEP));

@@ -585,10 +585,10 @@ vector<bool> CharacterAnalysis::filterByBoxSize(vector< vector< Point> > contour
  float aspecttolerance=0.25;

  vector<bool> includedIndices(contours.size());
-  for (int j = 0; j < contours.size(); j++)
+  for (uint j = 0; j < contours.size(); j++)
    includedIndices.push_back(false);

-  for (int i = 0; i < contours.size(); i++)
+  for (uint i = 0; i < contours.size(); i++)
  {
    if (goodIndices[i] == false)
      continue;
@@ -614,10 +614,10 @@ vector<bool> CharacterAnalysis::filterByBoxSize(vector< vector< Point> > contour
 vector< bool > CharacterAnalysis::filterContourHoles(vector< vector< Point > > contours, vector< Vec4i > hierarchy, vector< bool > goodIndices)
 {
  vector<bool> includedIndices(contours.size());
-  for (int j = 0; j < contours.size(); j++)
+  for (uint j = 0; j < contours.size(); j++)
    includedIndices.push_back(false);

-  for (int i = 0; i < contours.size(); i++)
+  for (uint i = 0; i < contours.size(); i++)
  {
    if (goodIndices[i] == false)
      continue;
@@ -646,13 +646,13 @@ vector< bool > CharacterAnalysis::filterContourHoles(vector< vector< Point > > c
 vector<bool> CharacterAnalysis::filterByParentContour( vector< vector< Point> > contours, vector<Vec4i> hierarchy, vector<bool> goodIndices)
 {
  vector<bool> includedIndices(contours.size());
-  for (int j = 0; j < contours.size(); j++)
+  for (uint j = 0; j < contours.size(); j++)
    includedIndices[j] = false;

  vector<int> parentIDs;
  vector<int> votes;

-  for (int i = 0; i < contours.size(); i++)
+  for (uint i = 0; i < contours.size(); i++)
  {
    if (goodIndices[i] == false)
      continue;
@@ -660,7 +660,7 @@ vector<bool> CharacterAnalysis::filterByParentContour( vector< vector< Point> >
    int voteIndex = -1;
    int parentID = hierarchy[i][3];
    // check if parentID is already in the lsit
-    for (int j = 0; j < parentIDs.size(); j++)
+    for (uint j = 0; j < parentIDs.size(); j++)
    {
      if (parentIDs[j] == parentID)
      {
@@ -683,7 +683,7 @@ vector<bool> CharacterAnalysis::filterByParentContour( vector< vector< Point> >
  int totalVotes = 0;
  int winningParentId = 0;
  int highestVotes = 0;
-  for (int i = 0; i < parentIDs.size(); i++)
+  for (uint i = 0; i < parentIDs.size(); i++)
  {
    if (votes[i] > highestVotes)
    {
@@ -694,7 +694,7 @@ vector<bool> CharacterAnalysis::filterByParentContour( vector< vector< Point> >
  }

  // Now filter out all the contours with a different parent ID (assuming the totalVotes > 2)
-  for (int i = 0; i < contours.size(); i++)
+  for (uint i = 0; i < contours.size(); i++)
  {
    if (goodIndices[i] == false)
      continue;
@@ -718,7 +718,7 @@ vector<bool> CharacterAnalysis::filterBetweenLines(Mat img, vector<vector<Point>
  static float MAX_DISTANCE_PERCENT_FROM_LINES = 0.15;

  vector<bool> includedIndices(contours.size());
-  for (int j = 0; j < contours.size(); j++)
+  for (uint j = 0; j < contours.size(); j++)
    includedIndices[j] = false;

  if (outerPolygon.size() == 0)
@@ -741,7 +741,7 @@ vector<bool> CharacterAnalysis::filterBetweenLines(Mat img, vector<vector<Point>
  fillConvexPoly(outerMask, outerPolygon.data(), outerPolygon.size(), Scalar(255,255,255));

  // For each contour, determine if enough of it is between the lines to qualify
-  for (int i = 0; i < contours.size(); i++)
+  for (uint i = 0; i < contours.size(); i++)
  {
    if (goodIndices[i] == false)
      continue;
@@ -767,7 +767,7 @@ vector<bool> CharacterAnalysis::filterBetweenLines(Mat img, vector<vector<Point>
    double totalArea = contourArea(contours[i]);
    double areaBetweenLines = 0;

-    for (int tempContourIdx = 0; tempContourIdx < tempContours.size(); tempContourIdx++)
+    for (uint tempContourIdx = 0; tempContourIdx < tempContours.size(); tempContourIdx++)
    {
      areaBetweenLines += contourArea(tempContours[tempContourIdx]);
    }
@@ -789,7 +789,7 @@ vector<bool> CharacterAnalysis::filterBetweenLines(Mat img, vector<vector<Point>
    int highPointValue = 999999999;
    int lowPointIndex = 0;
    int lowPointValue = 0;
-    for (int cidx = 0; cidx < contours[i].size(); cidx++)
+    for (uint cidx = 0; cidx < contours[i].size(); cidx++)
    {
      if (contours[i][cidx].y < highPointValue)
      {
@@ -831,7 +831,7 @@ std::vector< bool > CharacterAnalysis::filterByOuterMask(vector< vector< Point >
    return goodIndices;

  vector<bool> passingIndices;
-  for (int i = 0; i < goodIndices.size(); i++)
+  for (uint i = 0; i < goodIndices.size(); i++)
    passingIndices.push_back(false);

  Mat tempMaskedContour = Mat::zeros(plateMask.size(), CV_8U);
@@ -840,7 +840,7 @@ std::vector< bool > CharacterAnalysis::filterByOuterMask(vector< vector< Point >
  int charsInsideMask = 0;
  int totalChars = 0;

-  for (int i=0; i < goodIndices.size(); i++)
+  for (uint i=0; i < goodIndices.size(); i++)
  {
    if (goodIndices[i] == false)
      continue;
@@ -921,12 +921,12 @@ vector<Point> CharacterAnalysis::getCharArea()
  int leftX = MAX;
  int rightX = MIN;

-  for (int i = 0; i < bestContours.size(); i++)
+  for (uint i = 0; i < bestContours.size(); i++)
  {
    if (bestCharSegments[i] == false)
      continue;

-    for (int z = 0; z < bestContours[i].size(); z++)
+    for (uint z = 0; z < bestContours[i].size(); z++)
    {
      if (bestContours[i][z].x < leftX)
        leftX = bestContours[i][z].x;
--- a/src/openalpr/characterregion.cpp
+++ b/src/openalpr/characterregion.cpp
@@ -43,7 +43,7 @@ CharacterRegion::CharacterRegion(PipelineData* pipeline_data)
  if (this->debug && charAnalysis->linePolygon.size() > 0)
  {
    vector<Mat> tempDash;
-    for (int z = 0; z < pipeline_data->thresholds.size(); z++)
+    for (uint z = 0; z < pipeline_data->thresholds.size(); z++)
    {
      Mat tmp(pipeline_data->thresholds[z].size(), pipeline_data->thresholds[z].type());
      pipeline_data->thresholds[z].copyTo(tmp);
@@ -56,7 +56,7 @@ CharacterRegion::CharacterRegion(PipelineData* pipeline_data)
    charAnalysis->bestThreshold.copyTo(bestVal);
    cvtColor(bestVal, bestVal, CV_GRAY2BGR);

-    for (int z = 0; z < charAnalysis->bestContours.size(); z++)
+    for (uint z = 0; z < charAnalysis->bestContours.size(); z++)
    {
      Scalar dcolor(255,0,0);
      if (charAnalysis->bestCharSegments[z])
--- a/src/openalpr/colorfilter.cpp
+++ b/src/openalpr/colorfilter.cpp
@@ -119,7 +119,7 @@ void ColorFilter::findCharColors()
  vector<float> hMeans, sMeans, vMeans;
  vector<float> hStdDevs, sStdDevs, vStdDevs;

-  for (int i = 0; i < contours.size(); i++)
+  for (uint i = 0; i < contours.size(); i++)
  {
    if (hierarchy[i][3] != -1)
      continue;
@@ -372,11 +372,11 @@ int ColorFilter::getMajorityOpinion(vector<float> values, float minPercentAgreem
  float lowestOverallDiff = 1000000000;
  int bestPercentAgreementIndex = -1;

-  for (int i = 0; i < values.size(); i++)
+  for (uint i = 0; i < values.size(); i++)
  {
    int valuesInRange = 0;
    float overallDiff = 0;
-    for (int j = 0; j < values.size(); j++)
+    for (uint j = 0; j < values.size(); j++)
    {
      float diff = abs(values[i] - values[j]);
      if (diff < maxValDifference)
--- a/src/openalpr/config.h
+++ b/src/openalpr/config.h
@@ -93,9 +93,9 @@ class Config
    
    float postProcessMinConfidence;
    float postProcessConfidenceSkipLevel;
-    int postProcessMaxSubstitutions;
-    int postProcessMinCharacters;
-    int postProcessMaxCharacters;
+    uint postProcessMaxSubstitutions;
+    uint postProcessMinCharacters;
+    uint postProcessMaxCharacters;

    
    bool debugGeneral;
--- a/src/openalpr/detection/detector.cpp
+++ b/src/openalpr/detection/detector.cpp
@@ -70,17 +70,17 @@ vector<PlateRegion> Detector::aggregateRegions(vector<Rect> regions)
  std::sort(regions.begin(), regions.end(), rectHasLargerArea);
  
  // Create new PlateRegions and attach the rectangles to each
-  for (int i = 0; i < regions.size(); i++)
+  for (uint i = 0; i < regions.size(); i++)
  {
    PlateRegion newRegion;
    newRegion.rect = regions[i];
    orderedRegions.push_back(newRegion);
  }
  
-  for (int i = 0; i < orderedRegions.size(); i++)
+  for (uint i = 0; i < orderedRegions.size(); i++)
  {
    bool foundParent = false;
-    for (int k = i + 1; k < orderedRegions.size(); k++)
+    for (uint k = i + 1; k < orderedRegions.size(); k++)
    {
      Point center( orderedRegions[i].rect.x + (orderedRegions[i].rect.width / 2),
 		    orderedRegions[i].rect.y + (orderedRegions[i].rect.height / 2));
--- a/src/openalpr/detection/detectorcpu.cpp
+++ b/src/openalpr/detection/detectorcpu.cpp
@@ -103,7 +103,7 @@ vector<PlateRegion> DetectorCPU::doCascade(Mat frame, std::vector<cv::Rect> regi
    cout << "LBP Time: " << diffclock(startTime, endTime) << "ms." << endl;
  }

-  for( int i = 0; i < plates.size(); i++ )
+  for( uint i = 0; i < plates.size(); i++ )
  {
    plates[i].x = plates[i].x / scale_factor;
    plates[i].y = plates[i].y / scale_factor;
--- a/src/openalpr/featurematcher.cpp
+++ b/src/openalpr/featurematcher.cpp
@@ -41,7 +41,7 @@ FeatureMatcher::FeatureMatcher(Config* config)

 FeatureMatcher::~FeatureMatcher()
 {
-  for (int i = 0; i < trainingImgKeypoints.size(); i++)
+  for (uint i = 0; i < trainingImgKeypoints.size(); i++)
    trainingImgKeypoints[i].clear();
  trainingImgKeypoints.clear();

@@ -85,7 +85,7 @@ void FeatureMatcher::_surfStyleMatching(const Mat& queryDescriptors, vector<vect
  //cout << "starting matcher" << matchesKnn.size() << endl;
  for (int descInd = 0; descInd < queryDescriptors.rows; descInd++)
  {
-    const std::vector<DMatch> & matches = matchesKnn[descInd];
+    //const std::vector<DMatch> & matches = matchesKnn[descInd];
    //cout << "two: " << descInd << ":" << matches.size() << endl;

    // Check to make sure we have 2 matches.  I think this is always the case, but it doesn't hurt to be sure
@@ -107,7 +107,7 @@ void FeatureMatcher::_surfStyleMatching(const Mat& queryDescriptors, vector<vect
      {
        bool already_exists = false;
        // Quickly run through the matches we've already added and make sure it's not a duplicate...
-        for (int q = 0; q < matches12.size(); q++)
+        for (uint q = 0; q < matches12.size(); q++)
        {
          if (matchesKnn[descInd][0].queryIdx == matches12[q].queryIdx)
          {
@@ -152,12 +152,12 @@ void FeatureMatcher::crisscrossFiltering(const vector<KeyPoint> queryKeypoints,
  Rect crissCrossAreaVertical(0, 0, config->stateIdImageWidthPx, config->stateIdimageHeightPx * 2);
  Rect crissCrossAreaHorizontal(0, 0, config->stateIdImageWidthPx * 2, config->stateIdimageHeightPx);

-  for (int i = 0; i < billMapping.size(); i++)
+  for (uint i = 0; i < billMapping.size(); i++)
  {
    vector<DMatch> matchesForOnePlate;
-    for (int j = 0; j < inputMatches.size(); j++)
+    for (uint j = 0; j < inputMatches.size(); j++)
    {
-      if (inputMatches[j].imgIdx == i)
+      if (inputMatches[j].imgIdx == (int) i)
        matchesForOnePlate.push_back(inputMatches[j]);
    }

@@ -167,7 +167,7 @@ void FeatureMatcher::crisscrossFiltering(const vector<KeyPoint> queryKeypoints,
    vector<LineSegment> hlines;
    vector<int> matchIdx;

-    for (int j = 0; j < matchesForOnePlate.size(); j++)
+    for (uint j = 0; j < matchesForOnePlate.size(); j++)
    {
      KeyPoint tkp = trainingImgKeypoints[i][matchesForOnePlate[j].trainIdx];
      KeyPoint qkp = queryKeypoints[matchesForOnePlate[j].queryIdx];
@@ -184,10 +184,10 @@ void FeatureMatcher::crisscrossFiltering(const vector<KeyPoint> queryKeypoints,
      int mostIntersectionsIndex = -1;
      mostIntersections = 0;

-      for (int j = 0; j < vlines.size(); j++)
+      for (uint j = 0; j < vlines.size(); j++)
      {
        int intrCount = 0;
-        for (int q = 0; q < vlines.size(); q++)
+        for (uint q = 0; q < vlines.size(); q++)
        {
          Point vintr = vlines[j].intersection(vlines[q]);
          Point hintr = hlines[j].intersection(hlines[q]);
@@ -221,7 +221,7 @@ void FeatureMatcher::crisscrossFiltering(const vector<KeyPoint> queryKeypoints,
    }

    // Push the non-crisscrosses back on the list
-    for (int j = 0; j < matchIdx.size(); j++)
+    for (uint j = 0; j < matchIdx.size(); j++)
    {
      outputMatches.push_back(matchesForOnePlate[matchIdx[j]]);
    }
@@ -240,7 +240,7 @@ bool FeatureMatcher::loadRecognitionSet(string country)
    vector<Mat> trainImages;
    vector<string> plateFiles = getFilesInDir(country_dir.c_str());

-    for (int i = 0; i < plateFiles.size(); i++)
+    for (uint i = 0; i < plateFiles.size(); i++)
    {
      if (hasEnding(plateFiles[i], ".jpg") == false)
        continue;
@@ -312,12 +312,12 @@ RecognitionResult FeatureMatcher::recognize( const Mat& queryImg, bool drawOnIma
  // Create and initialize the counts to 0
  std::vector<int> bill_match_counts( billMapping.size() );

-  for (int i = 0; i < billMapping.size(); i++)
+  for (uint i = 0; i < billMapping.size(); i++)
  {
    bill_match_counts[i] = 0;
  }

-  for (int i = 0; i < filteredMatches.size(); i++)
+  for (uint i = 0; i < filteredMatches.size(); i++)
  {
    bill_match_counts[filteredMatches[i].imgIdx]++;
    //if (filteredMatches[i].imgIdx
@@ -326,7 +326,7 @@ RecognitionResult FeatureMatcher::recognize( const Mat& queryImg, bool drawOnIma
  float max_count = 0;	// represented as a percent (0 to 100)
  int secondmost_count = 0;
  int maxcount_index = -1;
-  for (int i = 0; i < billMapping.size(); i++)
+  for (uint i = 0; i < billMapping.size(); i++)
  {
    if (bill_match_counts[i] > max_count && bill_match_counts[i] >= 4)
    {
@@ -354,7 +354,7 @@ RecognitionResult FeatureMatcher::recognize( const Mat& queryImg, bool drawOnIma
    if (drawOnImage)
    {
      vector<KeyPoint> positiveMatches;
-      for (int i = 0; i < filteredMatches.size(); i++)
+      for (uint i = 0; i < filteredMatches.size(); i++)
      {
        if (filteredMatches[i].imgIdx == maxcount_index)
        {
@@ -379,7 +379,7 @@ RecognitionResult FeatureMatcher::recognize( const Mat& queryImg, bool drawOnIma

  if (this->config->debugStateId)
  {
-    for (int i = 0; i < billMapping.size(); i++)
+    for (uint i = 0; i < billMapping.size(); i++)
    {
      cout << billMapping[i] << " : " << bill_match_counts[i] << endl;
    }
--- a/src/openalpr/licenseplatecandidate.cpp
+++ b/src/openalpr/licenseplatecandidate.cpp
@@ -83,7 +83,7 @@ void LicensePlateCandidate::recognize()
 vector<Point2f> LicensePlateCandidate::transformPointsToOriginalImage(Mat bigImage, Mat smallImage, Rect region, vector<Point> corners)
 {
  vector<Point2f> cornerPoints;
-  for (int i = 0; i < corners.size(); i++)
+  for (uint i = 0; i < corners.size(); i++)
  {
    float bigX = (corners[i].x * ((float) region.width / smallImage.cols));
    float bigY = (corners[i].y * ((float) region.height / smallImage.rows));
--- a/src/openalpr/ocr.cpp
+++ b/src/openalpr/ocr.cpp
@@ -63,7 +63,7 @@ void OCR::performOCR(PipelineData* pipeline_data)
  if (pipeline_data->charRegions.size() < config->postProcessMinCharacters)
    return;

-  for (int i = 0; i < pipeline_data->thresholds.size(); i++)
+  for (uint i = 0; i < pipeline_data->thresholds.size(); i++)
  {
    // Make it black text on white background
    bitwise_not(pipeline_data->thresholds[i], pipeline_data->thresholds[i]);
@@ -71,7 +71,7 @@ void OCR::performOCR(PipelineData* pipeline_data)
 			pipeline_data->thresholds[i].size().width, pipeline_data->thresholds[i].size().height, 
 			pipeline_data->thresholds[i].channels(), pipeline_data->thresholds[i].step1());

-    for (int j = 0; j < pipeline_data->charRegions.size(); j++)
+    for (uint j = 0; j < pipeline_data->charRegions.size(); j++)
    {
      Rect expandedRegion = expandRect( pipeline_data->charRegions[j], 2, 2, pipeline_data->thresholds[i].cols, pipeline_data->thresholds[i].rows) ;

--- a/src/openalpr/pipeline_data.cpp
+++ b/src/openalpr/pipeline_data.cpp
@@ -21,7 +21,7 @@ PipelineData::~PipelineData()

 void PipelineData::clearThresholds()
 {
-  for (int i = 0; i < thresholds.size(); i++)
+  for (uint i = 0; i < thresholds.size(); i++)
  {
    thresholds[i].release();
  }
--- a/src/openalpr/platelines.cpp
+++ b/src/openalpr/platelines.cpp
@@ -84,9 +84,9 @@ void PlateLines::processImage(Mat inputImage, CharacterRegion* charRegion, float
  
  vector<PlateLine> hlines = this->getLines(edges, sensitivity, false);
  vector<PlateLine> vlines = this->getLines(edges, sensitivity, true);
-  for (int i = 0; i < hlines.size(); i++)
+  for (uint i = 0; i < hlines.size(); i++)
    this->horizontalLines.push_back(hlines[i]);
-  for (int i = 0; i < vlines.size(); i++)
+  for (uint i = 0; i < vlines.size(); i++)
    this->verticalLines.push_back(vlines[i]);

  // if debug is enabled, draw the image
@@ -227,7 +227,7 @@ Mat PlateLines::customGrayscaleConversion(Mat src)
    for (int col = 0; col < img_hsv.cols; col++)
    {
      int h = (int) img_hsv.at<Vec3b>(row, col)[0];
-      int s = (int) img_hsv.at<Vec3b>(row, col)[1];
+      //int s = (int) img_hsv.at<Vec3b>(row, col)[1];
      int v = (int) img_hsv.at<Vec3b>(row, col)[2];

      int pixval = pow(v, 1.05);
--- a/src/openalpr/segmentation/charactersegmenter.cpp
+++ b/src/openalpr/segmentation/charactersegmenter.cpp
@@ -58,7 +58,7 @@ CharacterSegmenter::CharacterSegmenter(PipelineData* pipeline_data)
    cvtColor(img_contours, img_contours, CV_GRAY2RGB);

    vector<vector<Point> > allowedContours;
-    for (int i = 0; i < charAnalysis->bestContours.size(); i++)
+    for (uint i = 0; i < charAnalysis->bestContours.size(); i++)
    {
      if (charAnalysis->bestCharSegments[i])
        allowedContours.push_back(charAnalysis->bestContours[i]);
@@ -92,7 +92,7 @@ CharacterSegmenter::CharacterSegmenter(PipelineData* pipeline_data)
    vector<int> charWidths;
    vector<int> charHeights;

-    for (int i = 0; i < charAnalysis->bestContours.size(); i++)
+    for (uint i = 0; i < charAnalysis->bestContours.size(); i++)
    {
      if (charAnalysis->bestCharSegments[i] == false)
        continue;
@@ -116,7 +116,7 @@ CharacterSegmenter::CharacterSegmenter(PipelineData* pipeline_data)
    vector<Mat> allHistograms;

    vector<Rect> allBoxes;
-    for (int i = 0; i < charAnalysis->allContours.size(); i++)
+    for (uint i = 0; i < charAnalysis->allContours.size(); i++)
    {
      Mat histogramMask = Mat::zeros(pipeline_data->thresholds[i].size(), CV_8U);

@@ -140,7 +140,7 @@ CharacterSegmenter::CharacterSegmenter(PipelineData* pipeline_data)

      if (this->config->debugCharSegmenter)
      {
-        for (int cboxIdx = 0; cboxIdx < charBoxes.size(); cboxIdx++)
+        for (uint cboxIdx = 0; cboxIdx < charBoxes.size(); cboxIdx++)
        {
          rectangle(allHistograms[i], charBoxes[cboxIdx], Scalar(0, 255, 0));
        }
@@ -149,7 +149,7 @@ CharacterSegmenter::CharacterSegmenter(PipelineData* pipeline_data)
        displayImage(config, "Char seg histograms", histDashboard);
      }

-      for (int z = 0; z < charBoxes.size(); z++)
+      for (uint z = 0; z < charBoxes.size(); z++)
        allBoxes.push_back(charBoxes[z]);
      //drawAndWait(&histogramMask);
    }
@@ -157,7 +157,7 @@ CharacterSegmenter::CharacterSegmenter(PipelineData* pipeline_data)
    float medianCharWidth = avgCharWidth;
    vector<int> widthValues;
    // Compute largest char width
-    for (int i = 0; i < allBoxes.size(); i++)
+    for (uint i = 0; i < allBoxes.size(); i++)
    {
      widthValues.push_back(allBoxes[i].width);
    }
@@ -177,7 +177,7 @@ CharacterSegmenter::CharacterSegmenter(PipelineData* pipeline_data)
    if (this->config->debugCharSegmenter)
    {
      // Setup the dashboard images to show the cleaning filters
-      for (int i = 0; i < pipeline_data->thresholds.size(); i++)
+      for (uint i = 0; i < pipeline_data->thresholds.size(); i++)
      {
        Mat cleanImg = Mat::zeros(pipeline_data->thresholds[i].size(), pipeline_data->thresholds[i].type());
        Mat boxMask = getCharBoxMask(pipeline_data->thresholds[i], candidateBoxes);
@@ -185,7 +185,7 @@ CharacterSegmenter::CharacterSegmenter(PipelineData* pipeline_data)
        bitwise_and(cleanImg, boxMask, cleanImg);
        cvtColor(cleanImg, cleanImg, CV_GRAY2BGR);

-        for (int c = 0; c < candidateBoxes.size(); c++)
+        for (uint c = 0; c < candidateBoxes.size(); c++)
          rectangle(cleanImg, candidateBoxes[c], Scalar(0, 255, 0), 1);
        imgDbgCleanStages.push_back(cleanImg);
      }
@@ -255,7 +255,7 @@ vector<Rect> CharacterSegmenter::getHistogramBoxes(VerticalHistogram histogram,
  vector<Rect> charBoxes;
  vector<Rect> allBoxes = get1DHits(histogram.histoImg, pxLeniency);

-  for (int i = 0; i < allBoxes.size(); i++)
+  for (uint i = 0; i < allBoxes.size(); i++)
  {
    if (allBoxes[i].width >= config->segmentationMinBoxWidthPx && allBoxes[i].width <= MAX_SEGMENT_WIDTH &&
        allBoxes[i].height > MIN_HISTOGRAM_HEIGHT )
@@ -311,7 +311,7 @@ vector<Rect> CharacterSegmenter::getBestCharBoxes(Mat img, vector<Rect> charBoxe
  {
    columnCount = 0;

-    for (int i = 0; i < charBoxes.size(); i++)
+    for (uint i = 0; i < charBoxes.size(); i++)
    {
      if (col >= charBoxes[i].x && col < (charBoxes[i].x + charBoxes[i].width))
        columnCount++;
@@ -343,7 +343,7 @@ vector<Rect> CharacterSegmenter::getBestCharBoxes(Mat img, vector<Rect> charBoxe

    float rowScore = 0;

-    for (int boxidx = 0; boxidx < allBoxes.size(); boxidx++)
+    for (uint boxidx = 0; boxidx < allBoxes.size(); boxidx++)
    {
      int w = allBoxes[boxidx].width;
      if (w >= config->segmentationMinBoxWidthPx && w <= MAX_SEGMENT_WIDTH)
@@ -402,7 +402,7 @@ vector<Rect> CharacterSegmenter::getBestCharBoxes(Mat img, vector<Rect> charBoxe
    Mat imgBestBoxes(img.size(), img.type());
    img.copyTo(imgBestBoxes);
    cvtColor(imgBestBoxes, imgBestBoxes, CV_GRAY2BGR);
-    for (int i = 0; i < bestBoxes.size(); i++)
+    for (uint i = 0; i < bestBoxes.size(); i++)
      rectangle(imgBestBoxes, bestBoxes[i], Scalar(0, 255, 0));

    this->imgDbgGeneral.push_back(addLabel(histoImg, "All Histograms"));
@@ -448,9 +448,9 @@ void CharacterSegmenter::removeSmallContours(vector<Mat> thresholds, vector<vect
  //const float MIN_CHAR_AREA = 0.02 * avgCharWidth * avgCharHeight;	// To clear out the tiny specks
  const float MIN_CONTOUR_HEIGHT = 0.3 * avgCharHeight;

-  for (int i = 0; i < thresholds.size(); i++)
+  for (uint i = 0; i < thresholds.size(); i++)
  {
-    for (int c = 0; c < allContours[i].size(); c++)
+    for (uint c = 0; c < allContours[i].size(); c++)
    {
      if (allContours[i][c].size() == 0)
        continue;
@@ -470,7 +470,7 @@ vector<Rect> CharacterSegmenter::combineCloseBoxes( vector<Rect> charBoxes, floa
 {
  vector<Rect> newCharBoxes;

-  for (int i = 0; i < charBoxes.size(); i++)
+  for (uint i = 0; i < charBoxes.size(); i++)
  {
    if (i == charBoxes.size() - 1)
    {
@@ -490,7 +490,7 @@ vector<Rect> CharacterSegmenter::combineCloseBoxes( vector<Rect> charBoxes, floa
      newCharBoxes.push_back(bigRect);
      if (this->config->debugCharSegmenter)
      {
-        for (int z = 0; z < pipeline_data->thresholds.size(); z++)
+        for (uint z = 0; z < pipeline_data->thresholds.size(); z++)
        {
          Point center(bigRect.x + bigRect.width / 2, bigRect.y + bigRect.height / 2);
          RotatedRect rrect(center, Size2f(bigRect.width, bigRect.height + (bigRect.height / 2)), 0);
@@ -519,7 +519,7 @@ void CharacterSegmenter::cleanCharRegions(vector<Mat> thresholds, vector<Rect> c

  Mat mask = getCharBoxMask(thresholds[0], charRegions);

-  for (int i = 0; i < thresholds.size(); i++)
+  for (uint i = 0; i < thresholds.size(); i++)
  {
    bitwise_and(thresholds[i], mask, thresholds[i]);
    vector<vector<Point> > contours;
@@ -536,14 +536,14 @@ void CharacterSegmenter::cleanCharRegions(vector<Mat> thresholds, vector<Rect> c

    findContours(tempImg, contours, RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE);

-    for (int j = 0; j < charRegions.size(); j++)
+    for (uint j = 0; j < charRegions.size(); j++)
    {
      const float MIN_SPECKLE_HEIGHT = ((float)charRegions[j].height) * MIN_SPECKLE_HEIGHT_PERCENT;
      const float MIN_CONTOUR_AREA = ((float)charRegions[j].area()) * MIN_CONTOUR_AREA_PERCENT;

      int tallestContourHeight = 0;
      float totalArea = 0;
-      for (int c = 0; c < contours.size(); c++)
+      for (uint c = 0; c < contours.size(); c++)
      {
        if (contours[c].size() == 0)
          continue;
@@ -615,7 +615,7 @@ void CharacterSegmenter::cleanCharRegions(vector<Mat> thresholds, vector<Rect> c
    morphologyEx(thresholds[i], thresholds[i], MORPH_CLOSE, closureElement);

    // Lastly, draw a clipping line between each character boxes
-    for (int j = 0; j < charRegions.size(); j++)
+    for (uint j = 0; j < charRegions.size(); j++)
    {
      line(thresholds[i], Point(charRegions[j].x - 1, charRegions[j].y), Point(charRegions[j].x - 1, charRegions[j].y + charRegions[j].height), Scalar(0, 0, 0));
      line(thresholds[i], Point(charRegions[j].x + charRegions[j].width + 1, charRegions[j].y), Point(charRegions[j].x + charRegions[j].width + 1, charRegions[j].y + charRegions[j].height), Scalar(0, 0, 0));
@@ -629,9 +629,9 @@ void CharacterSegmenter::cleanBasedOnColor(vector<Mat> thresholds, Mat colorMask
  // Consider it a bad news bear.  REmove the whole area.
  const float MIN_PERCENT_CHUNK_REMOVED = 0.6;

-  for (int i = 0; i < thresholds.size(); i++)
+  for (uint i = 0; i < thresholds.size(); i++)
  {
-    for (int j = 0; j < charRegions.size(); j++)
+    for (uint j = 0; j < charRegions.size(); j++)
    {
      Mat boxChar = Mat::zeros(thresholds[i].size(), CV_8U);
      rectangle(boxChar, charRegions[j], Scalar(255,255,255), CV_FILLED);
@@ -679,12 +679,12 @@ void CharacterSegmenter::cleanMostlyFullBoxes(vector<Mat> thresholds, const vect
 {
  float MAX_FILLED = 0.95 * 255;

-  for (int i = 0; i < charRegions.size(); i++)
+  for (uint i = 0; i < charRegions.size(); i++)
  {
    Mat mask = Mat::zeros(thresholds[0].size(), CV_8U);
    rectangle(mask, charRegions[i], Scalar(255,255,255), -1);

-    for (int j = 0; j < thresholds.size(); j++)
+    for (uint j = 0; j < thresholds.size(); j++)
    {
      if (mean(thresholds[j], mask)[0] > MAX_FILLED)
      {
@@ -713,12 +713,12 @@ vector<Rect> CharacterSegmenter::filterMostlyEmptyBoxes(vector<Mat> thresholds,

  vector<int> boxScores(charRegions.size());

-  for (int i = 0; i < charRegions.size(); i++)
+  for (uint i = 0; i < charRegions.size(); i++)
    boxScores[i] = 0;

-  for (int i = 0; i < thresholds.size(); i++)
+  for (uint i = 0; i < thresholds.size(); i++)
  {
-    for (int j = 0; j < charRegions.size(); j++)
+    for (uint j = 0; j < charRegions.size(); j++)
    {
      //float minArea = charRegions[j].area() * MIN_AREA_PERCENT;

@@ -729,15 +729,13 @@ vector<Rect> CharacterSegmenter::filterMostlyEmptyBoxes(vector<Mat> thresholds,
      vector<vector<Point> > contours;
      findContours(tempImg, contours, RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE);

-      float biggestContourHeight = 0;
-
      vector<Point> allPointsInBox;
-      for (int c = 0; c < contours.size(); c++)
+      for (uint c = 0; c < contours.size(); c++)
      {
        if (contours[c].size() == 0)
          continue;

-        for (int z = 0; z < contours[c].size(); z++)
+        for (uint z = 0; z < contours[c].size(); z++)
          allPointsInBox.push_back(contours[c][z]);
      }

@@ -761,7 +759,7 @@ vector<Rect> CharacterSegmenter::filterMostlyEmptyBoxes(vector<Mat> thresholds,
  vector<Rect> newCharRegions;

  int maxBoxScore = 0;
-  for (int i = 0; i < charRegions.size(); i++)
+  for (uint i = 0; i < charRegions.size(); i++)
  {
    if (boxScores[i] > maxBoxScore)
      maxBoxScore = boxScores[i];
@@ -771,7 +769,7 @@ vector<Rect> CharacterSegmenter::filterMostlyEmptyBoxes(vector<Mat> thresholds,
  int MIN_FULL_BOXES = maxBoxScore * 0.49;

  // Now check each score.  If it's below the minimum, remove the charRegion
-  for (int i = 0; i < charRegions.size(); i++)
+  for (uint i = 0; i < charRegions.size(); i++)
  {
    if (boxScores[i] > MIN_FULL_BOXES)
      newCharRegions.push_back(charRegions[i]);
@@ -784,7 +782,7 @@ vector<Rect> CharacterSegmenter::filterMostlyEmptyBoxes(vector<Mat> thresholds,
        cout << " this box had a score of : " << boxScores[i];;
        cout << " MIN_FULL_BOXES: " << MIN_FULL_BOXES << endl;;

-        for (int z = 0; z < thresholds.size(); z++)
+        for (uint z = 0; z < thresholds.size(); z++)
        {
          rectangle(thresholds[z], charRegions[i], Scalar(0,0,0), -1);

@@ -834,7 +832,7 @@ void CharacterSegmenter::filterEdgeBoxes(vector<Mat> thresholds, const vector<Re
  vector<int> leftEdges;
  vector<int> rightEdges;

-  for (int i = 0; i < thresholds.size(); i++)
+  for (uint i = 0; i < thresholds.size(); i++)
  {
    Mat rotated;

@@ -940,7 +938,7 @@ void CharacterSegmenter::filterEdgeBoxes(vector<Mat> thresholds, const vector<Re
        cout << "Edge Filter: Entire right region is erased" << endl;
    }

-    for (int i = 0; i < thresholds.size(); i++)
+    for (uint i = 0; i < thresholds.size(); i++)
    {
      bitwise_and(thresholds[i], mask, thresholds[i]);
    }
@@ -953,7 +951,7 @@ void CharacterSegmenter::filterEdgeBoxes(vector<Mat> thresholds, const vector<Re

      Mat invertedMask(mask.size(), mask.type());
      bitwise_not(mask, invertedMask);
-      for (int z = 0; z < imgDbgCleanStages.size(); z++)
+      for (uint z = 0; z < imgDbgCleanStages.size(); z++)
        fillMask(imgDbgCleanStages[z], invertedMask, Scalar(0,0,255));
    }
  }
@@ -1087,7 +1085,7 @@ int CharacterSegmenter::isSkinnyLineInsideBox(Mat threshold, Rect box, vector<ve
  Mat boxMask = Mat::zeros(threshold.size(), CV_8U);
  rectangle(boxMask, slightlySmallerBox, Scalar(255, 255, 255), -1);

-  for (int i = 0; i < contours.size(); i++)
+  for (uint i = 0; i < contours.size(); i++)
  {
    // Only bother with the big boxes
    if (boundingRect(contours[i]).height < MIN_EDGE_CONTOUR_HEIGHT)
@@ -1103,7 +1101,7 @@ int CharacterSegmenter::isSkinnyLineInsideBox(Mat threshold, Rect box, vector<ve
    int tallestContourHeight = 0;
    int tallestContourWidth = 0;
    float tallestContourArea = 0;
-    for (int s = 0; s < subContours.size(); s++)
+    for (uint s = 0; s < subContours.size(); s++)
    {
      Rect r = boundingRect(subContours[s]);
      if (r.height > tallestContourHeight)
@@ -1134,7 +1132,7 @@ int CharacterSegmenter::isSkinnyLineInsideBox(Mat threshold, Rect box, vector<ve
 Mat CharacterSegmenter::getCharBoxMask(Mat img_threshold, vector<Rect> charBoxes)
 {
  Mat mask = Mat::zeros(img_threshold.size(), CV_8U);
-  for (int i = 0; i < charBoxes.size(); i++)
+  for (uint i = 0; i < charBoxes.size(); i++)
    rectangle(mask, charBoxes[i], Scalar(255, 255, 255), -1);

  return mask;
--- a/src/openalpr/segmentation/verticalhistogram.cpp
+++ b/src/openalpr/segmentation/verticalhistogram.cpp
@@ -105,7 +105,7 @@ int VerticalHistogram::getHeightAt(int x)

 void VerticalHistogram::findValleys()
 {
-  int MINIMUM_PEAK_HEIGHT = (int) (((float) highestPeak) * 0.75);
+  //int MINIMUM_PEAK_HEIGHT = (int) (((float) highestPeak) * 0.75);

  int totalWidth = colHeights.size();

@@ -114,7 +114,7 @@ void VerticalHistogram::findValleys()
  HistogramDirection prevDirection = FALLING;

  int relativePeakHeight = 0;
-  int valleyStart = 0;
+  //int valleyStart = 0;

  for (int i = 0; i < totalWidth; i++)
  {
@@ -143,7 +143,7 @@ void VerticalHistogram::findValleys()
  }
 }

-HistogramDirection VerticalHistogram::getHistogramDirection(int index)
+HistogramDirection VerticalHistogram::getHistogramDirection(uint index)
 {
  int EXTRA_WIDTH_TO_AVERAGE = 2;

@@ -153,7 +153,7 @@ HistogramDirection VerticalHistogram::getHistogramDirection(int index)
  int trailStartIndex = index - EXTRA_WIDTH_TO_AVERAGE;
  if (trailStartIndex < 0)
    trailStartIndex = 0;
-  int forwardEndIndex = index + EXTRA_WIDTH_TO_AVERAGE;
+  uint forwardEndIndex = index + EXTRA_WIDTH_TO_AVERAGE;
  if (forwardEndIndex >= colHeights.size())
    forwardEndIndex = colHeights.size() - 1;

@@ -163,7 +163,7 @@ HistogramDirection VerticalHistogram::getHistogramDirection(int index)
  }
  trailingAverage = trailingAverage / ((float) (1 + index - trailStartIndex));

-  for (int i = index; i <= forwardEndIndex; i++)
+  for (uint i = index; i <= forwardEndIndex; i++)
  {
    forwardAverage += colHeights[i];
  }
--- a/src/openalpr/segmentation/verticalhistogram.h
+++ b/src/openalpr/segmentation/verticalhistogram.h
@@ -58,7 +58,7 @@ class VerticalHistogram
    void analyzeImage(cv::Mat inputImage, cv::Mat mask);
    void findValleys();

-    HistogramDirection getHistogramDirection(int index);
+    HistogramDirection getHistogramDirection(uint index);
 };

 #endif // OPENALPR_VERTICALHISTOGRAM_H
--- a/src/openalpr/utility.cpp
+++ b/src/openalpr/utility.cpp
@@ -45,13 +45,13 @@ Rect expandRect(Rect original, int expandXPixels, int expandYPixels, int maxX, i
  return expandedRegion;
 }

-Mat drawImageDashboard(vector<Mat> images, int imageType, int numColumns)
+Mat drawImageDashboard(vector<Mat> images, int imageType, uint numColumns)
 {
-  int numRows = ceil((float) images.size() / (float) numColumns);
+  uint numRows = ceil((float) images.size() / (float) numColumns);

  Mat dashboard(Size(images[0].cols * numColumns, images[0].rows * numRows), imageType);

-  for (int i = 0; i < numColumns * numRows; i++)
+  for (uint i = 0; i < numColumns * numRows; i++)
  {
    if (i < images.size())
      images[i].copyTo(dashboard(Rect((i%numColumns) * images[i].cols, floor((float) i/numColumns) * images[i].rows, images[i].cols, images[i].rows)));
@@ -386,6 +386,10 @@ std::string toString(int value)
  ss << value;
  return ss.str();
 }
+std::string toString(uint value)
+{
+  return toString((int) value);
+}
 std::string toString(float value)
 {
  stringstream ss;
--- a/src/openalpr/utility.h
+++ b/src/openalpr/utility.h
@@ -84,7 +84,7 @@ double median(int array[], int arraySize);

 std::vector<cv::Mat> produceThresholds(const cv::Mat img_gray, Config* config);

-cv::Mat drawImageDashboard(std::vector<cv::Mat> images, int imageType, int numColumns);
+cv::Mat drawImageDashboard(std::vector<cv::Mat> images, int imageType, uint numColumns);

 void displayImage(Config* config, std::string windowName, cv::Mat frame);
 void drawAndWait(cv::Mat* frame);
@@ -108,6 +108,7 @@ cv::Mat addLabel(cv::Mat input, std::string label);


 std::string toString(int value);
+std::string toString(uint value);
 std::string toString(float value);
 std::string toString(double value);