| gvSIG desktop 1

/*

 * Created on 16-may-2006

 *

 * gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2004 IVER T.I. and Generalitat Valenciana.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * 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 General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 * For more information, contact:

 *

 *  Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib??ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *      +34 963862235

 *   gvsig@gva.es

 *      www.gvsig.gva.es

 *

 *    or

 *

 *   IVER T.I. S.A

 *   Salamanca 50

 *   46005 Valencia

 *   Spain

 *

 *   +34 963163400

 *   dac@iver.es

 */

/* CVS MESSAGES:

 *

 * $Id: QuadtreeGt2.java 10627 2007-03-06 17:10:21Z caballero $

 * $Log$

 * Revision 1.3  2007-03-06 17:08:59  caballero

 * Exceptions

 *

 * Revision 1.2  2006/11/29 19:27:59  azabala

 * bug fixed (caused when we query for a bbox which is greater or equal to a layer bbox)

 *

 * Revision 1.1  2006/05/24 21:58:04  azabala

 * *** empty log message ***

 *

 *

 */

package org.gvsig.fmap.data.index.spatial.gt2;

import java.io.File;

import java.util.List;

import java.util.Stack;

import org.geotools.index.quadtree.Node;

import org.geotools.index.quadtree.QuadTree;

import org.geotools.index.quadtree.StoreException;

import org.geotools.index.quadtree.fs.FileSystemIndexStore;

import org.geotools.index.quadtree.fs.IndexHeader;

import org.gvsig.fmap.data.index.IndexException;

import org.gvsig.fmap.data.index.spatial.AbstractIntBasedSpatialIndex;

import org.gvsig.fmap.data.index.spatial.PersistentSpatialIndex;

import com.vividsolutions.jts.geom.Envelope;

/**

 * This Quadtree spatial index implementation is based in a fork of

 * org.geotools.index.quadtree.Quadtree implementation. <br>

 * This implementation offers us:

 * <ol>

 * <li>Persistence of spatial index</li>

 * </ol>

 * We had to fork geotools quadtree for many reasons:

 * <ol>

 * <li>It was strongly dependent of SHP format, so it returned not only a num

 * of rectangle, it also returned byte offset of this rectangle in shp file</li>

 * <li> Query artifact wasnt run well at all </li>

 * </ol>

 * 

 * @author azabala

 * 

 */

public class QuadtreeGt2 extends AbstractIntBasedSpatialIndex implements PersistentSpatialIndex {

        /**

         * Geotools quadtree implementation

         */

        QuadTree quadtree;

        /**

         * Persistent storage

         */

        String quadtreeFile;

        /**

         * Spatial index file extension

         */

        final String qExt = ".qix";

        /**

         * qix format has many versions, and allows different byte orders.

         */

        String byteOrder;

        /**

         * Bounds of the layer to index

         */

        Envelope bounds;

        /**

         * Number of records of the layer to index

         */

        int numRecs = 0;

        boolean inMemory = false;

        /**

         * Constructor. You must say a qix file path, and if you want to overwrite

         * this file if exists. Also, you must specify how many geometries are going

         * to index, and the bounding box of all the geometries.

         * 

         * 

         * @param quadtreeFile

         *            qix file path

         * @param byteOrder

         *            byte order (bigendian, etc)

         * @param bounds

         *            Envelope of all the geometries to index

         * @param numRecords

         *            num of geometries to index

         * @param overwrite

         *            if we want to overwrite a possible existing qix file

         * @throws IndexException

         */

        public QuadtreeGt2(String quadtreeFile, String byteOrder,

                        org.gvsig.fmap.geom.primitive.Envelope bounds, int numRecords,

                        boolean overwrite) throws IndexException {

                this.quadtreeFile = quadtreeFile + qExt;

                this.byteOrder = byteOrder;

                this.bounds = toJtsEnvelope(bounds);

                this.numRecs = numRecords;

                if (exists()) {

                        if (!overwrite) {

                                load();

                                return;

                        }

                }

                quadtree = new QuadTree(numRecs, this.bounds);

        }

        /**

         * If the spatial index file exists and has content

         */

        public boolean exists() {

                return (new File(quadtreeFile).length() != 0);

        }

        public void load() throws IndexException {

                if (quadtree == null) {

                        load(new File(quadtreeFile));

                }

        }

