Ignore:
Timestamp:
2009-06-26T22:11:40+02:00 (15 years ago)
Author:
jttt
Message:

Use getter for Node.coor and Node.eastNorth

Location:
applications/editors/josm/plugins/terracer
Files:
2 added
2 edited

Legend:

Unmodified
Added
Removed

  • applications/editors/josm/plugins/terracer/build.xml

    r15858 r16162  
    2626                <attribute name="Plugin-Description" value="Make terraced houses out of single blocks."/>
    2727                <attribute name="Plugin-Link" value="http://wiki.openstreetmap.org/wiki/JOSM/Plugins/Terracer"/>
    28                 <attribute name="Plugin-Mainversion" value="1598"/>
     28                <attribute name="Plugin-Mainversion" value="1638"/>
    2929                <attribute name="Plugin-Version" value="${version.entry.commit.revision}"/>
    3030            </manifest>

  • applications/editors/josm/plugins/terracer/src/terracer/TerracerAction.java

    r14048 r16162  
    11/**
    22 * Terracer: A JOSM Plugin for terraced houses.
    3  * 
     3 *
    44 * Copyright 2009 CloudMade Ltd.
    5  * 
     5 *
    66 * Released under the GPLv2, see LICENSE file for details.
    77 */
    … …  
    1111import static org.openstreetmap.josm.tools.I18n.trn;
    1212
    13 import java.awt.BorderLayout;
    1413import java.awt.Choice;
    1514import java.awt.Component;
    … …  
    2019import java.awt.event.KeyEvent;
    2120import java.util.ArrayList;
    22 import java.util.Arrays;
    2321import java.util.Collection;
    2422import java.util.Collections;
    25 import java.util.HashMap;
    2623import java.util.LinkedList;
    27 import java.util.List;
    28 import java.util.Map;
    29 import java.util.TreeMap;
    3024import java.util.TreeSet;
    3125
    32 import javax.swing.JComponent;
    3326import javax.swing.JFormattedTextField;
    3427import javax.swing.JLabel;
    … …  
    3629import javax.swing.JPanel;
    3730import javax.swing.JSpinner;
    38 import javax.swing.JTextField;
    3931import javax.swing.SpinnerNumberModel;
    40 import javax.swing.SpringLayout;
    4132import javax.swing.event.ChangeEvent;
    4233import javax.swing.event.ChangeListener;
    … …  
    5344import org.openstreetmap.josm.data.osm.RelationMember;
    5445import org.openstreetmap.josm.data.osm.Way;
    55 import org.openstreetmap.josm.gui.tagging.TaggingPreset.Item;
    5646import org.openstreetmap.josm.tools.AutoCompleteComboBox;
    5747import org.openstreetmap.josm.tools.GBC;
    … …  
    6252 * Terraces a quadrilateral, closed way into a series of quadrilateral,
    6353 * closed ways.
    64  * 
     54 *
    6555 * At present it only works on quadrilaterals, but there is no reason
    66  * why it couldn't be extended to work with other shapes too. The 
    67  * algorithm employed is naive, but it works in the simple case. 
    68  * 
     56 * why it couldn't be extended to work with other shapes too. The
     57 * algorithm employed is naive, but it works in the simple case.
     58 *
    6959 * @author zere
    7060 */
    … …  
    7666
    7767        public TerracerAction() {
    78                 super(tr("Terrace a building"), 
    79                                 "terrace", 
     68                super(tr("Terrace a building"),
     69                                "terrace",
    8070                                tr("Creates individual buildings from a long building."),
    81                                 Shortcut.registerShortcut("tools:Terracer", 
     71                                Shortcut.registerShortcut("tools:Terracer",
    8272                                                tr("Tool: {0}", tr("Terrace a building")),
    83                                                 KeyEvent.VK_T, Shortcut.GROUP_EDIT, 
     73                                                KeyEvent.VK_T, Shortcut.GROUP_EDIT,
    8474                                                Shortcut.SHIFT_DEFAULT),
    8575                                                true);
    … …  
    112102                                        optionPane.createDialog(Main.parent, title).setVisible(true);
    113103                                        Object answerObj = optionPane.getValue();
    114                                         if (answerObj != null && 
     104                                        if (answerObj != null &&
    115105                                                        answerObj != JOptionPane.UNINITIALIZED_VALUE &&
    116                                                         (answerObj instanceof Integer && 
     106                                                        (answerObj instanceof Integer &&
    117107                                                                        (Integer)answerObj == JOptionPane.OK_OPTION)) {
    118108
    119109                                                // call out to the method which does the actual
    120110                                                // terracing.
    121                                                 terraceBuilding(way, 
    122                                                                 dialog.numberFrom(), 
     111                                                terraceBuilding(way,
     112                                                                dialog.numberFrom(),
    123113                                                                dialog.numberTo(),
    124114                                                                dialog.stepSize(),
    … …  
    137127
    138128                if (badSelect) {
    139                         JOptionPane.showMessageDialog(Main.parent, 
     129                        JOptionPane.showMessageDialog(Main.parent,
    140130                                        tr("Select a single, closed way of at least four nodes."));
    141131                }
    … …  
    144134        /**
    145135         * Terraces a single, closed, quadrilateral way.
    146          * 
     136         *
    147137         * Any node must be adjacent to both a short and long edge, we naively
    148138         * choose the longest edge and its opposite and interpolate along them
    149139         * linearly to produce new nodes. Those nodes are then assembled into
    150140         * closed, quadrilateral ways and left in the selection.
    151          * 
     141         *
    152142         * @param w The closed, quadrilateral way to terrace.
    153143         */
    … …  
    167157                Collection<Way> ways = new LinkedList<Way>();
    168158
    169                 // create intermediate nodes by interpolating. 
     159                // create intermediate nodes by interpolating.
    170160                for (int i = 0; i <= nb; ++i) {
    171                         new_nodes[0][i] = interpolateAlong(interp.a, frontLength * (double)(i) / (double)(nb));
    172                         new_nodes[1][i] = interpolateAlong(interp.b, backLength * (double)(i) / (double)(nb));
     161                        new_nodes[0][i] = interpolateAlong(interp.a, frontLength * (i) / (nb));
     162                        new_nodes[1][i] = interpolateAlong(interp.b, backLength * (i) / (nb));
    173163                        commands.add(new AddCommand(new_nodes[0][i]));
    174164                        commands.add(new AddCommand(new_nodes[1][i]));
    … …  
    214204         * Creates a node at a certain distance along a way, as calculated by the
    215205         * great circle distance.
    216          * 
    217          * Note that this really isn't an efficient way to do this and leads to 
     206         *
     207         * Note that this really isn't an efficient way to do this and leads to
    218208         * O(N^2) running time for the main algorithm, but its simple and easy
    219209         * to understand, and probably won't matter for reasonable-sized ways.
    220          * 
     210         *
    221211         * @param w The way to interpolate.
    222212         * @param l The length at which to place the node.
    … …  
    226216                Node n = null;
    227217                for (Pair<Node,Node> p : w.getNodePairs(false)) {
    228                         final double seg_length = p.a.coor.greatCircleDistance(p.b.coor);
     218                        final double seg_length = p.a.getCoor().greatCircleDistance(p.b.getCoor());
    229219                        if (l <= seg_length) {
    230220                                n = interpolateNode(p.a, p.b, l / seg_length);
    … …  
    245235         * Calculates the great circle length of a way by summing the great circle
    246236         * distance of each pair of nodes.
    247          * 
     237         *
    248238         * @param w The way to calculate length of.
    249239         * @return The length of the way.
    … …  
    252242                double length = 0.0;
    253243                for (Pair<Node,Node> p : w.getNodePairs(false)) {
    254                         length += p.a.coor.greatCircleDistance(p.b.coor);
     244                        length += p.a.getCoor().greatCircleDistance(p.b.getCoor());
    255245                }
    256246                return length;
    … …  
    258248
    259249        /**
    260          * Given a way, try and find a definite front and back by looking at the 
     250         * Given a way, try and find a definite front and back by looking at the
    261251         * segments to find the "sides". Sides are assumed to be single segments
    262252         * which cannot be contiguous.
    263          * 
     253         *
    264254         * @param w The way to analyse.
    265255         * @return A pair of ways (front, back) pointing in the same directions.
    … …  
    327317                Node a = w.nodes.get(i);
    328318                Node b = w.nodes.get((i+1) % (w.nodes.size() - 1));
    329                 return a.coor.greatCircleDistance(b.coor);
     319                return a.getCoor().greatCircleDistance(b.getCoor());
    330320        }
    331321
    … …  
    334324         * into order and return the array of indexes such that, for a returned array
    335325         * x, a[x[i]] is sorted for ascending index i.
    336          * 
     326         *
    337327         * This isn't efficient at all, but should be fine for the small arrays we're
    338328         * expecting. If this gets slow - replace it with some more efficient algorithm.
    339          * 
     329         *
    340330         * @param a The array to sort.
    341          * @return An array of indexes, the same size as the input, such that a[x[i]] 
     331         * @return An array of indexes, the same size as the input, such that a[x[i]]
    342332         * is in sorted order.
    343333         */
    … …  
    370360
    371361        /**
    372          * Calculate "sideness" metric for each segment in a way. 
     362         * Calculate "sideness" metric for each segment in a way.
    373363         */
    374364        private double[] calculateSideness(Way w) {
    … …  
    385375                }
    386376                sideness[length-1] = calculateSideness(
    387                                 w.nodes.get(length - 2), w.nodes.get(length - 1), 
     377                                w.nodes.get(length - 2), w.nodes.get(length - 1),
    388378                                w.nodes.get(length), w.nodes.get(1));
    389379
    … …  
    397387         */
    398388        private double calculateSideness(Node a, Node b, Node c, Node d) {
    399                 final double ndx = b.coor.getX() - a.coor.getX();
    400                 final double pdx = d.coor.getX() - c.coor.getX();
    401                 final double ndy = b.coor.getY() - a.coor.getY();
    402                 final double pdy = d.coor.getY() - c.coor.getY();
    403 
    404                 return (ndx * pdx + ndy * pdy) / 
     389                final double ndx = b.getCoor().getX() - a.getCoor().getX();
     390                final double pdx = d.getCoor().getX() - c.getCoor().getX();
     391                final double ndy = b.getCoor().getY() - a.getCoor().getY();
     392                final double pdy = d.getCoor().getY() - c.getCoor().getY();
     393
     394                return (ndx * pdx + ndy * pdy) /
    405395                Math.sqrt((ndx * ndx + ndy * ndy) * (pdx * pdx + pdy * pdy));
    406396        }
    … …  
    426416                        chi = new JSpinner(hi);
    427417
    428                         lo.addChangeListener(new ChangeListener() { 
     418                        lo.addChangeListener(new ChangeListener() {
    429419                                public void stateChanged(ChangeEvent e) {
    430420                                        hi.setMinimum((Integer)lo.getNumber());
    431421                                }
    432422                        });
    433                         hi.addChangeListener(new ChangeListener() { 
     423                        hi.addChangeListener(new ChangeListener() {
    434424                                public void stateChanged(ChangeEvent e) {
    435425                                        lo.setMaximum((Integer)hi.getNumber());
    … …  
    521511
    522512        /**
    523          * Generates a list of all visible names of highways in order to do 
     513         * Generates a list of all visible names of highways in order to do
    524514         * autocompletion on the road name.
    525515         */
    … …  
    539529         * Creates a new node at the interpolated position between the argument
    540530         * nodes. Interpolates linearly in Lat/Lon coordinates.
    541          * 
     531         *
    542532         * @param a First node, at which f=0.
    543533         * @param b Last node, at which f=1.
    … …  
    551541
    552542        /**
    553          * Calculates the interpolated position between the argument nodes. Interpolates 
     543         * Calculates the interpolated position between the argument nodes. Interpolates
    554544         * linearly in Lat/Lon coordinates.
    555          * 
     545         *
    556546         * @param a First node, at which f=0.
    557547         * @param b Last node, at which f=1.
    … …  
    563553                // screen coordinates rather than lat/lon, but it doesn't seem to
    564554                // make a great deal of difference at the scale of most terraces.
    565                 return new LatLon(a.coor.lat() * (1.0 - f) + b.coor.lat() * f,
    566                                 a.coor.lon() * (1.0 - f) + b.coor.lon() * f);
     555                return new LatLon(a.getCoor().lat() * (1.0 - f) + b.getCoor().lat() * f,
     556                                a.getCoor().lon() * (1.0 - f) + b.getCoor().lon() * f);
    567557        }
    568558}
Note: See TracChangeset for help on using the changeset viewer.