Application: gvSIG desktop

 *

 * $Id$

 * $Log$

 * *** empty log message ***

 *

 * Revision 1.2  2006/07/27 17:21:06  azabala

import org.cresques.cts.ICoordTrans;

import com.iver.cit.gvsig.fmap.core.IFeature;

import com.iver.cit.gvsig.fmap.core.IGeometry;

import com.iver.cit.gvsig.fmap.core.v02.FConverter;

import com.iver.cit.gvsig.fmap.drivers.DriverIOException;

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.Strategy;

import com.iver.cit.gvsig.fmap.operations.strategies.StrategyManager;

import com.iver.cit.gvsig.geoprocess.core.fmap.FeatureProcessor;

import com.iver.cit.gvsig.geoprocess.core.fmap.GeoprocessException;

import com.iver.utiles.swing.threads.Cancellable;

 * Dissolve features in base of a given dissolve criteria.

 * </p>

 * By 'dissolving' we understand the union of the geometry of many features

 * @author azabala

 */

public class FeatureDissolver {

	 * Fetches attributes of disolved layer features

	 */

	protected SelectableDataSource recordset;

	protected ICoordTrans ct;

	/**

	/**

	 * It marks all features that have already been dissolved (to avoid process

	 * them in subsecuent steps)

	 */

	protected FBitSet dissolvedGeometries;

	protected IDissolveCriteria dissolveCriteria;

	/**

	 * @param processor

	 * @param layer

	 * @throws GeoprocessException

				recordset = ((AlphanumericData) layer).getRecordset();

				ct = dissolvedLayer.getCoordTrans();

				featureProcessor.start();

				throw new GeoprocessException(

						"Error al acceder al recordset de la capa "

								+ layer.getName(), e);

				throw new GeoprocessException(

						"Error al preparar donde se van a escribir los resultados del dissolve de la capa "

								+ layer.getName(), e);

					this.featureProcessor.finish();

					return;

				}

				//Ver si podemos optimizar esto de forma que solo

				//se procesasen los elementos no marcados en el bitset

				//(bitset de acceso aleatorio)

				if (!dissolvedGeometries.get(i)) {

					// if we havent processed this element yet

					try {

							process( i, va, cancel);

						else if(dissolveType == ALPHANUMERIC_DISSOLVE)

							processAlphanumeric(i, va, cancel);

						throw new GeoprocessException(

								"Error accediendo a datos durante dissolve", e);

						throw new GeoprocessException(

								"Error procesando datos durante dissolve", e);

						throw new GeoprocessException(

					}

				}// if

			}// for

			va.stop();

			this.featureProcessor.finish();

			e.printStackTrace();

		}

	}

	/**

	 * Verifies cancelation events, and return a boolean flag if processes must

	 * be stopped for this cancelations events.

	 * @param cancel

	 * @param va

	 * @param visitor

	}

	class DissolveVisitor implements FeatureVisitor {

		IDissolveCriteria criteria;

		int index1;

		Stack stack;

			this.cancel = cancel;

		}

			if(g == null)

				return;

			if (verifyCancelation(cancel, va)) {

				featureProcessor.finish();

				return;

			}

			if(index1 == index2){

				//we dont want dissolve a feature with itself

				return;

					stack.push(new Integer(index2));

				try {

					if(criteria instanceof ISpatialDissolveCriteria){

						//leido la geometria

						geometries.add(

								((ISpatialDissolveCriteria)criteria).

						geometries.add(g2.toJTSGeometry());

					}

					sumarizer.applySumarizeFunction(index2);

				}

				//Esto se debe hacer externamente

				if(stack == null)

			return "";

		}

		}

			return true;

		}

	}

	/**

	 * @param index1

	 * @param va

	 * @param cancel

	 * @throws DriverException

	 * @throws IOException

	 * @throws DriverIOException

	 */

	public void processAlphanumeric(int index1,

							CancellableMonitorable cancel)

		dissolvedGeometries.set(index1);

		Strategy strategy = StrategyManager.getStrategy(dissolvedLayer);

		ArrayList geometries = new ArrayList();

