// complexity is number of assumed heights * number of widths

sclass MultiLevelRecognizer2 {

  // how big do we think the prototype is in the whole image

  // (percentage by height)

  transient L<Double> assumedPrototypeHeightPercentages = ll(70.0, 70.0/sqrt(2), 35.0, 35.0/sqrt(2), 17.0);

  // widths to scale camera image to

  transient L<Int> widths = ll(32, 64, 128);

  transient JTabbedPane tabs; // initialize if you want visualization

  transient ImageSurface bestImageSurface;

  transient JLabel bestLabel;

  transient BWIntegralImage baseImage;

  transient new L<BWIntegralImage> prototypeImages;

  transient new Map<Int, IBWIntegralImage> integralImages; // key = width

  transient new L<Chain> chains; // one per assumed height & prototype

  // chain of recognizers for one assumed height

  class Chain {

    BWIntegralImage prototypeImage;

    double assumedHeightPercentage;

    new L<OneLevel> levels; // recognizers for each granularity

    new Map<Int, BWImage> scaledPrototypeImages; // key = height

    *(double *assumedHeightPercentage, BWIntegralImage *prototypeImage) { make(); }

    void make {

      for (int w : widths) {

        IBWIntegralImage ii = mapGetOrCreate(integralImages, w, () -> scaledIBWIntegralImage(baseImage, w));

        OneLevel lvl = new(this, last(levels), ii);

        levels.add(lvl);

        if (tabs != null && eq(w, last(widths))) {

          lvl.is = jPixelatedZoomedImageSurface(

            doubleRatio(baseImage.getWidth(), w), iBWIntegralImageToBWImage(ii));

          addTab(tabs, iround(assumedHeightPercentage) + ":" + w, northAndCenterWithMargins(

            lvl.infoLabel = jcenteredlabel(), jFullCenterScroll(lvl.is)));

        }

      }

    }

    void reset {

      for (OneLevel l : levels) l.reset();

    }

    Steppable makeSteppable() {

      ret iteratorToSteppable(roundRobinCombinedIterator(lambdaMap steppableToIterator(levels)));

    }

    Scored<Rect> bestResult() {

      ret last(levels).scoredBestRescaled();

    }

  }

  class OneLevel extends SteppableAndBest<Rect> {

    Chain chain;

    OneLevel previous, next;

    IBWIntegralImage ii; // scaled integral image

    BWImage image;       // scaled image

    BWImage prototype;   // scaled prototype

    float minSimilarity = 0.5f;

    ImageSurface is;

    JLabel infoLabel;

    // candidates are top-left corner of rect to try in our coordinates

    L<Pt> candidatesQueue = syncLinkedList();

    new Set<Pt> candidatesTried;

    Iterator<Pt> candidatesStream;

    *(Chain *chain, OneLevel *previous, IBWIntegralImage *ii) {

      if (previous != null) previous.next = this;

      image = iBWIntegralImageToBWImage(ii);

      // get assumed height of prototype in scaled-down image

      int ph = iround(ii.getHeight()*chain.assumedHeightPercentage/100.0);

      // resize prototype

      prototype = mapGetOrCreate(chain.scaledPrototypeImages, ph,

        () -> scaleDownUsingIntegralImageBW(chain.prototypeImage, ph);

      /*addTab(tabs, "proto " + ii.getWidth(),

 jFullCenterScroll(jPixelatedZoomedImageSurface(4.0, prototype)));

*/

      reset();

    }

    void reset {

      candidatesTried.clear();

      candidatesStream = fullStream();

    }

    // all candidates

    Iterator<Pt> fullStream() {

      ret allSubRectsOfSizeIterator_topLeftCorners(prototype.getWidth(), prototype.getHeight(),

        imageRect(image));

    }

    public bool step() {

      Pt p = nextCandidate();

      if (p != null) ret true with tryCandidate(p);

      false;

    }

    Pt nextCandidate() {

      try object Pt p = popFirst(candidatesQueue);

      ret nextFromIterator(candidatesStream);

    }

    void tryCandidate(Pt p) {

      if (!candidatesTried.add(p)) ret;

      int x = p.x, y = p.y, wp = prototype.getWidth(), hp = prototype.getHeight();

      float maxError = (1f-minSimilarity)*wp*hp;

      float diff = bwImageSectionsSimilarity(image, prototype, x, y, maxError);

      if (diff <= maxError)

        best.put(new Rect(x, y, wp, hp), 1-diff/(wp*hp));

    }

    void showBest() {

      setImageSurfaceSelection(is, best!);

      setText(infoLabel, best);

    }

    // best rect in original image coordinates

    Rect bestRescaled() {

      ret rescaleRect(best!, ii.getWidth(), ii.getHeight(),

        baseImage.getWidth(), baseImage.getHeight());

    }

    Scored<Rect> scoredBestRescaled() {

      ret scored(bestRescaled(), best.score);

    }

  }

  *() {}

  *(File imgFile) {

    baseImage = loadBWIntegralImage(imgFile);

  }

  void addPrototype(BufferedImage img) {

    prototypeImages.add(bwIntegralImage(img));

  }

  void addPrototype(File imgFile) {

    addPrototype(loadImage2(imgFile));

  }

  void addPrototypes(Iterable<BufferedImage> l) {

    fOr (BufferedImage img : l) addPrototype(img);

  }

  Scored<Rect> go() {

    if (empty(chains)) {

      assertNotNull(+baseImage);

      assertNempty(+prototypeImages);

      if (tabs != null)

        addTab(tabs, "Best", northAndCenterWithMargins(

          bestLabel = jcenteredlabel(), 

          jFullCenterScroll(bestImageSurface = jImageSurface(bwIntegralImageToBWImage(baseImage)))));

      makeChains();

    } else

      reset();

    time "Process" {

      print("Steps: " + stepAll_roundRobin(map(chains, c -> c.makeSteppable())));

    }

    showBest();

    ret bestResult();

  }

  void showBest {

    for (Chain c : chains)

      for (OneLevel l : c.levels)

        l.showBest();

    setText(bestLabel, bestResult());

    setImageSurfaceSelection(bestImageSurface, bestResult()!);

  }

  void makeChains {

    chains.clear();

    for (double ah : assumedPrototypeHeightPercentages)

      for (BWIntegralImage proto : prototypeImages)

        chains.add(new Chain(ah, proto));

  }

  Scored<Rect> bestResult() {

    ret bestScored(map(methodLambda0 bestResult, chains));

  }

  void reset {

    for (Chain c : chains) c.reset();

  }

}