Revision: 5884
http://sourceforge.net/p/jump-pilot/code/5884
Author: ma15569
Date: 2018-06-21 07:45:30 +0000 (Thu, 21 Jun 2018)
Log Message:
-----------
Prepearing to upgrade ProfileGraph plugin: added classes to compute profile
data and GUI
Modified Paths:
--------------
core/trunk/src/org/openjump/core/ui/plugin/raster/ProfileUtils.java
Added Paths:
-----------
core/trunk/src/org/openjump/core/ui/plugin/raster/ProfileGraphAlgorithms.java
core/trunk/src/org/openjump/core/ui/plugin/raster/ProfileGraphGUI.java
Added:
core/trunk/src/org/openjump/core/ui/plugin/raster/ProfileGraphAlgorithms.java
===================================================================
---
core/trunk/src/org/openjump/core/ui/plugin/raster/ProfileGraphAlgorithms.java
(rev 0)
+++
core/trunk/src/org/openjump/core/ui/plugin/raster/ProfileGraphAlgorithms.java
2018-06-21 07:45:30 UTC (rev 5884)
@@ -0,0 +1,152 @@
+package org.openjump.core.ui.plugin.raster;
+
+public class ProfileGraphAlgorithms {
+
+ private int m_iCount;
+ private double m_dZMin, m_dZMax, m_dPlanetLenght, m_dTerrainLength;
+ private final double totTime;
+ private double m_dSlopeAll;
+ private double[] doubleZ;
+ private double[] doublePlanet;
+ private double[] doubleTerrain;
+
+ private double[] doubleRelativeSlope;
+ private double[] doubleAbsoluteSlope;
+
+ public ProfileGraphAlgorithms() {
+ m_iCount = 0;
+ doubleZ = new double[] { 0 };
+ doublePlanet = new double[] { 0 };
+ m_dZMin = Double.MAX_VALUE;
+ totTime = 0.0D;
+ m_dZMax = Double.NEGATIVE_INFINITY;
+ ;
+
+ m_dSlopeAll = 0.0D;
+ m_dPlanetLenght = 0.0D;
+ m_dTerrainLength = 0.0D;
+ doubleTerrain = new double[] { 0 };
+ doubleRelativeSlope = new double[] { 0 };
+ doubleAbsoluteSlope = new double[] { 0 };
+
+ }
+
+ public void calculateValues(double[][] dataTableDouble)
+ // , double velFlat,
+ // double velUp, double velDown)
+ {
+ doubleZ = new double[dataTableDouble.length];
+ doublePlanet = new double[dataTableDouble.length];
+ doubleTerrain = new double[dataTableDouble.length];
+ doubleRelativeSlope = new double[dataTableDouble.length];
+ doubleAbsoluteSlope = new double[dataTableDouble.length];
+ for (int i = 0; i < dataTableDouble.length; i++) {
+ m_iCount++;
+ doubleZ[i] = ((Double) dataTableDouble[i][1]).doubleValue();
+ doublePlanet[i] = ((Double) dataTableDouble[i][0]).doubleValue();
+ m_dZMax = Math.max(m_dZMax, doubleZ[i]);// doubleZ[0];
+ m_dPlanetLenght = doublePlanet[doublePlanet.length - 1];
+ m_dZMin = Math.min(m_dZMin, doubleZ[i]);
+ if (i == 0) {
+ doubleTerrain[i] = 0;
+ doubleRelativeSlope[i] = 0;
+ doubleAbsoluteSlope[i] = 0;
+ } else {
+ final double dDist1 = ((Double) dataTableDouble[i][0])
+ .doubleValue();
+ final double dDist0 = ((Double) dataTableDouble[i - 1][0])
+ .doubleValue();
+ final double Z1 = ((Double) dataTableDouble[i][1])
+ .doubleValue();
+ final double Z0 = ((Double) dataTableDouble[i - 1][1])
+ .doubleValue();
+ doubleTerrain[i] = Math.sqrt(Math.pow(Z1 - Z0, 2)
+ + Math.pow(dDist1 - dDist0, 2))
+ + doubleTerrain[i - 1];
+ m_dTerrainLength = doubleTerrain[doubleTerrain.length - 1];
+ final double slope = Math.atan(((Z1 - Z0) / (dDist1 -
dDist0)));
+ doubleRelativeSlope[i] = Math.toDegrees(slope);
+ m_dSlopeAll += doubleRelativeSlope[i];
+ if (slope > 0 || slope == 0) {
+ doubleAbsoluteSlope[i] = doubleRelativeSlope[i];
+ } else if (slope < 0) {
+ doubleAbsoluteSlope[i] = doubleRelativeSlope[i] * -1;
+ }
+ }
+
+ /*
+ * if (doubleRelativeSlope[i] < 1.7184 && doubleRelativeSlope[i] >
+ * -1.7184 && doubleTerrain[i] != 0) { // Flat totTime +=
+ * ((doubleTerrain[i] - doubleTerrain[i - 1]) / 1000) (1 /
velFlat);
+ * } else if (doubleRelativeSlope[i] > 1.7184 && doubleTerrain[i]
!=
+ * 0) { // Up totTime += ((doubleTerrain[i] - doubleTerrain[i - 1])
+ * / 1000) (1 / velUp); } else if (doubleRelativeSlope[i] < 1.7184
+ * && doubleTerrain[i] != 0) { // Down totTime +=
((doubleTerrain[i]
+ * - doubleTerrain[i - 1]) / 1000) (1 / velDown);
+ *
+ * }
+ */
+
+ }
+
+ }
+
+ public double getTime() {
+ return totTime;
+ }
+
+ public double getSlope() {
+ return m_dSlopeAll / (m_iCount - 1);
+ }
+
+ public double[] getRelativeSlopeData() {
+ return doubleRelativeSlope;
+ }
+
+ public double[] getAbsoluteSlopeData() {
+ return doubleAbsoluteSlope;
+ }
+
+ public double[] getZData() {
+ return doubleZ;
+ }
+
+ public double[] getPlanetData() {
+ return doublePlanet;
+ }
+
+ public double[] getTerrainData() {
+ return doubleTerrain;
+ }
+
+ public int getCount() {
+
+ return m_iCount;
+
+ }
+
+ public double getZMin() {
+
+ return m_dZMin;
+
+ }
+
+ public double getTerrainLength() {
+
+ return m_dTerrainLength;
+
+ }
+
+ public double getPlanetLength() {
+
+ return m_dPlanetLenght;
+
+ }
+
+ public double getZMax() {
+
+ return m_dZMax;
+
+ }
+
+}
Property changes on:
core/trunk/src/org/openjump/core/ui/plugin/raster/ProfileGraphAlgorithms.java
___________________________________________________________________
Added: svn:mime-type
## -0,0 +1 ##
+text/plain
\ No newline at end of property
Added: core/trunk/src/org/openjump/core/ui/plugin/raster/ProfileGraphGUI.java
===================================================================
--- core/trunk/src/org/openjump/core/ui/plugin/raster/ProfileGraphGUI.java
(rev 0)
+++ core/trunk/src/org/openjump/core/ui/plugin/raster/ProfileGraphGUI.java
2018-06-21 07:45:30 UTC (rev 5884)
@@ -0,0 +1,757 @@
+package org.openjump.core.ui.plugin.raster;
+
+import java.awt.BorderLayout;
+import java.awt.Color;
+import java.awt.ComponentOrientation;
+import java.awt.Dimension;
+import java.awt.FlowLayout;
+import java.awt.Font;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.KeyEvent;
+import java.io.IOException;
+import java.text.DecimalFormat;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+import javax.swing.JButton;
+import javax.swing.JInternalFrame;
+import javax.swing.JLabel;
+import javax.swing.JLayeredPane;
+import javax.swing.JOptionPane;
+import javax.swing.JPanel;
+import javax.swing.JTable;
+import javax.swing.JTextField;
+import javax.swing.table.DefaultTableModel;
+
+import org.math.plot.plotObjects.Line;
+import org.math.plot.plots.Plot;
+import org.math.plot.render.AbstractDrawer;
+import org.openjump.core.rasterimage.RasterImageLayer;
+import org.openjump.core.ui.plot.Plot2DPanelOJ;
+import org.openjump.sextante.core.ObjectAndDescription;
+import org.openjump.sextante.gui.additionalResults.AdditionalResults;
+import org.openjump.sextante.gui.additionalResults.AdditionalResultsFrame;
+
+import com.vividsolutions.jts.geom.Coordinate;
+import com.vividsolutions.jts.geom.Geometry;
+import com.vividsolutions.jts.geom.GeometryFactory;
+import com.vividsolutions.jts.geom.LineString;
+import com.vividsolutions.jts.geom.Point;
+import com.vividsolutions.jump.I18N;
+import com.vividsolutions.jump.feature.AttributeType;
+import com.vividsolutions.jump.feature.BasicFeature;
+import com.vividsolutions.jump.feature.Feature;
+import com.vividsolutions.jump.feature.FeatureCollection;
+import com.vividsolutions.jump.feature.FeatureDataset;
+import com.vividsolutions.jump.feature.FeatureSchema;
+import com.vividsolutions.jump.workbench.JUMPWorkbench;
+import com.vividsolutions.jump.workbench.model.StandardCategoryNames;
+import com.vividsolutions.jump.workbench.ui.HTMLFrame;
+import com.vividsolutions.jump.workbench.ui.HTMLPanel;
+import com.vividsolutions.jump.workbench.ui.JTablePanel;
+import com.vividsolutions.jump.workbench.ui.TableFrame;
+import com.vividsolutions.jump.workbench.ui.WorkbenchFrame;
+import com.vividsolutions.jump.workbench.ui.images.IconLoader;
+
+public class ProfileGraphGUI {
+
+ private final static String NAME = I18N
+
.get("org.openjump.core.ui.plugin.raster.ProfileGraphPlugIn.Profile-Graph");
+ public final String LAYER_NAME = I18N
+
.get("org.openjump.core.ui.plugin.raster.RasterImageLayerPropertiesPlugIn.layer_name");
+ public final static String MIN = I18N
+
.get("org.openjump.core.ui.plugin.tools.JoinAttributesSpatiallyPlugIn.minimum");
+ public final static String MEAN = I18N
+
.get("org.openjump.core.ui.plugin.tools.statistics.StatisticOverViewTableModel.mean-mode");
+ public final static String MAX = I18N
+
.get("org.openjump.core.ui.plugin.tools.JoinAttributesSpatiallyPlugIn.maximum");
+ public final static String SUM = I18N
+
.get("org.openjump.core.ui.plugin.tools.JoinAttributesSpatiallyPlugIn.sum");
+ public final static String CELL_SIZE = I18N
+
.get("org.openjump.core.ui.plugin.raster.RasterImageLayerPropertiesPlugIn.dimension_cell");
+ public final static String PLOT = I18N
+
.get("org.openjump.core.ui.plugin.raster.ProfileGraphTool.Profile-Plot");
+ public final static String PROFILEPTS = I18N
+
.get("org.openjump.core.ui.plugin.raster.ProfileGraphTool.profile-pts");
+ public final static String PROFILE_INFO = I18N
+
.get("org.openjump.core.ui.plugin.layer.LayerPropertiesPlugIn.Info");
+ public final static String PROFILE_LENGTH = I18N
+
.get("org.openjump.core.ui.plugin.raster.ProfileGraphTool.Profile-length");
+ public final static String STARTING_POINT = I18N
+
.get("org.openjump.core.ui.plugin.raster.ProfileGraphTool.starting-point");
+ public final static String ENDING_POINT = I18N
+
.get("org.openjump.core.ui.plugin.raster.ProfileGraphTool.ending-point");
+ public final static String MEAN_SLOPE = I18N
+
.get("org.openjump.core.ui.plugin.raster.ProfileGraphTool.mean-slope");
+ public final static String TIMES = I18N
+
.get("org.openjump.core.ui.plugin.raster.ProfileGraphTool.Travel-time");
+ public final static String SLOPE = I18N
+ .get("org.openjump.core.ui.plugin.raster.ProfileGraphTool.Slope");
+ public final static String DEGREES = I18N
+
.get("org.openjump.core.ui.plugin.edittoolbox.cursortools.degrees");
+ public final static String TABLE_VIEW = I18N
+
.get("org.openjump.core.ui.plugin.queries.SimpleQuery.display-the-table");
+
+ public final static String RELATIVE_SLOPE = I18N
+
.get("org.openjump.core.ui.plugin.raster.ProfileGraphTool.Relative-slope");
+ public final static String ABSOLUTE_SLOPE = I18N
+
.get("org.openjump.core.ui.plugin.raster.ProfileGraphTool.Absolute-slope");
+ public final static String TYPE_SLOPE = I18N
+
.get("org.openjump.core.ui.plugin.raster.ProfileGraphTool.Choose-slope-profile");
+ public final static String HOURS = I18N.get("ui.GenericNames.hours");
+ public final static String MINUTES = I18N.get("ui.GenericNames.minutes");
+ public final static String FLAT = I18N.get("ui.GenericNames.flat");
+ public final static String UPHILL = I18N.get("ui.GenericNames.uphill");
+ public final static String DOWNHILL = I18N.get("ui.GenericNames.downhill");
+ public final static String CALCULATE_TIMES = I18N
+
.get("org.openjump.core.ui.plugin.raster.ProfileGraphTool.calculate-travel-time");
+
+ public final static String UNIT = I18N
+
.get("org.openjump.core.ui.plugin.file.ProjectInfoPlugIn.srs-unit");
+
+ public final static String TIMES_TOOLTIP = I18N
+
.get("org.openjump.core.ui.plugin.raster.ProfileGraphTool.travel-time-tooltip");
+
+ public static WorkbenchFrame wFrame = JUMPWorkbench.getInstance()
+ .getFrame();
+
+ public static RasterImageLayer getLayer() {
+ return ProfileGraphPlugIn.dialog
+ .getRasterLayer(ProfileGraphPlugIn.CLAYER);
+
+ }
+
+ public static int getBand() {
+ return ProfileGraphPlugIn.numband;
+
+ }
+
+ public static GeometryFactory gf = new GeometryFactory();
+ public static FeatureCollection resultFC = null;
+ public static FeatureSchema resultFSchema = null;
+ public static String htmlString;
+ public static double dDist = 0, dHorzDist = 0, dSlope = 0, dY = 0;
+ public static double m_dLastX, m_dLastY, m_dLastZ;
+ public static int nPoints = 0;
+ public static int n = 0;
+ public static ArrayList<Coordinate> coordinates = new
ArrayList<Coordinate>();
+ public static String layerUnit = "";
+ public static String unit = "";
+ public static String speedUnit = "";
+ public static double unitConvert;
+ protected static Font darkLabelFont = AbstractDrawer.DEFAULT_FONT;
+ public static String HEIGHT;
+ public static String WIDTH;
+
+ public static void calculateProfile(Coordinate[] coords)
+ throws IOException, RasterImageLayer.RasterDataNotFoundException {
+
+ final RasterImageLayer rLayer = getLayer();
+ // Workaround to consider also maps unit as foot
+ // In this case: kilometre per hour -> mile per hour
+ // and 1000 m ->5280 ft
+ layerUnit = ProfileGraphPlugIn.UNIT;
+
+ if (layerUnit.equals("foot") || layerUnit.equals("US survey foot")) {
+ speedUnit = " [mi/h]";
+ unitConvert = 5280;
+ unit = " [ft]";
+ } else if (layerUnit.equals("metre")) {
+ speedUnit = " [km/h]";
+ unitConvert = 1000.00;
+ unit = " [m]";
+
+ } else if (layerUnit.equals("Unknown")) {
+ speedUnit = " ?[km/h]";
+ unitConvert = 1000.00;
+ unit = " ?[m]";
+ } else if (layerUnit.equals("degree")) {
+ speedUnit = " [arc-second/h]";
+ unitConvert = 0.00027777777;// =1\xB0/3600
+ unit = " [deg]";
+ }
+
+ else {
+ speedUnit = " [" + "layerUnit" + "]/h]";
+ unitConvert = 0;
+ unit = " [" + "layerUnit" + "]";
+ }
+ HEIGHT = ProfileGraphPlugIn.HEIGHT;
+ WIDTH = ProfileGraphPlugIn.WIDTH;
+ final LineString line = gf.createLineString(coords);
+ if (line.within(rLayer.getWholeImageEnvelopeAsGeometry())) {
+ final Random rand = new Random();
+
+ n = rand.nextInt(100) + 1;
+ processLine(line);
+ if ((resultFC != null) && (resultFC.size() > 0)) {
+ final FeatureDataset fd = new FeatureDataset(resultFSchema);
+ fd.addAll(resultFC.getFeatures());
+ wFrame.getContext()
+ .getLayerManager()
+ .addLayer(StandardCategoryNames.RESULT,
+ PLOT + "-" + n + " " + PROFILEPTS, fd);
+
+ }
+ AdditionalResults.addAdditionalResultAndShow(PLOT + "-" + n,
+ getPlotPanel(resultFC, "" + n));
+
+ } else {
+ wFrame.getContext()
+ .getLayerViewPanel()
+ .getContext()
+ .warnUser(
+ "Query outside the extension of selected Raster
layer");
+ }
+ }
+
+ protected static Coordinate[] toArray(List<Coordinate> coordinates) {
+ return coordinates.toArray(new Coordinate[] {});
+ }
+
+ public static void processSegment(double x, double y, double x2, double y2)
+ throws RasterImageLayer.RasterDataNotFoundException, IOException {
+ double dx, dy, d, n;
+ dx = Math.abs(x2 - x);
+ dy = Math.abs(y2 - y);
+ if (dx > 0.0 || dy > 0.0) {
+ if (dx > dy) {
+ dx /= getLayer().getMetadata().getOriginalCellSize();//
this.rstLayer.getWindowCellSize().x;
+ n = dx;
+ dy /= dx;
+ dx = getLayer().getMetadata().getOriginalCellSize();//
this.rstLayer.getWindowCellSize().x;
+ } else {
+ dy /= getLayer().getMetadata().getOriginalCellSize();//
this.rstLayer.getWindowCellSize().y;
+ n = dy;
+ dx /= dy;
+ dy = getLayer().getMetadata().getOriginalCellSize();//
this.rstLayer.getWindowCellSize().y;
+ }
+ if (x2 < x) {
+ dx = -dx;
+ }
+ if (y2 < y) {
+ dy = -dy;
+ }
+ for (d = 0.0; d <= n; d++, x += dx, y += dy) {
+ addPoint(x, y);
+ }
+ }
+ }
+
+ public static void processLine(Geometry line) throws IOException,
+ RasterImageLayer.RasterDataNotFoundException {
+ double x, y, x2, y2;
+ final Coordinate[] coords = line.getCoordinates();
+ for (int i = 0; i < coords.length - 1; i++) {
+ x = coords[i].x;
+ y = coords[i].y;
+ x2 = coords[i + 1].x;
+ y2 = coords[i + 1].y;
+ processSegment(x, y, x2, y2);
+ }
+ // Giuseppe Aruta (2018-4-17) Missing last point of the profile
+ addPoint(coords[coords.length - 1].x, coords[coords.length - 1].y);
+ }
+
+ public static void addPoint(double x, double y)
+ throws RasterImageLayer.RasterDataNotFoundException, IOException {
+ if (resultFSchema == null) {
+ resultFSchema = new FeatureSchema();
+ resultFSchema.addAttribute("geometry", AttributeType.GEOMETRY);
+ resultFSchema.addAttribute("X", AttributeType.DOUBLE);
+ resultFSchema.addAttribute("Y", AttributeType.DOUBLE);
+ resultFSchema.addAttribute("Z", AttributeType.DOUBLE);
+ resultFSchema.addAttribute("PlaneDist", AttributeType.DOUBLE);
+ resultFSchema.addAttribute("TerrainDist", AttributeType.DOUBLE);
+ resultFC = new FeatureDataset(resultFSchema);
+ }
+ double z;
+ double dDX, dDY, dDZ;
+
+ z = getLayer().getCellValue(x, y, getBand());
+
+ if (nPoints == 0) {
+ dDist = 0.0;
+ dHorzDist = 0.0;
+ } else {
+
+ dDX = x - m_dLastX;
+ dDY = y - m_dLastY;
+ if (z == getLayer().getNoDataValue()
+ || m_dLastZ == getLayer().getNoDataValue()) {
+ dDZ = 0.0;
+ } else {
+ dDZ = z - m_dLastZ;
+ }
+ dDist += Math.sqrt(dDX * dDX + dDY * dDY);
+ dHorzDist += Math.sqrt(dDX * dDX + dDY * dDY + dDZ * dDZ);
+
+ }
+ m_dLastX = x;
+ m_dLastY = y;
+ m_dLastZ = z;
+ nPoints++;
+ final Point geometry = new GeometryFactory()
+ .createPoint(new Coordinate(x, y));
+
+ final Feature fpoint = new BasicFeature(resultFSchema);
+ fpoint.setGeometry(geometry);
+ fpoint.setAttribute("X", new Double(x));
+ fpoint.setAttribute("Y", new Double(y));
+ fpoint.setAttribute("Z", new Double(z));
+ fpoint.setAttribute("PlaneDist", new Double(dDist));
+ fpoint.setAttribute("TerrainDist", new Double(dHorzDist));
+ final Coordinate coord = new Coordinate(new Double(z), new Double(
+ dHorzDist));
+ coordinates.add(coord);
+ resultFC.add(fpoint);
+ }
+
+ public static double[][] datas2;
+
+ public static Plot2DPanelOJ getPlotPanel(FeatureCollection fc, String
name) {
+ final JPanel jPanel2 = new JPanel();
+ final JPanel jPanel3 = new JPanel();
+ final JLabel jLabel0 = new JLabel(CALCULATE_TIMES + speedUnit + ": ");
+
+ jLabel0.setToolTipText("<HTML><BODY><DIV style=\"width: 400px;
text-justification: justify;\">"
+ + TIMES_TOOLTIP + "</DIV></BODY></HTML>");
+ final JLabel jLabel1 = new JLabel();
+ final JLabel jLabel2 = new JLabel();
+ final JLabel jLabel3 = new JLabel();
+ final JLabel jLabel4 = new JLabel();
+ final JTextField jTextField_VelFlat = new JTextField();
+ final JTextField jTextField_VelUp = new JTextField();
+ final JTextField jTextField_VelDown = new JTextField();
+ jTextField_VelDown.setPreferredSize(new Dimension(50, 20));
+ jTextField_VelUp.setPreferredSize(new Dimension(50, 20));
+ jTextField_VelFlat.setPreferredSize(new Dimension(50, 20));
+
+ jTextField_VelDown.setMaximumSize(new Dimension(50, 20));
+ jTextField_VelUp.setMaximumSize(new Dimension(50, 20));
+ jTextField_VelFlat.setMaximumSize(new Dimension(50, 20));
+ jTextField_VelFlat.addKeyListener(new java.awt.event.KeyAdapter() {
+ @Override
+ public void keyTyped(KeyEvent e) {
+ final char vChar = e.getKeyChar();
+ if (!(Character.isDigit(vChar) || (vChar == KeyEvent.VK_PERIOD)
+ || (vChar == KeyEvent.VK_BACK_SPACE) || (vChar ==
KeyEvent.VK_DELETE))) {
+ e.consume();
+ }
+ }
+ });
+ jTextField_VelUp.addKeyListener(new java.awt.event.KeyAdapter() {
+ @Override
+ public void keyTyped(KeyEvent e) {
+ final char vChar = e.getKeyChar();
+ if (!(Character.isDigit(vChar) || (vChar == KeyEvent.VK_PERIOD)
+ || (vChar == KeyEvent.VK_BACK_SPACE) || (vChar ==
KeyEvent.VK_DELETE))) {
+ e.consume();
+ }
+ }
+ });
+ jTextField_VelDown.addKeyListener(new java.awt.event.KeyAdapter() {
+ @Override
+ public void keyTyped(KeyEvent e) {
+ final char vChar = e.getKeyChar();
+ if (!(Character.isDigit(vChar) || (vChar == KeyEvent.VK_PERIOD)
+ || (vChar == KeyEvent.VK_BACK_SPACE) || (vChar ==
KeyEvent.VK_DELETE))) {
+ e.consume();
+ }
+ }
+ });
+ jLabel1.setText(FLAT);
+ jLabel2.setText(UPHILL);
+ jLabel3.setText(DOWNHILL);
+ jLabel4.setText(UNIT + unit);
+ jTextField_VelFlat.setText("6");
+ jTextField_VelUp.setText("3");
+ jTextField_VelDown.setText("8");
+
+ final FlowLayout layout = new FlowLayout();
+ jPanel2.setLayout(layout);
+ layout.setAlignment(FlowLayout.LEADING);
+ jPanel2.setComponentOrientation(ComponentOrientation.LEFT_TO_RIGHT);
+
+ jPanel2.add(jLabel0);
+ jPanel2.add(jLabel1);
+ jPanel2.add(jTextField_VelFlat);
+ jPanel2.add(jLabel2);
+ jPanel2.add(jTextField_VelUp);
+
+ jPanel2.add(jLabel3);
+ jPanel2.add(jTextField_VelDown);
+ final Plot2DPanelOJ plot2dA = new Plot2DPanelOJ();
+ plot2dA.setName(name);
+ plot2dA.removeAllPlots();
+ plot2dA.plotToolBar.remove(5);
+ plot2dA.plotToolBar.remove(4);
+
+ // Build a 2D data set
+ final double[][] datas1 = new double[fc.size()][2];
+ for (int j = 0; j < fc.size(); j++) {
+ final Feature f = fc.getFeatures().get(j);
+ datas1[j][0] = (Double) f.getAttribute("PlaneDist");
+ datas1[j][1] = (Double) f.getAttribute("Z");
+ }
+
+ plot2dA.addLinePlot("Profile", datas1);
+ plot2dA.setAxisLabel(0, WIDTH + unit);
+ if (!layerUnit.equals("degree")) {
+ plot2dA.setAxisLabel(1, HEIGHT + unit);
+ } else {
+ plot2dA.setAxisLabel(1, HEIGHT);
+ }
+ plot2dA.getAxis(0).setLabelPosition(0.5, -0.15);
+ plot2dA.getAxis(1).setLabelPosition(-0.15, 0.5);
+ plot2dA.getAxis(1).setLabelAngle(-Math.PI / 2);
+
+ // Table part
+ double[][] dataTableDouble = null;
+ for (final Plot plot2 : plot2dA.getPlots()) {
+ dataTableDouble = plot2.getData();
+ }
+ final ProfileGraphAlgorithms profile = new ProfileGraphAlgorithms();
+
+ profile.calculateValues(dataTableDouble);
+ // profile.calculateValues(dataTableDouble, velFlat, velUp, velDown);
+ final double[] doubleZ = profile.getZData();
+ final double[] doublePlanet = profile.getPlanetData();
+ final double[] doubleTerrain = profile.getTerrainData();
+ final double[] doubleRelativeSlope = profile.getRelativeSlopeData();
+ final double[] doubleAbsoluteSlope = profile.getAbsoluteSlopeData();
+
+ // Buttons///////
+
+ // To generate a table with all partial values
+ final JButton tableBtn = new JButton(IconLoader.icon("Row_16.gif"));
+ tableBtn.setToolTipText(TABLE_VIEW);
+ tableBtn.addActionListener(new ActionListener() {
+ @Override
+ public void actionPerformed(ActionEvent e) {
+ final TableFrame freqFrame = new TableFrame();
+ freqFrame
+
.setDefaultCloseOperation(AdditionalResultsFrame.DISPOSE_ON_CLOSE);
+ final JInternalFrame[] frames = wFrame.getInternalFrames();
+ final ArrayList<JInternalFrame> list = new
ArrayList<JInternalFrame>();
+ for (final JInternalFrame iFrame : frames) {
+ if (iFrame instanceof TableFrame) {
+ list.add(iFrame);
+ }
+ }
+ if (list.size() == 1) {
+ freqFrame.toFront();
+ }
+
+ else {
+ final Object[] slopeData =
doubleToObject(doubleRelativeSlope);
+ final Object[] absoluteSlopeData =
doubleToObject(doubleAbsoluteSlope);
+ final Object[] zData = doubleToObject(doubleZ);
+ final Object[] planetDistData =
doubleToObject(doublePlanet);
+ final Object[] terrainDistData =
doubleToObject(doubleTerrain);
+ freqFrame.setLayout(new BorderLayout());
+ freqFrame.setResizable(true);
+ freqFrame.setClosable(true);
+ freqFrame.setIconifiable(true);
+ freqFrame.setMaximizable(true);
+ freqFrame.setPreferredSize(new Dimension(900, 450));
+ freqFrame.setSize(900, 450);
+ freqFrame.setLayer(JLayeredPane.MODAL_LAYER);
+ freqFrame.setTitle(PLOT + "-" + n);
+ final JTable jTable = new JTable();
+ final DefaultTableModel dtm = (DefaultTableModel) jTable
+ .getModel();
+ dtm.addColumn("Z", zData);
+ dtm.addColumn("PlaneDist", planetDistData);
+ dtm.addColumn("TerrainDist", terrainDistData);
+ dtm.addColumn(RELATIVE_SLOPE + " (\xB0)", slopeData);
+ dtm.addColumn(ABSOLUTE_SLOPE + " (\xB0)",
absoluteSlopeData);
+ final JTablePanel jTablePanel = new JTablePanel(dtm);
+ jTablePanel.getCommandPanel().setVisible(false);
+ freqFrame.add(jTablePanel);
+ wFrame.getContext().getWorkbench().getFrame()
+ .addInternalFrame(freqFrame, true, true);
+ }
+
+ }
+ });
+
+ // To generate a generate a profile of the slope
+ final JButton slopeBtn = new JButton(
+ IconLoader.icon("profileSlope.png"));
+ slopeBtn.setToolTipText(SLOPE);
+ slopeBtn.addActionListener(new ActionListener() {
+ @Override
+ public void actionPerformed(ActionEvent e) {
+ final JInternalFrame[] frames = wFrame.getInternalFrames();
+ final ArrayList<JInternalFrame> list = new
ArrayList<JInternalFrame>();
+ for (final JInternalFrame iFrame : frames) {
+ if (iFrame instanceof AdditionalResultsFrame) {
+ list.add(iFrame);
+ }
+ }
+ if (list.size() > 1) {
+ mosaicFrames();
+ } else {
+ String type = "";
+ final double[][] slopedt = new double[doubleZ.length][2];
+ final String[] options = { RELATIVE_SLOPE, ABSOLUTE_SLOPE
};
+ final int x = JOptionPane.showOptionDialog(null,
+ TYPE_SLOPE, NAME, JOptionPane.DEFAULT_OPTION,
+ JOptionPane.INFORMATION_MESSAGE, null, options,
+ options[0]);
+ if (x == JOptionPane.CLOSED_OPTION) {
+ return;
+ }
+ final Plot2DPanelOJ plotSlope = new Plot2DPanelOJ();
+ switch (x) {
+ case 0:
+
+ for (int j = 0; j < doubleZ.length; j++) {
+ slopedt[j][0] = doublePlanet[j];
+ slopedt[j][1] = doubleRelativeSlope[j];
+ }
+
+ type = RELATIVE_SLOPE;
+
+ break;
+
+ case 1:
+ for (int j = 0; j < doubleZ.length; j++) {
+ slopedt[j][0] = doublePlanet[j];
+ slopedt[j][1] = doubleAbsoluteSlope[j];
+ }
+ type = ABSOLUTE_SLOPE;
+ break;
+ }
+
+ plotSlope.plotToolBar.remove(5);
+ plotSlope.plotToolBar.remove(4);
+ plotSlope.setName(SLOPE);
+ plotSlope.addLinePlot(SLOPE, Color.red, slopedt);
+ plotSlope.setAxisLabel(0, WIDTH + unit);
+ plotSlope.setAxisLabel(1, type + " [" + DEGREES + "]");
+ plotSlope.getAxis(0).setLabelPosition(0.5, -0.15);
+ plotSlope.getAxis(1).setLabelPosition(-0.15, 0.5);
+ plotSlope.getAxis(1).setLabelAngle(-Math.PI / 2);
+ plotSlope.setFixedBounds(0, 0, profile.getPlanetLength());
+ plotSlope.getAxis(0)
+ .setOrigin(
+ new double[] {
+ plotSlope.plotCanvas.base
+ .getMinBounds()[0], 0 });
+ plotSlope.addPlotable(new Line(
+ Color.gray,
+ new double[] {
+
plotSlope.plotCanvas.base.getMinBounds()[0],
+ 0 },
+ new double[] {
+
plotSlope.plotCanvas.base.getMaxBounds()[0],
+ 0 }));
+ final ArrayList<ObjectAndDescription> m_Components = new
ArrayList<ObjectAndDescription>();
+ final ObjectAndDescription ob = new ObjectAndDescription(
+ SLOPE, plotSlope);
+ m_Components.add(ob);
+
+ final AdditionalResultsFrame slopeFrame = new
AdditionalResultsFrame(
+ m_Components);
+ slopeFrame.setTitle(PLOT + "-" + n + " " + SLOPE);
+ slopeFrame.setName(SLOPE);
+ slopeFrame.pack();
+
+ if (list.size() == 1) {
+ slopeFrame.setSize(plot2dA.getWidth(),
+ plot2dA.getHeight());
+ wFrame.getContext().getWorkbench().getFrame()
+ .addInternalFrame(slopeFrame, true, true);
+
+ } else {
+ slopeFrame.toFront();
+
+ }
+ mosaicFrames();
+ }
+ }
+ });
+
+ // The info panel
+ final JButton infoBtn = new JButton(
+ IconLoader.icon("information_16x16.png"));
+ infoBtn.setToolTipText(PROFILE_INFO);
+ infoBtn.addActionListener(new ActionListener() {
+ @Override
+ public void actionPerformed(ActionEvent e) {
+ final HTMLFrame frame = new HTMLFrame();
+
+ final JInternalFrame[] frames = JUMPWorkbench.getInstance()
+ .getFrame().getInternalFrames();
+ final ArrayList<JInternalFrame> list = new
ArrayList<JInternalFrame>();
+ for (final JInternalFrame iFrame : frames) {
+ if (iFrame instanceof HTMLFrame) {
+ list.add(iFrame);
+ }
+ }
+
+ if (list.size() == 1) {
+ frame.dispose();
+ }
+
+ String velFlatString = jTextField_VelFlat.getText();
+ if (velFlatString.isEmpty()) {
+ velFlatString = "0";
+ }
+ final double velFlat = Double.valueOf(velFlatString);
+
+ String velUpString = jTextField_VelUp.getText();
+ if (velUpString.isEmpty()) {
+ velUpString = "0";
+ }
+ final double velUp = Double.valueOf(velUpString);
+
+ String velDownString = jTextField_VelDown.getText();
+ if (velDownString.isEmpty()) {
+ velDownString = "0";
+ }
+
+ final double velDown = Double.valueOf(velDownString);
+ double totTime = 0;
+ for (int i = 0; i < doubleRelativeSlope.length; i++) {
+ if (doubleRelativeSlope[i] < 1.7184
+ && doubleRelativeSlope[i] > -1.7184
+ && doubleTerrain[i] != 0) {
+ // Flat
+ totTime += ((doubleTerrain[i] - doubleTerrain[i - 1])
/ unitConvert)
+ * (1 / velFlat);
+ } else if (doubleRelativeSlope[i] > 1.7184
+ && doubleTerrain[i] != 0) {
+ // Up
+ totTime += ((doubleTerrain[i] - doubleTerrain[i - 1])
/ unitConvert)
+ * (1 / velUp);
+ } else if (doubleRelativeSlope[i] < 1.7184
+ && doubleTerrain[i] != 0) {
+ // Down
+ totTime += ((doubleTerrain[i] - doubleTerrain[i - 1])
/ unitConvert)
+ * (1 / velDown);
+
+ }
+ }
+ final HTMLPanel out = new HTMLPanel();
+
+ final DecimalFormat df = new DecimalFormat("##.###");
+
+ final String totTimeHM = (int) totTime + " " + HOURS + " "
+ + (int) ((totTime - (int) totTime) * 60) + " "
+ + MINUTES;
+
+ final double min1 = profile.getZMin();
+ final double max1 = profile.getZMax();
+ final double lenght = profile.getTerrainLength();
+ final double width1 = profile.getPlanetLength();
+ final double height1 = Math.abs(max1 - min1);
+ final double slope1 = profile.getSlope();
+
+ htmlString = "<HTML><BODY>";
+ htmlString += "<h2 align=\"left\">" + PROFILE_INFO + "-" + n
+ + "</h2>";
+ htmlString += "<b><font face=\"" + darkLabelFont + "\">" + MIN
+ + ": </b>" + df.format(min1) + "<br>";
+ htmlString += "<b><font face=\"" + darkLabelFont + "\">" + MAX
+ + ": </b>" + df.format(max1) + "<br>";
+ htmlString += "<b><font face=\"" + darkLabelFont + "\">"
+ + PROFILE_LENGTH + ": </b>" + df.format(lenght)
+ + "<br>";
+ htmlString += "<b><font face=\"" + darkLabelFont + "\">"
+ + WIDTH + ": </b>" + df.format(width1) + "<br>";
+ htmlString += "<b><font face=\"" + darkLabelFont + "\">"
+ + HEIGHT + ": </b>" + df.format(height1) + "<br>";
+ htmlString += "<b><font face=\"" + darkLabelFont + "\">"
+ + MEAN_SLOPE + ": </b>" + df.format(slope1) +
"\xB0<br>";
+ if (!layerUnit.equals("degree") ||
!layerUnit.equals("UnKnown")) {
+ htmlString += "<b><font face=\"" + darkLabelFont + "\">"
+ + UNIT + " </b>" + layerUnit + "<br>";
+
+ htmlString += "<b><font face=\"" + darkLabelFont + "\">"
+ + FLAT + ": </b>" + velFlat + " " + speedUnit
+ + "<br>";
+ htmlString += "<b><font face=\"" + darkLabelFont + "\">"
+ + UPHILL + ": </b>" + velUp + " " + speedUnit
+ + "<br>";
+ htmlString += "<b><font face=\"" + darkLabelFont + "\">"
+ + DOWNHILL + ": </b>" + velDown + " " + speedUnit
+ + "<br>";
+ htmlString += "<b><font face=\"" + darkLabelFont + "\">"
+ + TIMES + ": </b>" + totTimeHM + "<br>";
+ }
+ htmlString += "</DIV></BODY></HTML>";
+ out.getRecordPanel().removeAll();
+ out.createNewDocument();
+ out.setBackground(Color.lightGray);
+ out.append(htmlString);
+ frame.setTitle(PLOT + "-" + n + " " + PROFILE_INFO);
+ frame.add(out);
+ frame.setClosable(true);
+ frame.setResizable(true);
+ frame.setMaximizable(true);
+ frame.setSize(230, 360);
+ frame.setVisible(true);
+ wFrame.getContext().getWorkbench().getFrame()
+ .addInternalFrame(frame, true, true);
+
+ }
+ });
+
+ plot2dA.plotToolBar.addSeparator(new Dimension(16, 16));
+
+ plot2dA.plotToolBar.add(tableBtn);
+ plot2dA.plotToolBar.add(slopeBtn);
+ plot2dA.plotToolBar.addSeparator(new Dimension(16, 16));
+ plot2dA.plotToolBar.add(jLabel4);
+ plot2dA.plotToolBar.addSeparator(new Dimension(16, 16));
+ plot2dA.plotToolBar.add(infoBtn);
+ if (!layerUnit.equals("degree") || !layerUnit.equals("UnKnown")) {
+ plot2dA.plotToolBar.add(jPanel2);
+ plot2dA.plotToolBar.addSeparator(new Dimension(16, 16));
+ plot2dA.plotToolBar.add(jPanel3);
+ }
+
+ plot2dA.setFixedBounds(0, 0, profile.getPlanetLength());
+ return plot2dA;
+
+ }
+
+ private static void mosaicFrames() {
+ final int xpos = 0;
+ int ypos = 0;
+ final Dimension deskDim = wFrame.getContext().getWorkbench().getFrame()
+ .getDesktopPane().getSize();
+ int deskWidth = deskDim.width;
+ final int deskHeight = deskDim.height;
+ deskWidth = deskDim.width;
+ final int frameWidth = deskWidth;
+ final int frameHeight = deskHeight / 2;
+
+ for (final JInternalFrame iFrame : JUMPWorkbench.getInstance()
+ .getFrame().getInternalFrames()) {
+ if (iFrame instanceof AdditionalResultsFrame) {
+ ((AdditionalResultsFrame) iFrame).reshape(xpos, ypos,
+ frameWidth, frameHeight);
+ ((AdditionalResultsFrame) iFrame).setLocation(xpos, ypos);
+ ((AdditionalResultsFrame) iFrame).getSplitPanel()
+ .setDividerLocation(0);
+ ((AdditionalResultsFrame) iFrame).moveToFront();
+ ypos += frameHeight;
+ }
+ }
+ }
+
+ public static Object[] doubleToObject(double[] data) {
+ final Object[] column = new Object[data.length];
+ for (int i = 0; i < column.length; i++) {
+ column[i] = data[i];
+ }
+ return column;
+ }
+
+}
Property changes on:
core/trunk/src/org/openjump/core/ui/plugin/raster/ProfileGraphGUI.java
___________________________________________________________________
Added: svn:mime-type
## -0,0 +1 ##
+text/plain
\ No newline at end of property
Modified: core/trunk/src/org/openjump/core/ui/plugin/raster/ProfileUtils.java
===================================================================
--- core/trunk/src/org/openjump/core/ui/plugin/raster/ProfileUtils.java
2018-06-21 07:38:45 UTC (rev 5883)
+++ core/trunk/src/org/openjump/core/ui/plugin/raster/ProfileUtils.java
2018-06-21 07:45:30 UTC (rev 5884)
@@ -49,7 +49,12 @@
import com.vividsolutions.jump.workbench.ui.images.IconLoader;
public class ProfileUtils {
-
+ /**
+ * Use ProfileGraphGUI and ProfileGraphAlgorithms instead
+ *
+ * @deprecated
+ */
+ @Deprecated
public final static String LAYER_NAME = I18N
.get("org.openjump.core.ui.plugin.raster.RasterImageLayerPropertiesPlugIn.layer_name");
public final static String MIN = I18N
------------------------------------------------------------------------------
Check out the vibrant tech community on one of the world's most
engaging tech sites, Slashdot.org! http://sdm.link/slashdot
_______________________________________________
Jump-pilot-devel mailing list
Jump-pilot-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/jump-pilot-devel
