training: Replace NULL by nullptr

Signed-off-by: Stefan Weil <sw@weilnetz.de>

Author: stweil

training/ambiguous_words.cpp

@@ -56,21 +56,21 @@ int main(int argc, char** argv) {
   vars_vec.push_back("output_ambig_words_file");
   vars_values.push_back(output_file_str);
   api.Init(tessdata_dir, lang.string(), tesseract::OEM_TESSERACT_ONLY,
-           NULL, 0, &vars_vec, &vars_values, false);
+           nullptr, 0, &vars_vec, &vars_values, false);
   tesseract::Dict &dict = api.tesseract()->getDict();
   FILE *input_file = fopen(input_file_str, "rb");
-  if (input_file == NULL) {
+  if (input_file == nullptr) {
     tprintf("Failed to open input wordlist file %s\n", input_file_str);
     exit(1);
   }
   char str[CHARS_PER_LINE];
 
   // Read word list and call Dict::NoDangerousAmbig() for each word
   // to record ambiguities in the output file.
-  while (fgets(str, CHARS_PER_LINE, input_file) != NULL) {
+  while (fgets(str, CHARS_PER_LINE, input_file) != nullptr) {
     chomp_string(str);  // remove newline
     WERD_CHOICE word(str, dict.getUnicharset());
-    dict.NoDangerousAmbig(&word, NULL, false, NULL);
+    dict.NoDangerousAmbig(&word, nullptr, false, nullptr);
   }
   // Clean up.
   fclose(input_file);

training/boxchar.cpp

@@ -39,7 +39,7 @@ const int kMinNewlineRatio = 5;
 namespace tesseract {
 
 BoxChar::BoxChar(const char* utf8_str, int len) : ch_(utf8_str, len) {
-  box_ = NULL;
+  box_ = nullptr;
 }
 
 BoxChar::~BoxChar() { boxDestroy(&box_); }
@@ -53,7 +53,7 @@ void BoxChar::TranslateBoxes(int xshift, int yshift,
                              std::vector<BoxChar*>* boxes) {
   for (int i = 0; i < boxes->size(); ++i) {
     BOX* box = (*boxes)[i]->box_;
-    if (box != NULL) {
+    if (box != nullptr) {
       box->x += xshift;
       box->y += yshift;
     }
@@ -69,7 +69,7 @@ void BoxChar::PrepareToWrite(std::vector<BoxChar*>* boxes) {
   InsertNewlines(rtl_rules, vertical_rules, boxes);
   InsertSpaces(rtl_rules, vertical_rules, boxes);
   for (int i = 0; i < boxes->size(); ++i) {
-    if ((*boxes)[i]->box_ == NULL) tprintf("Null box at index %d\n", i);
+    if ((*boxes)[i]->box_ == nullptr) tprintf("Null box at index %d\n", i);
   }
   if (rtl_rules) {
     ReorderRTLText(boxes);
@@ -84,14 +84,14 @@ void BoxChar::InsertNewlines(bool rtl_rules, bool vertical_rules,
   int max_shift = 0;
   for (int i = 0; i < boxes->size(); ++i) {
     Box* box = (*boxes)[i]->box_;
-    if (box == NULL) {
+    if (box == nullptr) {
       if (prev_i < 0 || prev_i < i - 1 || i + 1 == boxes->size()) {
         // Erase null boxes at the start of a line and after another null box.
         do {
           delete (*boxes)[i];
           boxes->erase(boxes->begin() + i);
           --i;
-        } while (i >= 0 && i + 1 == boxes->size() && (*boxes)[i]->box_ == NULL);
+        } while (i >= 0 && i + 1 == boxes->size() && (*boxes)[i]->box_ == nullptr);
       }
       continue;
     }
@@ -139,18 +139,18 @@ void BoxChar::InsertNewlines(bool rtl_rules, bool vertical_rules,
   }
 }
 
-// Converts NULL boxes to space characters, with appropriate bounding boxes.
+// Converts nullptr boxes to space characters, with appropriate bounding boxes.
 /* static */
 void BoxChar::InsertSpaces(bool rtl_rules, bool vertical_rules,
                            std::vector<BoxChar*>* boxes) {
   // After InsertNewlines, any remaining null boxes are not newlines, and are
   // singletons, so add a box to each remaining null box.
   for (int i = 1; i + 1 < boxes->size(); ++i) {
     Box* box = (*boxes)[i]->box_;
-    if (box == NULL) {
+    if (box == nullptr) {
       Box* prev = (*boxes)[i - 1]->box_;
       Box* next = (*boxes)[i + 1]->box_;
-      ASSERT_HOST(prev != NULL && next != NULL);
+      ASSERT_HOST(prev != nullptr && next != nullptr);
       int top = MIN(prev->y, next->y);
       int bottom = MAX(prev->y + prev->h, next->y + next->h);
       int left = prev->x + prev->w;
@@ -170,14 +170,14 @@ void BoxChar::InsertSpaces(bool rtl_rules, bool vertical_rules,
              j >= 0 && (*boxes)[j]->ch_ != " " && (*boxes)[j]->ch_ != "\t";
              --j) {
           prev = (*boxes)[j]->box_;
-          ASSERT_HOST(prev != NULL);
+          ASSERT_HOST(prev != nullptr);
           if (prev->x < right) {
             right = prev->x;
           }
         }
         // Left becomes the max right of all next boxes forward to the first
         // space or newline.
-        for (int j = i + 2; j < boxes->size() && (*boxes)[j]->box_ != NULL &&
+        for (int j = i + 2; j < boxes->size() && (*boxes)[j]->box_ != nullptr &&
                                 (*boxes)[j]->ch_ != "\t";
              ++j) {
           next = (*boxes)[j]->box_;
@@ -244,7 +244,7 @@ bool BoxChar::ContainsMostlyRTL(const std::vector<BoxChar*>& boxes) {
 bool BoxChar::MostlyVertical(const std::vector<BoxChar*>& boxes) {
   inT64 total_dx = 0, total_dy = 0;
   for (int i = 1; i < boxes.size(); ++i) {
-    if (boxes[i - 1]->box_ != NULL && boxes[i]->box_ != NULL &&
+    if (boxes[i - 1]->box_ != nullptr && boxes[i]->box_ != nullptr &&
         boxes[i - 1]->page_ == boxes[i]->page_) {
       int dx = boxes[i]->box_->x - boxes[i - 1]->box_->x;
       int dy = boxes[i]->box_->y - boxes[i - 1]->box_->y;
@@ -303,7 +303,7 @@ string BoxChar::GetTesseractBoxStr(int height,
   char buffer[kMaxLineLength];
   for (int i = 0; i < boxes.size(); ++i) {
     const Box* box = boxes[i]->box_;
-    if (box == NULL) {
+    if (box == nullptr) {
       tprintf("Error: Call PrepareToWrite before WriteTesseractBoxFile!!\n");
       return "";
     }

training/boxchar.h

@@ -60,8 +60,8 @@ class BoxChar {
   // Sort function for sorting by left edge of box. Note that this will not
   // work properly until after InsertNewlines and InsertSpaces.
   bool operator<(const BoxChar& other) const {
-    if (box_ == NULL) return true;
-    if (other.box_ == NULL) return false;
+    if (box_ == nullptr) return true;
+    if (other.box_ == nullptr) return false;
     return box_->x < other.box_->x;
   }
 
@@ -74,7 +74,7 @@ class BoxChar {
   // Inserts newline (tab) characters into the vector at newline positions.
   static void InsertNewlines(bool rtl_rules, bool vertical_rules,
                              vector<BoxChar*>* boxes);
-  // Converts NULL boxes to space characters, with appropriate bounding boxes.
+  // Converts nullptr boxes to space characters, with appropriate bounding boxes.
   static void InsertSpaces(bool rtl_rules, bool vertical_rules,
                            vector<BoxChar*>* boxes);
   // Reorders text in a right-to-left script in left-to-right order.

training/classifier_tester.cpp

@@ -40,7 +40,7 @@ enum ClassifierName {
 };
 
 const char* names[] = {"pruner", "full",
-                       NULL};
+                       nullptr};
 
 static tesseract::ShapeClassifier* InitializeClassifier(
     const char* classifer_name, const UNICHARSET& unicharset,
@@ -56,33 +56,33 @@ static tesseract::ShapeClassifier* InitializeClassifier(
   }
   if (classifier == CN_COUNT) {
     fprintf(stderr, "Invalid classifier name:%s\n", FLAGS_classifier.c_str());
-    return NULL;
+    return nullptr;
   }
 
   // We need to initialize tesseract to test.
   *api = new tesseract::TessBaseAPI;
   tesseract::OcrEngineMode engine_mode = tesseract::OEM_TESSERACT_ONLY;
-  tesseract::Tesseract* tesseract = NULL;
-  tesseract::Classify* classify = NULL;
+  tesseract::Tesseract* tesseract = nullptr;
+  tesseract::Classify* classify = nullptr;
   if (
       classifier == CN_PRUNER || classifier == CN_FULL) {
     if ((*api)->Init(FLAGS_tessdata_dir.c_str(), FLAGS_lang.c_str(),
                  engine_mode) < 0) {
       fprintf(stderr, "Tesseract initialization failed!\n");
-      return NULL;
+      return nullptr;
     }
     tesseract = const_cast<tesseract::Tesseract*>((*api)->tesseract());
     classify = reinterpret_cast<tesseract::Classify*>(tesseract);
-    if (classify->shape_table() == NULL) {
+    if (classify->shape_table() == nullptr) {
       fprintf(stderr, "Tesseract must contain a ShapeTable!\n");
-      return NULL;
+      return nullptr;
     }
   }
-  tesseract::ShapeClassifier* shape_classifier = NULL;
+  tesseract::ShapeClassifier* shape_classifier = nullptr;
 
   if (!FLAGS_T.empty()) {
     const char* config_name;
-    while ((config_name = GetNextFilename(argc, argv)) != NULL) {
+    while ((config_name = GetNextFilename(argc, argv)) != nullptr) {
       tprintf("Reading config file %s ...\n", config_name);
       (*api)->ReadConfigFile(config_name);
     }
@@ -93,7 +93,7 @@ static tesseract::ShapeClassifier* InitializeClassifier(
     shape_classifier = new tesseract::TessClassifier(false, classify);
   } else {
     fprintf(stderr, "%s tester not yet implemented\n", classifer_name);
-    return NULL;
+    return nullptr;
   }
   tprintf("Testing classifier %s:\n", classifer_name);
   return shape_classifier;
@@ -122,12 +122,12 @@ int main(int argc, char **argv) {
   ParseArguments(&argc, &argv);
   STRING file_prefix;
   tesseract::MasterTrainer* trainer = tesseract::LoadTrainingData(
-      argc, argv, false, NULL, &file_prefix);
+      argc, argv, false, nullptr, &file_prefix);
   tesseract::TessBaseAPI* api;
   // Decode the classifier string.
   tesseract::ShapeClassifier* shape_classifier = InitializeClassifier(
       FLAGS_classifier.c_str(), trainer->unicharset(), argc, argv, &api);
-  if (shape_classifier == NULL) {
+  if (shape_classifier == nullptr) {
     fprintf(stderr, "Classifier init failed!:%s\n", FLAGS_classifier.c_str());
     return 1;
   }
@@ -139,7 +139,7 @@ int main(int argc, char **argv) {
 
   trainer->TestClassifierOnSamples(tesseract:: CT_UNICHAR_TOP1_ERR,
                                    MAX(3, FLAGS_debug_level), false,
-                                   shape_classifier, NULL);
+                                   shape_classifier, nullptr);
   delete shape_classifier;
   delete api;
   delete trainer;

training/cntraining.cpp

@@ -137,7 +137,7 @@ int main(int argc, char *argv[]) {
   const char  *PageName;
   FILE  *TrainingPage;
   LIST  CharList = NIL_LIST;
-  CLUSTERER  *Clusterer = NULL;
+  CLUSTERER  *Clusterer = nullptr;
   LIST    ProtoList = NIL_LIST;
   LIST    NormProtoList = NIL_LIST;
   LIST pCharList;
@@ -147,11 +147,11 @@ int main(int argc, char *argv[]) {
 
   ParseArguments(&argc, &argv);
   int num_fonts = 0;
-  while ((PageName = GetNextFilename(argc, argv)) != NULL) {
+  while ((PageName = GetNextFilename(argc, argv)) != nullptr) {
     printf("Reading %s ...\n", PageName);
     TrainingPage = Efopen(PageName, "rb");
     ReadTrainingSamples(FeatureDefs, PROGRAM_FEATURE_TYPE,
-                        100, NULL, TrainingPage, &CharList);
+                        100, nullptr, TrainingPage, &CharList);
     fclose(TrainingPage);
     ++num_fonts;
   }
@@ -168,7 +168,7 @@ int main(int argc, char *argv[]) {
     CharSample = (LABELEDLIST)first_node(pCharList);
     Clusterer =
       SetUpForClustering(FeatureDefs, CharSample, PROGRAM_FEATURE_TYPE);
-    if (Clusterer == NULL) {  // To avoid a SIGSEGV
+    if (Clusterer == nullptr) {  // To avoid a SIGSEGV
       fprintf(stderr, "Error: NULL clusterer!\n");
       return 1;
     }
@@ -229,7 +229,7 @@ void WriteNormProtos(const char *Directory, LIST LabeledProtoList,
   int N;
 
   Filename = "";
-  if (Directory != NULL && Directory[0] != '\0')
+  if (Directory != nullptr && Directory[0] != '\0')
   {
     Filename += Directory;
     Filename += "/";