// grayscale, actually

sclass BWIntegralImage > Meta implements IBWIntegralImage, IIntegralImage {

  int w, h;

  int[] data; // 1 entry per pixel

  ifdef BWIntegralImage_CountAccesses

    long accesses;

  endifdef

  // constructors

  *() {}

  *(File f) { this(loadImage2(f)); }

  *(MakesBufferedImage img) { this(toBufferedImage(img)); }

  *(BufferedImage image) { grab(image); }

  *(BufferedImage image, Decolorizer decolorizer) { grab(image, decolorizer); }

  *(GrabbableIntPixels gp) { grab(gp); }

  *(GrabbableRGBBytePixels gp) { grab(gp, new Decolorizer.Simple); }

  *(GrabbableGrayPixels gp) { grab(gp); }

  *(BWImage img) {

    grab(new GrabbableGrayPixels(img.pixels, img.width, img.height,

      0, img.width);

  }

  // grab functions

  void grab(BufferedImage image, Decolorizer decolorizer default null) {

    if (image.getType() == BufferedImage.TYPE_BYTE_GRAY)

      grab(grabbableGrayPixels(image));

    else { // rgb image

      var gp = grabbableRGBBytePixels(image);

      if (gp != null)

        grab(gp, decolorizer);

      else

        grab(grabbableIntPixels_fastOrSlow(image), decolorizer);

    }

  }

  void grab(GrabbableRGBBytePixels gp, Decolorizer decolorizer) {

    if (decolorizer == null) decolorizer = new Decolorizer.Simple;

    alloc(gp.w, gp.h);

    int w = this.w, h = this.h;

    ifdef BWIntegralImage_debug

      print("BWIntegralImage grabbing: " + gp);

    endifdef

    // first row

    int iImage = gp.offset, sum = 0, pixelStride = gp.pixelStride;

    byte[] image = gp.data;

    for x to w: {

      int packed = rgbInt(image[iImage], image[iImage+1], image[iImage+2]);

      iImage += pixelStride;

      int brightness = decolorizer.toGrayScale(packed);

      data[x] = (sum += brightness);

    }

    // subsequent rows

    var ping = pingSource();

    int scanlineExtra = gp.scanlineStride-w*pixelStride;

    iImage = gp.offset+gp.scanlineStride;

    int i = w;

    for (int y = 1; y < h; y++) {

      sum = 0;

      for x to w: {

        int packed = rgbInt(image[iImage], image[iImage+1], image[iImage+2]);

        iImage += pixelStride;

        int brightness = decolorizer.toGrayScale(packed);

        sum += brightness;

        data[i] = sum + data[i-w];

        i++;

      }

      iImage += scanlineExtra;

      ping?!;

    } // for y

  }

  void grab(GrabbableIntPixels gp, Decolorizer decolorizer) {

    if (isDefaultDecolorizer(decolorizer))

      ret with grab(gp);

    alloc(gp.w, gp.h);

    int w = this.w, h = this.h;

    ifdef BWIntegralImage_debug

      print("BWIntegralImage grabbing: " + gp);

    endifdef

    int offset = gp.offset, sum = 0;

    int[] image = gp.data;

    for x to w: {

      int packed = image[offset+x];

      int brightness = decolorizer.toGrayScale(packed);

      data[x] = (sum += brightness);

    }

    var ping = pingSource();

    int scanlineExtra = gp.scanlineStride-w;

    int iImage = offset+gp.scanlineStride, i = w;

    for (int y = 1; y < h; y++) {

      sum = 0;

      for x to w: {

        int packed = image[iImage];

        int brightness = decolorizer.toGrayScale(packed);

        sum += brightness;

        data[i] = sum + data[i-w];

        iImage++; i++;

      }

      iImage += scanlineExtra;

      ping?!;

    } // for y

  }

  void grab(GrabbableIntPixels gp) {

    alloc(gp.w, gp.h);

    int w = this.w, h = this.h;

    ifdef BWIntegralImage_debug

      print("BWIntegralImage grabbing: " + gp);

    endifdef

    int offset = gp.offset, sum = 0;

    int[] image = gp.data;

    for x to w: {

      int packed = image[offset+x];

      int brightness = packedToBrightness(packed);

      data[x] = (sum += brightness);

    }

    var ping = pingSource();

    int scanlineExtra = gp.scanlineStride-w;

    int iImage = offset+gp.scanlineStride, i = w;

    for (int y = 1; y < h; y++) {

      sum = 0;

      for x to w: {

        int packed = image[iImage];

        int brightness = packedToBrightness(packed);

        sum += brightness;

        data[i] = sum + data[i-w];

        iImage++; i++;

      }

      iImage += scanlineExtra;

      ping?!;

    } // for y

  }

  void grab(GrabbableGrayPixels gp) {

    alloc(gp.w, gp.h);

    ifdef BWIntegralImage_debug

      print("BWIntegralImage grabbing: " + gp);

    endifdef

    int offset = gp.offset, sum = 0;

    byte[] image = gp.data;

    for x to w: {

      int brightness = image[offset+x];

      data[x] = (sum += brightness);

    }

    var ping = pingSource();

    int scanlineExtra = gp.scanlineStride-w;

    int iImage = offset+gp.scanlineStride, i = w;

    for (int y = 1; y < h; y++) {

      sum = 0;

      for x to w: {

        int brightness = image[iImage];

        sum += brightness;

        data[i] = sum + data[i-w];

        iImage++; i++;

      }

      iImage += scanlineExtra;

      ping?!;

    } // for y

  }

  private void alloc(int w, int h) {

    this.w = w;

    this.h = h;

    if (w*h > 8*1024*1024)

      fail("Image too large (more than 8 MP): " + w + "*" + h);

    data = new int[w*h];

  }

  // pixels outside of image are considered black

  int get(int x, int y) {

    ifdef BWIntegralImage_CountAccesses

      ++accesses;

    endifdef

    ret x < 0 || y < 0 ? 0

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

  }

  // precise version [TO TEST!]

  public double getIIValue(double x, double y) {

    int xFloor = ifloor(x), yFloor = ifloor(y);

    double val = getIIValue(xFloor, yFloor);

    // at integer coordinate?

    if (xFloor == x && yFloor == y)

      ret val;

    // at non-integer coordinate, perform subpixel calculation

    double val2 = getIIValue(xFloor+1, yFloor);

    double val3 = getIIValue(xFloor  , yFloor+1);

    double val4 = getIIValue(xFloor+1, yFloor+1);

    ret blend2D(val, val2, val3, val4, x-xFloor, y-yFloor);

  }

  public int getIIValue(int x, int y) { ret get(x, y); }

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

    ret get(x, y);

  }

  public double getPixelAverage(int x1, int y1, int x2, int y2) {

    int area = (x2-x1)*(y2-y1);

    ret doubleRatio(bwIntegralImage_sumRect(this, x1, y1, x2, y2), area);

  }

  public int getWidth() { ret w; }

  public int getHeight() { ret h; }

  int packedToBrightness(int packed) {

    int b = (packed & 0xFF);

    ifdef BWIntegralImage_brightnessCheat

      ret b;

    endifdef

    ifndef BWIntegralImage_brightnessCheat

      int r = ((packed >> 16) & 0xFF);

      int g = ((packed >> 8) & 0xFF);

      ret (r+g+b+1)/3;

    endifndef

  }

  // get brightness of pixel

  public int getInt(int x, int y) {

    ret iround(rectSum(x, y, x+1, y+1, 0));

  }

  // returns RGB pixel without alpha

  public int getPixel(int x, int y) {

    ret rgbIntFromGrayscale(getInt(x, y));

  }

  public BufferedImage getBufferedImage() {

    //ret scaleDownUsingIntegralImageBW(this, w).getBufferedImage();

    O src = metaGet src(this);

    if (src cast BufferedImage) ret src;

    ret grayImageFromIBWIntegralImage(this);

  }

}