| gvSIG desktop 1

	<classpathentry combineaccessrules="false" kind="src" path="/_fwAndami"/>

	<classpathentry combineaccessrules="false" kind="src" path="/libIverUtiles"/>

* Revision 1.4  2006-03-15 18:34:50  azabala

* *** empty log message ***

*

* Revision 1.3  2006/03/14 18:32:46  fjp

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

 * vectorial layers to produce a new vectorial layer.

 * So geoprocesses could be costly task, extends IBackgroundExecution

 * interface that offers a method to run in background.

 * TODO Migrate to libGeoprocess all geoprocessing logic,

 * 

 * 

public interface IGeoprocess extends IBackgroundExecution{

* Revision 1.4  2006-03-15 18:34:03  azabala

* *** empty log message ***

*

* Revision 1.3  2006/03/14 18:32:46  fjp

/*

 * Created on 15-mar-2006

 *

 * gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2004 IVER T.I. and Generalitat Valenciana.

 *

 * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 * For more information, contact:

 *

 *  Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib??ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *      +34 963862235

 *   gvsig@gva.es

 *      www.gvsig.gva.es

 *

 *    or

 *

 *   IVER T.I. S.A

 *   Salamanca 50

 *   46005 Valencia

 *   Spain

 *

 *   +34 963163400

 *   dac@iver.es

 */

/* CVS MESSAGES:

*

* $Id$

* $Log$

* Revision 1.1  2006-03-15 18:33:53  azabala

* *** empty log message ***

*

*

*/

package com.iver.gvsig.geoprocessing.impl.jtsprocessors;

import com.iver.cit.gvsig.fmap.edition.EditionException;

import com.iver.cit.gvsig.fmap.edition.IWriter;

/**

 * Subclass of FeaturePersisterProcessor2 that

 * deferred postProcess call to subjacent IWriter.

 * 

 * It is thinked for batch processes, because delegates

 * preprocess and postprocess calls to external processes

 * that uses this class' instances.

 * 

 * PRECONDITIONS: IWriter has preprocessed yet.

 * POSTCONDITIONS: Must call IWriter postprocess externally

 * 

 * 

 * @author azabala

 *

 */

public class DeferredFeaturePersisterProcessor extends

		FeaturePersisterProcessor2 {

	public DeferredFeaturePersisterProcessor(IWriter writer) {

		super(writer);

	}

	public void start() throws EditionException{

	}

	public void finish() {

	}

}

* Revision 1.3  2006-03-15 18:34:03  azabala

* Revision 1.2  2006/03/05 19:58:58  azabala

* *** empty log message ***

*

/**

 * It saves in a persistent data store Features, by using a IWriter.

 * It does preprocess and postprocess in start() and stop() methods.

 * @author azabala

 *

 */

 * Revision 1.5  2006-03-15 18:33:36  azabala

 * *** empty log message ***

 *

 * Revision 1.4  2006/03/14 18:32:46  fjp

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

import com.iver.cit.gvsig.fmap.operations.CancellableMonitorable;

import com.iver.cit.gvsig.fmap.operations.DefaultCancellableMonitorable;

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

	public IMonitorableTask createTask() {

		try {

			return new IntersectionMonitorableTask();

		} catch (DriverIOException e) {

			return null;

		}

	}

	/**

	 * IMonitorableTask that allows to run diff geoprocess in background,

	 * with cancelation requests.

	 * 

	 * @author azabala

	 * 

	 */

	class IntersectionMonitorableTask implements IMonitorableTask {

		private CancellableMonitorable cancelMonitor = null;

		// FIXME INTERNACIONALIZAR ESTO

		String INTERSECTION_MESSAGE = "Computing intersections: ";

		private boolean finished = false;

		IntersectionMonitorableTask() throws DriverIOException {

			initialize();

		}

		void initialize() throws DriverIOException {

			cancelMonitor = createCancelMonitor();

		}

		private CancellableMonitorable createCancelMonitor()

