Application: gvSIG desktop » gvSIG Linear Reference System

/* 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.lrs.app.showmeasures;

import java.awt.Color;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.ComponentEvent;

import java.awt.event.ComponentListener;

import java.text.DecimalFormat;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import javax.swing.JOptionPane;

import org.apache.commons.lang3.StringUtils;

import org.cresques.cts.ICoordTrans;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.andami.IconThemeHelper;

import org.gvsig.andami.plugins.Extension;

import org.gvsig.app.ApplicationLocator;

import org.gvsig.app.ApplicationManager;

import org.gvsig.app.project.documents.view.ViewDocument;

import org.gvsig.app.project.documents.view.gui.IView;

import org.gvsig.fmap.dal.DataSet;

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

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

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

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

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

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

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

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

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.layers.FLayer;

import org.gvsig.fmap.mapcontext.layers.vectorial.FLyrVect;

import org.gvsig.fmap.mapcontext.layers.vectorial.GraphicLayer;

import org.gvsig.fmap.mapcontext.rendering.symbols.ISymbol;

import org.gvsig.fmap.mapcontext.rendering.symbols.SymbolManager;

import org.gvsig.gui.beans.ProgressDialog;

import org.gvsig.lrs.lib.api.LrsAlgorithm;

import org.gvsig.lrs.lib.api.LrsAlgorithmsLocator;

import org.gvsig.lrs.lib.api.LrsAlgorithmsManager;

import org.gvsig.lrs.lib.api.LrsShowMeasuresAlgorithmParams;

import org.gvsig.lrs.lib.api.exceptions.LrsGettingParametersException;

import org.gvsig.lrs.lib.api.exceptions.LrsNeededParameterException;

import org.gvsig.lrs.swing.api.JLrsAlgorithmParams;

import org.gvsig.lrs.swing.api.JLrsProgressDialog;

import org.gvsig.lrs.swing.api.LrsAlgorithmsSwingLocator;

import org.gvsig.lrs.swing.api.LrsAlgorithmsSwingManager;

import org.gvsig.lrs.swing.impl.JLrsShowMeasuresParamsController;

import org.gvsig.lrs.swing.impl.JLrsUtils;

import org.gvsig.symbology.SymbologyLocator;

import org.gvsig.symbology.SymbologyManager;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.text.ISimpleTextSymbol;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposableIterator;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.locator.LocatorException;

import org.gvsig.tools.swing.api.ToolsSwingLocator;

import org.gvsig.tools.swing.api.windowmanager.WindowManager;

import org.gvsig.tools.task.SimpleTaskStatus;

/**

 * @author dmartinez

 *

 */

public class ShowMeasuresExtension extends Extension implements ComponentListener {

    private static final Logger logger = LoggerFactory.getLogger(ShowMeasuresExtension.class);

    public static final String SHOW_MEASURES_GRAPHICS_ID = "ShowMeasures";

    private JLrsShowMeasuresParamsController panel;

    /*

     * (non-Javadoc)

     *

     * @see org.gvsig.andami.plugins.IExtension#execute(java.lang.String)

     */

