public class GilbertPixelIterator implements IPixIterator {

    static Logger logger =  LoggerFactory.getLogger(GilbertPixelIterator.class);

    private BlockingQueue<Point> blockingQueue = new ArrayBlockingQueue<>(256, true);

    private Thread worker;

    private int u = 1;

    private Point poisonedPill = new Point(Integer.MIN_VALUE, Integer.MIN_VALUE);

    private int glx;
    private int gly;

    private Point current = null;

    private boolean finished = false;

    private void a(int i) {
        if (i > 0) {
            d(i - 1);
            linerel(+u, 0);
            a(i - 1);
            linerel(0, u);
            a(i - 1);
            linerel(-u, 0);
            c(i - 1);
        }
    }

    private void b(int i) {
        if (i > 0) {
            c(i - 1);
            linerel(-u, 0);
            b(i - 1);
            linerel(0, -u);
            b(i - 1);
            linerel(u, 0);
            d(i - 1);
        }
    }

    private void c(int i) {
        if (i > 0) {
            b(i - 1);
            linerel(0, -u);
            c(i - 1);
            linerel(-u, 0);
            c(i - 1);
            linerel(0, u);
            a(i - 1);
        }
    }

    private void d(int i) {
        if (i > 0) {
            a(i - 1);
            linerel(0, u);
            d(i - 1);
            linerel(u, 0);
            d(i - 1);
            linerel(0, -u);
            b(i - 1);
        }
    }

    private void safePut(Point point) {
        try {
            blockingQueue.put(point);
        } catch (InterruptedException ex) {
            Thread.currentThread().interrupt();
            logger.warn("Thread interrupted during put!");
        }
    }

    private void linerel(int x, int y) {
        glx += x;
        gly += y;
        safePut(new Point(glx, gly));
    }

    private void moveto(int x, int y) {
        glx = x;
        gly = y;
        safePut(new Point(glx, gly));
    }

    public GilbertPixelIterator(int size) {
        checkArgument(size >= 4 , "Impossible to create gilbert gurve less than 4x4 plane!");
        int level = Utils.log2up(size);
        logger.trace(":: level = {}", level);
        worker = new Thread(() -> {
            moveto(0, 0);
            a(level);
            safePut(poisonedPill);
        });
        worker.start();
    }


    @Override
    public int getX() {
        if (finished) throw new IllegalStateException("Iterator is finished!");
        return current.x;
    }

    @Override
    public int getY() {
        if (finished) throw new IllegalStateException("Iterator is finished!");
        return current.y;
    }

    @Override
    public boolean next() {
        if (finished) {
            return false;
        } else {
            try {
                current = blockingQueue.take(); 
                finished = (current == poisonedPill);
            } catch (InterruptedException ex) {
                Thread.currentThread().interrupt();
                logger.warn("Thread interrupted during take!");
                finished = true;
            }
            return !finished;
        }
    }

    @Override
    public void reset() {
        throw new RuntimeException("Not implemented for mt-iterator");
    }
}

/**
    * Prime candidates generator
    *
    * @return
    */
  def primeCandidates() : Stream[Int] = {
    def primeCandidates(n : Int, step : Int) : Stream[Int] = {
      n #:: primeCandidates(n + step, step^0x6)
    }

    2 #:: 3 #:: primeCandidates(5, 2)
  }

class ConsWrapper[A](tl : => scala.collection.immutable.Stream[A]) extends scala.AnyRef {
    def #::[B >: A](hd : B) : scala.collection.immutable.Stream[B] = { /* compiled code */ }
    def #:::[B >: A](prefix : scala.collection.immutable.Stream[B]) : scala.collection.immutable.Stream[B] = { /* compiled code */ }
  }

class ConsWrapper[A](tl : => scala.collection.immutable.Stream[A]) extends scala.AnyRef {
    def #::[B >: A](hd : B) : scala.collection.immutable.Stream[B] = { /* compiled code */ }
    def #:::[B >: A](prefix : scala.collection.immutable.Stream[B]) : scala.collection.immutable.Stream[B] = { /* compiled code */ }
  }

def#::[B >: A](elem: B): Stream[B]
Construct a Stream consisting of a given first element followed by elements from another Stream.

def#:::[B >: A](prefix: Stream[B]): Stream[B]
Construct a Stream consisting of the concatenation of the given Stream and another Stream.

package mayton.image.iterators.scala

class GilbertLazyStream {

  val u = 1

  var glx = 0
  var gly = 0

  private def linerel(x: Int, y: Int) : Point = {
    glx = glx + x
    gly = gly + y
    Point(glx, gly)
  }

  private def moveto(x: Int, y: Int) : Point = {
    glx = x
    gly = y
    Point(x, y)
  }

  private def a(i: Int): Stream[Point] = {
    if (i > 0) {
      d(i - 1) #::: linerel(+u, 0) #:: a(i - 1) #::: linerel(0, u) #:: a(i - 1) #::: linerel(-u, 0) #:: c(i - 1)
    } else {
      Stream.empty
    }
  }

  private def b(i: Int): Stream[Point] = {
    if (i > 0) {
      c(i - 1) #::: linerel(-u, 0) #:: b(i - 1) #::: linerel(0, -u) #:: b(i - 1) #::: linerel(u, 0) #:: d(i - 1)
    } else {
      Stream.empty
    }
  }

  private def c(i: Int): Stream[Point] = {
    if (i > 0) {
      b(i - 1) #::: linerel(0, -u) #:: c(i - 1) #::: linerel(-u, 0) #:: c(i - 1) #::: linerel(0, u) #:: a(i - 1)
    } else {
      Stream.empty
    }
  }

  private def d(i: Int): Stream[Point] = {
    if (i > 0) {
      a(i - 1) #::: linerel(0, u) #:: d(i - 1) #::: linerel(u, 0) #:: d(i - 1) #::: linerel(0, -u) #:: b(i - 1)
    } else {
      Stream.empty
    }
  }

  def nlz(xArg: Int): Int = {
    var x = xArg
    var n = 0
    if (x == 0) return 32
    n = 1
    if ((x >>> 16) == 0) {
      n += 16
      x <<= 16
    }
    if ((x >>> 24) == 0) {
      n += 8
      x <<= 8
    }
    if ((x >>> 28) == 0) {
      n += 4
      x <<= 4
    }
    if ((x >>> 30) == 0) {
      n += 2
      x <<= 2
    }
    n = n - (x >>> 31)
    n
  }

  def log2up(x: Int): Int = {
    if (x < 1) return 0
    32 - nlz(x - 1)
  }

  def gilbertPoinsStream(size : Int) : Stream[Point] = {
    val level = log2up(size)
    moveto(0, 0)
    Point(0,0) #:: a(level)
  }

}