		if(sumarizedValues != null || sumarizedValues.size() != 0){

			dissolvedFeature =  dissolveCriteria.

							getFeatureBuilder().

												index1);

		}else{

			dissolvedFeature = dissolveCriteria.

								getFeatureBuilder().

								createFeature(newGeometry,

										fid);

		}

		fid++;

		featureProcessor.processFeature(dissolvedFeature);

		dissolveCriteria.clear();

	}

	class SpatialDissolveVisitor implements FeatureVisitor {

		IDissolveCriteria criteria;

		Geometry geom1;

		StackEntry entry1;

		FunctionSummarizer sumarizer;

		CancellableMonitorable cancel;

				Stack stack,

				List geometries, ReadableVectorial va,

				FunctionSummarizer sumarizer, CancellableMonitorable cancel) {

			this.sumarizer = sumarizer;

			this.cancel = cancel;

		}

		void setSeed(StackEntry entry, Geometry jtsGeo){

			this.entry1 = entry;

			this.geom1 = jtsGeo;

		}

			if(g == null)

				return;

			if (verifyCancelation(cancel, va)) {

				featureProcessor.finish();

				return;

			}

			if(entry1.index == index2){

				//we dont want dissolve a feature with itself

				return;

					geometries.add(g.toJTSGeometry());

				try {

					sumarizer.applySumarizeFunction(index2);

				}

				dissolvedGeometries.set(index2);

			}

			return "";

		}

		}

			return true;

		}

	}

	class StackEntry{

		public IGeometry g;

		public int index;

	 * Processes the given feature looking for features to dissolve with. The

	 * criteria to decide if dissolve two features is given by

	 * IDissolveCriteria.

	 * @param criteria

	 *            decides if dissolve two features

	 * @param index1

	 *            it reads geometry of features

	 * @param cancel

	 *            listen cancelations

	 * @throws DriverException

	 * @throws IOException

	 * @throws DriverIOException

	 */

	public void process(int index1,

			CancellableMonitorable cancel)

		if(dissolvedGeometries.get(index1))

			return;

		IGeometry g1 = va.getShape(index1);

		if(g1 == null)

			return;

		Stack stack = new Stack();//it saves FMap geometries

		stack.push(entry);

		ArrayList geometries = new ArrayList();

		Geometry jtsGeo = g1.toJTSGeometry();

		geometries.add(jtsGeo);//it saves jts geometries

		if(dissolveCriteria instanceof ISpatialDissolveCriteria){

			((ISpatialDissolveCriteria)dissolveCriteria).setCoordTrans(ct);

			((ISpatialDissolveCriteria)dissolveCriteria).setFirstGeometry(g1);

		}

		FunctionSummarizer sumarizer = new FunctionSummarizer(

				numericField_sumarizeFunction, recordset);

																			stack,

																			cancel);

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

			dumpStack(stack);

			StackEntry sEntry = (StackEntry) stack.pop();

			dissolvedGeometries.set(sEntry.index);

			/*//TODO

			 * Revisar si no deberiamos hacer

			 * ct.getInverted().convert(rect);

			 * */

			Rectangle2D rect = sEntry.g.getBounds2D();

			if(ct != null)

			visitor.setSeed(sEntry, jts);

			strategy.process(visitor, query);

		}// while

		IGeometry newGeometry = FConverter.jts_to_igeometry(union2(geometries));

		List sumarizedValues = sumarizer.getValues();

		IFeature dissolvedFeature = null;

		if(sumarizedValues != null || sumarizedValues.size() != 0){

			dissolvedFeature =  dissolveCriteria.

								getFeatureBuilder().

													index1);

		}else{

			dissolvedFeature = dissolveCriteria.

								getFeatureBuilder().

								createFeature(newGeometry,

										fid);

		}

		fid++;

	/**

	 * Returns the union of all geometries of the list

	 * @param geometries

	 * @return

	 */

		Geometry union = null;

		GeometryFactory fact = ((Geometry)geometries.

									get(0)).getFactory();

				union = g;

			else{

				Geometry[] geomArray = {union, g};

					fact.

					createGeometryCollection(geomArray);

				union = gCol.buffer(0d);

		}

		return union;

	}

	protected Geometry union3(List geometries) {

				Geometry union = null;

				Iterator geomIt = geometries.iterator();

				while(geomIt.hasNext()){

						union = g;

					else{

						union = union.union(g);

				}

		long t1 = System.currentTimeMillis();

		System.out.println((t1-t0)+ " en procesar union 3");

				return union;

			}

			Geometry union = null;

			Geometry[] geom = new Geometry[geometries.size()];

			geometries.toArray(geom);

		    union = geomColl.buffer(0);

//		    System.out.println(union.toText());

		    return union;

	}

}