    public void execute(String actionCommand) {

        if (StringUtils.equalsIgnoreCase(actionCommand, "show-measures")) {

            IView view = getActiveView();

            final MapContext mapContext = view.getMapControl().getMapContext();

            final GraphicLayer graphics = mapContext.getGraphicsLayer();

            final FLyrVect activeLayer = getActiveLayer(view);

            final WindowManager winManager = ToolsSwingLocator.getWindowManager();

            final LrsAlgorithmsSwingManager manager = LrsAlgorithmsSwingLocator.getLrsAlgorithmsSwingManager();

            final I18nManager i18nManager = ToolsLocator.getI18nManager();

            try {

                panel =

                    (JLrsShowMeasuresParamsController) manager.createJLrsShowMeasuresAlgorithmParameters(activeLayer,

                        null);

                panel.addComponentListener(this);

            } catch (LrsNeededParameterException e2) {

                logger.error("Error creating panel", e2);

                JOptionPane.showMessageDialog(

                    null,

                    new StringBuilder().append(i18nManager.getTranslation("error_creating_panel")).append(":")

                        .append(e2.getLocalizedMessage()), i18nManager.getTranslation("error"),

                    JOptionPane.ERROR_MESSAGE);

                return;

            }

            panel.setVisibleAceptCancel(true);

            panel.addActionListener(new ActionListener() {

                public void actionPerformed(ActionEvent e) {

                    JLrsAlgorithmParams panel = (JLrsAlgorithmParams) e.getSource();

                    if (panel.isCanceled()) {

                        return;

                    }

                    LrsShowMeasuresAlgorithmParams params = null;

                    try {

                        params = (LrsShowMeasuresAlgorithmParams) panel.getParams();

                    } catch (LrsGettingParametersException e1) {

                        logger.error("Error getting parameters", e1);

                        JOptionPane.showMessageDialog(

                            null,

                            new StringBuilder().append(i18nManager.getTranslation("error_getting_parameters"))

                                .append(":").append(e1.getLocalizedMessage()), i18nManager.getTranslation("error"),

                            JOptionPane.ERROR_MESSAGE);

                        return;

                    } catch (LrsNeededParameterException e1) {

                        logger.warn("Error getting parameters", e1);

                        JOptionPane.showMessageDialog(null, i18nManager.getTranslation(e1.getMessage()),

                            i18nManager.getTranslation("warning"), JOptionPane.WARNING_MESSAGE);

                        return;

                    }

                    final SimpleTaskStatus taskStatus =

                        ToolsLocator.getTaskStatusManager().createDefaultSimpleTaskStatus(

                            i18nManager.getTranslation("progress"));

                    final JLrsProgressDialog progressDialog = manager.createJLrsProgressDialog(taskStatus);

                    winManager.showWindow(progressDialog.asJComponent(), i18nManager.getTranslation("show_measures"),

                        WindowManager.MODE.WINDOW);

                    final double distance = params.getDistance();

                    Thread task = new Thread(new Runnable() {

                        public void run() {

                            try {

                                showMeasures(graphics, activeLayer, distance, taskStatus);

                                mapContext.invalidate();

                                if(!taskStatus.isRunning() && progressDialog.asJComponent().isVisible()){

                                    progressDialog.asJComponent().setVisible(false);

                                }

                            } catch (Exception e) {

                                logger.error("Error showing measures", e);

                                String message = e.getMessage();

                                if (e.getCause() != null) {

                                    message = e.getCause().getMessage();

                                }

                                JOptionPane.showMessageDialog(progressDialog.asJComponent(), message,

                                    i18nManager.getTranslation("show_measures"), JOptionPane.ERROR_MESSAGE);

                            }

                        }

                    });

                    task.start();

                }

            });

            winManager.showWindow(panel.asJComponent(), i18nManager.getTranslation("show_measures"),

                WindowManager.MODE.WINDOW);

        }

    }

    /*

     * (non-Javadoc)

     *

     * @see org.gvsig.andami.plugins.IExtension#initialize()

     */

    public void initialize() {

        registerIcons();

    }

    /*

     * (non-Javadoc)

     *

     * @see org.gvsig.andami.plugins.IExtension#isEnabled()

     */

    public boolean isEnabled() {

        IView view = getActiveView();

        FLyrVect activeLayer = getActiveLayer(view);

        if (panel == null && activeLayer != null) {

            return JLrsUtils.hasMLayersWithSelectedFeatures(activeLayer);

        }

        return false;

    }

    /*

     * (non-Javadoc)

     *

     * @see org.gvsig.andami.plugins.IExtension#isVisible()

     */

    public boolean isVisible() {

        return true;

    }

    private void registerIcons() {

        IconThemeHelper.registerIcon("lrs", "pk_green", this);

    }

    /*

     * Shows measurements along the selected features in a layer with a fixed spacing

     *

     */

    private void showMeasures(GraphicLayer graphics, FLyrVect layer, double distance, SimpleTaskStatus taskStatus)

