!7

cmodule TestWordRecognizers > DynSingleFunctionWithPrintLog {

  S scoreModule;

  long maxMBs = 256; // save dat memory

  transient L<Result> results = syncList();

  new Best<S> best;

  transient int maxDiff = 2;

  transient long dataSize;

  transient new L<TestImage> images;

  transient JProgressBar progressBar;

  transient Map<S, BufferedImage> preloadedImages;

  srecord Recognizer(S name, IF1<BufferedImage, S> function, long size) {

    toString { ret name; }

  }

  // result for recognizer

  srecord noeq Result(

    Recognizer recognizer,

    double score, Map<TestResult, Double> individualScores) {}

  // individual test result

  srecord noeq TestResult(

    TestImage test,

    S line,

    long time

  ) {

    void showDetails { activateFrame(quickShowImage(test.img)); }

    Map<S, O> extraColumns() {

      ret litorderedmap("Image" := test.img);

    }

  }

  srecord noeq TestImage(S caseName, BufferedImage img, S interpretation) {

    toString { ret caseName + ": " + interpretation; }

  }

  bool spaceToSpare() { ret toMB(dataSize) < maxMBs; }

  void doIt {

    prepare();

    results.clear();

    dm_rcall clear(scoreModule);

    SimpleRecognizer r = simpleRecognizer();

    testRecognizer("simpleRecognizer", r);

    r = simpleRecognizer();

    r.wordImagePreprocessor = lambda1 bwAutoContrast;

    testRecognizer("simpleRecognizer autoContrast", r);

  }

  void testRecognizer(S desc, SimpleRecognizer r) {

    testRecognizer(new Recognizer(

      desc + " (" + r.sizeStats() + ")",

      img -> r.recognize(BWImage(img)),

      guessObjectSize(r)));

  }

  void prepare runInQAndWait {

    if (empty(images)) loadImages();

    setField(scoreModule := dm_loadOrActivateScoreMatrixModule(scoreModule));

  }

  Result scoreRecognizer(Recognizer rec) {

    Result result = new(rec, 0, new LinkedHashMap);

    try {

      new Scorer scorer;

      for (TestImage img : images) {

        long time = sysNow();

        S out = rec.function.get(img.img);

        time = sysNow()-time;

        int diff = leven_limited(img.interpretation, out, maxDiff);

        //double score = eq(out, img.groupedChars) ? 1 : 0; // TODO

        double score = 1.0-doubleRatio(diff, min(l(img.interpretation), maxDiff));

        scorer.addZeroToOne(score);

        result.individualScores.put(new TestResult(img, out, time), score);

      }

      print(scorer);

      result.score = scorer.score();

    } catch print e {

      print("RECOGNIZER TOTAL FAIL");

    }

    ret result;

  }

  void loadImages {

    File dir = screenClipsDir();

    L<File> in = asLinkedList(listFilesWithExtension(".line", dir));

    while (nempty(in)) {

      if (!spaceToSpare())

        break with print("Out of space (" + toM(dataSize) + " MB used), skipping " + nImages(in));

      File f = popFirst(in);

      File fImg = replaceExtension(f, ".png");

      if (!fileExists(fImg)) continue;

      S desc = firstLineOfFile(f);

      new Matches m;

      if (!find3("the images * are the grouped characters *", desc, m)) continue;

      S interpretation = dropSpaces($2); // why drop spaces?

      interpretation = join(map deSquareBracket(ocr_parseGlyphs(interpretation));

      //LS characters = ocr_parseGlyphs(interpretation);

      pcall {

        BufferedImage img = or_func(mapGet(preloadedImages, fileName(fImg)), () -> loadImage2(fImg));

        images.add(new TestImage(fileName(fImg), img, interpretation);

        dataSize += bufferedImageDataSize(img);

        print("Have " + nImages(images) + ", data size: " + toM(dataSize) + " MB");

      }

    }

    print("Loading done");

  }

  start { setFunctionName("Run tests"); }

  visual centerAndSouthWithMargin(super, withMargin(progressBar = jProgressBarWithText()));

  void testRecognizer(Recognizer rec) {

    prepare();

    Result r = scoreRecognizer(rec);

    print("Score for " + rec + ": " + r.score);

    results.add(r);

    if (best.put(name, r.score))

      print("NEW BEST!");

    change();

    dm_rcall add(scoreModule,

      dm_rcall newEntry(scoreModule, r.recognizer, r.score, r.individualScores));

  }

  Map<S, BufferedImage> _getReloadData() { ret mapFieldToField('caseName, 'img, images); }

  void _setReloadData(Map<S, BufferedImage> map) { preloadedImages = map; }

}