do not include class IntegralImage.

do not include class IIntegralImage.

// Note: featureSize should not be smaller than maxDescentLevel

srecord noeq MinimalRecognizer(BufferedImage inputImage) {

  replace Channel with int.

  IntegralImage mainImage;

  bool verbose, verboseLookAt, verboseValues,

    verboseDescentProbabilities, verboseFound, verboseImageSize,

    verboseDecentLevelReached;

  new Map<Rect, IIntegralImage> clipCache;

  static final int grayscale = 3; // channel number for grayscale

  static final int channels = 4;

  abstract class IIntegralImage {

    // width and height of image

    int w, h;

    int liveliness_cachedChannel = -1;

    double liveliness_cache;

    long discoveredInStep;

    abstract double integralValue(int x, int y, Channel channel);

    BufferedImage render() {

      ret imageFromFunction(w, h, (x, y) -> rgbPixel(x, y, x+1, y+1) | fullAlphaMask());

    }

    double getPixel(Rect r, int channel) {

      ret getPixel(r.x, r.y, r.x2(), r.y2(), channel);

    }

    double getPixel(int channel) { ret getPixel(0, 0, w, h, channel); }

    // return value ranges from 0 to 1 (usually)

    double getPixel(int x1, int y1, int x2, int y2, int channel) {

      ret doubleRatio(rectSum(x1, y1, x2, y2, channel), (x2-x1)*(y2-y1)*255.0);

    }

    double rectSum(Rect r, int channel) {

      ret rectSum(r.x, r.y, r.x2(), r.y2(), channel);

    }

    double rectSum(int x1, int y1, int x2, int y2, int channel) {

      double bottomLeft  = integralValue(x1-1, y2-1, channel);

      double bottomRight = integralValue(x2-1, y2-1, channel);

      double topLeft     = integralValue(x1-1, y1-1, channel);

      double topRight    = integralValue(x2-1, y1-1, channel);

      ret bottomRight-topRight-bottomLeft+topLeft;

    }

    int rgbPixel(int x1, int y1, int x2, int y2) {

      int r = iround(clampZeroToOne(getPixel(x1, y1, x2, y2, 0))*255);

      int g = iround(clampZeroToOne(getPixel(x1, y1, x2, y2, 1))*255);

      int b = iround(clampZeroToOne(getPixel(x1, y1, x2, y2, 2))*255);

      ret rgbInt(r, g, b);

    }

    double liveliness(int channel) {

      if (liveliness_cachedChannel != channel) {

        // optimization (but no change in semantics):

        // if (w <= 1 && h <= 1) ret 0; // liveliness of single pixel is 0

        liveliness_cache = standardDeviation(map(q -> q.getPixel(channel), quadrants()));

        liveliness_cachedChannel = channel;

      }

      ret liveliness_cache;

    }

    // no duplicates, without full image

    L<IIntegralImage> descentShapes_cleaned() {

      ret uniquify(listMinus(descentShapes(), this));

    }

    L<IIntegralImage> descentShapes() {

      ret centerPlusQuadrants();

    }

    L<IIntegralImage> centerPlusQuadrants() {

      int midX = w/2, midY = h/2;

      Rect r = rectAround(iround(midX), iround(midY), max(midX, 1), max(midY, 1));

      ret itemPlusList(clip(r), quadrants());

    }

    L<IIntegralImage> quadrants() {

      if (w <= 1 && h <= 1) null; // let's really not have quadrants of a single pixel

      int midX = w/2, midY = h/2;

      ret mapLL clip(

        rect(0, 0, max(midX, 1), max(midY, 1)),

        rect(midX, 0, w-midX, max(midY, 1)),

        rect(0, midY, max(midX, 1), h-midY),

        rect(midX, midY, w-midX, h-midY)

      );

    }

    IIntegralImage liveliestSubshape(int channel) {

      ret highestBy(q -> q.liveliness(channel), quadrants());

    }

    ProbabilisticList<IIntegralImage> liveliestSubshape_probabilistic(int channel) {

      ret new ProbabilisticList<IIntegralImage>(map(descentShapes(), shape ->

        withProbability(shape.liveliness(channel), shape)));

    }

    IIntegralImage clip(Rect r) {

      Rect me = rect(0, 0, w, h);

      r = intersectRects(me, r);

      if (eq(r, me)) this;

      ret actuallyClip(r);

    }

    IIntegralImage actuallyClip(Rect r) {

      ret newClip(this, r);

    }    

    IIntegralImage clip(int x1, int y1, int w, int h) { ret clip(rect(x1, y1, w, h)); }

    Rect positionInImage(IIntegralImage mainImage) {

      ret this == mainImage ? positionInImage() : null;

    }

    Rect positionInImage() {

      ret rect(0, 0, w, h);

    }

    double area() { ret w*h; }

    double relativeArea() { ret area()/mainImage.area(); }

    bool singlePixel() { ret w <= 1 && h <= 1; }

    toString { ret w + "*" + h; }

  }

  // virtual clip of an integral image

  class Clip extends IIntegralImage {

    IIntegralImage fullImage;

    int x1, y1;

    *(IIntegralImage *fullImage, Rect r) {

      x1 = r.x; y1 = r.y; w = r.w; h = r.h;

    }

    *(IIntegralImage *fullImage, int *x1, int *y1, int *w, int *h) {}

    public double integralValue(int x, int y, int channel) {

      ret fullImage.integralValue(x+x1, y+y1, channel);

    }

    // don't clip a clip - be smarter than that!

    IIntegralImage actuallyClip(Rect r) {

      ret newClip(fullImage, translateRect(r, x1, y1));

    }

    Rect positionInImage() {

      ret rect(x1, y1, w, h);

    }

    Rect positionInImage(IIntegralImage mainImage) {

      try object Rect r = super.positionInImage(mainImage);

      if (fullImage == mainImage) ret rect(x1, y1, w, h);

      null;

    }

    toString { ret positionInImage() + " in " + fullImage; }

    // no need for these, we have clipCache

    /*

    @Override public bool equals(O o) {

      if (o == this) true;

      if (o cast Clip)

        ret eq(positionInImage(), o.positionInImage());

      false;

    }

    @Override public int hashCode() {

      ret positionInImage().hashCode();

    }

    */

  }

  class IntegralImage extends IIntegralImage {

    int[] data;

    *(IntegralImage img) {

      w = img.w;

      h = img.h;

      data = img.data;

    }

    *(BufferedImage img) {

      w = img.getWidth(); h = img.getHeight();

      if (longMul(w, h) > 8000000) fail("Image too big: " + w + "*" + h);

      int[] pixels = pixelsOfBufferedImage(img);

      data = new int[w*h*channels];

      int i = 0, j = 0;

      int[] sum = new[channels];

      for y to h: {

        for c to channels: sum[c] = 0;

        for x to w: {

          int rgb = pixels[j++] & 0xFFFFFF;

          for c to channels: {

            if (c == grayscale)

              data[i] = iround((sum[0]+sum[1]+sum[2])/3);

            else {

              data[i] = (sum[c] += rgb >> 16);

              rgb = (rgb << 8) & 0xFFFFFF;

            }

            if (y > 0)

              data[i] += data[i-w*channels];

            i++;

          }

        }

      }

    }

    public double integralValue(int x, int y, Channel channel) {

      /*if (channel == grayscale)

        ret doubleAvg(countIterator(3, c -> integralValue(x, y, c)));*/

      ret x < 0 || y < 0 ? 0

        : data[(min(y, h-1)*w+min(x, w-1))*channels+channel];

    }

  }

  IIntegralImage newClip(IIntegralImage fullImage, Rect r) {

    assertSame(fullImage, mainImage);

    ret getOrCreate(clipCache, r, () -> new Clip(fullImage, r));

  }

  IIntegralImage liveliestPointIn(IIntegralImage image) {

    ret applyUntilEqual_goOneBackOnNull(c -> c.liveliestSubshape(grayscale), image);

  }

  int maxPoints = 1000;

  long maxSteps = 1000;

  int maxDescentLevel = 2; // stop descent early

  // probability of a completely un-lively block to be looked at

  double minLiveliness = .1;

  // How likely we are to drill down from an area we actually look at

  double drillDownProbability = 1.0;

  // child must improve liveliness by a factor of this

  // in order to win against the parent in search order

  // (child is assumed to have a quarter the size of the parent)

  double childLivelinessFactor = 1.1;

  double featureSize = 0.1;

  // feature-level liveliness is scaled with this in the end

  // - TODO: calculate from actual values?

  double finalLivelinessFactor = 3.0;

  // discard beneath this value (after factor is applied)

  double finalMinLiveliness = 0;

  double minMarkAlpha = 0.2; // so we see stuff on dark monitors

  double markScale = .5; // make marks smaller by this amount

  long steps;

  double lowestExecutedProbability;

  new ProbabilisticList<IIntegralImage> liveliestPoints;

  // level++ <=> a fourth the area

  double level(IIntegralImage image) {

    ret -log(image.relativeArea(), 4);

  }

  double descentProbability(IIntegralImage image, int channel) {

    // what depth we at

    double level = level(image);

    // descent limit reached?

    if (level >= maxDescentLevel+0.5) {

      if (verboseDecentLevelReached) printVars_str("Descent limit reached", +level, +image);

      ret 0;

    }

    // liveliness of area

    double liveliness = rebaseZeroTo(minLiveliness, image.liveliness(channel));

    // correct liveliness for child-ness (distance from root)

    double levelFactor = pow(1.0/childLivelinessFactor, level-1);

    double corrected = liveliness*levelFactor;

    if (verbose || verboseDescentProbabilities)

      printVars(level := formatDouble(level, 1),

        rawDescentProbability := formatDouble(corrected, 5), +image, +liveliness, +levelFactor);

    //ret scoreToProbability(corrected);

    ret corrected;

  }

  // featureSize = relative to smaller image dimension

  double actualFeatureSize() {

    ret featureSize*min(mainImage.w, mainImage.h);

  }

  Rect featureArea(IIntegralImage image) {

   ret rectAround(center(image.positionInImage()),

      iround(max(actualFeatureSize(), 1)));

  }

  // keeps 0 liveliness as 0 value (=the point is discarded)

  // Any other liveliness is proceeding to possibly make it

  // into the "list of interesting points"

  double leafValue(IIntegralImage image, int channel) {

    Rect pos = image.positionInImage();

    Pt center = center(pos);

    int actualFeatureSize = iround(max(actualFeatureSize(), 1));

    Rect r = featureArea(image);

    double value = mainImage.clip(r).liveliness(channel);

    double scaled = value*finalLivelinessFactor;

    if (verbose || verboseValues) printVars(+scaled, +value, +image, +pos, +center, +actualFeatureSize, +r);

    ret scaled;

  }

  void clearCaches {

    clipCache.clear();

  }

  ProbabilisticList<IIntegralImage> scheduler;

  Set<IIntegralImage> lookedAt;

  run {

    if (mainImage == null)

      mainImage = new IntegralImage(inputImage);

    else

      mainImage = new IntegralImage(mainImage);

    //inputImage = null; // save space

    //print(liveliness := mainImage.liveliness(grayscale));

    if (verbose || verboseImageSize) print("Full image size: " + mainImage.w + "*" + mainImage.h);

    time "Recognition" {

      liveliestPoints = new ProbabilisticList;

      scheduler = new ProbabilisticList;

      lookedAt = new Set;

      lowestExecutedProbability = 1;

      steps = 0;

      scheduler.add(WithProbability(mainImage));

      int channel = grayscale;

      while (nempty(scheduler) && steps++ < maxSteps) {

        WithProbability<IIntegralImage> clip = popFirst(scheduler);

        var cp = clip.probability();

        lowestExecutedProbability = min(lowestExecutedProbability, cp);

        if (!lookedAt.add(clip!))

          continue; // We were here before...

        if (verbose || verboseLookAt)

          print("LEVEL " + formatDouble(level(clip!), 1) + " (p=" 

            + cp + ") - "

            + clip);

        L<WithProbability<IIntegralImage>> subs1

          = mapToProbabilities(clip->descentShapes_cleaned(),

            shape -> descentProbability(shape, channel));

        var preferredSub = getVar(first(subs1));

        ProbabilisticList<IIntegralImage> subs = new ProbabilisticList<>(subs1);

        if (empty(subs)) {

          if (verbose) print("  Is leaf");

          // leaf (single point) - save with value based on

          // liveliness of surroundings on a certain level (=scale)

          if (!liveliestPoints.containsElement(clip!)) {

            if (verboseFound) print("Found point: " + clip);

            clip->discoveredInStep = steps;

            liveliestPoints.add(withProbability(leafValue(clip!, channel), clip!));

            if (l(liveliestPoints) >= maxPoints) break;

          }

        } else {

          if (verbose) print("  Has " + n2(subs, "sub") + ":");

          if (verbose) pnlIndent(subs);

          for (var sub : subs) {

            // always force at least one descent of every area we actually looked at

            //var p = descentProbability(sub!, channel);

            var p = sub.probability();

            if (p == 0) continue;

            if (sub! == preferredSub) p = drillDownProbability;

            if (verbose) print("  Descending at " + p + " to " + sub!);

            scheduler.at(p, sub!);

          }

        }

      }

    }

  }

  void show {    

    print("Have " + nPoints(liveliestPoints) + " after " + nSteps(steps) + " (areas looked at: " + n2(lookedAt) + ", cache size=" + n2(clipCache) + ")");

    print("p=" + lowestExecutedProbability);

    pnl(takeFirst(10, liveliestPoints));

    int n = l(liveliestPoints);

    liveliestPoints.truncateBelow(finalMinLiveliness);

    int m = l(liveliestPoints);

    if (m < n)

      print("Truncated to " + nPoints(m));

    L<Long> stepList = map(liveliestPoints, p -> p->discoveredInStep);

    print("Points found in steps: " + sorted(stepList));

    var markedImage = mainImage.render();

    int markSize = max(3, iround(actualFeatureSize()*markScale));

    forEach(liveliestPoints, p ->

      markPointInImageWithAlpha(

        markedImage,

        center(p->positionInImage()), 

        Color.red,

        rebaseZeroTo(minMarkAlpha, p.probability()),

        markSize));

    showImage(markedImage);

  }

}