| gvSIG desktop 1

/* gvSIG. Geographic Information System of the Valencian Government

*

* Copyright (C) 2007-2008 Infrastructures and Transports Department

* of the Valencian Government (CIT)

* 

* 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., 51 Franklin Street, Fifth Floor, Boston, 

* MA  02110-1301, USA.

* 

*/

/*

* AUTHORS (In addition to CIT):

* 2008 {{Company}}   {{Task}}

*/

package org.gvsig.fmap.data.index;

import java.awt.Rectangle;

import java.awt.geom.Rectangle2D;

import java.util.List;

import junit.framework.TestCase;

import org.apache.log4j.ConsoleAppender;

import org.apache.log4j.Logger;

import org.apache.log4j.SimpleLayout;

import org.gvsig.fmap.data.DataManager;

import org.gvsig.fmap.data.feature.AttributeDescriptor;

import org.gvsig.fmap.data.feature.DefaultFeatureType;

import org.gvsig.fmap.data.feature.Feature;

import org.gvsig.fmap.data.feature.FeatureAttributeDescriptor;

import org.gvsig.fmap.data.feature.FeatureCollection;

import org.gvsig.fmap.data.feature.FeatureType;

import org.gvsig.fmap.data.feature.IsNotAttributeSettingException;

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

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

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

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

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

import org.gvsig.fmap.data.index.spatial.gt2.QuadTreeGt2Factory;

import org.gvsig.fmap.data.index.spatial.jsi.RTreeJsiFactory;

import org.gvsig.fmap.data.index.spatial.jts.QuadTreeJtsFactory;

import org.gvsig.fmap.data.index.spatial.spatialindex.RTreeSptLibFactory;

import org.gvsig.fmap.geom.Geometry;

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

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

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

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

public class SpatialIndexTest extends TestCase {

        private static Logger logger = Logger.getLogger("org.gvsig");

        static {

                logger.addAppender(new ConsoleAppender(new SimpleLayout()));

        }

        protected void setUp() throws Exception {

                QuadTreeJtsFactory f1 = new QuadTreeJtsFactory();

                QuadTreeGt2Factory f2 = new QuadTreeGt2Factory();

                RTreeJsiFactory f3 = new RTreeJsiFactory();

                RTreeSptLibFactory f4 = new RTreeSptLibFactory();

                super.setUp();

        }

        public void testSpatialIndex() {

                try {

                        SpatialIndexFactory factory = SpatialIndexFactory.getFactory(SpatialIndexFactory.Factories.JTS_QUADTREE);                        

                        List l1 = tryFactory(factory, null);

                        factory = SpatialIndexFactory.getFactory(SpatialIndexFactory.Factories.SPATIALINDEX_RTREE);

                        List l2 = tryFactory(factory, null);

                        factory = SpatialIndexFactory.getFactory(SpatialIndexFactory.Factories.JSI_RTREE);

                        List l3 = tryFactory(factory, null);

                        SpatialIndexParameters p = new SpatialIndexParameters();

                        p.setFeatureCount(1000);                        

                        factory = SpatialIndexFactory.getFactory(SpatialIndexFactory.Factories.GT2_QUADTREE);

                        List l4 = tryFactory(factory, p);

                } catch (Exception e) {

                        logger.error("Error, ", e);

                }

        }

        private List tryFactory(SpatialIndexFactory factory, SpatialIndexParameters p) throws IndexException {                

                SpatialIndex index = factory.createSpatialIndex(p);

                Envelope envelope = fillIndex(index);

                if (p != null)        p.setEnvelope(envelope);

                if (index instanceof PersistentSpatialIndex) {

                        logger.debug("*** Persistent Index.***");

                        PersistentSpatialIndex psi = (PersistentSpatialIndex) index; 

                        psi.flush();

                        assertTrue(psi.getFile().exists());

                        logger.debug(psi.getFile().getAbsolutePath());

                }

                Envelope env = new Curve2D(new GeneralPathX(new Rectangle(0,0,100,100))).getEnvelope();

                logger.debug("index.query(env)");

                SpatialQueryParameters sqp = new SpatialQueryParameters();

                sqp.setEnvelope(env);                

                List result = index.query(sqp); 

                logger.debug(result);

                return result;

        }

        private Envelope fillIndex(SpatialIndex index) {

                Envelope extent = new DefaultEnvelope(2);

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

                        Rectangle2D r = new Rectangle(i, -i, i + 10, i * 2 - i);

                        Envelope env = new Curve2D(new GeneralPathX(r)).getEnvelope();

                        extent.add(env);

                        // FIXME index.insert(env, i);

                        if(i%100 == 0) logger.debug(env.toString());

                }                

                logger.debug("index done.");

