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.

 */

package org.gvsig.geoprocess.algorithm.groupby;

import java.util.ArrayList;

import java.util.Calendar;

import java.util.Date;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Set;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

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

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

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

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

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.Geometry.SUBTYPES;

import org.gvsig.fmap.geom.Geometry.TYPES;

import org.gvsig.fmap.geom.aggregate.MultiCurve;

import org.gvsig.fmap.geom.aggregate.MultiPoint;

import org.gvsig.fmap.geom.aggregate.MultiPrimitive;

import org.gvsig.fmap.geom.aggregate.MultiSurface;

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

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

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

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

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.gvsig.geoprocess.lib.sextante.dataObjects.FlyrVectIVectorLayer;

import org.gvsig.timesupport.AbsoluteInstant;

import org.gvsig.timesupport.Instant;

import org.gvsig.timesupport.RelativeInstant;

import org.gvsig.timesupport.Time;

import org.gvsig.tools.dispose.DisposableIterator;

import org.gvsig.tools.evaluator.Evaluator;

import es.unex.sextante.additionalInfo.AdditionalInfoNumericalValue;

import es.unex.sextante.core.Sextante;

import es.unex.sextante.dataObjects.IVectorLayer;

import es.unex.sextante.exceptions.GeoAlgorithmExecutionException;

import es.unex.sextante.exceptions.RepeatedParameterNameException;

import es.unex.sextante.exceptions.UnsupportedOutputChannelException;

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

import es.unex.sextante.outputs.OutputVectorLayer;

import java.sql.Timestamp;

/**

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

 */

public class GroupByAlgorithm extends AbstractSextanteGeoProcess {

        public static final String         RESULT            = "RESULT";

        public static final String         LAYER             = "LAYER";

        public static final String         FIELD             = "FIELD";

        public static final String         FIELD_DATE        = "FIELD_DATE";

        public static final String         FIELD_LIST        = "FIELD_LIST";

        public static final String         LAYER_NAME        = "LAYER_NAME";

        /**

         * <P>Possible values</P>

         * <UL>

         * <LI>-1: Without geometry</LI>

         * <LI>0: First geometry </LI>

         * <LI>1: Creates a multigeometry </LI>

         * <LI>2: Fusion of polygons </LI>

         * </UL>

         **/

        public static final String         GEOM_OPTION       = "GEOM_OPTION";

        public static final String         FUNCTION_LIST     = "FUNCTION_LIST";

        public static final String         Summary[]         = {"Min", "Max", "Sum", "Avg", "Last", "Any"};

        /*

         * (non-Javadoc)

         * @see es.unex.sextante.core.GeoAlgorithm#defineCharacteristics()

         */

        public void defineCharacteristics(){

        setName(getTranslation("groupby"));

        setGroup(getTranslation("basic_vect_algorithms"));

        // setGeneratesUserDefinedRasterOutput(false);

                try {

                        m_Parameters.addInputVectorLayer(LAYER, getTranslation("Input_layer"), IVectorLayer.SHAPE_TYPE_WRONG, true);

                        m_Parameters.addString(FIELD, getTranslation("Field"));

                        m_Parameters.addString(FIELD_DATE, getTranslation("Field_date"));

                        m_Parameters.addString(FIELD_LIST, getTranslation("Field_list"));

                        m_Parameters.addString(FUNCTION_LIST, getTranslation("Function_list"));

                        m_Parameters.addString(LAYER_NAME, getTranslation("Layer_name"));

                        m_Parameters.addNumericalValue(GEOM_OPTION, getTranslation("Geom"), -1, AdditionalInfoNumericalValue.NUMERICAL_VALUE_INTEGER);

                        addOutputVectorLayer(RESULT, getTranslation("group_by"), OutputVectorLayer.SHAPE_TYPE_UNDEFINED);

                } catch (RepeatedParameterNameException e) {

                        Sextante.addErrorToLog(e);

                }

        }

        /*

         * (non-Javadoc)

         * @see es.unex.sextante.core.GeoAlgorithm#processAlgorithm()

         */

