sclass G22CriticalPixelSearch is Steppable {

  // input

  settable IG22MasksHolder<?> masksHolder;

  settable bool keepAllEntries;

  settable bool sortPixelsFirst = true;

  // internal

  int w, h;

  Iterator<Pt> pixelIterator;

  // output

  new Best<Pt> bestPixel;

  Entry bestEntry;

  Pt lastPixelLookedAt;

  Entry lastEntry;

  Entry[] pixelEntries;

  float[] pixelScores;

  int nPixelsTested;

  // stores all subsets of masks found if not null

  CompactHashSet<HashedByteArray> subSets;

  *() {}

  *(IG22MasksHolder *masksHolder) {}

  class Entry {

    Pt pixel;

    // child mask holders for pixel dark or pixel bright

    //IG22MasksHolder darkChild, brightChild;

    gettable L<IG22Mask> darkMasks;

    gettable L<IG22Mask> brightMasks;

    G22GhostImage darkGhost;

    G22GhostImage brightGhost;

    simplyCached IG22MasksHolder darkHolder() {

      ret new G22HashedMasks(darkMasks, darkGhost);

    }

    simplyCached IG22MasksHolder brightHolder() {

      ret new G22HashedMasks(brightMasks, brightGhost);

    }

    void calcGhosts {

      if (l(darkMasks) < l(brightMasks)) {

        darkGhost = new G22GhostImage(lmapMethod image(darkMasks));

        brightGhost = masksHolder().ghost().minus(darkGhost);

      } else {

        brightGhost = new G22GhostImage(lmapMethod image(brightMasks));

        darkGhost = masksHolder().ghost().minus(brightGhost);

      }

    }

    toString {

      ret commaCombine(

        "Split at " + pixel,

        "dark=" + darkHolder().renderCountAndCertainty(),

        "bright=" + brightHolder().renderCountAndCertainty());

    }

  }

  public bool step() {

    if (w == 0) {

      if (!masksHolder.canSplit()) false;

      meta-for w also as h { w = masksHolder.maskSize().w(); }

      pixelEntries = new Entry[w*h];

      pixelScores = new float[w*h];

      arrayfill(pixelScores, -1);

      pixelIterator = makePixelIterator();

    }

    if (!pixelIterator.hasNext()) false;

    lastPixelLookedAt = pixelIterator.next();

    testPixel(lastPixelLookedAt);

    true;

  }

  int idx(Pt p) { ret p.y*w+p.x; }

  void testPixel(Pt p) {

    double score;

    Entry e = null;

    ++nPixelsTested;

    // Find out if pixel is the same in all masks

    float ghostBrightness = masksHolder.ghost().getFloatPixel(p);

    if (ghostBrightness == 0 || ghostBrightness == 1)

      // Pixel is determined, not usable for splitting

      score = -2;

    else {

      // Pixel is not determined - let's make the 2 subsets

      e = new Entry;

      e.pixel = p;

      lastEntry = e;

      if (keepAllEntries)

        pixelEntries[idx(p)] = e;

      L<IG22Mask> masks = wideningListCast(masksHolder.masks());

      int n = l(masks);

      // bit is 1 when pixel is bright

      byte[] brightBits = byteArrayForNBits(n);

      // calculate the split

      for i to n:

        if (masks.get(i).image().getBoolPixel(p))

          setBit(brightBits, i);

      subSets?.add(new HashedByteArray(brightBits));

      var splitMasks = filterAntiFilterByBitSet(masks, brightBits);

      e.brightMasks = splitMasks.a;

      e.darkMasks = splitMasks.b;

      e.calcGhosts();

      score = scoreEntry(e);

    }

    pixelScores[idx(p)] = (float) score;

    if (score > 0 && bestPixel.put(p, score))

      bestEntry = e;

  }

  swappable double scoreEntry(Entry e) {

    double c1 = e.darkGhost.certainty();

    double c2 = e.brightGhost.certainty();

    // ret avg(c1, c2);

    ret min(c1, c2);

  }

  double bestScore() {

    ret bestPixel.score();

  }

  BWImage scoreImage() {

    double min = masksHolder.certainty();

    double max = bestPixel.score();

    ret bwImageFromFunction(w, h,

      (x, y) -> transformToZeroToOne(pixelScores[y*w+x], max, min));

  }

  G22PixelSplitMasks<?> splitMasksHolder() {

    if (!bestPixel.has()) null;

    ret new G22PixelSplitMasks()

      .splitPixel(bestPixel!)

      .darkHolder(bestEntry.darkHolder())

      .brightHolder(bestEntry.brightHolder());

  }

  IG22MasksHolder makeBestTree aka bestTree aka get() {

    stepAll(this);

    G22PixelSplitMasks<?> split = splitMasksHolder();

    if (split == null) ret masksHolder;

    split.transformSubHolders(subHolder

      -> new G22CriticalPixelSearch(subHolder).makeBestTree());

    ret split;

  }

  void collectSubSets {

    subSets if null = new CompactHashSet;

  }

  Iterator<Pt> makePixelIterator() {

    if (sortPixelsFirst)

      // try least certain pixels first

      ret iterator(pixelsByBrightness(masksHolder().ghost().certaintyImage()));

    else

      ret new WeightlessShuffledIterator<Pt>(pixelsInImage(w, h));

  }

}