sclass MultiLevelRecognizer1 {

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

  // (percentage by height)

  transient double assumedPrototypeHeightPercentage = 70;

  transient JTabbedPane tabs; // initialize if you want visualization

  transient BWIntegralImage baseImage;

  transient BWImage prototypeImage;

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

  transient new L<IBWIntegralImage> integralImages;

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

  class OneLevel extends SteppableAndBest<Rect> {

    IBWIntegralImage ii; // scaled integral image

    BWImage image;       // scaled image

    BWImage prototype;   // scaled prototype

    float minSimilarity = 0.5f;

    ImageSurface is;

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

    L<Pt> candidatesQueue = syncLinkedList();

    new Set<Pt> candidatesTried;

    Iterator<Pt> candidatesStream;

    *(IBWIntegralImage *ii) {

      image = iBWIntegralImageToBWImage(ii);

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

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

      // resize prototype

      prototype = bwResizeToHeightSmooth(prototypeImage, ph);

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

        jFullCenterScroll(jPixelatedZoomedImageSurface(4.0, prototype)));

      candidatesStream = mapI rectTopLeftCorner(allSubRectsOfSizeIterator(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!);

    }

    // 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 prototypeImage, File imgFile) {

    this.prototypeImage = loadBWImage(prototypeImage);

    this.baseImage = loadBWIntegralImage(imgFile);

  }

  Scored<Rect> go() {

    assertNotNull(+baseImage);

    assertNotNull(+prototypeImage);

    for (int w : widths) {

      IBWIntegralImage ii = scaledIBWIntegralImage(baseImage, w);

      integralImages.add(ii);

      OneLevel lvl = new(ii);

      levels.add(lvl);

      if (tabs != null) {

        ImageSurface is = jPixelatedZoomedImageSurface(

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

        addTab(tabs, "w=" + w, jFullCenterScroll(is));

        lvl.is = is;

      }

    }

    if (tabs != null)

      addTab(tabs, "Prototype", jFullCenterScroll(jPixelatedZoomedImageSurface(4, prototypeImage)));

    time "Process" {

      print("Steps: " + stepAll_roundRobin(levels));

    }

    if (tabs != null)

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

    ret bestResult();

  }

  Scored<Rect> bestResult() {

    ret last(levels).scoredBestRescaled();

  }

}