sclass SimpleRecognizer {

  bool useCache1 = true, useCache2 = true;

  S initial = [[

  The images "9176714c9a935fc91e14595dbb3adddf 35731666e72dd0c9448f616ff3a7464a da9bc5a24bd503e898f69ad43bb9b92e" are the characters "yet".

  The images "412f9e0f8e177817a4fa285415c5a13f 386b289407599f31e3a7c57c3adb2587 6cd2a2284a5a6fda3a7cad3e3a048671 b0c47c014d665ec5b658f510c258dc47 b273ff598fe6afa04cfed9f9e8fb4109" are the grouped characters "[Ob]ject".

  The images "175116b749670b7b65707c10c935b42c ddaf2b9c198818c49628387ecc2910ed 3777597e39eb0de16c022293c8c91cc0 fad86bda3f716ef4e7fa9d199f6c4383 35731666e72dd0c9448f616ff3a7464a 03b96c30adaaed5b60cea4ab9bc37263" are the characters "images".

  ]];

  Lock lock = lock();

  class GlyphInfo {

    S meaning;

    bool multi; // multiple meanings seen

  }

  // key = md5

  new Map<S, GlyphInfo> glyphInfos;

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

  Map<BWImage, S> fullSearchMap;

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

  *() {

    load(initial);

  }

  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) {

    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));

  }

  // lookup stored recognition of whole image

  Scored<S> recognizeCheat(BWImage img) {

    lock lock;

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

    GlyphInfo info = getVar(scored);

    if (info != null && info.meaning != null) ret scored(info.meaning, scored);

    null;

  }

  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<L<S>>> recognizeGrouped_cache = synchroMap();

  int cantCache, cacheHits, cacheMisses;

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

    S md5 = null;

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

    else {

      md5 = md5OfBWImage(img);

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

      if (result != null) {

        ++cacheHits;

        ret result;

      } else ++cacheMisses;

    }

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

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

    ret result;

  }

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

    lock lock;

    // TODO: auto-crop here?

    Scored<S> s = recognizeCheat(img);

    if (s != null) {

      if (clips_out != null) clips_out.add(new Rect(0, 0, img.w(), img.h()));

      ret scored(ll(ocr_escapeMeaning(s!)), s); // hmm... how to group? does it matter?

    }

    new L<S> buf;

    L<Rect> rects = horizontalAutoSplit2ThenAutoCrop(img);

    if (empty(rects)) ret scored(ll(unknownCharacter), 0.5);

    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, bool fullSearch) {

    S md5 = md5OfBWImage(img);

    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 : 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);

  }

}