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