org.oscim.utils.quadtree.TileIndex Maven / Gradle / Ivy

Go to download
/*
 * Copyright 2013 Hannes Janetzek
 *
 * This file is part of the OpenScienceMap project (http://www.opensciencemap.org).
 *
 * This program is free software: you can redistribute it and/or modify it under the
 * terms of the GNU Lesser General Public License as published by the Free Software
 * Foundation, either version 3 of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT ANY
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
 * PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License along with
 * this program. If not, see .
 */
package org.oscim.utils.quadtree;

/**
 * A quad tree for the standard map tiling schema.
 */
public abstract class TileIndex, E> {

    protected final T root;

    protected T pool;

    public TileIndex() {
        root = create();
        root.id = -1;
        root.parent = root;
    }

    static void checkIndex(int x, int y, int max) {
        if (x < 0 || x >= max || y < 0 || y >= max) {
            throw new IllegalArgumentException("invalid position "
                    + x + '/' + y + '/' + (max >> 1));
        }
    }

    public abstract T create();

    public abstract void removeItem(E item);

    public T add(int x, int y, int z) {

        checkIndex(x, y, 1 << z);

        if (z == 0)
            return root;

        T leaf = root;

        for (int level = z - 1; level >= 0; level--) {

            int id = ((x >> level) & 1) | ((y >> level) & 1) << 1;

            leaf.refs++;

            T cur = null;

            switch (id) {
                case 0:
                    cur = leaf.child00;
                    break;
                case 1:
                    cur = leaf.child01;
                    break;
                case 2:
                    cur = leaf.child10;
                    break;
                case 3:
                    cur = leaf.child11;
                    break;
            }

            if (cur != null) {
                leaf = cur;
                continue;
            }

            if (pool != null) {
                cur = pool;
                pool = pool.parent;
            } else {
                cur = create();
            }

            cur.refs = 0;
            cur.id = (byte) id;
            cur.parent = leaf;

            switch (id) {
                case 0:
                    cur.parent.child00 = cur;
                    break;
                case 1:
                    cur.parent.child01 = cur;
                    break;
                case 2:
                    cur.parent.child10 = cur;
                    break;
                case 3:
                    cur.parent.child11 = cur;
                    break;
            }

            leaf = cur;
        }

        leaf.refs++;

        return leaf;
    }

    public E getTile(int x, int y, int z) {

        checkIndex(x, y, 1 << z);

        if (z == 0)
            return root.item;

        T leaf = root;
        for (int level = z - 1; level >= 0; level--) {

            int id = ((x >> level) & 1) | ((y >> level) & 1) << 1;

            switch (id) {
                case 0:
                    leaf = leaf.child00;
                    break;
                case 1:
                    leaf = leaf.child01;
                    break;
                case 2:
                    leaf = leaf.child10;
                    break;
                case 3:
                    leaf = leaf.child11;
                    break;
            }

            if (leaf == null)
                return null;

            if (level == 0) {
                return leaf.item;
            }
        }
        return null;
    }

    public boolean remove(T item) {
        T cur = item;

        while (cur != root) {
            if (cur == null)
                throw new IllegalStateException("Item not in index");

            /* keep pointer to parent */
            T next = cur.parent;
            cur.refs--;

            /* if current node has no children */
            if (cur.refs == 0) {
                /* unhook from parent */
                switch (cur.id) {
                    case 0:
                        next.child00 = null;
                        break;
                    case 1:
                        next.child01 = null;
                        break;
                    case 2:
                        next.child10 = null;
                        break;
                    case 3:
                        next.child11 = null;
                        break;
                }

                /* add item back to pool */
                cur.parent = pool;
                pool = cur;
            }
            cur = next;
        }

        root.refs--;

        return true;
    }

    public int size() {
        return root.refs;
    }

    public void drop() {
        root.item = null;
        root.child00 = null;
        root.child01 = null;
        root.child10 = null;
        root.child11 = null;
    }
}