// U for stands for the "Ultra-Fast Recognition" family of recognizers
sclass URecognizer {
  IIntegralImage image;
  
  *() {}
  *(IIntegralImage *image) {}
  *(BufferedImage image) {
    this.image = IntegralImage(image);
  }
  
  // returns 0, 1 or 2
  int posterizeToInt(double x) {
    ret ifloor(clampZeroToOne(x)*3);
  }

  // returns 0, .5 or 1
  double posterizeInPlace(double x) {
    ret posterizeToInt(x)*.5;
  }
  
  class Cell {
    // Which part of the image we are looking at (x/y)
    // dimension 0 = x, dimension 1 = y
    DoubleRange[] clip = new[2];
  
    // color transformations in place
    DoubleRange[] colorClips = new[3];
  
    Cell copy() {
      ret copyTo(new Cell);
    }
    
    Cell copyTo(Cell c) {
      arrayCopy(clip, c.clip);
      arrayCopy(colorClips, c.colorClips);
      ret c;
    }
  
    DoubleRect rawDoubleRect() {
      ret doubleRectFromRanges(clip[0], clip[1]);
    }
    
    Rect rectInImage() {
      ret rectMinSize(1, 1, toRect_floor(doubleRectFromRanges(clip[0], clip[1])));
    }
    
    // uses full pixels to match the pixel queries
    double screenArea() { ret rectArea(rectInImage()); }
  
    // get color of cell
  
    double color(int channel) {
      double color = ii_averageBrightnessOfArea(image, rectInImage(), channel);
      ret transformBetweenDoubleRanges(color, colorClips[channel], zeroToOne());
    }
    
    // unposterized color of all 3 channels
    double[] colors() {
      double[] c = new[3];
      for i to 3:
        c[i] = color(i);
      ret c;
    }
    
    RGB rgb aka averageColor() {
      ret RGB(colors());
    }
    
    toString {
      ret rectInImage() + ", color: " + map(asList(colors()), x -> formatDoubleX(x, 4));
    }
  
    int posterizedIntColor(int channel) {
      ret posterizeToInt(color(channel));
    }
  
    // get sub-cells
    
    Cell[] cellArray(int n) {
      ret new Cell[n];
    }
    
    Cell[] split(int dimension, int n default 3) {
      Cell[] cells = cellArray(n);
      for i to n: cells[i] = slice(dimension, doubleRatio(i, n), doubleRatio(i+1, n));
      ret cells;
    }
  
    Cell slice(int dimension, double a, double b) {
      Cell c = copy();
      c.clip[dimension] = transformBetweenDoubleRanges(DoubleRange(a, b), zeroToOne(), clip[dimension]);
      ret c;
    }
    
    // rect is within 0 to 1 in both dimensions
    Cell clip(DoubleRect r) {
      ret slice(0, r.x1(), r.x2()).slice(1, r.y1(), r.y2());
    }
    
    // index = 0 to 2
    Cell third(int dimension, int index) {
      ret slice(dimension, index/3.0, (index+1)/3.0);
    }
    
    // convert to B/W
    
    BWCell channel(int channel) {
      new BWCell c;
      copyTo(c);
      c.colorToBW = rgb -> rgb[channel];
      ret c;
    }
    
    BWCell brightness() {
      new BWCell c;
      copyTo(c);
      ret c;
    }
    
    double averageBrightness aka get() {
      ret brightness().color();
    }
    
    double getWidth() { ret clip[0].length(); }
    double getHeight() { ret clip[1].length(); }
    
    double pixelSum() {
      ret image.rectSum(rectInImage());
    }
  }

  class BWCell extends Cell {
    IF1<double[], Double> colorToBW = rgb -> (rgb[0]+rgb[1]+rgb[2])/3;
    
    double color() {
      ret colorToBW.get(colors());
    }
    
    BWCell copy() {
      new BWCell c;
      copyTo(c);
      ret c;
    }
    
    void copyTo(BWCell c) {
      super.copyTo(c);
      c.colorToBW = colorToBW;
    }
    
    toString {
      ret rectInImage() + ", Color: " + formatDoubleX(color(), 4);
    }
  
    // lift methods
    
    BWCell[] cellArray(int n) {
      ret new BWCell[n];
    }
    
    BWCell slice(int dimension, double a, double b) {
      ret (BWCell) super.slice(dimension, a, b);
    }
    
    BWCell[] split(int dimension) {
      ret (BWCell[]) super.split(dimension);
    }
    
    BWCell third(int dimension, int index) {
      ret (BWCell) super.third(dimension, index);
    }
  }
  
  // make the root cell
  Cell rootCell aka cell() {
    new Cell c;
    c.clip[0] = doubleRange(0, image.getWidth());
    c.clip[1] = doubleRange(0, image.getHeight());
    for i to 3: c.colorClips[i] = doubleRange(0, 255);
    ret c;
  }
  
  int outlierPosition(BWCell[] cells) {
    double a = cells[0].color();
    double b = cells[1].color();
    double c = cells[2].color();
    double ab = abs(a-b), bc = abs(b-c), ac = abs(a-c);
    if (bc < min(ab, ac)) ret 0; // b and c close together
    if (ac < min(ab, bc)) ret 1; // a and c close together
    if (ab < min(ac, bc)) ret 2; // a and b close together
    ret -1; // unknown
  }
}