Application: gvSIG desktop » gvSIG geoprocess

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2012 gvSIG Association.

 *

 * 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., 51

 * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us at info AT

 * gvsig.com, or visit our website www.gvsig.com.

 */

/*

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

 *

 * Copyright (C) 2010 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.

 */

package org.gvsig.geoprocess.algorithm.dissolve;

import java.util.ArrayList;

import java.util.List;

import org.gvsig.fmap.dal.exception.DataException;

import org.gvsig.fmap.dal.feature.EditableFeature;

import org.gvsig.fmap.dal.feature.Feature;

import org.gvsig.fmap.dal.feature.FeatureSelection;

import org.gvsig.fmap.dal.feature.FeatureSet;

import org.gvsig.fmap.dal.feature.FeatureStore;

import org.gvsig.fmap.geom.exception.CreateGeometryException;

import org.gvsig.geoprocess.algorithm.base.core.GeometryOperation;

import org.gvsig.geoprocess.algorithm.base.util.GeometryUtil;

import org.gvsig.geoprocess.algorithm.base.util.JTSFacade;

import org.gvsig.geoprocess.lib.sextante.AbstractSextanteGeoProcess;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import com.vividsolutions.jts.geom.Geometry;

import java.util.Iterator;

/**

 * Dissolve operation

 *

 * @author <a href="mailto:nachobrodin@gmail.com">Nacho Brodin</a>

 */

public class DissolveOperationFast extends GeometryOperation {

    private static Logger logger = LoggerFactory.getLogger(DissolveOperationFast.class.getName());

    private EditableFeature lastEditFeature = null;

    private ArrayList<Element> featureList = null;

    private IDissolveRule rule = null;

    private Summary summary = null;

    class Element {

        public int id = -1;

        public Feature feat = null;

        public List<Element> overlapList = new ArrayList<Element>();

        public boolean insertedToJoin = false;

        public Geometry jtsGeom = null;

    }

    class NodeTree {

        public Element element = null;

        public int pos = 0;

        public NodeTree parent = null;

        public NodeTree(Element node, NodeTree parent) {

            this.element = node;

            this.parent = parent;

        }

        public Element getNext() {

            if (pos < element.overlapList.size()) {

                return element.overlapList.get(pos++);

            }

            return null;

        }

    }

    public DissolveOperationFast(IDissolveRule rule, AbstractSextanteGeoProcess p) {

        super(p);

        this.rule = rule;

        featureList = new ArrayList<Element>();

    }

    /*

     * (non-Javadoc)

     * @see org.gvsig.geoprocess.algorithm.base.core.GeometryOperation#invoke(org.gvsig.fmap.geom.Geometry, org.gvsig.fmap.dal.feature.Feature)

     */

    public EditableFeature invoke(org.gvsig.fmap.geom.Geometry g, Feature feature) {

        return null;

    }

    /*

     * (non-Javadoc)

     * @see org.gvsig.geoprocess.algorithm.base.core.GeometryOperation#invoke(org.gvsig.fmap.geom.Geometry, org.gvsig.fmap.dal.feature.EditableFeature)

     */

    public void invoke(org.gvsig.fmap.geom.Geometry g, EditableFeature feature) {

        if (g == null) {

            return;

        }

    }

    /*

     * (non-Javadoc)

     * @see org.gvsig.geoprocess.algorithm.base.core.IOperation#getResult()

     */

    public Object getResult() {

        return lastEditFeature;

    }

    /**

     * Computes a complete operation over the input FeatureStore. The result of

     * this operation is stored in the output FeatureStore.

     *

     * @param inFeatStore Input FeatureStore

     * @param outFeatStore Output FeatureStore

     * @param attrNames List of attributes to build the output feature store

     * @param selectedGeom If it is true only the selected geometries will be

     * processed

     * @throws DataException

     */

    @SuppressWarnings({"deprecation"})