        public void load(File f) throws IndexException {

                try {

                        FileSystemIndexStore store = new FileSystemIndexStore(f);

                        quadtree = store.load();

                        this.quadtreeFile = f.getAbsolutePath();

                } catch (StoreException e) {

                        throw new IndexException(e);

                }

        }

        /**

         * 

         * 

         */

        public List query(org.gvsig.fmap.geom.primitive.Envelope env) {

                if (quadtree == null)

                        throw new IllegalStateException("This quadtree is null.");

                if (env == null)

                        throw new IllegalArgumentException("Envelope cannot be null.");

                return quadtree.query(toJtsEnvelope(env));

        }

        /**

         * Inserts an object in the index

         */

        public void insert(org.gvsig.fmap.geom.primitive.Envelope env, int index) {

                if (env == null)

                        throw new IllegalArgumentException("Envelope cannot be null");

                Envelope e = toJtsEnvelope(env);

                if (e == null)

                        throw new IllegalStateException(

                                        "JTS Envelope conversion returns null");

                System.out.println("recno=" + index);

                if (quadtree == null)

                        throw new IllegalStateException("quadtree is null");

                try {

                        quadtree.insert(index, toJtsEnvelope(env));

                } catch (StoreException se) {

                        // TODO Auto-generated catch block

                        se.printStackTrace();

                }

        }

        public void delete(org.gvsig.fmap.geom.primitive.Envelope env, int index) {

                if (inMemory)

                        quadtree.delete(toJtsEnvelope(env), index);

        }

        public Envelope toJtsEnvelope(org.gvsig.fmap.geom.primitive.Envelope env) {

                if (env == null)

                        return null;

                double[] min = env.getLowerCorner();

                double[] max = env.getUpperCorner();

                return new Envelope(min[0], max[0], min[1], max[1]);

        }

        /**

         * 

         * @throws StoreException

         * @deprecated

         */

        void openQuadTree() throws StoreException {

                if (quadtree == null) {

                        File file = new File(quadtreeFile);

                        // Intento de cargar todo el quadtree en memoria

                        FileSystemIndexStore store = new FileSystemIndexStore(file);

                        quadtree = store.load();

                }

        }

        void openQuadTreeInMemory() throws StoreException {

                if (quadtree == null) {

                        File file = new File(quadtreeFile);

                        // Intento de cargar todo el quadtree en memoria

                        FileSystemIndexStore store = new FileSystemIndexStore(file);

                        QuadTree filequadtree = store.load();

                        quadtree = new QuadTree(filequadtree.getNumShapes(), filequadtree

                                        .getMaxDepth(), filequadtree.getRoot().getBounds());

                        Stack nodes = new Stack();

                        nodes.push(filequadtree.getRoot());

                        while (nodes.size() != 0) {

                                Node node = (Node) nodes.pop();

                                Envelope nodeEnv = node.getBounds();

                                int[] shapeIds = node.getShapesId();

                                for (int i = 0; i < shapeIds.length; i++) {

                                        quadtree.insert(shapeIds[i], nodeEnv);

                                }

                                int numSubnodes = node.getNumSubNodes();

                                for (int i = 0; i < numSubnodes; i++) {

                                        nodes.push(node.getSubNode(i));

                                }

                        }// while

                        filequadtree.close();

                }

        }

        public void flush() throws IndexException {

                flush(new File(quadtreeFile));

        }

        public void flush(File f) throws IndexException {

                byte order = 0;

                if ((byteOrder == null) || byteOrder.equalsIgnoreCase("NM")) {

                        order = IndexHeader.NEW_MSB_ORDER;

                } else if (byteOrder.equalsIgnoreCase("NL")) {

                        order = IndexHeader.NEW_LSB_ORDER;

                }

                FileSystemIndexStore store = new FileSystemIndexStore(f, order);

                try {

                        store.store(quadtree);

                        this.quadtreeFile = f.getAbsolutePath();

                } catch (StoreException e) {

                        throw new IndexException(e);

                }

        }

        public void close() {

                try {

                        quadtree.close();

                } catch (StoreException e) {

                        // TODO Auto-generated catch block

                        e.printStackTrace();

                }

        }

        public File getFile() {

                return new File(this.quadtreeFile);

        }

}