Mona_Lisa.jpg JPEG 2835x4289 2835x4289+0+0 8-bit sRGB 3.506MB 0.000u 0:00.000

package mayton.image.iterators

import static java.lang.Math.max
import static java.lang.Math.min

/**
 * GilbertPixelRecursiveIterator
 */
class GilbertPixelRecursiveIterator implements IPixIterator {

    def x;
    def y;

    def u=1;
    def v=0;

    def x1;
    def y1;
    def x2;
    def y2;

    public LinearPixIterator(int width,int height)
    {
        x1=min(0,width);
        y1=min(0,height);
        x2=max(0,width);
        y2=max(0,height);
        reset();
    }

    boolean isReset = false

    @Override
    int getX() {
        return x
    }

    @Override
    int getY() {
        return y
    }

    @Override
    boolean next() {
        yield false
    }

    @Override
    void reset() {
        isReset = true
    }
}

192.168.0.1-192.168.0.254, US, United States
10.60.10.1-10.60.10, JP, Japanese
....

01-01.png ( Rectangle (0,0) - (799,599)
01-02.png .....
02-01.png .....
02-02.png .....

01-01-02-02.zoom2x.png
02-02-03-03.zoom2x.png
....
01-01-xx-xx.zoom...png

public class GilbertIteratorBlockingQueue implements Iterator<Position> {

    static Logger logger = LogManager.getLogger(GilbertIteratorBlockingQueue.class);

    Producer producer;
    int size;
    BlockingQueue<Position> queue;
    Position position = Position.DUMMY;
    int state = 0;

    public GilbertIteratorBlockingQueue(int size) {
        if (size<4){
            throw new IllegalArgumentException("The dimension of 'Gilbert' curve cannot be less than 4 x 4!");
        }
        this.size = size;
        queue = new ArrayBlockingQueue<>(1024);
        producer = new Producer();
        new Thread(producer).start();
    }

    class Producer implements Runnable {

        static final int u = 1;
        int glx;
        int gly;
        int level;

        public Producer() {
            level = log2up(size);
            int clp2size = clp2(size);
            if (clp2size > size) {
                logger.warn("Warning! The real dimension of iterator's space has been extended to {}x{} pixels", clp2size, clp2size);
            }
            state = 1;
        }

        public void run() {
            try {
                moveto(0, 0);
                a(level);
                queue.put(Position.DUMMY);
            } catch (InterruptedException e) {
                logger.error(e);
            }
        }

        void linerel(int x, int y) throws InterruptedException {
            glx += x;
            gly += y;
            queue.put(new Position(glx, gly));
        }

        void moveto(int x, int y) throws InterruptedException {
            glx = x;
            gly = y;
            queue.put(new Position(glx, gly));
        }

        // Elements of curve
        void a(int i) throws InterruptedException {
            if (i > 0) {
                d(i - 1);
                linerel(+u, 0);
                a(i - 1);
                linerel(0, u);
                a(i - 1);
                linerel(-u, 0);
                c(i - 1);
            }
        }

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

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

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


    }

    @Override
    public boolean hasNext() {
        if (state == 2){
            return false;
        }
        try {
            position = queue.take();
            if (position == Position.DUMMY) {
                state = 2;
                return false;
            }
        } catch (InterruptedException e) {
            logger.error(e);
        }
        return true;
    }

    @Override
    public Position next() {
        return position;
    }
}