    public void computesGeometryOperation(FeatureStore inFeatStore,

            FeatureStore outFeatStore,

            String[] attrNames,

            boolean selectedGeomInput,

            boolean selectedGeomOutput,

            boolean closeOutStore) throws DataException {

        this.inFeatureStore = inFeatStore;

        FeatureSet featuresSet = null;

        featuresSet = inFeatStore.getFeatureSet();

        setFeatureStore(outFeatStore, attrNames);

        Iterator it = null;

        if (selectedGeomInput) {

            FeatureSelection ds = inFeatStore.getFeatureSelection();

            it = ds.iterator();

            numberOfFeatures = (int) ds.getSelectedCount();

        } else {

            it = featuresSet.iterator();

            numberOfFeatures = (int) featuresSet.getSize();

        }

        if (status != null && process != null) {

            status.setRangeOfValues(0, numberOfFeatures);

            process.setProgress(0, numberOfFeatures);

        }

        //Crear lista de elementos

        int iCount = 0;

        while (it.hasNext() && !process.getTaskMonitor().isCanceled()) {

            Feature feat = (Feature) it.next();

            Element el = new Element();

            el.feat = feat.getCopy();

            el.id = iCount;

            featureList.add(el);

            if (status != null && process != null) {

                status.setCurValue(iCount);

                process.setProgress(iCount, numberOfFeatures);

            }

            iCount++;

        }

        //it.dispose();

        //Crear listas de solapes para cada feature

        iCount = 0;

        while (iCount < featureList.size() && !process.getTaskMonitor().isCanceled()) {

            Element elem1 = featureList.get(iCount);

            org.gvsig.fmap.geom.Geometry geom1 = elem1.feat.getDefaultGeometry();

            elem1.jtsGeom = GeometryUtil.geomToJTS(geom1);

            if (status != null) {

                status.setCurValue(iCount);

            }

            if (process != null) {

                process.setProgress(iCount, numberOfFeatures);

            }

            for (int i = iCount + 1; i < featureList.size(); i++) {

                Element elem2 = featureList.get(i);

                org.gvsig.fmap.geom.Geometry geom2 = elem2.feat.getDefaultGeometry();

                elem2.jtsGeom = GeometryUtil.geomToJTS(geom2);

                if (rule.verifyIfDissolve(elem1.jtsGeom, elem2.jtsGeom, elem1.feat, elem2.feat)) {

                    elem1.overlapList.add(elem2);

                    elem2.overlapList.add(elem1);

                }

            }

            iCount++;

        }

		//Se calculan las listas de geometrias a unir

        //Para cada feature se obtiene su lista de elementos que solapan y para

        //cada elemento que solapa se obtiene su lista. Finalmente todas se unen y

        //y se hace un insert de una feature nueva

        List<Geometry> listResult = new ArrayList<Geometry>();

        iCount = 0;

        int iFeat = 0;

        summary = new Summary(rule, outFeatStore.getDefaultFeatureType());

        while (iCount < featureList.size() && !process.getTaskMonitor().isCanceled()) {

            Element elem1 = featureList.get(iCount);

            summary.loadDefaultSummarizes(elem1.feat);

            if (status != null) {

                status.setCurValue(iCount);

            }

            if (process != null) {

                process.setProgress(iCount, numberOfFeatures);

            }

            if (!elem1.insertedToJoin) {

                buildListToJoin(elem1, iFeat);

                iFeat++;

            }

            /*if(!elem1.insertedToJoin) {

             elem1.insertedToJoin = true;

             listResult.clear();

             //org.gvsig.fmap.geom.Geometry dalGeom = elem1.feat.getDefaultGeometry();

             //Geometry jtsGeom = GeometryUtil.geomToJTS(dalGeom);

             listResult.add(elem1.jtsGeom);

             buildListToJoin(listResult, elem1.overlapList);

             Geometry newGeom = computesUnion(listResult, elem1);//GeometryUtil.geometryUnion(listResult, elem1.feat.getDefaultGeometry().getGeometryType().getType());

             try {

             addFeatureToOutput(newGeom, elem1.feat, iFeat);

             } catch (CreateGeometryException e) {

             logger.info("Error a?adiendo geometr?a", e);

             } catch (DataException e) {

             logger.info("Error a?adiendo geometr?a", e);

             }

             iFeat ++;

             }*/

            iCount++;

        }

        if (closeOutStore && persister != null) {

            persister.end();

        }

    }

    /**

     * Computes the union of the list of geometries

     *

     * @param listResult

     * @param elem1

     * @return

     */

    private Geometry computesUnion(List<Geometry> listResult, Element elem1) {

        int splitValue = 500;

        Geometry newGeom = null;

        if (listResult.size() > splitValue) {

            List<List<Geometry>> list = splitList(listResult, splitValue);

            List<Geometry> result = new ArrayList<Geometry>();

            for (int i = 0; i < list.size(); i++) {

                Geometry aux = GeometryUtil.geometryUnion(list.get(i), elem1.feat.getDefaultGeometry().getGeometryType().getType());

                result.add(aux);

            }

            for (int i = 0; i < result.size(); i++) {

                newGeom = GeometryUtil.geometryUnion(result, elem1.feat.getDefaultGeometry().getGeometryType().getType());

            }

        } else {

            newGeom = GeometryUtil.geometryUnion(listResult, elem1.feat.getDefaultGeometry().getGeometryType().getType());

        }

        return newGeom;

    }

    private Geometry computesUnion3(List<Geometry> listResult) {

        Geometry newGeom = null;

        int iCount = 0;

        int max = listResult.size();

        if (process != null) {

            process.setName("Generating union");

        }

        while (listResult.size() > 1) {

            List<Geometry> list = new ArrayList<Geometry>();

            if (status != null) {

                status.setCurValue(iCount);

            }

            if (process != null) {

                process.setProgress(iCount, max);

            }

            for (int i = 0; i < listResult.size(); i = i + 2) {

                if (i == (listResult.size() - 1)) {

                    list.add(listResult.get(i));

                } else {

                    newGeom = JTSFacade.union(listResult.get(i), listResult.get(i + 1));

                    list.add(newGeom);

                }

            }

            listResult = list;

        }

        return newGeom;

    }

    /**

     * Splits the array of geometries to compute its union because JTS cannot

     * support a lot of geometries

     *

     * @param list

     * @param n

     * @return

     */

    private List<List<Geometry>> splitList(List<Geometry> list, int n) {

        int elements = (int) (list.size() / n);

        List<List<Geometry>> l = new ArrayList<List<Geometry>>();

        for (int i = 0; i < elements; i++) {

            l.add(list.subList((i * n), (i * n) + n));

        }

        if (elements * n < list.size()) {

            l.add(list.subList((elements * n), list.size()));

        }

        return l;

    }

    /**

     * Adds a feature to the output

     *

     * @param newGeom

     * @param feat

     * @param newFeatID

     * @throws DataException

     * @throws CreateGeometryException

     */

    private void addFeatureToOutput(Geometry newGeom, Feature feat, int newFeatID) throws DataException, CreateGeometryException {

        EditableFeature result = persister.getOutputFeatureStore().createNewFeature();

        result.setDouble(0, newFeatID);

        result.set(1, feat.get(rule.getFieldName()));

        result.setGeometry("GEOMETRY", GeometryUtil.jtsToGeom(newGeom));

        summary.loadEditableFeature(result);

        lastEditFeature = persister.addFeature(result, result.getDefaultGeometry());

    }

