Application: gvSIG desktop

import java.awt.Rectangle;

import java.awt.geom.Rectangle2D;

import java.util.List;

import org.apache.log4j.ConsoleAppender;

import org.apache.log4j.Logger;

import org.apache.log4j.SimpleLayout;

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

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

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.primitive.Curve2D;

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

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

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

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

	static {

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

	}

		QuadTreeJtsFactory f1 = new QuadTreeJtsFactory();

		QuadTreeGt2Factory f2 = new QuadTreeGt2Factory();

		RTreeJsiFactory f3 = new RTreeJsiFactory();

		RTreeSptLibFactory f4 = new RTreeSptLibFactory();

	public void testSpatialIndex() {

		try {

			IndexFactory factory = IndexFactory.getFactory(IndexFactory.Factories.GEOMETRY.JTS_QUADTREE);			

			List l1 = tryFactory(factory, null);

			factory = IndexFactory.getFactory(IndexFactory.Factories.GEOMETRY.SPATIALINDEX_RTREE);

			List l2 = tryFactory(factory, null);

			factory = IndexFactory.getFactory(IndexFactory.Factories.GEOMETRY.JSI_RTREE);

			List l3 = tryFactory(factory, null);

			IndexParameters p = new IndexParameters();

			//p.setFeatureCount(1000);			

			factory = IndexFactory.getFactory(IndexFactory.Factories.GEOMETRY.GT2_QUADTREE);

			List l4 = tryFactory(factory, p);

		} catch (Exception e) {

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

		}

	}

	private List tryFactory(IndexFactory factory, IndexParameters p) throws IndexException {		

		Index index = factory.createIndex(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(Index index) {

		if (!(index instanceof SpatialIndex)) {

			throw new UnsupportedOperationException("Can't create this type of 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 FeatureType newFeatureType() {

		FeatureType fType = new DefaultFeatureType();

		try {

			FeatureAttributeDescriptor descriptorID = (FeatureAttributeDescriptor) fType.

					.createAttributeDescriptor();

			descriptorID.loading();

			descriptorID.setType(FeatureAttributeDescriptor.INT);

			descriptorID.setName("ID");

			descriptorID.setDefaultValue(new Integer(0));

			descriptorID.stopLoading();

			fType.add(descriptorID);

			FeatureAttributeDescriptor descriptorShape = (FeatureAttributeDescriptor) fType

					.createAttributeDescriptor();

			descriptorShape.loading();

			descriptorShape.setType(FeatureAttributeDescriptor.GEOMETRY);

			descriptorShape.setName("GEOMETRY");

			descriptorShape.setDefaultValue(null);

			descriptorShape.stopLoading();

			fType.add(descriptorShape);

			fType.setDefaultGeometry("GEOMETRY");

			FeatureAttributeDescriptor descriptorEntity = (FeatureAttributeDescriptor) fType

					.createAttributeDescriptor();

			descriptorEntity.loading();

			descriptorEntity.setType(FeatureAttributeDescriptor.STRING);

			descriptorEntity.setName("Entity");

			descriptorEntity.setDefaultValue("Entity");

			descriptorEntity.stopLoading();

			fType.add(descriptorEntity);

			FeatureAttributeDescriptor descriptorLayer = (FeatureAttributeDescriptor) fType

					.createAttributeDescriptor();

			descriptorLayer.loading();

			descriptorLayer.setType(FeatureAttributeDescriptor.STRING);

			descriptorLayer.setName("Layer");

			descriptorLayer.setDefaultValue("default");

			descriptorLayer.stopLoading();

			fType.add(descriptorLayer);

			FeatureAttributeDescriptor descriptorColor = (FeatureAttributeDescriptor) fType

					.createAttributeDescriptor();

			descriptorColor.loading();

			descriptorColor.setType(FeatureAttributeDescriptor.INT);

			descriptorColor.setName("Color");

			descriptorColor.setDefaultValue(new Integer(0));

			descriptorColor.stopLoading();

			fType.add(descriptorColor);

			FeatureAttributeDescriptor descriptorElevation = (FeatureAttributeDescriptor) fType

					.createAttributeDescriptor();

			descriptorElevation.loading();

			descriptorElevation.setType(FeatureAttributeDescriptor.DOUBLE);

			descriptorElevation.setName("Elevation");

			descriptorElevation.setDefaultValue(new Double(0));

			descriptorElevation.stopLoading();

			fType.add(descriptorElevation);

			FeatureAttributeDescriptor descriptorThickness = (FeatureAttributeDescriptor) fType

					.createAttributeDescriptor();

			descriptorThickness.loading();

			descriptorThickness.setType(FeatureAttributeDescriptor.DOUBLE);

			descriptorThickness.setName("Thickness");

			descriptorThickness.setDefaultValue(new Double(0));

			descriptorThickness.stopLoading();

			fType.add(descriptorThickness);

			FeatureAttributeDescriptor descriptorText = (FeatureAttributeDescriptor) fType

					.createAttributeDescriptor();

			descriptorText.loading();

			descriptorText.setType(FeatureAttributeDescriptor.STRING);

			descriptorText.setName("Text");

			descriptorText.setDefaultValue("");

			descriptorText.stopLoading();

			fType.add(descriptorText);

			FeatureAttributeDescriptor descriptorHeightText = (FeatureAttributeDescriptor) fType

					.createAttributeDescriptor();

			descriptorHeightText.loading();

			descriptorHeightText.setType(FeatureAttributeDescriptor.FLOAT);

			descriptorHeightText.setName("HeightText");

			descriptorHeightText.setDefaultValue(new Float(10));

			descriptorHeightText.stopLoading();

			fType.add(descriptorHeightText);

			FeatureAttributeDescriptor descriptorRotationText = (FeatureAttributeDescriptor) fType

					.createAttributeDescriptor();

			descriptorRotationText.loading();

			descriptorRotationText

					.setType(FeatureAttributeDescriptor.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;

		return null;

	}	

*/