persistable sclass Image2B is IBinaryImage {
  int w, h;
  byte[] pixels;
  
  *(int *w, int *h, byte[] *pixels) { cleanPixelArray(); }
  
  *(Image2B img) {
    w = img.getWidth();
    h = img.getHeight();
    pixels = cloneByteArray(img.pixels);
  }
  
  *(RGBImage img) {
    w = img.getWidth();
    h = img.getHeight();
    pixels = new byte[(w*h+7)/8];
    for y to h: for x to w:
      if (img.getPixel(x, y).getBrightness() >= 0.5f) {
        int i = y*w+x;
        pixels[i/8] |= 1 << (i & 7);
      }
  }
  
  *(BWImage img) {
    this(img, 128);
  }
  
  // >= threshold
  *(BWImage img, int threshold) {
    w = img.w(); h = img.h();
    int n = w*h;
    int nOut = (n+7)/8;
    byte[] pixels = this.pixels = new byte[nOut];
    byte[] bwPixels = img.pixels;
    int iIn = 0;
    
    // do the bulk
    for (int iOut = 0; iOut < nOut-1; iOut++) {
      int value = 0;
      for bit to 8: {
        value >>= 1;
        if (ubyteToInt(bwPixels[iIn++]) >= threshold)
          value |= 0x80;
      }
      pixels[iOut] = (byte) value;
    }
    
    // do last (up to 7) bits
    for (; iIn < n; iIn++)
      if (ubyteToInt(bwPixels[iIn]) >= threshold)
        pixels[nOut-1] |= 1 << (iIn & 7);
  }
  
  *(BufferedImage img) {
    this(img, 128);
  }
  
  *(BufferedImage img, int threshold) {
    this(BWImage(img), threshold);
  }
  
  // initializes with black
  *(int *w, int *h) {
    pixels = new byte[(w*h+7)/8];
  }
  
  RGBImage toRGB() {
    RGBImage img = new RGBImage(w, h, Color.black);
    for y to h: for x to w: {
      int i = y*w+x;
      if ((pixels[i/8] & (1 << (i & 7))) != 0)
        img.setPixel(x, y, Color.white);
    }
    ret img;
  }
  
  BWImage toBW() {
    BWImage img = new BWImage(w, h, 0f);
    for y to h: for x to w: {
      int i = y*w+x;
      if ((pixels[i/8] & (1 << (i & 7))) != 0)
        img.setPixel(x, y, 1f);
    }
    ret img;
  }
  
  public BufferedImage getBufferedImage() { ret toBW().getBufferedImage(); }
  
  // x and y must be inside the image
  public bool getPixel aka getBoolPixel(int x, int y) {
    int i = y*w+x;
    ret (pixels[i/8] & (1 << (i & 7))) != 0;
  }
  
  // defaultColor is color outside of image
  public bool getPixel aka getBoolPixel(int x, int y, bool defaultColor) {
    if (x < 0 || y < 0 || x >= w || y >= h) ret defaultColor;
    ret getPixel(x, y);
  }
  
  public void setPixel(int x, int y, bool b) {
    int i = y*w+x;
    byte val = pixels[i/8], shifted = (byte) (1 << (i & 7));
    val = (byte) (b ? val | shifted : val & ~shifted);
    pixels[i/8] = val;
  }
  
  void setPixel(int x, int y) {
    int i = y*w+x;
    pixels[i/8] |= 1 << (i & 7);
  }
  
  public int getWidth() { ret w; }
  public int getHeight() { ret h; }
  
  toString {
    ret "Image2B " + str_px(w, h);
  }
  
  // clear unused bits in pixel array after we received
  // a possibly dirty array
  void cleanPixelArray {
    int n = w*h;
    if ((n & 7) != 0)
      pixels[n/8] &= (1 << (n & 7))-1;
  }
  
  public double averageBrightness() {
    ret doubleRatio(bitCount(pixels), w*h);
  }
}