/trunk/extensions/extGeoProcessing/src/com/iver/cit/gvsig/geoprocess/impl/spatialjoin/fmap/NearestHeuristicSpatialJoinVisitor.java - Diff - Application: gvSIG desktop - gvSIG

Revision 10626 trunk/extensions/extGeoProcessing/src/com/iver/cit/gvsig/geoprocess/impl/spatialjoin/fmap/NearestHeuristicSpatialJoinVisitor.java

+    *
     * $Id$
     * $Log$
     * Revision 1.1  2006-06-20 18:20:45  azabala
     * Revision 1.2  2007-03-06 16:47:58  caballero
     * Exceptions
+    *
     * Revision 1.1  2006/06/20 18:20:45  azabala
     * first version in cvs
+    *
     * Revision 1.2  2006/06/02 18:21:28  azabala
-...
     import java.awt.geom.Rectangle2D;
     import java.util.Stack;
     import com.iver.cit.gvsig.fmap.DriverException;
     import com.hardcode.gdbms.driver.exceptions.ReadDriverException;
     import com.hardcode.gdbms.engine.data.driver.DriverException;
     import com.iver.cit.gvsig.exceptions.expansionfile.ExpansionFileReadException;
     import com.iver.cit.gvsig.exceptions.visitors.ProcessVisitorException;
     import com.iver.cit.gvsig.exceptions.visitors.StartVisitorException;
     import com.iver.cit.gvsig.exceptions.visitors.VisitorException;
     import com.iver.cit.gvsig.fmap.core.IFeature;
     import com.iver.cit.gvsig.fmap.core.IGeometry;
     import com.iver.cit.gvsig.fmap.layers.FBitSet;
     import com.iver.cit.gvsig.fmap.layers.FLayer;
     import com.iver.cit.gvsig.fmap.layers.FLyrVect;
     import com.iver.cit.gvsig.fmap.operations.strategies.FeatureVisitor;
     import com.iver.cit.gvsig.fmap.operations.strategies.VisitException;
     import com.iver.cit.gvsig.geoprocess.core.fmap.FeatureProcessor;
     import com.vividsolutions.jts.geom.Envelope;
     import com.vividsolutions.jts.geom.Geometry;
-...
      * the parent node in the quad-tree structure).
      * <br>
      * A critical aspect is optimization of the number of levels of quad-tree.
+     *
+     *
      * If we take very few levels, the spatial query will return a lot of
      * candidates to nearest, so we wont get advantage of this stuff.
+     *
+     *
      * If we take a lot of levels, we wont get result in the spatial queries,
      * and we'll have to do a lot of querys.
+     *
+     *
      * @author azabala
+     *
+     *
      * FIXME EL ALGORITMO FALLA!!!!!!!! EL QUADTREE ES UNA ESTRUCTURA
      * BUENA PARA RECTANGULOS, PERO PARA PUNTOS CREO QUE NO FUNCIONA.
      * NO TIENE EN CUENTA LOS EXTREMOS DE LOS RECTANGULOS