    /**

     * Builds the union of all lists

     *

     * @param listResult

     * @param listToJoin

     */

    private void buildListToJoin(List<Geometry> listResult, List<Element> listToJoin) {

        for (int i = 0; i < listToJoin.size(); i++) {

            Element elem = listToJoin.get(i);

            if (!elem.insertedToJoin) {

                elem.insertedToJoin = true;

                buildListToJoin(listResult, elem.overlapList);

                summary.updateValues(elem.feat);

				//org.gvsig.fmap.geom.Geometry dalGeom = elem.feat.getDefaultGeometry();

                //Geometry jtsGeom = GeometryUtil.geomToJTS(dalGeom);

                listResult.add(elem.jtsGeom);

            }

        }

    }

    /**

     * Builds the union of all lists

     *

     * @param listResult

     * @param listToJoin

     */

    private void buildListToJoin(Element elem, int iFeat) {

        Geometry newGeom = null;

        if (elem.overlapList.size() == 0) {

            if (!elem.insertedToJoin) {

                elem.insertedToJoin = true;

            }

            try {

                summary.updateValues(elem.feat);

                addFeatureToOutput(elem.jtsGeom, elem.feat, iFeat);

            } catch (CreateGeometryException e) {

                logger.info("Error a?adiendo geometr?a", e);

            } catch (DataException e) {

                logger.info("Error a?adiendo geometr?a", e);

            }

        } else {

            List<Geometry> listResult = new ArrayList<Geometry>();

            NodeTree subtree = new NodeTree(elem, null);

			//Hacemos un recorrido en profundidad del ?rbol para a?adir

            //todos los elementos a la lista de geometrias a unir sin

            //repetir ninguna.

            while (subtree != null) {

                if (!subtree.element.insertedToJoin) {

                    listResult.add(subtree.element.jtsGeom);

                    summary.updateValues(subtree.element.feat);

                    subtree.element.insertedToJoin = true;

                }

                boolean back = false;

                Element l = subtree.getNext();

                if (l == null) {

                    back = true;

                }

                while (!back && l.insertedToJoin) {

                    l = subtree.getNext();

                    if (l == null) {

                        back = true;

                    }

                }

                if (back) {

                    subtree = subtree.parent;

                    continue;

                }

                subtree = new NodeTree(l, subtree);

            }

            newGeom = computesUnion3(listResult);

            try {

                addFeatureToOutput(newGeom, elem.feat, iFeat);

            } catch (DataException e) {

                logger.info("Imposible insertar en la tabla", e);

            } catch (CreateGeometryException e) {

                logger.info("Error a?adiendo geometr?a", e);

            }

        }

    }

}

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2012 gvSIG Association.

 *

 * 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., 51

 * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us at info AT

 * gvsig.com, or visit our website www.gvsig.com.

 */

/*

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

 *

 * Copyright (C) 2010 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.

 */

package org.gvsig.geoprocess.algorithm.dissolve;

import java.util.ArrayList;

import org.gvsig.fmap.dal.exception.DataException;

import org.gvsig.fmap.dal.feature.EditableFeature;

import org.gvsig.fmap.dal.feature.Feature;

import org.gvsig.fmap.dal.feature.FeatureSelection;

import org.gvsig.fmap.dal.feature.FeatureSet;

import org.gvsig.fmap.dal.feature.FeatureStore;

import org.gvsig.fmap.geom.exception.CreateGeometryException;

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

import org.gvsig.geoprocess.algorithm.base.core.GeometryOperation;

import org.gvsig.geoprocess.algorithm.base.util.GeometryUtil;

import org.gvsig.geoprocess.lib.sextante.AbstractSextanteGeoProcess;

import com.vividsolutions.jts.geom.Geometry;

import es.unex.sextante.core.Sextante;

import java.util.Iterator;

/**

 * Dissolve operation

 *

 * @author <a href="mailto:nachobrodin@gmail.com">Nacho Brodin</a>

 */

public class DissolveOperation extends GeometryOperation {

    private EditableFeature lastEditFeature = null;

    private ArrayList<Geometry> geometries = new ArrayList<Geometry>();

    private IDissolveRule criteria = null;

    private AtomicDissolveOperation atomicOperation = null;

    /**

     * Cada elemento representa una feature del vectorial de entrada. Cuando se

     * hace un dissolve de esa feature con otra su posici?n en el array se pone

     * a false para no volver a procesarla.

     */

	//private boolean[]                        analizedFeats    = null;

    public DissolveOperation(IDissolveRule criteria, AbstractSextanteGeoProcess p) {

        super(p);

        this.criteria = criteria;

    }

    public AtomicDissolveOperation getAtomicDissolveOperation() {

        if (atomicOperation == null) {

            atomicOperation = new AtomicDissolveOperation(process);

        }

        return atomicOperation;

    }

    /*

     * (non-Javadoc)

     * @see org.gvsig.geoprocess.algorithm.base.core.GeometryOperation#invoke(org.gvsig.fmap.geom.Geometry, org.gvsig.fmap.dal.feature.Feature)

     */

    public EditableFeature invoke(org.gvsig.fmap.geom.Geometry g, Feature feature) {

        if (g == null) {

            return lastEditFeature;

        }

        getAtomicDissolveOperation().setFeature(feature);

        try {

            getAtomicDissolveOperation().computesOperation(selectedGeomInput);

            EditableFeature res = (EditableFeature) getAtomicDissolveOperation().getResult();

            lastEditFeature = persister.addFeature(res, res.getDefaultGeometry());

        } catch (DataException e) {

            Sextante.addErrorToLog(e);

        } catch (CreateGeometryException e) {

            Sextante.addErrorToLog(e);

        }

        return lastEditFeature;

    }