        public boolean processAlgorithm() throws GeoAlgorithmExecutionException {

                if(existsOutPutFile(GroupByAlgorithm.RESULT, 0)) {

                    throw new GeoAlgorithmExecutionException(getTranslation("file_exists"));

            }

                IVectorLayer layer = m_Parameters.getParameterValueAsVectorLayer(LAYER);

                String groupByField = m_Parameters.getParameterValueAsString(FIELD);

                String fieldDate = m_Parameters.getParameterValueAsString(FIELD_DATE);

                String fieldsString = m_Parameters.getParameterValueAsString(FIELD_LIST);

                String functionsString = m_Parameters.getParameterValueAsString(FUNCTION_LIST);

                String layerName = m_Parameters.getParameterValueAsString(LAYER_NAME);

                int geomOption = m_Parameters.getParameterValueAsInt(GEOM_OPTION);

                int inputShapeType = layer.getShapeType();

                String[] funcList = functionsString.split(";");

                String[] fieldList = null;

                if(!fieldsString.equals(""))

                        fieldList = fieldsString.split(";");

                if(fieldList != null && funcList != null) {

                        if(fieldList.length != funcList.length) {

                                Sextante.addErrorToLog("invalid_input_parameters");

                        }

                }

                FeatureStore featureStore = null;

                if(layer instanceof FlyrVectIVectorLayer)

                        featureStore = ((FlyrVectIVectorLayer)layer).getFeatureStore();

                else

                        return false;

                try {

                        FeatureType featureType = featureStore.getDefaultFeatureType();

                        FeatureAttributeDescriptor desc = featureType.getAttributeDescriptor(groupByField);

                        String fieldNameGrouped = desc.getName();

                        FeatureStore outFeatStore = buildOutPutStore(featureType, 

                                                                                                                layerName, 

                                                                                                                groupByField, 

                                                                                                                fieldList, 

                                                                                                                funcList, 

                                                                                                                geomOption,

                                                                                                                inputShapeType);

                        Set<String> list = getGroupedValues(featureStore, groupByField);

                        int numberOfFeatures = list.size();

                        if (getStatus() != null) {

                                getStatus().setRangeOfValues(0, numberOfFeatures);

                }

                        int cont = 0;

                        Iterator<String> it = list.iterator();

                        while( it.hasNext() ) {

                                if (getStatus() != null) {

                                        getStatus().setCurValue(cont);

                        }        

                                setProgress(cont, numberOfFeatures);

                                String groupedValue = it.next();

                                loadFeature(featureStore, 

                                                outFeatStore, 

                                                fieldNameGrouped, 

                                                fieldDate, 

                                                groupedValue, 

                                                fieldList, 

                                                funcList,

                                                geomOption);

                                cont++;

                        }

                        outFeatStore.finishEditing();

                } catch (DataException e) {

                        Sextante.addErrorToLog(e);

                }

                return true;

        }