+     *
      */
     public class NearestHeuristicSpatialJoinVisitor extends NearestSpatialJoinVisitor {
     	private QuadTreeUtil quadTree = new QuadTreeUtil();
     	/**
     	 * Full extent of the layer where we are looking for
-...
     	 */
     	private Envelope targetLayerEnv = null;
     	/**
+    	 *
+    	 *
     	 * @param sourceLayer
     	 * @param targetLayer
     	 * @param processor
     	 * @throws DriverException
     	 */
     	public NearestHeuristicSpatialJoinVisitor(FLyrVect sourceLayer,
     			FLyrVect targetLayer,
     			FeatureProcessor processor) throws DriverException {
     	public NearestHeuristicSpatialJoinVisitor(FLyrVect sourceLayer,
     			FLyrVect targetLayer,
     			FeatureProcessor processor) throws ReadDriverException {
     		super(sourceLayer, targetLayer, processor);
     		Rectangle2D rect = targetLayer.getFullExtent();
     		targetLayerEnv = new Envelope(rect.getMinX(),
     		Rectangle2D rect;
     		try {
     			rect = targetLayer.getFullExtent();
     		} catch (ExpansionFileReadException e) {
     			throw new ReadDriverException(sourceLayer.getName(),e);
+    		}
     		targetLayerEnv = new Envelope(rect.getMinX(),
     				rect.getMaxX(),
     				rect.getMinY(),
     				rect.getMaxY());
+    	}
     	//	TODO If we need a class to look for nearest feature to a given
     	//feature, move to a public class
-...
     		 * consideer features selected.
     		 */
     		FBitSet selection;
     		public boolean hasFoundShortest(){
     			return nearestFeatureIndex != -1;
+    		}
     		public int getNearestFeatureIndex(){
     			return nearestFeatureIndex;
+    		}
     		public void setSelection(FBitSet bitSet){
     			this.selection = bitSet;
+    		}
     		public void setGeometry(Geometry firstG){
     			this.firstG = firstG;
+    		}
     		public void visit(IGeometry g, int index) throws VisitException {
     		public void visit(IGeometry g, int index) throws VisitorException, ProcessVisitorException {
     			if(selection != null){
     				if(! selection.get(index)){
     					return;
-...
     		public String getProcessDescription() {
     			return "";
+    		}
     		public void stop(FLayer layer) {
     		public void stop(FLayer layer) throws VisitorException {
+    		}
     		public boolean start(FLayer layer) {
     		public boolean start(FLayer layer) throws StartVisitorException {
     			return true;
+    		}
     	};
-...
     	 * Processes a Feature of source layer, looking for its nearest feature of
     	 * target layer and taking attributes from it
     	 */
     	public void visit(IGeometry g, int sourceIndex) throws VisitException {
     	public void visit(IGeometry g, int sourceIndex) throws VisitorException, ProcessVisitorException {
     		if(g == null)
     			return;
     		final Geometry geometry = g.toJTSGeometry();
     		final Geometry geometry = g.toJTSGeometry();
     		Stack stackOfEnvelopes = quadTree.getNearestEnvelopeOfIdealDimension(geometry,
     				targetLayerEnv);
     		LookForNearest visitor = new LookForNearest();
     		visitor.setGeometry(geometry);
     		while((stackOfEnvelopes.size() > 0) ) {
     			Envelope envelope = (Envelope) stackOfEnvelopes.pop();
     			Rectangle2D.Double rect = new Rectangle2D.Double(envelope.getMinX(),
     			Rectangle2D.Double rect = new Rectangle2D.Double(envelope.getMinX(),
     					envelope.getMinY(),
     					envelope.getWidth(),
     					envelope.getHeight());
-...
     				strategy.process(visitor, rect);
     				if(visitor.hasFoundShortest()){
     					int targetIndex = visitor.getNearestFeatureIndex();
     					IFeature joinedFeature = createFeature(g,
     														sourceIndex,
     					IFeature joinedFeature = createFeature(g,
     														sourceIndex,
     														targetIndex, -1);
     					this.featureProcessor.processFeature(joinedFeature);
     					return;
+    				}
     			} catch (DriverException e) {
     				throw new VisitException("Error accediendo a los datos buscando el feature mas proximo", e);
     			} catch (com.hardcode.gdbms.engine.data.driver.DriverException e) {
     				throw new VisitException("Error accediendo a los datos buscando el feature mas proximo", e);
+    			}
     			} catch (ReadDriverException e) {
     				throw new ProcessVisitorException(targetRecordset.getName(),e,"Error accediendo a los datos buscando el feature mas proximo");
     			} catch (ExpansionFileReadException e) {
     				throw new ProcessVisitorException(targetRecordset.getName(),e,"Error accediendo a los datos buscando el feature mas proximo");
+    			}
     		}//while
+    	}
     	/**
     	 * FIXME Refinar muy mucho, pero de momento me vale para hacer la busqueda
     	 * de la geometria mas proxima a una dada mediante subdivisi?n del espacio.
+    	 *
+    	 *
     	 * @author azabala
+    	 *
     	 */
     	class QuadTreeUtil{
     		double DEFAULT_IDEAL_DIMENSION = 500d;
     		double idealDimension = DEFAULT_IDEAL_DIMENSION;
     		public void setIdealDimension(double idealDimension){
     			this.idealDimension = idealDimension;
+    		}
     		public double distance(Geometry geo, Envelope rect){
     			GeometryFactory geoFact = new GeometryFactory();
     			Geometry poly = geoFact.toGeometry(rect);
     			return DistanceOp.distance(geo, poly);
+    		}
     		public double getMaxDimension(Envelope env){
     			double w = env.getWidth();
     			double h = env.getHeight();
     			return (w > h ? w : h);
+    		}
     		public Stack getNearestEnvelopeOfIdealDimension(Geometry nearest,
     				Envelope originalEnvelope){
     			//stack with all the hierarchical envelopes of the solution quad
-...
     					firstsolution = quads[1];
     				else if(d2 <= d0 && d2 <= d1 && d2 <= d3)
     					firstsolution = quads[2];
     				else
     				else
     					firstsolution = quads[3];
     				solution.push(firstsolution);
     				maxDimension = getMaxDimension(firstsolution);
+    			}
     			return solution;
+    		}
     		public  Envelope[] getNextQtreeLevel(Envelope rect){
     			Envelope[] solution = new Envelope[4];
     			int SW = 0;

Also available in: Unified diff