| gvSIG desktop 1

/*

 * Created on 23-feb-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: DissolveGeoprocess.java 5412 2006-05-24 21:15:07Z azabala $

* $Log$

* Revision 1.1  2006-05-24 21:11:14  azabala

* primera version en cvs despues de refactoring orientado a crear un framework extensible de geoprocessing

*

* Revision 1.10  2006/05/08 15:37:26  azabala

* added alphanumeric dissolve

*

* Revision 1.9  2006/05/01 19:14:50  azabala

* la cancelacion no solo para el ITask que ejecuta el geoproceso, adem?s llama al metodo cancel() del mismo (que se supone que deber?a hacer un drop() con los resultados del geoproceso inconcluso)

*

* Revision 1.8  2006/03/23 21:03:45  azabala

* *** empty log message ***

*

* Revision 1.7  2006/03/17 19:53:14  azabala

* *** empty log message ***

*

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

* *** empty log message ***

*

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

* Cambio con LayerDefinition para que sea compatible con la definici?n de tablas tambi?n.

*

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

* *** empty log message ***

*

* Revision 1.3  2006/03/06 19:48:39  azabala

* *** empty log message ***

*

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

* *** empty log message ***

*

* Revision 1.1  2006/02/26 20:53:44  azabala

* *** empty log message ***

*

*

*/

package com.iver.cit.gvsig.geoprocess.dissolve.fmap;

import java.util.Map;

import com.iver.andami.PluginServices;

import com.iver.cit.gvsig.fmap.DriverException;

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

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

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

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

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

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

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

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

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

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

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

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

/**

 * Processes each geometry of a polygonal vectorial layer, looking for

 * its adjacent polygons. If this adjacent polygons has the same specified 

 * field value as processed geometry, this polygons will be dissolved.

 * 

 * 

 * @author azabala

 *

 */

public class DissolveGeoprocess extends AbstractGeoprocess

                                                        implements IOneLayerGeoprocess {

        private String dissolveField;

        private boolean dissolveOnlySelection;

        private ILayerDefinition resultLayerDefinition;

        private Map fields_functions;

        //AZABALA

        /*

        private DissolveVisitor visitor;

        */

private FeatureDissolver visitor;        

private IDissolveCriteria criteria;        

private int dissolveType = FeatureDissolver.ALPHANUMERIC_DISSOLVE;

        private boolean dissolveOnlyAdjacents;

        /**

         * Constructor.

         * 

         * @param inputLayer Layer whose geometries we are 

         * going to dissolve

         */

        public DissolveGeoprocess(FLyrVect inputLayer, String dissolveField) {

                setFirstOperand(inputLayer);

                this.dissolveField = dissolveField;

        }

        public void setFieldsFunctions(Map fieldsFunctions){

                this.fields_functions = fieldsFunctions;

        }

        public void setFirstOperand(FLyrVect inputLayer) {

                this.firstLayer = inputLayer;

        }

        public void setParameters(Map params) throws GeoprocessException {

                Boolean onlySelection =

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

                if(onlySelection != null)

                        dissolveOnlySelection = onlySelection.booleanValue();

                Boolean onlyAdjacents =

                        (Boolean) params.get("only_adjacents");

                if(onlyAdjacents != null)

                        dissolveOnlyAdjacents = onlyAdjacents.booleanValue();

                try {

                        if(dissolveOnlyAdjacents){

                                dissolveType = FeatureDissolver.SPATIAL_DISSOLVE;

                                criteria = 

                                        new SingleFieldAdjacencyDissolveCriteria(dissolveField,

                                                        firstLayer);

//                        visitor = new DissolveVisitor(dissolveField, processor);        

                        }else{

//                        visitor = new AlphanumericDissolveVisitor(dissolveField, processor);

                                criteria = new SingleFieldDissolveCriteria(dissolveField,

                                                firstLayer);        

                        }

                } catch (com.hardcode.gdbms.engine.data.driver.DriverException e) {

                        throw new GeoprocessException("Error preparando la lectura del dissolve field", e);

                }

        }

        public void checkPreconditions() throws GeoprocessException {

                if (firstLayer == null)

                        throw new GeoprocessException("Buffer con capa de entrada a null");

                if(this.writer == null || 

                   this.schemaManager == null){

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

                }

                try {

                        if(firstLayer.getShapeType() != XTypes.POLYGON)

                                throw new GeoprocessException("La capa a disolver debe ser de pol?gonos");

                } catch (DriverException e) {

                        throw new GeoprocessException("Error intentando verificar el tipo de geometria de la capa a disolver");

                } 

                if(this.dissolveField == null)

                        throw new GeoprocessException("No se ha proporcionado el campo para dissolver");

        }

        public void process() throws GeoprocessException {

                /*

                try {

                        FeaturePersisterProcessor2 processor =

                                new FeaturePersisterProcessor2(writer);

                        if(dissolveOnlyAdjacents){

                                visitor = new AlphanumericDissolveVisitor(dissolveField, processor);

                        }else{

                                visitor = new DissolveVisitor(this.dissolveField, processor);        

                        }

                        visitor.setDissolvedAttributesInfo(fields_functions);

                        Strategy strategy =

                                StrategyManager.getStrategy(firstLayer);

                        visitor.setStrategy(strategy);

                        if(this.dissolveOnlySelection){

                                strategy.process(visitor, firstLayer.

                                                                                           getRecordset().

                                                                                           getSelection());

                        }else{

                                strategy.process(visitor);

                        }

                } 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");

                }

                */

        }

        public void cancel() {

                try {

                        schemaManager.drop();

                } catch (EditionException e) {

                        // TODO Auto-generated catch block

                        e.printStackTrace();

                }

        }

        public ILayerDefinition createLayerDefinition() {

                if(resultLayerDefinition == null)

                        resultLayerDefinition = criteria.createLayerDefinition(fields_functions);

                return resultLayerDefinition;

        }

        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;

                String DISSOLVE_MESSAGE = PluginServices.getText(this, "Mensaje_dissolve");

                String DISSOLVE_NOTE = PluginServices.getText(this, "Mensaje_procesando_dissolves");

                String OF = PluginServices.getText(this, "De");

                private boolean finished = false;

                FeatureDissolver dissolver = null;

                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);

                        //FIXME: Si solo dissolvemos la seleccion, esto esta mal

                        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();

                        if(dissolver == null)

                                return getInitialStep();

                        else

                                return dissolver.getNumProcessedGeometries();

                }

                public String getStatusMessage() {

                        return DISSOLVE_MESSAGE;

                }

                public String getNote() {

                        return DISSOLVE_NOTE + " "+

                        getCurrentStep() + " " +

                        OF + " " +

                        getFinishStep();

                }

                public void cancel() {

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

                        DissolveGeoprocess.this.cancel();

                }

                public void run() throws GeoprocessException {

                        try {

                                FeaturePersisterProcessor2 processor =

                                        new FeaturePersisterProcessor2(writer);

                                dissolver = new

                                        FeatureDissolver(processor, 

                                                        firstLayer, 

                                                        fields_functions,

                                                        criteria,

                                                        dissolveType);

                                dissolver.dissolve(cancelMonitor);

//                                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(Exception e){

                                e.printStackTrace();

                        } finally{

                                finished = true;

                        }

                }

                public boolean isDefined() {

                        return cancelMonitor.isDeterminatedProcess();

                }

                public boolean isCanceled() {

                        return cancelMonitor.isCanceled();

                }

                public boolean isFinished() {

                        return finished;

                }

        }

}