// 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(BWImage_FastRegions regions, int iRegion) extends AbstractSteppable {

  event newTrace(bool isHole);

  event foundPoint(Pt p);

  event traceDone;

  int w, x, y, dir;

  BWImage_FastRegions.RegionIterator it;

  byte[] reachedInDirections; // bits 0 to 3

  bool tracing;

  gettable bool tracingHole;

  // 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 {

    w = regions.w;

    reachedInDirections = new byte[w*regions.h];

    it = regions.regionIterator(iRegion);

  }

  public bool step() {

    if (reachedInDirections == null) init();

    if (tracing) {

      int pos = y*w+x;

      if ((reachedInDirections[pos] & (1 << dir)) != 0) {

        traceDone();

        tracing = false;

        true;

      }

      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 = regions.inRegion(iRegion, 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; // i think this ends the trace in next iteration

    } else {

      // search for first border pixel

      if (!it.next()) false; // done

      x = it.x(); y = it.y();

      if (reachedInDirections[y*w+x] != 0) true; // seen pixel before

      // if pixel above is empty, walk to the right

      if (!regions.inRegion(iRegion, x, y-1))

        ret true with startTrace(0);

      // if pixel on the left is empty, walk upwards

      if (!regions.inRegion(iRegion, x-1, y))

        ret true with startTrace(3);

      // if pixel on the right is empty, walk downwards

      if (!regions.inRegion(iRegion, x+1, y))

        ret true with startTrace(1);

      // if pixel below is empty, walk left

      if (!regions.inRegion(iRegion, 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(tracingHole);

    set tracingHole;

  }

  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() {

    ret new OnePath(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);

  }

}