    /*

     * (non-Javadoc)

     * @see org.gvsig.geoprocess.algorithm.base.core.GeometryOperation#invoke(org.gvsig.fmap.geom.Geometry, org.gvsig.fmap.dal.feature.EditableFeature)

     */

    public void invoke(org.gvsig.fmap.geom.Geometry g, EditableFeature feature) {

        if (g == null) {

            return;

        }

    }

    /*

     * (non-Javadoc)

     * @see org.gvsig.geoprocess.algorithm.base.core.IOperation#getResult()

     */

    public Object getResult() {

        return lastEditFeature;

    }

    /**

     * Computes a complete operation over the input FeatureStore. The result of

     * this operation is stored in the output FeatureStore.

     *

     * @param inFeatStore Input FeatureStore

     * @param outFeatStore Output FeatureStore

     * @param attrNames List of attributes to build the output feature store

     * @param selectedGeom If it is true only the selected geometries will be

     * processed

     * @throws DataException

     */

    @SuppressWarnings({"deprecation"})

    public void computesGeometryOperation(FeatureStore inFeatStore,

            FeatureStore outFeatStore,

            String[] attrNames,

            boolean selectedGeomInput,

            boolean selectedGeomOutput,

            boolean closeOutStore) throws DataException {

        this.inFeatureStore = inFeatStore;

        this.selectedGeomInput = selectedGeomInput;

        this.selectedGeomOverlay = selectedGeomOutput;

        FeatureSet featuresSet = null;

        featuresSet = inFeatStore.getFeatureSet();

        setFeatureStore(outFeatStore, attrNames);

        Iterator it = null;

        if (selectedGeomInput) {

            FeatureSelection ds = inFeatStore.getFeatureSelection();

            it = ds.iterator();

            numberOfFeatures = (int) ds.getSelectedCount();

        } else {

            it = featuresSet.iterator();

            numberOfFeatures = (int) featuresSet.getSize();

        }

        if (status != null && process != null) {

            status.setRangeOfValues(0, numberOfFeatures);

            process.setProgress(0, numberOfFeatures);

        }

        ArrayList<Feature> featList = new ArrayList<Feature>();

        int iCount = 0;

        while (it.hasNext() && !process.getTaskMonitor().isCanceled()) {

            featList.add((Feature) it.next());

            if (status != null && process != null) {

                status.setCurValue(iCount);

                process.setProgress(iCount, numberOfFeatures);

            }

            iCount++;

        }

        getAtomicDissolveOperation().setTaskStatus(status);

        getAtomicDissolveOperation().setGeoProcess(process, numberOfFeatures);

        getAtomicDissolveOperation().setCriteria(criteria);

        getAtomicDissolveOperation().setGeometryList(geometries);

        getAtomicDissolveOperation().setFeatureStore(persister.getOutputFeatureStore(), null);

        getAtomicDissolveOperation().setFeatureList(featList);

        iCount = 0;

        while (featList.size() > 0 && !process.getTaskMonitor().isCanceled()) {

            Feature feature = featList.remove(0);

            geometries.clear();

            if (status != null && process != null) {

                status.setCurValue(numberOfFeatures - featList.size());

                process.setProgress(numberOfFeatures - featList.size(), numberOfFeatures);

            }

            org.gvsig.fmap.geom.Geometry geom = feature.getDefaultGeometry();

            if (!(geom instanceof NullGeometry)) {

                geometries.add(GeometryUtil.geomToJTS(geom));

                invoke(geom, feature);

            }

            continue;

        }

        if (closeOutStore && persister != null) {

            persister.end();

        }

    }

    /**

     * Computes a complete operation over the input FeatureStore. The result of

     * this operation is stored in the output FeatureStore.

     *

     * @param inFeatStore Input FeatureStore

     * @param outFeatStore Output FeatureStore

     * @param attrNames List of attributes to build the output feature store

     * @param selectedGeom If it is true only the selected geometries will be

     * processed

     * @throws DataException

     */

//	public void computesGeometryOperation(FeatureStore inFeatStore,

//									FeatureStore outFeatStore,

//									String[] attrNames,

//									boolean selectedGeom,

//									boolean closeOutStore) throws DataException {

//		this.inFeatureStore = inFeatStore;

//		this.selectedGeom = selectedGeom;

//		FeatureSet featuresSet = null;

//		featuresSet = inFeatStore.getFeatureSet();

//		

//		setFeatureStore(outFeatStore, attrNames);

//		DisposableIterator it = null;

//

//		if(selectedGeom) {

//            FeatureSelection ds = inFeatStore.getFeatureSelection();

//            it = ds.iterator();

//            numberOfFeatures = (int) ds.getSelectedCount();

//		} else {

//			it = featuresSet.iterator();

//			numberOfFeatures = (int)featuresSet.getSize();

//		}

//		

//        if (status != null && process != null) {

//            status.setRangeOfValues(0, numberOfFeatures);

//            process.setProgress(0, numberOfFeatures);

//        }

//		analizedFeats = new boolean[numberOfFeatures];

//		

//		getAtomicDissolveOperation().setCriteria(criteria);

//		getAtomicDissolveOperation().setGeometryList(geometries);

//		getAtomicDissolveOperation().setFeatureStore(persister.getOutputFeatureStore(), null);

//		getAtomicDissolveOperation().setAnalizedFeatureList(analizedFeats);

//		getAtomicDissolveOperation().setFeatureStore(inFeatureStore);

//		

//		int iCount = 0;

//		int featAnalized = 0;

//		while( it.hasNext() && !process.getTaskMonitor().isCanceled()) {

//			Feature feature = (Feature)it.next();

//			

//			if(analizedFeats[featAnalized]) {

//				featAnalized ++;

//				continue;

//			}

//			

//			analizedFeats[featAnalized] = true;

//			List geomList = feature.getGeometries();

//			geometries.clear();

//			

//            if (status != null && process != null) {

//                status.setCurValue(iCount);

//                process.setProgress(iCount, numberOfFeatures);

//            }

//			iCount ++;

//			

//			if(geomList == null) {

//				org.gvsig.fmap.geom.Geometry geom = feature.getDefaultGeometry();

//				geometries.add(GeometryUtil.geomToJTS(geom));

//				invoke(geom, feature);

//				featAnalized ++;

//				continue;

//			}

//

//			Iterator<org.gvsig.fmap.geom.Geometry> itGeom = geomList.iterator();

//			while(itGeom.hasNext() && !process.getTaskMonitor().isCanceled()) {

//				org.gvsig.fmap.geom.Geometry g = itGeom.next();

//				geometries.add(GeometryUtil.geomToJTS(g));

//				invoke(g, feature);

//			}

//			

//			featAnalized ++;

//		}

//	

//		if(closeOutStore && persister != null)

//			persister.end();

//	}

}

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2012 gvSIG Association.

 *

 * 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., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.geoprocess.algorithm.dissolve;