        private void loadFeature(FeatureStore inStore, 

                        FeatureStore outStore, 

                        String fieldNameGrouped,

                        String fieldDate,

                        String groupedValue, 

                        String[] fieldList, 

                        String[] funcList,

                        int geomOption) throws DataException {

                DataManager manager = DALLocator.getDataManager();

                EditableFeature feat = outStore.createNewFeature(outStore.getDefaultFeatureType(), true);

                FeatureQuery query = inStore.createFeatureQuery();

                Evaluator filter = manager.createExpresion(fieldNameGrouped + " = '" + groupedValue + "'");

                query.setFilter(filter);

                FeatureSet featSet = inStore.getFeatureSet(query);

                Iterator it = featSet.iterator();

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

                Object[] values = null;

                if(fieldList != null)

                        values = new Object[fieldList.length];

                int nFeaturesByGroup = 0;

                Date lastDate = null;

                while(it.hasNext()) {

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

                        if(fieldList != null) {

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

                                        Object v = feature.get(fieldList[i]);

                                        //Class<?> c = inStore.getDefaultFeatureType().getAttributeDescriptor(funcList[i]).getClassOfValue();

                                        if(v instanceof Number) {

                                                if(funcList[i].compareToIgnoreCase("Min") == 0) {

                                                        if(values[i] == null) 

                                                                values[i] = Double.POSITIVE_INFINITY;

                                                        values[i] = updateMinimum((Double)values[i], v);

                                                }

                                                if(funcList[i].compareToIgnoreCase("Max") == 0) {

                                                        if(values[i] == null) 

                                                                values[i] = Double.NEGATIVE_INFINITY;

                                                        values[i] = updateMaximum((Double)values[i], v);

                                                }

                                                if(funcList[i].compareToIgnoreCase("Sum") == 0 || funcList[i].compareToIgnoreCase("Average") == 0) {

                                                        if(values[i] == null) 

                                                                values[i] = new Double(0D);

                                                        values[i] = sum((Double)values[i], v);

                                                }

                                        }

                                        if(funcList[i].compareToIgnoreCase("First") == 0) {

                                                if(values[i] == null) 

                                                        values[i] = objectConversion(v);

                                        }

                                        if(funcList[i].compareToIgnoreCase("Last") == 0 && fieldDate != null) {

                                                if(lastDate == null || values[i] == null || lastDate.getTime() > feature.getTimestamp(fieldDate).getTime()) {

                                                        lastDate = feature.getTimestamp(fieldDate);

                                                        values[i] = objectConversion(v);

                                                }

                                        }

                                }

                        }

                        if(geomOption >= 0) {

                                switch (geomOption) {

                                case 0: //Adds only the first geometry

                                        if(nFeaturesByGroup == 0) { //If is the first feature

                                                Geometry g = feature.getDefaultGeometry();

                                                if(!(g instanceof MultiPrimitive)) {

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

                                                        gList.add(g);

                                                        g = buildMultiGeometry(gList);

                                                }

                                                feat.set(outStore.getDefaultFeatureType().getDefaultGeometryAttributeName(), g);

                                        }

                                        break;

                                case 1: //Multigeometry with all geometries

                                case 2: //Union among all geometries

                                        geomList.add(feature.getDefaultGeometry().cloneGeometry());

                                        break;

                                }

                        }

                        nFeaturesByGroup ++;

                }

//                it.dispose();

                featSet.dispose();

                feat.set(fieldNameGrouped, groupedValue);

                //Se asignan los campos calculados

