Application: gvSIG desktop » gvSIG legends: base legends

/* gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2015 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.legend.urbanhorizontalsignage.lib.impl;

import java.io.File;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import java.util.UUID;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataStoreParameters;

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.store.jdbc.JDBCNewStoreParameters;

import org.gvsig.fmap.dal.store.jdbc.JDBCServerExplorerParameters;

import org.gvsig.fmap.dal.store.jdbc2.JDBCServerExplorer;

import org.gvsig.fmap.geom.Geometry;

import static org.gvsig.fmap.geom.Geometry.JOIN_STYLE_MITRE;

import static org.gvsig.fmap.geom.Geometry.JOIN_STYLE_ROUND;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

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

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

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

import org.gvsig.fmap.geom.operation.GeometryOperationException;

import org.gvsig.fmap.geom.operation.GeometryOperationNotSupportedException;

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

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

import org.gvsig.fmap.geom.type.GeometryType;

import org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageConfig;

import org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageData;

import static org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageData.CONTINUITY_MODE_CONT;

import static org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageData.CONTINUITY_MODE_CONT_CONT;

import static org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageData.CONTINUITY_MODE_CONT_DISC;

import static org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageData.CONTINUITY_MODE_DISC;

import static org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageData.CONTINUITY_MODE_DISC_CONT;

import static org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageData.CONTINUITY_MODE_DISC_DISC;

import org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageLegend;

import org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageLocator;

import org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageManager;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.folders.FoldersManager;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.tools.util.HasAFile;

import org.slf4j.LoggerFactory;

public class DefaultUrbanHorizontalSignageManager implements UrbanHorizontalSignageManager {

    private static final org.slf4j.Logger LOGGER = LoggerFactory.getLogger(DefaultUrbanHorizontalSignageManager.class);

    @Override

    public UrbanHorizontalSignageLegend create() {

        return new DefaultUrbanHorizontalSignageLegend();

    }

    @Override

    public Class<? extends UrbanHorizontalSignageLegend> getLegendClass() {

        return DefaultUrbanHorizontalSignageLegend.class;

    }

    @Override

    public UrbanHorizontalSignageData createUrbanHorizontalSignageData() {

        return new DefaultUrbanHorizontalSignageData();

    }

    @Override

    public void calculateGeometries(Geometry originalGeometry, UrbanHorizontalSignageData data) {

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        try {

            MultiPolygon segments = geomManager.createMultiPolygon(originalGeometry.getGeometryType().getSubType());

            MultiPolygon holes = geomManager.createMultiPolygon(originalGeometry.getGeometryType().getSubType());

            MultiLine lines = originalGeometry.toLines();

            final double offsetValueInMeters = data.getGapWidth()/2.0+data.getWidth()/2.0;

            final double bufferValueInMeters = data.getWidth() / 2.0;

            for (Geometry geom : lines) {

                Line line = (Line) geom;

                switch (data.getContinuity()) {

                    case CONTINUITY_MODE_CONT:

                    default:

                        Geometry buffer = line.buffer(

                                bufferValueInMeters,

                                data.isRoundVertex() ? JOIN_STYLE_ROUND : JOIN_STYLE_MITRE,

                                true

                        );

                        segments.addPrimitives(buffer);

                        break;

                    case CONTINUITY_MODE_DISC:

                        SplittedLine splittedLine = splitLine(line, data.getSegmentsLength(), data.getHolesLength());

                        List<Line> splittedSegments = splittedLine.getSegments();

                        List<Line> splittedHoles = splittedLine.getHoles();

                        for (Line segment : splittedSegments) {

                            buffer = segment.buffer(bufferValueInMeters,

                                    data.isRoundVertex() ? JOIN_STYLE_ROUND : JOIN_STYLE_MITRE,

                                    true

                            );

                            segments.addPrimitives(buffer);

                        }

                        for (Line hole : splittedHoles) {

                            buffer = hole.buffer(

                                    bufferValueInMeters,

                                    data.isRoundVertex() ? JOIN_STYLE_ROUND : JOIN_STYLE_MITRE,

                                    true

                            );

                            holes.addPrimitives(buffer);

                        }

                        break;

                    case CONTINUITY_MODE_CONT_CONT:

                        /* The left and right sides would be indistinguishable but 

                        I perform the same calculations as in the cases below 

                        to maintain semantic coherence */

                        //Left

                        if (line.isClosed() && line.getNumVertices() > 2 && line.isCCW()) {

                            Line cloned = line.cloneGeometry();

                            cloned.flip();

                            addOffsetedAndBufferedSegment(segments, cloned, offsetValueInMeters, bufferValueInMeters, data.isRoundVertex());

                        } else {

                            addOffsetedAndBufferedSegment(segments, line, -offsetValueInMeters, bufferValueInMeters, data.isRoundVertex());

                        }

                        //Right

                        if (line.isClosed() && line.getNumVertices() > 2 && line.isCCW()) {

                            Line cloned = line.cloneGeometry();

                            cloned.flip();

                            addOffsetedAndBufferedSegment(segments, cloned, -offsetValueInMeters, bufferValueInMeters, data.isRoundVertex());

                        } else {

                            addOffsetedAndBufferedSegment(segments, line, offsetValueInMeters, bufferValueInMeters, data.isRoundVertex());

                        }

                        break;

                    case CONTINUITY_MODE_CONT_DISC:

                        //Left

                        if (line.isClosed() && line.getNumVertices() > 2 && line.isCCW()) {

                            Line cloned = line.cloneGeometry();

                            cloned.flip();

                            addOffsetedAndBufferedSegment(segments, cloned, offsetValueInMeters, bufferValueInMeters, data.isRoundVertex());

                        } else {

                            addOffsetedAndBufferedSegment(segments, line, -offsetValueInMeters, bufferValueInMeters, data.isRoundVertex());

                        }

                        //Right

                        splittedLine = splitLine(line, data.getSegmentsLength(), data.getHolesLength());

                        splittedSegments = splittedLine.getSegments();

                        splittedHoles = splittedLine.getHoles();

                        for (Line segment : splittedSegments) {

                            addOffsetedAndBufferedSegment(segments, segment, offsetValueInMeters, bufferValueInMeters, true);

                        }

                        for (Line hole : splittedHoles) {

                            addOffsetedAndBufferedSegment(holes, hole, offsetValueInMeters, bufferValueInMeters, true);

                        }

                        break;

                    case CONTINUITY_MODE_DISC_CONT:

                        //Left

                        splittedLine = splitLine(line, data.getSegmentsLength(), data.getHolesLength());

                        splittedSegments = splittedLine.getSegments();

                        splittedHoles = splittedLine.getHoles();

                        for (Line segment : splittedSegments) {

                            addOffsetedAndBufferedSegment(segments, segment, -offsetValueInMeters, bufferValueInMeters, true);

                        }

                        for (Line hole : splittedHoles) {

                            addOffsetedAndBufferedSegment(holes, hole, -offsetValueInMeters, bufferValueInMeters, true);

                        }

                        //Right

                        if (line.isClosed() && line.getNumVertices() > 2 && line.isCCW()) {

                            Line cloned = line.cloneGeometry();

                            cloned.flip();

                            addOffsetedAndBufferedSegment(segments, cloned, -offsetValueInMeters, bufferValueInMeters, data.isRoundVertex());

                        } else {

                            addOffsetedAndBufferedSegment(segments, line, offsetValueInMeters, bufferValueInMeters, data.isRoundVertex());

                        }

                        break;

                    case CONTINUITY_MODE_DISC_DISC:

                        splittedLine = splitLine(line, data.getSegmentsLength(), data.getHolesLength());

                        splittedSegments = splittedLine.getSegments();

                        splittedHoles = splittedLine.getHoles();

                        //Left

                        for (Line segment : splittedSegments) {

                            addOffsetedAndBufferedSegment(segments, segment, -offsetValueInMeters, bufferValueInMeters, true);

                        }

                        for (Line hole : splittedHoles) {

                            addOffsetedAndBufferedSegment(holes, hole, -offsetValueInMeters, bufferValueInMeters, true);

                        }

                        //Right

                        for (Line segment : splittedSegments) {

                            addOffsetedAndBufferedSegment(segments, segment, offsetValueInMeters, bufferValueInMeters, true);

                        }

                        for (Line hole : splittedHoles) {

                            addOffsetedAndBufferedSegment(holes, hole, offsetValueInMeters, bufferValueInMeters, true);

                        }

                        break;

                }

            }

            data.setSegmentsGeometry(segments);

            data.setHolesGeometry(holes);

        } catch (Exception ex) {

            LOGGER.warn("Can't calculate geometries.", ex);

//            Logger.getLogger(DefaultUrbanHorizontalSignageManager.class.getName()).log(Level.SEVERE, null, ex);

        }

    }

    protected void addOffsetedAndBufferedSegment(MultiPolygon segments, Line segment, final double offsetValueInMeters, final double bufferValueInMeters, boolean roundVertex) throws GeometryOperationException, GeometryOperationNotSupportedException {

        Geometry buffer;

        final int joinStyle = roundVertex ? JOIN_STYLE_ROUND : JOIN_STYLE_MITRE;

        Geometry segmentOffset = segment.cloneGeometry().offset(

                joinStyle,

                offsetValueInMeters

        );

        if(segmentOffset == null){

            return;

        }

        buffer = segmentOffset.buffer(bufferValueInMeters, joinStyle,

                true

        );

        segments.addPrimitives(buffer);

    }

    /*

        segmentLength & holesLenght in meters

    */

    /*friend*/SplittedLine splitLine(Line line, double segmentLength, double holesLength) throws CreateGeometryException, GeometryOperationNotSupportedException, GeometryOperationException, CloneNotSupportedException {

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        SplittedLine res = new SplittedLine();

        Point previousPoint = null;

        double previousLength = 0;

        Line currentSegment = geomManager.createLine(line.getGeometryType().getSubType());

        boolean isHole = false;

        boolean advanceToNext = true;

        Iterator<Point> it = line.iterator();

        Point currentPoint = null;

        while (it.hasNext() || !advanceToNext) {

            if (advanceToNext) {

                currentPoint = it.next();

            }

            if (previousPoint == null) {

                previousPoint = currentPoint.clone();

                currentSegment.addVertex(previousPoint);

                advanceToNext = true;

                continue;

            }

            double distance = previousPoint.distance(currentPoint);

            if (!isHole) {

                if (previousLength + distance < segmentLength) {

                    previousLength += distance;

                    if(distance > 0.0){

                        currentSegment.addVertex(currentPoint);

                    }

                    previousPoint = currentPoint.cloneGeometry();

                    advanceToNext = true;

                    continue;

                } else {

                    //buscar punto dentro del segmento a una distancia = segmentLengthMeters-previousLength

                    Point point = calculateIntermediatePoint(previousPoint, currentPoint, (segmentLength - previousLength) / distance);

                    //a?adirlo al currentSegment,

                    currentSegment.addVertex(point);

                    //a?adir  el currentSegment a la lista de segmentos

                    res.addSegment(currentSegment.cloneGeometry());

                    //crear un nuevo currentSegment y meter el punto como primero

                    currentSegment = geomManager.createLine(line.getGeometryType().getSubType());

                    currentSegment.addVertex(point);

                    //cambiar modo ==> isHole = true

                    isHole = !isHole;

                    previousPoint = point.clone();

                    previousLength = 0;

                    advanceToNext = false;

                    continue;

                }

            } else {

                if (previousLength + distance < holesLength) {

                    previousLength += distance;

                    if(distance > 0.0){

                        currentSegment.addVertex(currentPoint);

                    }

                    previousPoint = currentPoint.cloneGeometry();

                    advanceToNext = true;

                    continue;

                } else {

                    //buscar punto dentro del segmento a una distancia = segmentLengthMeters-previousLength

                    Point point = calculateIntermediatePoint(previousPoint, currentPoint, (holesLength - previousLength) / distance);

                    //a?adirlo al currentSegment,

                    currentSegment.addVertex(point);

                    //a?adir  el surrentSegment a la lista de segmentos

                    res.addHole(currentSegment.cloneGeometry());

                    //crear un nuevo currentSegment y meter el punto como primero

                    currentSegment = geomManager.createLine(line.getGeometryType().getSubType());

                    currentSegment.addVertex(point);

                    //Cambiar modo Segment <==> Hole

                    isHole = !isHole;

                    previousPoint = point.clone();

                    previousLength = 0;

                    advanceToNext = false;

                    continue;

                }

            }

        }

//        currentSegment.addVertex(currentPoint);

        if (currentSegment.getNumVertices() > 1) {

            if (isHole) {

                res.addHole(currentSegment.cloneGeometry());

            } else {

                res.addSegment(currentSegment.cloneGeometry());

            }

        }

        return res;

    }

    Point calculateIntermediatePoint(Point p1, Point p2, double lambda) throws CreateGeometryException, GeometryOperationNotSupportedException, GeometryOperationException {

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        GeometryType geomType = p1.getGeometryType();

        int subtype = geomType.getSubType();

        int dimension = geomType.getDimension();

        double[] coords = new double[dimension];

        Point p = geomManager.createPoint(0, 0, subtype);

        double distance = p1.distance(p2);

        for (int d = 0; d < dimension; d++) {

            p.setCoordinateAt(

                    d,

                    p1.getCoordinateAt(d) + (p2.getCoordinateAt(d) - p1.getCoordinateAt(d)) * lambda);

        }

        return p;

    }

    /*friend*/ static class SplittedLine {

        List<Line> segments;

        List<Line> holes;

        public SplittedLine() {

            segments = new ArrayList<>();

            holes = new ArrayList<>();

        }

        public List<Line> getSegments() {

            return this.segments;

        }

        public List<Line> getHoles() {

            return this.holes;

        }

        public void addSegment(Line segment) {

            this.segments.add(segment);

        }

        public void addHole(Line hole) {

            this.holes.add(hole);

        }

    }

    public FeatureStore convertLinesToPolygons(FeatureSet sourceFeatureSet, UrbanHorizontalSignageConfig config, SimpleTaskStatus status) {

        //TODO: el status....

                UrbanHorizontalSignageManager uhsManager = UrbanHorizontalSignageLocator.getUrbanHorizontalSignageManager();

        EditableFeatureType targetFeatureType = createTargetFeatureType(sourceFeatureSet.getFeatureStore());

        FeatureStore targetStore = createTemporalStore(targetFeatureType);

        try {

            targetStore.edit(FeatureStore.MODE_APPEND);

            for (Feature feature : sourceFeatureSet) {

                Geometry originalGeometry = feature.getDefaultGeometry();

                UrbanHorizontalSignageData data = config.getValues(feature);

                uhsManager.calculateGeometries(originalGeometry, data);

                MultiPolygon multiGeom = data.getSegmentsGeometry();

                if (multiGeom != null && multiGeom.getPrimitivesNumber() > 0) {

                    for (Geometry geometry : multiGeom) {

                        EditableFeature targetFeature = targetStore.createNewFeature();

                        targetFeature.copyFrom(feature, (FeatureAttributeDescriptor t) -> !(t.isPrimaryKey() || (t.isIndexed() && !t.allowIndexDuplicateds()) || t.getType() == org.gvsig.fmap.geom.DataTypes.GEOMETRY));

                        targetFeature.setDefaultGeometry(geometry);

                        targetStore.insert(targetFeature);

                    }

                }

                switch (data.getContinuity()) {

                    case CONTINUITY_MODE_CONT_DISC:

                    case CONTINUITY_MODE_DISC_CONT:

                    case CONTINUITY_MODE_DISC:

                    case CONTINUITY_MODE_DISC_DISC:

                        if (data.isPaintHoles()) {

                            multiGeom = data.getHolesGeometry();

                            if (multiGeom != null && multiGeom.getPrimitivesNumber() > 0) {

                                for (Geometry geometry : multiGeom) {

                                    EditableFeature targetFeature = targetStore.createNewFeature();

                                    targetFeature.copyFrom(feature, (FeatureAttributeDescriptor t) -> !(t.isPrimaryKey() || (t.isIndexed() && !t.allowIndexDuplicateds()) || t.getType() == org.gvsig.fmap.geom.DataTypes.GEOMETRY));

                                    targetFeature.setDefaultGeometry(geometry);

                                    targetStore.insert(targetFeature);

                                }

                            }

                        }

                }

            }

            targetStore.finishEditing();

            return targetStore;

        } catch (Exception e) {

            LOGGER.debug("Can't create temporary polygons store.", e);

        }

        return null;

    }

    private EditableFeatureType createTargetFeatureType(FeatureStore store) {

        DataManager dataManager = DALLocator.getDataManager();

        EditableFeatureType featureType = dataManager.createFeatureType();

        featureType.addAll(store.getDefaultFeatureTypeQuietly());

        EditableFeatureAttributeDescriptor attr = (EditableFeatureAttributeDescriptor) featureType.getDefaultGeometryAttribute();

        attr.setGeometryType(Geometry.TYPES.POLYGON, Geometry.SUBTYPES.GEOM2D);

        return featureType;

    }

    private FeatureStore createTemporalStore(EditableFeatureType featType) {

        if (featType.getStore() != null) {

            throw new IllegalArgumentException("Can't create temporal store from a feature type of a already existent store.");

        }

        try {

            // crear ruta de archivo temporal

            FoldersManager foldersManager = ToolsLocator.getFoldersManager();

            File tempFile = foldersManager.getUniqueTemporaryFile("urbanHorizontalSignage_temporal_store_" + UUID.randomUUID().toString());

            // crear SERVER STORE

            DataManager dataManager = DALLocator.getDataManager();

            JDBCServerExplorerParameters serverParameters = (JDBCServerExplorerParameters) dataManager.createServerExplorerParameters("H2Spatial");

            ((HasAFile) serverParameters).setFile(tempFile);

            JDBCServerExplorer serverExplorer = (JDBCServerExplorer) dataManager.openServerExplorer("H2Spatial", serverParameters);

            //Crear tablas en server store

            JDBCNewStoreParameters parametersResults = serverExplorer.getAddParameters();

            parametersResults.setDynValue("Table", "results");

            parametersResults.setDefaultFeatureType(featType);

            serverExplorer.add("H2Spatial", parametersResults, true);

            DataStoreParameters storeParametersResults = dataManager.createStoreParameters("H2Spatial");

            storeParametersResults.setDynValue("database_file", tempFile);

            storeParametersResults.setDynValue("Table", "results");

            //Creaci?n del store con los resultados

            FeatureStore storeResults = (FeatureStore) dataManager.openStore("H2Spatial", storeParametersResults);

            return storeResults;

        } catch (Exception ex) {

            LOGGER.debug("Can't create temporal store.", ex);

            return null;

        }

    }

}