        throws DataException, CreateGeometryException, LocatorException {

        FeatureStore featureStore = layer.getFeatureStore();

        FeatureSelection selection = featureStore.getFeatureSelection();

        if (selection != null && !selection.isEmpty()) {

            long range = getRange(selection);

            taskStatus.setRangeOfValues(0, range);

            long curValue = 0;

            taskStatus.setCurValue(curValue);

            DisposableIterator it = selection.fastIterator();

            ICoordTrans ct = layer.getCoordTrans();

            while (it.hasNext()) {

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

                Geometry geometry = feature.getDefaultGeometry();

                if (geometry instanceof Line) {

                    curValue = showLineMeasures(graphics, curValue, (Line) geometry, distance, ct);

                    taskStatus.setCurValue(curValue);

                } else if (geometry instanceof MultiLine) {

                    MultiLine multiLine = (MultiLine) geometry;

                    int primitives = multiLine.getPrimitivesNumber();

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

                        curValue = showLineMeasures(graphics, curValue, (Line) multiLine.getPrimitiveAt(i), distance, ct);

                        taskStatus.setCurValue(curValue);

                    }

                }

            }

            it.dispose();

        }

        taskStatus.terminate();

    }

    /**

     * Shows measurements along a line with a fixed spacing

     *

     * @param curValue

     * @param ct2

     * @param taskStatus

     * @param geometry

     * @return

     * @throws LocatorException

     * @throws CreateGeometryException

     */

    private long showLineMeasures(GraphicLayer graphics, long curValue, Line line, Double distance, ICoordTrans ct) throws CreateGeometryException, LocatorException {

        long value = curValue;

        for (int i = 0; i < line.getNumVertices() - 1; i++) {

            value++;

            Point vertex = (Point) line.getVertex(i);

            double m0 = vertex.getCoordinateAt(vertex.getDimension() - 1);

            double div = m0 / distance;

            if (isMultiple(m0, distance)) {

                showMeasure(graphics, vertex, m0, ct);

            }

            Point nextVertex = line.getVertex(i + 1);

            double m1 = nextVertex.getCoordinateAt(vertex.getDimension() - 1);

            List<Double> multiples = calculateMultiplesBetweenTwoValues(distance, m0, m1);

            for (Iterator iterator = multiples.iterator(); iterator.hasNext();) {

                Double m = (Double) iterator.next();

                Point point = getPointWithMBetweenTwoVertex(m, vertex, nextVertex);

                showMeasure(graphics, point, m, ct);

            }

        }

        value++;

        return value;

    }

    /**

     * Show the m in the point p on the graphicLayer

     *

     * @param m

     * @param ct

     */

    private void showMeasure(GraphicLayer graphics, Point p, double m, ICoordTrans ct) {

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        SymbolManager symbolManager = MapContextLocator.getSymbolManager();

        ISymbol markerSymbol = symbolManager.createSymbol(Geometry.TYPES.POINT, Color.RED);

        ISimpleTextSymbol textSymbol = getTextSymbol();

        DecimalFormat formato = new DecimalFormat("0.000");

        textSymbol.setText(formato.format(m).replace(",", " + "));

        int idMarkerSymbol = graphics.addSymbol(markerSymbol);

        int idTextSymbol = graphics.addSymbol(textSymbol);

        Point clonedPoint = (Point) p.cloneGeometry();

        clonedPoint.reProject(ct);

        graphics.addGraphic(SHOW_MEASURES_GRAPHICS_ID, clonedPoint, idTextSymbol);

        graphics.addGraphic(SHOW_MEASURES_GRAPHICS_ID, clonedPoint, idMarkerSymbol);

    }

    /*

     * Creates a text symbol to be used in showMeasure

     */

    private ISimpleTextSymbol getTextSymbol(){

        SymbologyManager symbologyManager = SymbologyLocator.getSymbologyManager();

        ISimpleTextSymbol textSymbol = symbologyManager.createSimpleTextSymbol();

        textSymbol.setFontSize(10);

        return textSymbol;

    }

    /**

     * Dados dos puntos con coordenada M, calcula el punto correspondiente a la m dada.

     *

     * @param m

     * @param vertex

     * @param nextVertex

     * @return

     * @throws LocatorException

     * @throws CreateGeometryException

     */

    private Point getPointWithMBetweenTwoVertex(Double m, Point vertex, Point nextVertex) throws CreateGeometryException, LocatorException {

        Point point = (Point)GeometryLocator.getGeometryManager().create(Geometry.TYPES.POINT, Geometry.SUBTYPES.GEOM2D);

        point.setX(

            getCoordinateBetweenTwoValues(

                m,

                vertex.getCoordinateAt(vertex.getDimension()-1),

                nextVertex.getCoordinateAt(vertex.getDimension()-1),

                vertex.getX(),

                nextVertex.getX()));

        point.setY(

            getCoordinateBetweenTwoValues(

                m,

                vertex.getCoordinateAt(vertex.getDimension()-1),

                nextVertex.getCoordinateAt(vertex.getDimension()-1),

                vertex.getY(),

                nextVertex.getY()));

        return point;

    }

    /**

     * Dados los valores en una dimensi?n de dos puntos y sus "m" correspondientes,

     * calcula el valor en esa dimensi?n correspondiente a la "m" dada.

     *

     * @param m

     * @param m1

     * @param m2

     * @param v1

     * @param v2

     * @return

     */

    private double getCoordinateBetweenTwoValues(double m, double m1, double m2, double v1, double v2) {

        if (v1==v2){

            return Double.POSITIVE_INFINITY;

        }

         return ((v2-v1)*(m-m1)/(m2-m1))+v1;

    }

    /**

     * Calcula los m?ltiplos de "distance" que existen entre los valores "value0" y "value1"

     *

     * @param distance

     * @param value0

     * @param value1

     * @return

     */

    private List<Double> calculateMultiplesBetweenTwoValues(Double distance, double value0, double value1) {

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

        double v0;

        double v1;

        if(value0<=value1){

            v0 = value0;

            v1 = value1;

        } else {

            v0 = value1;

            v1 = value0;

        }

        int factor1 = (int) Math.ceil(v0/distance);

        int factor2 = (int) Math.floor(v1/distance);

            for (int factor = factor1; factor <= factor2; factor++) {

                double m = factor * distance;

                if(m>=v0 && m<=v1){

                    result.add(m);

                }

            }

        return result;

    }

    /**

     * Calcula si el valor del par?metro n es m?ltiplo del valor del par?metro d

     * @param n

     * @param d

     */

    private boolean isMultiple(double n, double d) {

        double div = n / d;

        return ((div - (int) div) < 0.000001);

    }

    /**

     * @param selection

     * @throws DataException

     */

    private long getRange(FeatureSelection selection) throws DataException {

        long range = 0;

        DisposableIterator it = selection.fastIterator();

        while (it.hasNext()) {

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

            Geometry geometry = feature.getDefaultGeometry();

            if (geometry instanceof Line) {

                range += ((Line) geometry).getNumVertices();

            } else if (geometry instanceof MultiLine) {

                MultiLine multiLine = (MultiLine) geometry;

                int primitives = multiLine.getPrimitivesNumber();

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

                    range += ((Line) multiLine.getPrimitiveAt(i)).getNumVertices();

                }

            }

        }

        it.dispose();

        return range;

    }

    private IView getActiveView() {

        ApplicationManager application = ApplicationLocator.getManager();

        IView view = (IView) application.getActiveComponent(ViewDocument.class);

        return view;

    }

    private FLyrVect getActiveLayer(IView vista) {

        if (vista != null) {

            ViewDocument viewDocument = vista.getViewDocument();

            FLayer[] actives = viewDocument.getMapContext().getLayers().getActives();

            if ((actives.length == 1) && (actives[0] instanceof FLyrVect)) {

                return (FLyrVect) actives[0];

            }

        }

        return null;

    }

    /*

     * (non-Javadoc)

     *

     * @see java.awt.event.ComponentListener#componentResized(java.awt.event.

     * ComponentEvent)

     */

    public void componentResized(ComponentEvent e) {

        // TODO Auto-generated method stub

    }

    /*

     * (non-Javadoc)

     *

     * @see

     * java.awt.event.ComponentListener#componentMoved(java.awt.event.ComponentEvent

     * )

     */

    public void componentMoved(ComponentEvent e) {

        // TODO Auto-generated method stub

    }

    /*

     * (non-Javadoc)

     *

     * @see

     * java.awt.event.ComponentListener#componentShown(java.awt.event.ComponentEvent

     * )

     */

    public void componentShown(ComponentEvent e) {

        // TODO Auto-generated method stub

    }

    /*

     * (non-Javadoc)

     *

     * @see java.awt.event.ComponentListener#componentHidden(java.awt.event.

     * ComponentEvent)

     */

    public void componentHidden(ComponentEvent e) {

        panel = null;

    }

}