| gvSIG desktop 1

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

import java.io.File;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.util.ArrayList;

import java.util.List;

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

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

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

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

import org.gvsig.fmap.geom.primitive.Envelope;

import org.gvsig.fmap.geom.primitive.Point2D;

import spatialindex.rtree.RTree;

import spatialindex.spatialindex.IData;

import spatialindex.spatialindex.INode;

import spatialindex.spatialindex.IVisitor;

import spatialindex.spatialindex.Region;

import spatialindex.storagemanager.DiskStorageManager;

import spatialindex.storagemanager.IBuffer;

import spatialindex.storagemanager.IStorageManager;

import spatialindex.storagemanager.PropertySet;

import spatialindex.storagemanager.RandomEvictionsBuffer;

/**

 * <p>

 * RTree spatial index based in spatial index library: <br>

 * http://u-foria.org/marioh/spatialindex/index.html <br>

 * marioh@cs.ucr.edu

 * </p>

 * It has the problem that spatial index file creation is a bit slowly

 * (in comparation with other indexes).

 */

public class RTreeSptLib extends AbstractIntBasedSpatialIndex implements PersistentSpatialIndex,

                                                                        NearestNeighbourFinder{

        /**

         * Page size of associated file

         */

        private static final int defaultPageSize = 32 * 1024;

        private static final double defaultFillFactor = 0.85d;

        /**

         * Size of memory buffer of the index

         */

        private static final int BUFFER_SIZE = 25000;

        RTree rtree;

        String rtreeFile;

        IStorageManager diskfile;

        /**

         * Constructor

         * @param overwriteFile tells if we must override existing files.

         * If we are goint to create a new spatial index (or if we want to overwrite

         * an existing one) we must to use always 'true'. If we want to load

         * an existing spatial index file, overwrite must be 'false'

         * @param fileName name of the rtree spatial index file

         * @throws IndexException

         */

        public RTreeSptLib(boolean overwriteFile, String fileName)

                        throws IndexException {

                try {

                        this.rtreeFile = fileName;

                        PropertySet ps = new PropertySet();

                        // overwrite the file if it exists.

                        Boolean b = new Boolean(overwriteFile);

                        ps.setProperty("Overwrite", b);

                        // .idx and .dat extensions will be added.

                        ps.setProperty("FileName", fileName);

                        Integer i = new Integer(defaultPageSize);

                        ps.setProperty("PageSize", i);

                        diskfile = new DiskStorageManager(ps);

                        load();

                } catch (SecurityException e) {

                        throw new IndexException(e);

                } catch (FileNotFoundException e) {

                        throw new IndexException(e);

                } catch (IOException e) {

                        throw new IndexException(e);

                }

        }

        /**

         * If the spatial index file exists and has content

         */

        public boolean exists(){

                return (new File(rtreeFile+".dat").length() != 0);

        }

        class RTreeVisitor implements IVisitor{

                ArrayList solution = new ArrayList();

                public void visitNode(INode n) {

                }

                public void visitData(IData d) {

                        solution.add(new Integer(d.getIdentifier()));

                }

                public List getSolution(){

                        return solution;

                }

        }

        public List query(Envelope env) {

                List solution = null;

                Region region = createRegion(env);

                RTreeVisitor visitor = new RTreeVisitor();

                rtree.intersectionQuery(region,visitor);

                solution = visitor.getSolution();

                return solution;

        }

        public List containtmentQuery(Envelope env) {

                List solution = null;

                Region region = createRegion(env);

                RTreeVisitor visitor = new RTreeVisitor();

                rtree.containmentQuery(region,visitor);

                solution = visitor.getSolution();

                return solution;

        }

        /**

         * Warn! This RTree implemention doesnt care if 'index'

         * entry has been indexed yet

         */

        public void insert(Envelope env, int index) {

                rtree.insertData(null, createRegion(env), index);

        }

        private Region createRegion(Envelope env){

                return new Region(env.getLowerCorner(), env.getUpperCorner());

        }

        public void delete(Envelope env, int index) {

                rtree.deleteData(createRegion(env), index);

        }

        /**

         * Looks for N indexes nearest to the specified rect.

         * @param numberOfNearest

         * @param rect

         * @return

         */

        public List findNNearest(int numberOfNearest, Envelope env) {

                List solution = null;

                Region region = createRegion(env);

                RTreeVisitor visitor = new RTreeVisitor();

                rtree.nearestNeighborQuery(numberOfNearest, region,visitor);

                solution = visitor.getSolution();

                return solution;

        }

        /**

         * Looks for the N indexes nearest to the specified point

         * @param numberOfNearest

         * @param point

         * @return

         */

        public List findNNearest(int numberOfNearest, Point2D point) {

                List solution = null;

                spatialindex.spatialindex.Point sptPoint = new

                        spatialindex.spatialindex.Point(new double[]{point.getX(), point.getY()});

                RTreeVisitor visitor = new RTreeVisitor();

                rtree.nearestNeighborQuery(numberOfNearest, sptPoint,visitor);

                solution = visitor.getSolution();

                return solution;

        }

        public void flush(){

                rtree.flush();

        }

        public void load() {

//                 applies a main memory random buffer on top of the persistent

                // storage manager

                IBuffer buffer = new RandomEvictionsBuffer(diskfile, BUFFER_SIZE, false);

                // Create a new, empty, RTree with dimensionality 2, minimum load

                // 70%, using "file" as

                // the StorageManager and the RSTAR splitting policy.

                PropertySet ps2 = new PropertySet();

                Double f = new Double(defaultFillFactor);

                ps2.setProperty("FillFactor", f);

                Integer i = new Integer(2);

                ps2.setProperty("Dimension", i);

                File file = new File(rtreeFile + ".dat");

                if(file.length() != 0){

                        ps2.setProperty("IndexIdentifier", new Integer(1));

                }

                rtree = new RTree(ps2, buffer);

        }

        public void load(File f) throws IndexException {

                load();

        }

        public void flush(File f) throws IndexException {

                flush();

        }

        public void close() {

        }

        public File getFile() {

                return new File(this.rtreeFile);

        }

}