sclass SimpleRecognizer {

  bool useCache1 = true, useCache2 = true;

  Lock lock = lock();

  transient IF1<BWImage> wordImagePreprocessor; // optional preprocessor for word images (e.g. auto-contast)

  class GlyphInfo {

    S meaning;

    bool multi; // multiple meanings seen

    toString { ret meaning; }

  }

  // key = md5

  Map<S, GlyphInfo> glyphInfos = synchroMap();

  // optional for full similarity search - character image to MD5

  Map<BWImage, S> fullSearchMap;

  S unknownCharacter = ocr_unknownCharacterPlaceholder(); // "\u2666" - diamond suit symbol; used for unknown characters

  *() {}

  void load(S info) {

    lock lock;

    recognizeGrouped_cache.clear();

    new Matches m;

    for (S s : toLinesFullTrim(info)) {

      if (find3("the images * are the characters *", s, m)) {

        L<S> md5s = splitAtSpace($1);

        L<S> characters = eachCharAsString(dropSpaces($2));

        saveMeanings(md5s, characters);

      } else if (find3("the images * are the grouped characters *", s, m)) {

        L<S> md5s = splitAtSpace($1);

        L<S> characters = ocr_parseGlyphs(dropSpaces($2));

        saveMeanings(md5s, characters);

      } else if (nempty(javaTokC(s))) {

        print("huh? " + s);

      }

    }

    //print("Have " + n(l(glyphInfos), "glyph info"));

    //psl(glyphInfos);

  }

  void saveMeaning(S md5, S meaning) {

    GlyphInfo info = getGlyphInfo(md5);

    if (info.multi) ret;

    if (hasDifferent(info.meaning, meaning)) {

      //info.meaning = null;

      info.meaning = meaning;

      info.multi = true;

      //print("multi");

    } else

      info.meaning = meaning;

  }

  // gets or creates GlyphInfo

  GlyphInfo getGlyphInfo(S md5) {

    synchronized(glyphInfos) {

      GlyphInfo info = glyphInfos.get(md5);

      if (info == null)

        glyphInfos.put(md5, info = new GlyphInfo);

      ret info;

    }

  }

  void saveMeanings(L<S> md5s, L<S> characters) {

    if (l(md5s) != l(characters)) { print("huh?"); ret; }

    for i over md5s:

      saveMeaning(md5s.get(i), characters.get(i));

  }

  S recognize(BWImage img) {

    ret ocr_joinGroups(recognizeGrouped(img));

  }

  Scored<S> recognizeScored(BWImage img) {

    Scored<L<S>> s = recognizeGrouped(img, null);

    ret scored(ocr_joinGroups(s!), s);

  }

  L<S> recognizeGrouped(BWImage img) {

    ret getVar(recognizeGrouped(img, null));

  }

  // md5 -> recognition result

  Map<S, Scored<LS>> recognizeGrouped_cache = synchroMap();

  int cantCache, cacheHits, cacheMisses;

  Scored<LS> recognizeGrouped(BWImage img, L<Rect> clips_out) {

    S md5 = null;

    if (clips_out != null || !useCache1) ++cantCache;

    else {

      img = callFOrKeep(wordImagePreprocessor, img);

      md5 = md5OfBWImage(img);

      Scored<LS> result = recognizeGrouped_cache.get(md5);

      if (result != null) {

        ++cacheHits;

        ret result;

      } else ++cacheMisses;

    }

    Scored<LS> result = recognizeGrouped_uncached(img, clips_out);

    if (md5 != null) recognizeGrouped_cache.put(md5, result);

    ret result;

  }

  Scored<LS> recognizeGrouped_uncached(BWImage img, L<Rect> clips_out) {

    new LS buf;

    L<Rect> rects = horizontalAutoSplit2ThenAutoCrop(img);

    if (empty(rects)) ret scored((L<S>) emptyList(), 0.99);

    new L<Scored> scores;

    iLoop: for (int i = 0; i < l(rects); i++) {

      Rect r = null;

      for (int j = i; j < l(rects); j++) {

        r = rectUnion(r, rects.get(j));

        BWImage cImg = img.clip(r);

        Scored<GlyphInfo> scored = recognizeGlyph(cImg, false);

        GlyphInfo info = getVar(scored);

        if (info != null && info.meaning != null) {

          buf.add(info.meaning);

          buf.addAll(rep("_", j-i));

          if (clips_out != null) clips_out.addAll(rep(r, j-i+1));

          scores.add(scored);

          i = j;

          continue iLoop;

        }

      }

      r = rects.get(i);

      Scored<GlyphInfo> scored = recognizeGlyph(img.clip(r), true);

      GlyphInfo info = getVar(scored);

      if (info != null && info.meaning != null)

        buf.add(info.meaning);

      else

        buf.add(unknownCharacter);

      if (clips_out != null) clips_out.add(r);

      scores.add(scored);

    }

    ret scored(buf, averageScore(scores));

  }

  // md5 -> recognition result

  Map<S, Scored<GlyphInfo>> recognizeGlyph_cache = synchroMap();

  static int cacheHits2, cacheMisses2;

  Scored<GlyphInfo> recognizeGlyph(BWImage img) {

    ret recognizeGlyph(img, true);

  }

  Scored<GlyphInfo> recognizeGlyph(BWImage img, bool fullSearch) {

    S md5 = md5OfBWImage(img);

    {

      //lock lock;

      GlyphInfo info = glyphInfos.get(md5);

      if (info != null || !fullSearch || fullSearchMap == null) ret fullScored(info);

      if (useCache2) {

        Scored<GlyphInfo> result = recognizeGlyph_cache.get(md5);

        if (result != null) { ++cacheHits2; ret result; }

        cacheMisses2++;

      }

    }

    new Best<S> best;

    for (BWImage cImg : /*concurrentlyIterateKeys*/keys(fullSearchMap)) {

      float sim = bwImageSimilarityResized(img, cImg, (float) best.bestScore());

      best.put(fullSearchMap.get(cImg), sim);

    }

    Scored<GlyphInfo> result = !best.has() ? null : scored(glyphInfos.get(best!), best.score());

    if (useCache2)

      recognizeGlyph_cache.put(md5, result);

    ret result;

  }

  S cacheStats() {

    //ret "Cache size: " + l(recognizeGrouped_cache) + ", hits: " + cacheHits + ", misses: " + cacheMisses + ", uncachable: " + cantCache;

    ret "Cache size: " + l(recognizeGlyph_cache) + ", hits: " + cacheHits2 + ", misses: " + cacheMisses2 + ", full search map: " + l(fullSearchMap);

  }

  S sizeStats() {

    ret l(glyphInfos) + "/" + l(fullSearchMap);

  }

}