                return extent;

        }

        private FeatureCollection newFeatureCollection() {

                DataManager man = DataManager.getManager();

                return null;                

        }

        private FeatureType newFeatureType() {

                DefaultFeatureType fType = new DefaultFeatureType();

                try {

                        AttributeDescriptor descriptorID = (AttributeDescriptor) fType

                                        .createAttributeDescriptor();

                        descriptorID.loading();

                        descriptorID.setType(FeatureAttributeDescriptor.TYPE_INT);

                        descriptorID.setName("ID");

                        descriptorID.setDefaultValue(new Integer(0));

                        descriptorID.stopLoading();

                        fType.add(descriptorID);

                        AttributeDescriptor descriptorShape = (AttributeDescriptor) fType

                                        .createAttributeDescriptor();

                        descriptorShape.loading();

                        descriptorShape.setType(FeatureAttributeDescriptor.TYPE_GEOMETRY);

                        descriptorShape.setName("GEOMETRY");

                        descriptorShape.setDefaultValue(null);

                        descriptorShape.stopLoading();

                        fType.add(descriptorShape);

                        fType.setDefaultGeometry("GEOMETRY");

                        AttributeDescriptor descriptorEntity = (AttributeDescriptor) fType

                                        .createAttributeDescriptor();

                        descriptorEntity.loading();

                        descriptorEntity.setType(FeatureAttributeDescriptor.TYPE_STRING);

                        descriptorEntity.setName("Entity");

                        descriptorEntity.setDefaultValue("Entity");

                        descriptorEntity.stopLoading();

                        fType.add(descriptorEntity);

                        AttributeDescriptor descriptorLayer = (AttributeDescriptor) fType

                                        .createAttributeDescriptor();

                        descriptorLayer.loading();

                        descriptorLayer.setType(FeatureAttributeDescriptor.TYPE_STRING);

                        descriptorLayer.setName("Layer");

                        descriptorLayer.setDefaultValue("default");

                        descriptorLayer.stopLoading();

                        fType.add(descriptorLayer);

                        AttributeDescriptor descriptorColor = (AttributeDescriptor) fType

                                        .createAttributeDescriptor();

                        descriptorColor.loading();

                        descriptorColor.setType(FeatureAttributeDescriptor.TYPE_INT);

                        descriptorColor.setName("Color");

                        descriptorColor.setDefaultValue(new Integer(0));

                        descriptorColor.stopLoading();

                        fType.add(descriptorColor);

                        AttributeDescriptor descriptorElevation = (AttributeDescriptor) fType

                                        .createAttributeDescriptor();

                        descriptorElevation.loading();

                        descriptorElevation.setType(FeatureAttributeDescriptor.TYPE_DOUBLE);

                        descriptorElevation.setName("Elevation");

                        descriptorElevation.setDefaultValue(new Double(0));

                        descriptorElevation.stopLoading();

                        fType.add(descriptorElevation);

                        AttributeDescriptor descriptorThickness = (AttributeDescriptor) fType

                                        .createAttributeDescriptor();

                        descriptorThickness.loading();

                        descriptorThickness.setType(FeatureAttributeDescriptor.TYPE_DOUBLE);

                        descriptorThickness.setName("Thickness");

                        descriptorThickness.setDefaultValue(new Double(0));

                        descriptorThickness.stopLoading();

                        fType.add(descriptorThickness);

                        AttributeDescriptor descriptorText = (AttributeDescriptor) fType

                                        .createAttributeDescriptor();

                        descriptorText.loading();

                        descriptorText.setType(FeatureAttributeDescriptor.TYPE_STRING);

                        descriptorText.setName("Text");

                        descriptorText.setDefaultValue("");

                        descriptorText.stopLoading();

                        fType.add(descriptorText);

                        AttributeDescriptor descriptorHeightText = (AttributeDescriptor) fType

                                        .createAttributeDescriptor();

                        descriptorHeightText.loading();

                        descriptorHeightText.setType(FeatureAttributeDescriptor.TYPE_FLOAT);

                        descriptorHeightText.setName("HeightText");

                        descriptorHeightText.setDefaultValue(new Float(10));

                        descriptorHeightText.stopLoading();

                        fType.add(descriptorHeightText);

                        AttributeDescriptor descriptorRotationText = (AttributeDescriptor) fType

                                        .createAttributeDescriptor();

                        descriptorRotationText.loading();

                        descriptorRotationText

                                        .setType(FeatureAttributeDescriptor.TYPE_DOUBLE);

                        descriptorRotationText.setName("Rotation");

                        descriptorRotationText.setDefaultValue(new Double(10));

                        descriptorRotationText.stopLoading();

                        fType.add(descriptorRotationText);

                        fType.setDefaultGeometry("GEOMETRY");

                        fType.setGeometryTypes(new int[] { Geometry.TYPES.GEOMETRY });

                } catch (IsNotAttributeSettingException e) {

                        e.printStackTrace();

                }

                return fType;

        }        

}