import com.vividsolutions.jts.geom.Geometry;

import org.gvsig.fmap.dal.feature.Feature;

/**

 * Forces to IDissolveCriteria to fetch geometries from 

 * ReadableVectorial (for performance reasons, once a criteria

 * has verified a spatial conditions, it caches IGeometry, to

 * avoid reading them many times)

 * @author azabala

 *

 */

public interface IDissolveRule {

	/**

	 * Verifies if the given geometries will be dissolved 

	 * @param g1

	 * @param g2

	 * @param f

	 * @return true if the given geometries will be dissolved or false 

	 * if not.

	 */

	public boolean verifyIfDissolve(Geometry g1, Geometry g2, Feature f1, Feature f2);

	/**

	 * Returns true if the selected function is included in the summary

	 * @param func

	 * @return

	 */

	public boolean isFunctionIncluded(String func);

	/**

	 * Returns the name of the field for the selected function

	 * @return

	 */

	public String getFieldName(String func);

	/**

	 * Gets the index of the field to apply the dissolve rule

	 * @return

	 */

	public String getFieldName();

}

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2012 gvSIG Association.

 *

 * 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., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.geoprocess.algorithm.dissolve;

import java.awt.BorderLayout;

import java.awt.Dimension;

import java.awt.GridBagConstraints;

import java.awt.GridBagLayout;

import java.awt.Insets;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.util.ArrayList;

import java.util.List;

import javax.swing.ComboBoxModel;

import javax.swing.DefaultComboBoxModel;

import javax.swing.JCheckBox;

import javax.swing.JComboBox;

import javax.swing.JLabel;

import javax.swing.JPanel;

import org.gvsig.fmap.dal.exception.DataException;

import org.gvsig.fmap.dal.feature.FeatureStore;

import org.gvsig.geoprocess.lib.api.GeoProcessLocator;

import org.gvsig.geoprocess.lib.sextante.dataObjects.FlyrVectIVectorLayer;

import org.gvsig.geoprocess.sextante.gui.algorithm.AlgorithmOutputPanel;

import org.gvsig.gui.beans.table.TableContainer;

import org.gvsig.gui.beans.table.exceptions.NotInitializeException;

import es.unex.sextante.core.GeoAlgorithm;

import es.unex.sextante.core.ObjectAndDescription;

import es.unex.sextante.core.OutputObjectsSet;

import es.unex.sextante.core.ParametersSet;

import es.unex.sextante.core.Sextante;

import es.unex.sextante.dataObjects.IVectorLayer;

import es.unex.sextante.gui.algorithm.GeoAlgorithmParametersPanel;

import es.unex.sextante.gui.algorithm.OutputChannelSelectionPanel;

import es.unex.sextante.gui.core.SextanteGUI;

import es.unex.sextante.outputs.Output;

import java.util.Arrays;

/**

 * Panel for dissolve algorithm

 * @author <a href="mailto:nachobrodin@gmail.com">Nacho Brodin</a>

 */

public class DissolveParametersPanel extends GeoAlgorithmParametersPanel implements ActionListener {

	private static final long                serialVersionUID   = 1L;

	private GeoAlgorithm                     m_Algorithm        = null;

	private JComboBox                        layersCombo        = null;

	private JComboBox                        fieldsCombo        = null;

	private JCheckBox                        selectionOnly      = null;

	private JCheckBox                        adjacentOnly       = null;

	//private AlgorithmOutputPanel             output             = null;

	private final String[]                   columnNames        = { "Min", "Max", "Sum", "Avg", "Field ID" };

	private final int[]                      columnWidths       = { 35, 35, 35, 35, 334 };

	private TableContainer                   table              = null;

	private AlgorithmOutputPanel             algorithmOutputPanel  = null;

	private OutputChannelSelectionPanel      outputChannelSelectionPanel;

	private JPanel                           outputPanel;

	public DissolveParametersPanel() {

		super();

	}

    public void init(GeoAlgorithm algorithm) {

    	m_Algorithm = algorithm;

    	initGUI();

    }

