Application: gvSIG desktop » gvSIG geoprocess

import java.util.HashSet;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.fmap.geom.GeometryUtils;

import org.gvsig.tools.namestranslator.NamesTranslator;

import org.gvsig.tools.util.CompareUtils;

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

    /*

     */

    public void defineCharacteristics() {

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

        }

    }

    /*

     */

    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<Object> groupedValues = getGroupedValues(featureStore, groupByField);

            int numberOfFeatures = groupedValues.size();

            if (getStatus() != null) {

                getStatus().setRangeOfValues(0, numberOfFeatures);

            }

            int cont = 0;

            Iterator<Object> it = groupedValues.iterator();

            while (it.hasNext()) {

                if (getStatus() != null) {

                    getStatus().setCurValue(cont);

                }

                setProgress(cont, numberOfFeatures);

                Object 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,

            Object groupedValue,

            String[] fieldList,

            String[] funcList,

            int geomOption) throws DataException {

        DataManager manager = DALLocator.getDataManager();

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

        FeatureQuery query = inStore.createFeatureQuery();

        ExpressionBuilder expressionBuilder = outStore.createExpressionBuilder();

        Evaluator filter = manager.createFilter(expressionBuilder.column(fieldNameGrouped) + " = " + expressionBuilder.constant(groupedValue) );

        query.setFilter(filter);

        query.retrievesAllAttributes();

        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(values[i], v);

                        }

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

                            if (values[i] == null) {

                                values[i] = Double.NEGATIVE_INFINITY;

                            }

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

                        }

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

                            if (values[i] == null) {

                                values[i] = 0L;

                            }

                            values[i] = sum(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++;

        }

        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] = ((Number) 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.insert(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 {

                    int geomType = geomList.get(0).getType();

                    int geomSubtype = geomList.get(0).getGeometryType().getSubType();

                    if (GeometryUtils.isSubtype(TYPES.POINT, geomType) || GeometryUtils.isSubtype(TYPES.MULTIPOINT, geomType)) {

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

                    } else if (GeometryUtils.isSubtype(TYPES.CURVE, geomType) || GeometryUtils.isSubtype(TYPES.MULTICURVE, geomType)) {

                        newGeom = (MultiCurve) geomManager.create(TYPES.MULTILINE, geomSubtype);

                    } else if (GeometryUtils.isSubtype(TYPES.SURFACE, geomType) || GeometryUtils.isSubtype(TYPES.MULTISURFACE, geomType)) {

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

                    }

                } catch (CreateGeometryException e) {

                    LOGGER.warn("Can't create geometry.", e);

                }

            }

            Geometry geom = geomList.get(i);

            ((MultiPrimitive)newGeom).addPrimitives(geom);

//            if (geom instanceof Surface) {

//                ((MultiSurface) newGeom).addPrimitives(geom);

//            }

//            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 Object updateMinimum(Object min, Object value) {

        if (value instanceof Comparable && min instanceof Comparable && CompareUtils.compare((Comparable)value, (Comparable)min) < 0) {

            return value;

        }

        return min;

    }

    private Object updateMaximum(Object max, Object value) {

        if (value instanceof Comparable && max instanceof Comparable && CompareUtils.compare((Comparable)value, (Comparable)max) > 0) {

            return value;

        }

        return max;

    }

    private Object sum(Object current, Object value) {

        if(!(current instanceof Number) || !(value instanceof Number)){

            return current;

        }

        if(current instanceof Double || value instanceof Double){

            return ((Number) value).doubleValue() + ((Number)current).doubleValue();

        }

        if(current instanceof Float || value instanceof Float){

            return ((Number) value).floatValue()+ ((Number)current).floatValue();

        }

        return ((Number) value).longValue()+ ((Number)current).longValue();

    }

    /**

     * Gets the list of grouped values

     *

     * @param featureStore

     * @param groupByField

     * @return

     * @throws DataException

     */

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

        Set<Object> valueGrouped = new HashSet<>();

        FeatureSet featureSet = featureStore.getFeatureSet();

        Iterator it = featureSet.iterator();

        while (it.hasNext()) {

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

            Object obj = feature.get(groupByField);

            valueGrouped.add(obj);

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

//            }

        }

        featureSet.dispose();

        return valueGrouped; //.keySet();

    }

     *

            String sextanteLayerName,

            String groupByField,

            String[] fieldList,

            String[] funcList,

            int geomOption,

            int inputShapeType) {

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

        if (fieldList != null) {

            NamesTranslator nTranslator = NamesTranslator.createTrimTranslator(10);

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

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

                switch(funcList[i-1].toLowerCase()){

                    case "max": 

                        nTranslator.addSource("max_"+desc.getName());

                        break;

                    case "min": 

                        nTranslator.addSource("min_"+desc.getName());

                        break;

                    case "first": 

                        nTranslator.addSource("fst_"+desc.getName());

                        break;

                    case "average": 

                        nTranslator.addSource("avg_"+desc.getName());

                        break;

                    case "sum": 

                        nTranslator.addSource("sum_"+desc.getName());

                        break;

                    case "last": 

                        nTranslator.addSource("lst_"+desc.getName());

                        break;

                }

            }

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

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

                switch(funcList[i-1].toLowerCase()){

                    case "min": 

                        attrNames[i] = nTranslator.getTranslation("min_"+desc.getName());

                        types[i] = desc.getObjectClass();

                        break;

                    case "max": 

                        attrNames[i] = nTranslator.getTranslation("max_"+desc.getName());

                        types[i] = desc.getObjectClass();

                        break;

                    case "first": 

                        attrNames[i] = nTranslator.getTranslation("fst_"+desc.getName());

                        types[i] = desc.getObjectClass();

                        break;

                    case "last": 

                        attrNames[i] = nTranslator.getTranslation("lst_"+desc.getName());

                        types[i] = desc.getObjectClass();

                        break;

                    case "sum": 

                        attrNames[i] = nTranslator.getTranslation("sum_"+desc.getName());

                        if(Double.class.isAssignableFrom(desc.getObjectClass())){

                            types[i] = Double.class;

                        } else if(Float.class.isAssignableFrom(desc.getObjectClass())) {

                            types[i] = Double.class;

                        } else if(Number.class.isAssignableFrom(desc.getObjectClass())) {

                            types[i] = Long.class;

                        } else {

                            types[i] = desc.getObjectClass();

                        }

                        break;

                    case "average": 

                        attrNames[i] = nTranslator.getTranslation("avg_"+desc.getName());

                        types[i] = Double.class;

                        break;

                }

            }

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

                types[i] = Date.class;

            }

        }

                    inputShapeType, types, attrNames);

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

     *

    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;

    }