sinterface IIntegralImage extends MakesBufferedImage {
  public int getWidth();
  public int getHeight();
  default public Pt getSize() { ret pt(getWidth(), getHeight()); }
  
  default public int defaultChannel() { ret 0; }
  default public int nChannels() { ret 3; }

  // get value for 1 channel
  // normal range [0; pixelCount*256)
  public double getIntegralValue(int x, int y, int channel);
  
  default double getIntegralValue(double x, double y, int channel) {
    ret getIntegralValue(ifloor(x), ifloor(y), channel);
  }
    
  // gets summed value of the 3 channels
  // normal range [0; pixelCount*256*3)
  default double getIntegralValue(int x, int y) {
    ret getIntegralValue(x, y, 0)
      + getIntegralValue(x, y, 1)
      + getIntegralValue(x, y, 2);
  }
  
  default double rectSum(int x1, int y1, int x2, int y2, int channel) {
    double bottomLeft  = getIntegralValue(x1-1, y2-1, channel);
    double bottomRight = getIntegralValue(x2-1, y2-1, channel);
    double topLeft     = getIntegralValue(x1-1, y1-1, channel);
    double topRight    = getIntegralValue(x2-1, y1-1, channel);
    ret bottomRight+topLeft-topRight-bottomLeft;
  }
  
  default double rectSum(double x1, double y1, double x2, double y2, int channel) {
    double bottomLeft  = getIntegralValue(x1-1, y2-1, channel);
    double bottomRight = getIntegralValue(x2-1, y2-1, channel);
    double topLeft     = getIntegralValue(x1-1, y1-1, channel);
    double topRight    = getIntegralValue(x2-1, y1-1, channel);
    ret bottomRight+topLeft-topRight-bottomLeft;
  }
  
  default double rectSum(int x1, int y1, int x2, int y2) {
    double bottomLeft  = getIntegralValue(x1-1, y2-1);
    double bottomRight = getIntegralValue(x2-1, y2-1);
    double topLeft     = getIntegralValue(x1-1, y1-1);
    double topRight    = getIntegralValue(x2-1, y1-1);
    ret bottomRight+topLeft-topRight-bottomLeft;
  }
  
  default double rectAverage(int x1, int y1, int x2, int y2, int channel) {
    ret doubleRatio(rectSum(x1, y1, x2, y2, channel), areaFromPoints(x1, y1, x2, y2));
  }
  
  default double rectAverage(Rect r, int channel) {
    ret doubleRatio(rectSum(r, channel), rectArea(r));
  }
  
  default double rectSum(Rect r) {
    ret rectSum(r.x, r.y, r.x2(), r.y2());
  }
  
  default double rectSum(Rect r, int channel) {
    ret rectSum(r.x, r.y, r.x2(), r.y2(), channel);
  }
  
  default double pixelSum(DoubleRect r) {
    ret rectSum(toRect_floor(r), defaultChannel());
  }
  
  default IIntegralImage clip(int x, int y, int w, int h) {
    ret IIVirtualClip(this, x, y, w, h);
  }
  
  default double averageBrightness() {
    int w = getWidth(), h = getHeight();
    ret doubleRatio(getIntegralValue(w-1, h-1), w*h*3*255.0);
  }
  
  default RGB averageRGB() {
    int w = getWidth(), h = getHeight();
    double factor = 1/(255.0*(w*h));
    ret RGB(
      rectSum(0, 0, w, h, 0)*factor,
      rectSum(0, 0, w, h, 1)*factor,
      rectSum(0, 0, w, h, 2)*factor);
  }
  
  // normal range: (0, 255)
  default double getPixel(int x, int y, int channel) {
    ret rectSum(x, y, x+1, y+1, channel);
  }
  
  // returns RGB pixel without alpha
  default int getPixel(int x, int y) {
    int r = iround(rectSum(x, y, x+1, y+1, 0));
    int g = iround(rectSum(x, y, x+1, y+1, 1));
    int b = iround(rectSum(x, y, x+1, y+1, 2));
    ret rgbInt(r, g, b);
  }
  
  default int nPixels() { ret getWidth()*getHeight(); }
  
  default BufferedImage getBufferedImage() {
    int w = getWidth(), h = getHeight();
    int[] pixels = new[w*h];
    int i = 0;
    for y to h:
      for x to w:
        pixels[i++] = getPixel(x, y) | fullAlphaMask();
    ret intArrayToBufferedImage(pixels, w, h);
  }
  
  // minimum and maximum brightness possible in image 
  // Better not to use because without this information
  // you have a more general recognition algorithm.
  //default DoubleRange colorRange(int channel) { ret doubleRange(0, 256); }
}