                if(fieldList != null) {

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

                                if(funcList[i].compareToIgnoreCase("Average") == 0) {

                                        values[i] = ((Double)values[i]).doubleValue() / nFeaturesByGroup; 

                                } 

                                feat.set(i + 1, values[i]);                                        

                        }

                }

                //Si hay que convertir a multigeometr?a

                if(geomOption == 1 && geomList.size() > 0)

                        feat.set(outStore.getDefaultFeatureType().getDefaultGeometryAttributeName(), buildMultiGeometry(geomList));

                if(geomOption == 2 && geomList.size() > 0)

                        feat.set(outStore.getDefaultFeatureType().getDefaultGeometryAttributeName(), computesUnion(geomList));

                outStore.update(feat);

        }

        private Object objectConversion(Object obj) {

                if(obj instanceof Instant) 

                        return convertInstantToDate((Instant)obj);

                return obj;

        }

        /**

         * Converts an Instant to Date. This is useful to save a Instant in a DBF file

         * @param instant

         * @return

         */

        private Date convertInstantToDate(Instant instant) {

                if(instant instanceof AbsoluteInstant) {

                        int year = ((AbsoluteInstant)instant).getYears();

                        int month = ((AbsoluteInstant)instant).getMonths();

                        int day = ((AbsoluteInstant)instant).getDays();

                        int min = ((AbsoluteInstant)instant).getMinutes();

                        int hour = ((AbsoluteInstant)instant).getHours();

                        int second = ((AbsoluteInstant)instant).getSeconds();

                        int millis = ((AbsoluteInstant)instant).getMillis();

                        Calendar c = Calendar.getInstance();

                        c.set(year, month, day, hour, min);

                        return new Date(c.getTimeInMillis() + (second * 1000) + millis);

                }

                if(instant instanceof RelativeInstant) {

                        return new Date(((RelativeInstant)instant).toMillis());

                }

                return null;

        }

        /**

         * Builds a unique geometry with all geometries in the list

         * @param geomList

         * @return

         */

        private Geometry buildMultiGeometry(List<Geometry> geomList) {

                Geometry newGeom = null;

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

                        if(i == 0) {

                                try {

                                        if(geomList.get(0).getType() == TYPES.POINT || geomList.get(0).getType() == TYPES.MULTIPOINT)

                                                newGeom = (MultiPoint)geomManager.create(TYPES.MULTIPOINT, SUBTYPES.GEOM2D);

                                        if(geomList.get(0).getType() == TYPES.CURVE || geomList.get(0).getType() == TYPES.MULTICURVE)

                                                newGeom = (MultiCurve)geomManager.create(TYPES.MULTICURVE, SUBTYPES.GEOM2D);

                                        if(geomList.get(0).getType() == TYPES.SURFACE || geomList.get(0).getType() == TYPES.MULTISURFACE)

                                                newGeom = (MultiSurface)geomManager.create(TYPES.MULTISURFACE, SUBTYPES.GEOM2D);

                                } catch (CreateGeometryException e) {

                                }        

                        }

                        if(geomList.get(i) instanceof Surface) {

                                ((MultiSurface)newGeom).addPrimitive((Surface)geomList.get(i));

                        } 

                        if(geomList.get(i) instanceof MultiSurface) {

                                int nPrimitives = ((MultiSurface)geomList.get(i)).getPrimitivesNumber();

                                for (int iPrimitive = 0; iPrimitive < nPrimitives; iPrimitive++) {

                                        ((MultiSurface)newGeom).addPrimitive(((MultiSurface)geomList.get(i)).getSurfaceAt(iPrimitive));

                                }

                        }

                        if(geomList.get(i) instanceof Curve) {

                                ((MultiCurve)newGeom).addPrimitive((Curve)geomList.get(i));

                        } 

                        if(geomList.get(i) instanceof MultiCurve) {

                                int nPrimitives = ((MultiSurface)geomList.get(i)).getPrimitivesNumber();

                                for (int iPrimitive = 0; iPrimitive < nPrimitives; iPrimitive++) {

                                        ((MultiCurve)newGeom).addPrimitive(((MultiCurve)geomList.get(i)).getCurveAt(iPrimitive));

                                }

                        }

                        if(geomList.get(i) instanceof Point) {

                                ((MultiPoint)newGeom).addPrimitive((Point)geomList.get(i));

                        } 

                        if(geomList.get(i) instanceof MultiPoint) {

                                int nPrimitives = ((MultiPoint)geomList.get(i)).getPrimitivesNumber();

                                for (int iPrimitive = 0; iPrimitive < nPrimitives; iPrimitive++) {

                                        ((MultiPoint)newGeom).addPrimitive(((MultiPoint)geomList.get(i)).getPointAt(iPrimitive));

                                }

                        }

                }

                return newGeom;

        }

        /**

         * Computes the union of gemetries in the list

         * @param listInput

         * @return

         */

        private Geometry computesUnion(List<Geometry> listInput) {

                List<com.vividsolutions.jts.geom.Geometry> listResult = new ArrayList<com.vividsolutions.jts.geom.Geometry>();

                for (int i = listInput.size() - 1; i >= 0; i--) {

                        listResult.add(GeometryUtil.geomToJTS(listInput.get(i)));

                        listInput.remove(i);

                }

                com.vividsolutions.jts.geom.Geometry newGeom = listResult.size() > 0 ? listResult.get(0) : null;

                while(listResult.size() > 1) {

                        List<com.vividsolutions.jts.geom.Geometry> list = new ArrayList<com.vividsolutions.jts.geom.Geometry>();

                        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 GeometryUtil.jtsToGeom(newGeom);

        }

        private Double updateAny(Double min, Object value) {

                if(value instanceof Double)

                        return (Double)value;

                else if(value instanceof Integer)

                        return ((Integer)value).doubleValue();

                return min;

        }

        private Double updateMinimum(Double min, Object value) {

                if(value instanceof Double && ((Double)value).doubleValue() < min)

                        return (Double)value;

                else if(value instanceof Integer && ((Integer)value).intValue() < min)

                        return ((Integer)value).doubleValue();

                return min;

        }

        private Double updateMaximum(Double max, Object value) {

                if(value instanceof Double && ((Double)value).doubleValue() > max)

                        return (Double)value;

                else if(value instanceof Integer && ((Integer)value).intValue() > max)

                        return ((Integer)value).doubleValue();

                return max;

        }

        private Double sum(Double current, Object value) {

                if(value instanceof Double)

                        return ((Double)value) + current;

                else if(value instanceof Integer)

                        return ((Integer)value) + current;

                return current;

        }

        /**

         * Gets the list of grouped values

         * @param featureStore

         * @param groupByField

         * @return

         * @throws DataException

         */

        private Set<String> getGroupedValues(FeatureStore featureStore, String groupByField) throws DataException {

                HashMap<String, String> valueGrouped = new HashMap<String, String>();

                FeatureSet featureSet = featureStore.getFeatureSet();

                Iterator it = featureSet.iterator();

                while( it.hasNext() ) {

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

                        Object obj = feature.get(groupByField);

                        String s = null;

                        if(obj instanceof String)

                                s = new String(((String)obj));

                        else if(obj instanceof Double)

                                s = String.valueOf((Double)obj);

                        else if(obj instanceof Integer)

                                s = String.valueOf((Integer)obj);

                        else if(obj instanceof Float)

                                s = String.valueOf((Float)obj);

                        else if(obj instanceof Boolean)

                                s = String.valueOf((Boolean)obj);

                        else if(obj instanceof Long)

                                s = String.valueOf((Long)obj);

                        else if(obj instanceof Byte)

                                s = String.valueOf((Byte)obj);

                        else if(obj instanceof Date)

                                s = ((Date)obj).toString();

                        if(valueGrouped.get(s) == null) {

                                valueGrouped.put(s, s);

                        }

                }

//                it.dispose();

                featureSet.dispose();

                return valueGrouped.keySet();

        }

    /**

     * Builds the output FeatureStore

     * 

     * @param featureType

     * @return FeatureStore

     */

    private FeatureStore buildOutPutStore(FeatureType featureType,

                    String sextanteLayerName,

                    String groupByField,

                    String[] fieldList,

                    String[] funcList,

                    int geomOption,

                    int inputShapeType) {

            int len = fieldList != null ? fieldList.length + 2 : 2;

        Class<?>[] types = new Class[len];

        attrNames = new String[len];

        FeatureAttributeDescriptor desc = featureType.getAttributeDescriptor(groupByField);

        attrNames[0] = desc.getName();

        types[0] = desc.getObjectClass();

        if(fieldList != null) {

                for (int i = 1; i < attrNames.length - 1; i++) {

                        desc = featureType.getAttributeDescriptor(fieldList[i - 1]);

                        attrNames[i] = desc.getName();

                        if(attrNames[i].length() >= 6)

                                attrNames[i] = attrNames[i].substring(0, 5);

                        attrNames[i] += "_" + funcList[i - 1];

                        types[i] = desc.getObjectClass(); 

                }

        }

        attrNames[attrNames.length - 1] = featureType.getDefaultGeometryAttributeName();

        types[types.length - 1] = featureType.getDefaultGeometryAttribute().getObjectClass();

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

                        if(Time.class.isAssignableFrom(types[i])) {

                                types[i] = Date.class;

                        }

                }

        try {

            IVectorLayer output = getNewVectorLayer(RESULT, sextanteLayerName,

                            inputShapeType, types, attrNames);

            return ((FlyrVectIVectorLayer) output).getFeatureStore();

        } catch (UnsupportedOutputChannelException e) {

            Sextante.addErrorToLog(e);

        } catch (GeoAlgorithmExecutionException e) {

            Sextante.addErrorToLog(e);

        }

        return null;

    }

    /**

     * Gets the list of fields index to add to the table. 

     * @param fieldsString

     * @return

     */

        private int[] getFieldList(String fieldsString) {

                String[] list = fieldsString.split(";");

                int[] l = new int[list.length];

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

                        try {

                                l[i] = new Integer(list[i]);

                        } catch (NumberFormatException e) {

                                return null;

                        }

                }

                return l;

        }

    @Override

    public Class<? extends GeoAlgorithmParametersPanel> getCustomParametersPanelClass() {

        return GroupByParametersPanel.class;

    }

}