// both the outer outline and the outline of a hole are called a "trace"
// should return outer outline first and then outline of holes

// seems to return first point again at the end sometimes

srecord noeq RegionBorder_innerPoints_v2(IImageRegion region) extends AbstractSteppable {
  event newTrace(bool isHole);
  event foundPoint(Pt p);
  event traceDone;
  
  settable bool includeHoles = true;
  
  int w, x, y, dir;
  Iterator<Pt> it;
  byte[] reachedInDirections; // bits 0 to 3
  bool tracing;
  int nTrace; // 1 for outline, 2+ for hole

  // directions (0 = right, 1 = down, 2 = left, 3 = up)
  static Pt[] directions = {
    pt(1, 0), pt(0, 1), pt(-1, 0), pt(0, -1) // r, d, l, u
  };
  
  void init {
    var image = region.image();
    w = image.w();
    reachedInDirections = new byte[w*image.h()];
    it = region.pixelIterator();
  }

  public bool step() {
    if (reachedInDirections == null) init();
    
    if (tracing)
      ret walkOnePixel();
    else
      ret findFirstPixel();
  }
  
  bool walkOnePixel() {
    int pos = y*w+x;
    if ((reachedInDirections[pos] & (1 << dir)) != 0) {
      traceDone();
      tracing = false;
      ret includeHoles;
    }
    
    reachedInDirections[pos] |= (byte) 1 << dir;
    foundPoint(x, y);
      
    for (int turn = 3; turn <= 6; turn++) { // try left, straight, right, back
      int newDir = (dir+turn) & 3;
      Pt d = directions[newDir];
      int x2 = x+d.x, y2 = y+d.y;
      bool b = region.contains(x2, y2);
      ifdef RegionBorder_innerPoints_debug
        printVars(+x, +y, +dir, +turn, +newDir, +x2, +y2, +b);
      endifdef
      if (b) {
        x = x2; y = y2; dir = newDir;
        true;
      }
    }
    
    true; // no black pixels found in any direction - region must be a single pixel
  }
    
  bool findFirstPixel() {
    // search for first border pixel
    
    if (!it.hasNext()) false; // done
    Pt p = it.next();
    x = p.x; y = p.y;
      
    if (reachedInDirections[y*w+x] != 0) true; // seen pixel before
    
    // if pixel above is empty, walk to the right
    if (!region.contains(x, y-1))
      ret true with startTrace(0);
      
    // if pixel on the left is empty, walk upwards
    if (!region.contains(x-1, y))
      ret true with startTrace(3);
    
    // if pixel on the right is empty, walk downwards
    if (!region.contains(x+1, y))
      ret true with startTrace(1);
    
    // if pixel below is empty, walk left
    if (!region.contains(x, y+1))
      ret true with startTrace(2);
  
    // not a border pixel, continue search
    true;
  }
  
  void startTrace(int dir) {
    this.dir = dir;
    
    // mark point reached from all directions in next step
    reachedInDirections[y*w+x] = (byte) (15 & ~(1 << dir));
      
    set tracing;
    newTrace(++nTrace > 1);
  }
  
  void foundPoint(int x, int y) { foundPoint(pt(x, y)); }
  
  // get all points as list
  
  simplyCached L<Pt> allPoints() {
    new PtBuffer l;
    onFoundPoint(p -> l.add(p));
    run();
    ret l;
  }
  
  // get outline as OnePath
  
  simplyCached OnePath onePath() {
    includeHoles(false);
    ret new OnePath(allPoints(), true);
  }
  
  // or as OnePathWithOrigin
  
  simplyCached OnePathWithOrigin onePathWithOrigin() {
    includeHoles(false);
    ret new OnePathWithOrigin(allPoints(), true);
  }

  // for debugging 
  void runAndPrint {
    onNewTrace(hole -> print(!hole ? "new outline" : "new hole"));
    onTraceDone(-> print("traceDone"));
    onFoundPoint(p -> print("foundPoint " + p));
    stepMaxWithStats(this, 10000);
  }
  
  bool tracingHole() { ret nTrace > 1; }
}

Began life as a copy of #1034656