	private void initGUI() {

		GridBagLayout gbl = new GridBagLayout();

		this.setLayout(gbl);

		GridBagConstraints gbc = new GridBagConstraints();

		gbc.fill = GridBagConstraints.HORIZONTAL;

		gbc.weightx = 1.0;

		gbc.gridx = 0;

		gbc.gridy = 0;

		gbc.insets = new Insets(0, 0, 8, 0);

		this.add(getComboPanel(GeoProcessLocator.getGeoProcessManager().getTranslation("Input_layer"), getLayersCombo()), gbc);

		gbc.gridy = 1;

		this.add(getComboPanel(GeoProcessLocator.getGeoProcessManager().getTranslation("Field"), getFieldsCombo()), gbc);

		gbc.gridy = 2;

		this.add(getSelectionCheck(), gbc);

		gbc.gridy = 3;

		this.add(getAdjacentCheck(), gbc);

		gbc.gridy = 4;

		this.add(new JLabel(GeoProcessLocator.getGeoProcessManager().getTranslation("summary_function")), gbc);

		gbc.gridy = 5;

		gbc.fill = GridBagConstraints.BOTH;

		gbc.insets = new Insets(0, 0, 12, 0);

		gbc.weighty = 1.0;

		this.add(getRadioButtonTable(), gbc);

		gbc.gridy = 6;

		gbc.fill = GridBagConstraints.HORIZONTAL;

		gbc.weighty = 0.0;

		this.add(getOutputChannelSelectionPanel(), gbc);

		initTable();

	}

	/**

	 * Gets the output panel (SEXTANTE)

	 * @return

	 */

	private JPanel getOutputChannelSelectionPanel() {

		if(outputPanel == null) {

			try {

				outputPanel = new JPanel();

				outputPanel.setLayout(new BorderLayout());

				final OutputObjectsSet ooSet = m_Algorithm.getOutputObjects();

				final Output out = ooSet.getOutput(DissolveAlgorithm.RESULT);

				outputChannelSelectionPanel = new OutputChannelSelectionPanel(out, m_Algorithm.getParameters());

				outputPanel.add(new JLabel(" " + GeoProcessLocator.getGeoProcessManager().getTranslation("Dissolve") +

						" [" + GeoProcessLocator.getGeoProcessManager().getTranslation("Vectorial") +

						"]               "), BorderLayout.WEST);

				outputPanel.add(outputChannelSelectionPanel, BorderLayout.CENTER);

			} catch (final Exception e) {

				Sextante.addErrorToLog(e);

			}

		}

		return outputPanel;

	}

	/**

	 * Gets the output panel

	 * @return

	 */

	@SuppressWarnings("unused")

	private AlgorithmOutputPanel getAlgorithmOutputPanel() {

		if(algorithmOutputPanel == null)

		    algorithmOutputPanel = new AlgorithmOutputPanel();

		return algorithmOutputPanel;

	}

	/**

	 * Gets a new JPanel with the text and JComboBox 

	 * @param text

	 * @param combo

	 * @return

	 */

	public JPanel getComboPanel(String text, JComboBox combo) {

		JPanel panel = new JPanel();

		GridBagLayout gbl = new GridBagLayout();

		panel.setLayout(gbl);

		GridBagConstraints gbc = new GridBagConstraints();

		gbc.fill = GridBagConstraints.NONE;

		gbc.weightx = 0;

		gbc.gridx = 0;

		gbc.insets = new Insets(0, 2, 0, 5);

		JLabel label = new JLabel(text);

		label.setPreferredSize(new Dimension(180, 18));

		panel.add(label, gbc);

		gbc.fill = GridBagConstraints.HORIZONTAL;

		gbc.weightx = 1.0;

		gbc.gridx = 1;

		gbc.anchor = GridBagConstraints.EAST;

		gbc.insets = new Insets(0, 2, 0, 0);

		panel.add(combo, gbc);

		return panel;

	}

	/**

	 * Gets a ComboBox

	 * @return

	 */

	public JComboBox getLayersCombo() {

		if(layersCombo == null) {

			layersCombo = new JComboBox();

			layersCombo.setPreferredSize(new Dimension(0, 18));

			ComboBoxModel comboModel = new DefaultComboBoxModel(getLayerList());

			layersCombo.setModel(comboModel);

			layersCombo.addActionListener(this);

		}

		return layersCombo;

	}

	/**

	 * Gets a ComboBox

	 * @return

	 */

	public JComboBox getFieldsCombo() {

		if(fieldsCombo == null) {

			fieldsCombo = new JComboBox();

			fieldsCombo.setPreferredSize(new Dimension(0, 18));

			List<String> fieldList = getFieldList();

			fieldsCombo.removeAllItems();

			for (int i = 0; i < fieldList.size(); i++) 

				fieldsCombo.addItem(fieldList.get(i));

		}

		return fieldsCombo;

	}

	/**

	 * Gets a CheckBox

	 * @return

	 */

	public JCheckBox getSelectionCheck() {

		if(selectionOnly == null) {

			selectionOnly = new JCheckBox(GeoProcessLocator.getGeoProcessManager().getTranslation("Selected_geometries"));

		}

		return selectionOnly;

	}

	/**

	 * Gets a CheckBox

	 * @return

	 */

	public JCheckBox getAdjacentCheck() {

		if(adjacentOnly == null) {

			adjacentOnly = new JCheckBox(GeoProcessLocator.getGeoProcessManager().getTranslation("adjacent_geometries_only"));

		}

		return adjacentOnly;

	}

	/**

	 * Gets the summary table

	 * @return TableContainer

	 */

