persistable sclass Image2BAsLongs is IBinaryImage {
  int w, h;
  gettable long[] pixels;
  
  *(int *w, int *h, long[] *pixels) { cleanPixelArray(); }
  
  *(Image2B img) {
    w = img.getWidth();
    h = img.getHeight();
    pixels = longArrayFromBytes_littleEndian_flexLength(img.pixels);
  }
  
  *(Image2BAsLongs img) {
    w = img.getWidth();
    h = img.getHeight();
    pixels = cloneLongArray(img.pixels);
  }
  
  *(RGBImage img) {
    w = img.getWidth();
    h = img.getHeight();
    pixels = new long[(w*h+63)/64];
    for y to h: for x to w:
      if (img.getPixel(x, y).getBrightness() >= 0.5f) {
        int i = y*w+x;
        pixels[i/64] |= 1L << (i & 63);
      }
  }
  
  *(BWImage img) {
    this(img, 128);
  }
  
  // >= threshold
  *(BWImage img, int threshold) {
    w = img.w(); h = img.h();
    int n = w*h;
    int nOut = (n+63)/64;
    long[] pixels = this.pixels = new long[nOut];
    byte[] bwPixels = img.pixels;
    int iIn = 0;
    
    // do the bulk
    for (int iOut = 0; iOut < nOut-1; iOut++) {
      long value = 0;
      for bit to 64: {
        value >>>= 1;
        if (ubyteToInt(bwPixels[iIn++]) >= threshold)
          value |= 0x80000000;
      }
      pixels[iOut] = value;
    }
    
    // do last (up to 63) bits
    for (; iIn < n; iIn++)
      if (ubyteToInt(bwPixels[iIn]) >= threshold)
        pixels[nOut-1] |= 1L << (iIn & 63);
  }
  
  *(BufferedImage img) {
    this(img, 128);
  }
  
  *(BufferedImage img, int threshold) {
    this(BWImage(img), threshold);
  }
  
  // initializes with black
  *(int *w, int *h) {
    pixels = new long[(w*h+63)/64];
  }
  
  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/64] & (1L << (i & 63))) != 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/64] & (1L << (i & 63))) != 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/64] & (1L << (i & 63))) != 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;
    long val = pixels[i/64], shifted = 1L << (i & 63);
    val = b ? val | shifted : val & ~shifted;
    pixels[i/64] = val;
  }
  
  void setPixel(int x, int y) {
    int i = y*w+x;
    pixels[i/64] |= 1L << (i & 63);
  }
  
  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 & 63) != 0)
      pixels[n/64] &= (1L << (n & 63))-1;
  }
}

Began life as a copy of #1036036