				throws DriverIOException {

			DefaultCancellableMonitorable monitor = new 

							DefaultCancellableMonitorable();

			monitor.setInitialStep(0);

			//Really its undeterminated, but  we must to process all

			//elements of first layer (or selection) we are going to 

			//consideer determinated

			monitor.setDeterminatedProcess(true);

			int numSteps = 0;

			if (onlyFirstLayerSelection) {

				FBitSet selection = firstLayer.getRecordset().getSelection();

				numSteps = selection.cardinality();

			} else {

				numSteps = firstLayer.getSource().getShapeCount();

			}

			monitor.setFinalStep(numSteps);

			return monitor;

		}

		public int getInitialStep() {

			return cancelMonitor.getInitialStep();

		}

		public int getFinishStep() {

			return cancelMonitor.getFinalStep();

		}

		public int getCurrentStep() {

			return cancelMonitor.getCurrentStep();

		}

		public String getStatusMessage() {

			// FIXME Cambiar esto por un mecanismo de eventos,

			// de forma que la tarea lo que tenga sea un escuchador

			// que cambie el mensaje de estado segun los eventos

			// de tareas que se est?n realizando

			return "Intersection Geoprocess...";

		}

		public String getNote() {

			// FIXME Cambiar esto por un mecanismo de eventos,

			// de forma que la tarea lo que tenga sea un escuchador

			// que cambie el mensaje de estado segun los eventos

			// de tareas que se est?n realizando

			return INTERSECTION_MESSAGE + getCurrentStep() + "of " + getFinishStep();

		}

		public void cancel() {

			((DefaultCancellableMonitorable) cancelMonitor).setCanceled(true);

		}

		public void run() throws GeoprocessException {

			try {

				//Prepare the result

				schemaManager.createOrAlterSchema(createLayerDefinition());

				writer.preProcess();

				Strategy strategy = 

					StrategyManager.getStrategy(firstLayer);

				Strategy overlayStrategy = 

					StrategyManager.getStrategy(overlayLayer);

				FeaturePersisterProcessor2 featureProcessor =

					new FeaturePersisterProcessor2(writer);

				IntersectVisitor visitor = new IntersectVisitor(overlayLayer, 

															featureProcessor, 

															overlayStrategy,

															onlyClipLayerSelection);

				if(onlyFirstLayerSelection){

					strategy.process(visitor, 

						firstLayer.getRecordset().getSelection(),

						cancelMonitor);

				}else{

					strategy.process(visitor, cancelMonitor);

				}

			} catch (EditionException e) {

				throw new GeoprocessException("Error al crear el esquema/fichero de la nueva capa");

			} catch (DriverException e) {

				throw new GeoprocessException("Error de driver al calcular el geoproceso interseccion");

			} catch (com.iver.cit.gvsig.fmap.DriverException e) {

				throw new GeoprocessException("Error de driver al calcular el geoproceso interseccion");

			} catch (VisitException e) {

				throw new GeoprocessException("Error al procesar el feature de una capa durante el geoproceso interseccion");

			}finally{

				finished = true;

			}

		}

		public boolean isDefined() {

			return cancelMonitor.isDeterminatedProcess();

		}

		public boolean isCanceled() {

			return cancelMonitor.isCanceled();

		}

		public boolean isFinished() {

			return finished;

		}

	}

* Revision 1.8  2006-03-15 18:30:39  azabala

* *** empty log message ***

*

* Revision 1.7  2006/03/14 18:32:46  fjp

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

import com.iver.cit.gvsig.fmap.operations.CancellableMonitorable;

import com.iver.cit.gvsig.fmap.operations.DefaultCancellableMonitorable;

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

 * A clip between two layers is the intersection of the first layer with the

 * convex hull of the second layer.

 * It is an individual case of OverlayGeoprocess. When we would have piped

 * geoprocesses, we could model it like a pipe of a ConvexHull geoprocess and an

 * intersection geoprocess.

 * 

 * 

public class ClipGeoprocess extends AbstractGeoprocess implements