	public TableContainer getRadioButtonTable() {

		if (table == null) {

			table = new TableContainer(columnNames, columnWidths, null);

			table.setModel("ARGBBandSelectorModel");

			table.setControlVisible(false);

			table.initialize();

		}

		return table;

	}

	//------------------------------------------------------------

	/*

	 * (non-Javadoc)

	 * @see java.awt.event.ActionListener#actionPerformed(java.awt.event.ActionEvent)

	 */

	public void actionPerformed(ActionEvent e) {

		if(e.getSource() ==  getLayersCombo()) {

			//Recarga el combo de campos

			List<String> fieldList = getFieldList();

			getFieldsCombo().removeAllItems();

			for (int i = 0; i < fieldList.size(); i++) 

				getFieldsCombo().addItem(fieldList.get(i));

			initTable();

		}

	}

	/**

	 * Adds to the table one entry for each field

	 */

	private void initTable() {

		try {

			getRadioButtonTable().removeAllRows();

			for (int i = 0; i < getSelectedVectorLayer().getFieldCount(); i++) {

				if(Number.class.isAssignableFrom(getSelectedVectorLayer().getFieldType(i)))

					addTableRow(getSelectedVectorLayer().getFieldName(i));

			}

		} catch (NotInitializeException e) {

			Sextante.addErrorToLog(e);

		}

	}

	/**

	 * A�ade una banda a la tabla bandas de la imagen asignandole un nombre y

	 * valor a los checkbox

	 * @param bandName Nombre de la banda

	 * @throws NotInitializeException 

	 */

	private void addTableRow(String fieldName) throws NotInitializeException {

		Object[] row = {	new Boolean(false), 

							new Boolean(false), 

							new Boolean(false), 

							new Boolean(false), 

							fieldName };

		getRadioButtonTable().addRow(row);

	}

	@Override

    public void assignParameters() {

		try {

			ParametersSet params = m_Algorithm.getParameters();

			params.getParameter(DissolveAlgorithm.LAYER).setParameterValue(getSelectedVectorLayer());

			params.getParameter(DissolveAlgorithm.FIELD).setParameterValue(fieldsCombo.getSelectedIndex());

			params.getParameter(DissolveAlgorithm.SELECTED_GEOM).setParameterValue(getSelectionCheck().isSelected());

			params.getParameter(DissolveAlgorithm.DISSOLV_ADJ).setParameterValue(getAdjacentCheck().isSelected());

			params.getParameter(DissolveAlgorithm.FUNCTION_LIST).setParameterValue(getValues());

			OutputObjectsSet ooSet = m_Algorithm.getOutputObjects();

			Output out = ooSet.getOutput(DissolveAlgorithm.RESULT);

			//Reponer estas l?neas para cambiar el panel de salida y comentar la siguiente

			//AlgorithmOutputPanel fsp = getAlgorithmOutputPanel();

			//out.setOutputChannel(new CompositeSourceOutputChannel(fsp.getOutputParameters()));

	         out.setOutputChannel(outputChannelSelectionPanel.getOutputChannel());

		} catch (Exception e) {

			Sextante.addErrorToLog(e);

		}

	}

	/**

	 * Formats the content of the table

	 * @return

	 */

	private String getValues() {

    	String str = "";

    	try {

			for (int i = 0; i < getRadioButtonTable().getRowCount(); i++) {

				str = str + (String)getRadioButtonTable().getModel().getValueAt(i, 4) + ",";

				for (int j = 0; j < getRadioButtonTable().getModel().getColumnCount() - 1; j++)

					if(((Boolean)getRadioButtonTable().getModel().getValueAt(i, j)).booleanValue())

						str = str + DissolveAlgorithm.Summary[j] + ",";

				str = str.substring(0, str.length() - 1) + ";";

			}

		} catch (NotInitializeException e) {

			Sextante.addErrorToLog(e);

		}

    	return (str.equals("")) ? str : str.substring(0, str.length() - 1);

    }

	@Override

	public void setOutputValue(String arg0, String arg1) {

	}

	@Override

	public void setParameterValue(String arg0, String arg1) {

	}

	/**

	 * Gets the input layer list

	 * @return

	 */

	private ObjectAndDescription[] getLayerList() {

		IVectorLayer[] layers = SextanteGUI.getInputFactory()

					.getVectorLayers(IVectorLayer.SHAPE_TYPE_WRONG);

		ObjectAndDescription[] oad = new ObjectAndDescription[layers.length];

		for (int i = 0; i < layers.length; i++)

			oad[i] = new ObjectAndDescription(layers[i].getName(), layers[i]);

		return oad;

	}

	/**

	 * Gets the selected vector layer in the JComboBox

	 * @return

	 */

	private IVectorLayer getSelectedVectorLayer() {

		if(layersCombo.getSelectedItem() != null)

			return (IVectorLayer)((ObjectAndDescription)layersCombo.getSelectedItem()).getObject();

		return null;

	}

	/**

	 * Gets the field list of the selected layer

	 * @return

	 */

	public List<String> getFieldList() {

		IVectorLayer layer = getSelectedVectorLayer();

		return Arrays.asList(layer.getFieldNames());

	}

}

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2012 gvSIG Association.

 *

 * 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., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.geoprocess.algorithm.dissolve;

import org.gvsig.geoprocess.algorithm.base.core.AlgorithmAbstractLibrary;

import org.gvsig.i18n.Messages;

import org.gvsig.tools.library.LibraryException;

/**

 * Initialization of DissolveLibrary library.

 * 

 * @author <a href="mailto:nachobrodin@gmail.com">Nacho Brodin</a>

 */

public class DissolveLibrary extends AlgorithmAbstractLibrary {