		IOverlayGeoprocess {

	 * processes input layer's features to clip its geometries with clipping

	 * layer bounding box

	 * Constructor

	 * 

	public ClipGeoprocess(FLyrVect inputLayer) {

		Boolean firstLayerSelection = (Boolean) params

				.get("firstlayerselection");

		if (firstLayerSelection != null)

		Boolean secondLayerSelection = (Boolean) params

				.get("secondlayerselection");

		if (secondLayerSelection != null)

		if (this.writer == null || this.schemaManager == null) {

			throw new GeoprocessException(

					"Operacion de clip sin especificar capa de resultados");

			if (overlayLayer.getShapeType() != XTypes.POLYGON) {

				throw new GeoprocessException(

						"La capa de recorte no es de pol?gonos");

			throw new GeoprocessException(

					"Error al tratar de chequear si la capa de recorte es de pol?gonos");

			clippingGeometry = computeJtsClippingPoly(null);

			throw new GeoprocessException(

					"Error calculando el convex hull de la clipping layer");

		visitor = new ClipVisitor(clippingGeometry, resultLayerDefinition,

				schemaManager, writer);

		Strategy strategy = StrategyManager.getStrategy(firstLayer);

			if (onlyFirstLayerSelection) {

				strategy.process(visitor, firstLayer.getRecordset()

						.getSelection());

			} else {

			throw new GeoprocessException(

					"Problemas al leer los datos de la capa a clipear");

				resultLayerDefinition = DefinitionUtils

						.createLayerDefinition(firstLayer);

				// TODO Quizas createLayerDefinition deberia lanzar

				// una excepcion

	/**

	 * Computes union of all geometries of the clipping layer

	 * 

	 * @param cancel

	 *            monitors cancellations and progress of clipping polygon

	 *            computation.

	 * @return

	 * @throws com.iver.cit.gvsig.fmap.DriverException

	 * @throws VisitException

	 */

	private Geometry computeJtsClippingPoly(CancellableMonitorable cancel)

			throws com.iver.cit.gvsig.fmap.DriverException, VisitException {

		ScalableUnionVisitor visitor = new ScalableUnionVisitor();

		Strategy strategy = StrategyManager.getStrategy(overlayLayer);

		if (onlyClipLayerSelection) {

			strategy.process(visitor, overlayLayer.getRecordset()

					.getSelection(), cancel);

		} else {

			strategy.process(visitor, cancel);

		return visitor.getJtsConvexHull();

	public IFeature[] computeIntersection(IGeometry firsLayerGeometry,

			int firstLayerFeatureIndex, IGeometry secondLayerGeometry,

			int secondLayerFeatureIndex) {

	public IMonitorableTask createTask() {

		final CancellableMonitorable cancelMonitor = 

			createCancelMonitor();

		return new IMonitorableTask() {

			String CLIP_MESSAGE = "Computing clip polygon: ";

			String INTERS_MESSAGE = "Clipping geometries: ";

			String currentMsg = CLIP_MESSAGE;

			private boolean finished = false;

			public int getInitialStep() {

				return cancelMonitor.getInitialStep();

			}

			public int getFinishStep() {

				return cancelMonitor.getFinalStep();

			}

			public int getCurrentStep() {

				return cancelMonitor.getCurrentStep();

			}

			public String getStatusMessage() {

				// FIXME Cambiar esto por un mecanismo de eventos,

				// de forma que la tarea lo que tenga sea un escuchador

				// que cambie el mensaje de estado segun los eventos

				// de tareas que se est?n realizando

				return "Clip Geoprocess...";

			}

			public String getNote() {

				// FIXME Cambiar esto por un mecanismo de eventos,

				// de forma que la tarea lo que tenga sea un escuchador

				// que cambie el mensaje de estado segun los eventos

				// de tareas que se est?n realizando

				return currentMsg  +

				getCurrentStep()+ 

				" de "+

				getFinishStep();

			}

			public void cancel() {

				((DefaultCancellableMonitorable) cancelMonitor)

						.setCanceled(true);

			}

			public void run() {

				Geometry clippingGeometry = null;

				try {

					clippingGeometry = computeJtsClippingPoly(cancelMonitor);

				} catch (Exception e) {

					//FIXME Ver que pasa con las excepciones que

					//que pueda lanzar un ITask

				}

				currentMsg = INTERS_MESSAGE;

				visitor = new ClipVisitor(clippingGeometry, resultLayerDefinition,

						schemaManager, writer);

				Strategy strategy = StrategyManager.getStrategy(firstLayer);

				try {

					if (onlyFirstLayerSelection) {

						strategy.process(visitor, firstLayer.getRecordset()

								.getSelection(), cancelMonitor);

					} else {

						strategy.process(visitor, cancelMonitor);

					}

				} catch (Exception e) {

					//FIXME Ver que pasa con las excepciones de las ITask

				}

				finished = true;

			}

			public boolean isDefined() {

				return cancelMonitor.isDeterminatedProcess();

			}

			public boolean isCanceled() {

				return cancelMonitor.isCanceled();

			}

			public boolean isFinished() {

				return finished;

			}

		};

	}

	private DefaultCancellableMonitorable createCancelMonitor() {

		DefaultCancellableMonitorable monitor = new DefaultCancellableMonitorable();

		monitor.setInitialStep(0);

		monitor.setDeterminatedProcess(true);

		int clipSteps = 0;

		if (onlyClipLayerSelection){

			FBitSet selection = overlayLayer.getRecordset().getSelection();

			clipSteps = selection.cardinality();

		}else{

			try {

				clipSteps = overlayLayer.getSource().getShapeCount();

			} catch (DriverIOException e) {

				// TODO Auto-generated catch block

				e.printStackTrace();

			}

		}

		int  firstSteps = 0;

		if (onlyFirstLayerSelection) {

			FBitSet selection = firstLayer.getRecordset().getSelection();

			firstSteps = selection.cardinality();

		} else {

			try {

				firstSteps = firstLayer.getSource()

								.getShapeCount();

			} catch (DriverIOException e) {

				e.printStackTrace();

			}

		}

		int totalSteps = clipSteps + firstSteps;

		monitor.setFinalStep(totalSteps);

		return monitor;

	}

* Revision 1.4  2006-03-15 18:30:39  azabala

* *** empty log message ***

*

* Revision 1.3  2006/03/14 18:32:46  fjp

* Revision 1.3  2006-03-15 18:31:06  azabala

* Revision 1.2  2006/03/07 21:01:33  azabala

* *** empty log message ***

*

* Revision 1.7  2006-03-15 18:31:06  azabala

* *** empty log message ***

*

* Revision 1.6  2006/03/14 18:32:46  fjp

 *

 *

 */

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

import com.iver.cit.gvsig.fmap.layers.FBitSet;

import com.iver.cit.gvsig.fmap.operations.CancellableMonitorable;

import com.iver.cit.gvsig.fmap.operations.DefaultCancellableMonitorable;

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

 * Geoprocess that computes the convex hull of all geometries of the input

 * layer.

 * 

public class ConvexHullGeoprocess extends AbstractGeoprocess implements

		IOneLayerGeoprocess {

	 * Iterates over geometries computing convex hull. 

	 * TODO Comparative Memory

	 * vs Scalable

	 * If only consideer selection to compute convex hull

	public ConvexHullGeoprocess() {

		Boolean onlySelection = (Boolean) params.get("layer_selection");

		if (onlySelection != null)

			throw new GeoprocessException(

					"Convex Hull con capa de entrada a null");

		if (this.writer == null || this.schemaManager == null) {

			throw new GeoprocessException(

					"Operacion de convex hull sin especificar capa de resultados");

		Strategy strategy = StrategyManager.getStrategy(firstLayer);

			if (convexSelection) {

				strategy.process(visitor, firstLayer.getRecordset()

						.getSelection());

			} else {

			IGeometry convexHull = visitor.getConvexHull();

			IFeature feature = FeatureFactory.createFeature(attrs, convexHull,

			DefaultRowEdited editedFeature = new DefaultRowEdited(feature,

					DefaultRowEdited.STATUS_ADDED, 0);

			throw new GeoprocessException(

					"Problemas con el driver calculando el convex hull");

			throw new GeoprocessException(

					"Problemas durante el proceso de calculo del convex hull");

		} catch (EditionException e) {

			throw new GeoprocessException(

					"Problemas al guardar la capa resultado del convex hull");

		//llamar a ISchemaManager.drop() para borrar la capa

		//resultado

	public IMonitorableTask createTask() {

		try {

			return new ConvexHullMonitorableTask();

		} catch (DriverIOException e) {

			return null;

		}

	}

	/**

	 * IMonitorableTask that allows to run convex hull geoprocess in background,

	 * with cancelation requests.

	 * 

	 * @author azabala

	 * 

	 */

	class ConvexHullMonitorableTask implements IMonitorableTask {

		private CancellableMonitorable cancelMonitor = null;

		// FIXME INTERNACIONALIZAR ESTO

		String HULL_MESSAGE = "Computing convex hull:";

		private boolean finished = false;

		ConvexHullMonitorableTask() throws DriverIOException{

			initialize();

		}

		void initialize() throws DriverIOException {

			cancelMonitor = createCancelMonitor();

		}

		private CancellableMonitorable createCancelMonitor()

				throws DriverIOException {

			DefaultCancellableMonitorable monitor = new DefaultCancellableMonitorable();

			monitor.setInitialStep(0);

			monitor.setDeterminatedProcess(true);

			int numSteps = 0;

			if (convexSelection) {

				FBitSet selection = firstLayer.getRecordset().getSelection();

				numSteps = selection.cardinality();

			} else {

				numSteps = firstLayer.getSource().getShapeCount();

			}

			monitor.setFinalStep(numSteps);

			return monitor;

		}

		public int getInitialStep() {

			return cancelMonitor.getInitialStep();

		}

		public int getFinishStep() {

			return cancelMonitor.getFinalStep();

		}

		public int getCurrentStep() {

			return cancelMonitor.getCurrentStep();

		}

		public String getStatusMessage() {

			// FIXME Cambiar esto por un mecanismo de eventos,

			// de forma que la tarea lo que tenga sea un escuchador

			// que cambie el mensaje de estado segun los eventos

			// de tareas que se est?n realizando

			return "Convex Hull Geoprocess...";

		}

		public String getNote() {

			// FIXME Cambiar esto por un mecanismo de eventos,

			// de forma que la tarea lo que tenga sea un escuchador

			// que cambie el mensaje de estado segun los eventos

			// de tareas que se est?n realizando

			return HULL_MESSAGE +

			getCurrentStep()+ 

			" de "  +

			getFinishStep();

		}

		public void cancel() {

			((DefaultCancellableMonitorable) cancelMonitor).setCanceled(true);

		}

		public void run() throws GeoprocessException {

			Strategy strategy = StrategyManager.getStrategy(firstLayer);

			try {

				if (convexSelection) {

					strategy.process(visitor, firstLayer.getRecordset()

							.getSelection(), cancelMonitor);

				} else {

					strategy.process(visitor, cancelMonitor);

				}

				IGeometry convexHull = visitor.getConvexHull();

				Object[] attrs = new Object[1];

				attrs[0] = new Long(0);

				IFeature feature = FeatureFactory.createFeature(attrs,

						convexHull, resultLayerDefinition);

				writer.preProcess();

				DefaultRowEdited editedFeature = new DefaultRowEdited(feature,

						DefaultRowEdited.STATUS_ADDED, 0);

				writer.process(editedFeature);

				writer.postProcess();

			} catch (DriverException e) {

				throw new GeoprocessException(

						"Problemas con el driver calculando el convex hull");

			} catch (VisitException e) {

				throw new GeoprocessException(

						"Problemas durante el proceso de calculo del convex hull");

			} catch (EditionException e) {

				throw new GeoprocessException(

						"Problemas al guardar la capa resultado del convex hull");

			}

			finished = true;

		}

		public boolean isDefined() {

			return cancelMonitor.isDeterminatedProcess();

		}

		public boolean isCanceled() {

			return cancelMonitor.isCanceled();

		}

		public boolean isFinished() {

			return finished;

		}

	}

 * Revision 1.3  2006-03-15 18:33:24  azabala

 * Revision 1.2  2006/03/07 21:01:33  azabala

 * *** empty log message ***

 *

	public int getNumProcessedGeometries(){

		return dissolvedGeometries.cardinality();

	}

* Revision 1.6  2006-03-15 18:33:24  azabala

* *** empty log message ***

*

* Revision 1.5  2006/03/14 18:32:46  fjp

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

import com.iver.cit.gvsig.fmap.edition.EditionException;

import com.iver.cit.gvsig.fmap.operations.CancellableMonitorable;

import com.iver.cit.gvsig.fmap.operations.DefaultCancellableMonitorable;

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

			throw new GeoprocessException("Operacion de dissolve sin especificar capa de resultados");

		try {

			schemaManager.drop();

		} catch (EditionException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

	public IMonitorableTask createTask() {

		try {

			return new DissolveMonitorableTask();

		} catch (DriverIOException e) {

			return null;

		}

	}

	/**

	 * IMonitorableTask that allows to run diff geoprocess in background,

	 * with cancelation requests.

	 * 

	 * @author azabala

	 * 

	 */

	class DissolveMonitorableTask implements IMonitorableTask {

		private CancellableMonitorable cancelMonitor = null;

		// FIXME INTERNACIONALIZAR ESTO

		String DISSOLVE_MESSAGE = "Computing dissolve: ";

		private boolean finished = false;

		DissolveMonitorableTask() throws DriverIOException {

			initialize();

		}

		void initialize() throws DriverIOException{

			cancelMonitor = createCancelMonitor();

		}

		private CancellableMonitorable createCancelMonitor() throws DriverIOException{

			DefaultCancellableMonitorable monitor = new 

							DefaultCancellableMonitorable();

			monitor.setInitialStep(0);

			//monitor.setDeterminatedProcess(false);

			monitor.setFinalStep(firstLayer.getSource().getShapeCount());

			monitor.setDeterminatedProcess(true);

			return monitor;

		}

		public int getInitialStep() {

			return cancelMonitor.getInitialStep();

		}

		public int getFinishStep() {

			return cancelMonitor.getFinalStep();

		}

		public int getCurrentStep() {

			//return cancelMonitor.getCurrentStep();

			if(visitor == null)

				return getInitialStep();

			else

				return visitor.getNumProcessedGeometries();

		}

		public String getStatusMessage() {

			// FIXME Cambiar esto por un mecanismo de eventos,

			// de forma que la tarea lo que tenga sea un escuchador

			// que cambie el mensaje de estado segun los eventos

			// de tareas que se est?n realizando

			return "Dissolve Geoprocess...";

		}

		public String getNote() {

			// FIXME Cambiar esto por un mecanismo de eventos,

			// de forma que la tarea lo que tenga sea un escuchador

			// que cambie el mensaje de estado segun los eventos

			// de tareas que se est?n realizando

			return DISSOLVE_MESSAGE + getCurrentStep() + " of " +

													getFinishStep();

		}

		public void cancel() {

			((DefaultCancellableMonitorable) cancelMonitor).setCanceled(true);

		}

		public void run() throws GeoprocessException {

			try {

				FeaturePersisterProcessor2 processor =

					new FeaturePersisterProcessor2(writer);

				visitor = new DissolveVisitor(dissolveField, processor);

				visitor.setDissolvedAttributesInfo(fields_functions);

				Strategy strategy =

					StrategyManager.getStrategy(firstLayer);

				visitor.setStrategy(strategy);

				if(dissolveOnlySelection){

					strategy.process(visitor, firstLayer.

												   getRecordset().

												   getSelection(),

												   cancelMonitor);

				}else{

					strategy.process(visitor, cancelMonitor);

				}

			} catch (DriverException e) {

				throw new GeoprocessException("Error accediendo a los datos durante un dissolve");

			} catch (VisitException e) {

				throw new GeoprocessException("Error al procesar los elementos de la capa de entrada durante un dissolve");

			} finally{

				finished = true;

			}

		}

		public boolean isDefined() {

			return cancelMonitor.isDeterminatedProcess();

		}

		public boolean isCanceled() {

			return cancelMonitor.isCanceled();

		}

		public boolean isFinished() {

			return finished;

		}

	}

* Revision 1.7  2006-03-15 18:34:41  azabala

* *** empty log message ***

*

* Revision 1.6  2006/03/14 18:32:46  fjp

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

import com.iver.cit.gvsig.fmap.operations.CancellableMonitorable;

import com.iver.cit.gvsig.fmap.operations.DefaultCancellableMonitorable;

import com.iver.gvsig.geoprocessing.impl.jtsprocessors.DeferredFeaturePersisterProcessor;

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

 * <br>

 *  Algorithm makes these three passes:

 *  a) computing intersections and saves them in a temp file.

 *  b) computing differences with first layer.

 *  c) computing differences with second layer.

	public IMonitorableTask createTask() {

		try {

			return new UnionMonitorableTask();

		} catch (DriverIOException e) {

			return null;

		}

	}

	/**

	 * IMonitorableTask that allows to run diff geoprocess in background,

	 * with cancelation requests.

	 * 

	 * @author azabala