    @Override

    protected void doInitialize() throws LibraryException {

    }

    @Override

    protected void doPostInitialize() throws LibraryException {

        Messages.addResourceFamily(

            "org.gvsig.geoprocess.algorithm.dissolve.dissolve",

            DissolveLibrary.class.getClassLoader(), DissolveLibrary.class

                .getClass().getName());

        registerGeoProcess(new DissolveAlgorithm());

    }

}

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2012 gvSIG Association.

 *

 * 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., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.geoprocess.algorithm.dissolve;

import es.unex.sextante.core.Sextante;

import org.gvsig.fmap.dal.feature.EditableFeature;

import org.gvsig.fmap.dal.feature.Feature;

import org.gvsig.fmap.dal.feature.FeatureAttributeDescriptor;

import org.gvsig.fmap.dal.feature.FeatureType;

/**

 * <p>

 * Computes summary functions. There are four summary functions, maximum, minimum,

 * average and sum. 

 * </p>

 * <p>

 * At the beginning you have to call loadDefaultSummarizes with the

 * first analyzed feature. Next, the function updateValues will update the statistics 

 * values and in the end you have to load the statistics value in the output feature 

 * calling the function loadEditableFeature.

 * </p>

 * 

 * @author <a href="mailto:nachobrodin@gmail.com">Nacho Brodin</a>

 */

public class Summary {

	private IDissolveRule                    rule             = null;

	private double                           max              = Double.NEGATIVE_INFINITY;

	private double                           min              = Double.POSITIVE_INFINITY;

	private double                           avg              = 0;

	private double                           sum              = 0;

	private double                           sumAvg           = 0;

	private double                           nfeat            = 0;

	private FeatureType                      featType         = null;

	public Summary(IDissolveRule criteria, FeatureType featType) {

		this.rule = criteria;

		this.featType = featType;

	}

	/**

	 * This function updates statistics values reading the field 

	 * values of the selected feature .

	 * @param feature

	 */

	public void updateValues(Feature feature) {

		try {

			FeatureAttributeDescriptor[] desc = featType.getAttributeDescriptors();

			Object obj = null;

			String fName = null;

			for (int i = 0; i < desc.length; i++) {

				String fieldName = desc[i].getName();

				if(fieldName.endsWith("_Max")) {

					fName = rule.getFieldName("Max");

					if(fName != null) {

						obj = feature.get(fName);

						max = Math.max(max, ((Number)obj).doubleValue());

					}

				}

				if(fieldName.endsWith("_Min")) {

					fName = rule.getFieldName("Min");

					if(fName != null) {

						obj = feature.get(fName);

						min = Math.min(min, ((Number)obj).doubleValue());

					}

				}

				if(fieldName.endsWith("_Sum")) {

					fName = rule.getFieldName("Sum");

					if(fName != null) {

						obj = feature.get(fName);

						sum = sum + ((Number)obj).doubleValue();

					}

				}

				if(fieldName.endsWith("_Avg")) {

					fName = rule.getFieldName("Avg");

					if(fName != null) {

						obj = feature.get(fName);

						sumAvg = sumAvg + ((Number)obj).doubleValue();

						nfeat ++;

						avg = sumAvg / nfeat;

					}

				}

				fName = null;

			}

		} catch (NumberFormatException e) {

			Sextante.addErrorToLog(e);

		}

	}

	/**

	 * Loads an EditableFeature with the statistics

	 * @param feat

	 */

	public void loadEditableFeature(EditableFeature feat) {

		FeatureAttributeDescriptor[] desc = featType.getAttributeDescriptors();

		for (int i = 0; i < desc.length; i++) {

			String fieldName = desc[i].getName();

			if(fieldName.endsWith("_Max")) {

				if(feat.getType().getAttributeDescriptor(fieldName) != null)

					feat.setDouble(fieldName, getMax());

			}

			if(fieldName.endsWith("_Min")) {

				if(feat.getType().getAttributeDescriptor(fieldName) != null)

					feat.setDouble(fieldName, getMin());

			}

			if(fieldName.endsWith("_Sum")) {

				if(feat.getType().getAttributeDescriptor(fieldName) != null)

					feat.setDouble(fieldName, getSum());

			}

			if(fieldName.endsWith("_Avg")) {

				if(feat.getType().getAttributeDescriptor(fieldName) != null)

					feat.setDouble(fieldName, getAvg());

			}

		}

	}

	/**

	 * Loads the default statistics values.

	 * @param feature

	 */

	public void loadDefaultSummarizes(Feature feature) {

		try {

			FeatureAttributeDescriptor[] desc = featType.getAttributeDescriptors();

			Object obj = null;

			String fName = null;

			sum = avg = sumAvg = nfeat = 0;

			for (int i = 0; i < desc.length; i++) {

				String fieldName = desc[i].getName();

				if(fieldName.endsWith("_Max")) {

					fName = rule.getFieldName("Max");

					if(fName != null) {

						obj = feature.get(fName);

						max = ((Number)obj).doubleValue();

					}

				}

				if(fieldName.endsWith("_Min")) {

					fName = rule.getFieldName("Min");

					if(fName != null) {

						obj = feature.get(fName);

						min = ((Number)obj).doubleValue();

					}

				}

				fName = null;

			}

		} catch (NumberFormatException e) {

			Sextante.addErrorToLog(e);

		}

	}

	public double getMax() {

		return max;

	}

	public void setMax(double max) {

		this.max = max;

	}

	public double getMin() {

		return min;

	}

	public void setMin(double min) {

		this.min = min;

	}

	public double getAvg() {

		return avg;