Changeset 143 in josm


Ignore:
Timestamp:
2006-09-30T19:05:43+02:00 (18 years ago)
Author:
imi
Message:

added "gpx" as flag to the external tool feature to also export raw gps data

Files:
10 edited
1 moved

Legend:

Unmodified
Added
Removed

  • src/org/openstreetmap/josm/actions/ExternalToolsAction.java

    r142 r143  
    77import java.io.FileReader;
    88import java.io.IOException;
    9 import java.io.OutputStream;
     9import java.io.PrintWriter;
    1010import java.util.Arrays;
    1111import java.util.Collection;
    … …  
    3333import org.openstreetmap.josm.data.osm.Way;
    3434import org.openstreetmap.josm.data.osm.visitor.AddVisitor;
     35import org.openstreetmap.josm.data.osm.visitor.AllNodesVisitor;
    3536import org.openstreetmap.josm.data.osm.visitor.CollectBackReferencesVisitor;
    3637import org.openstreetmap.josm.gui.PleaseWaitRunnable;
     38import org.openstreetmap.josm.gui.layer.Layer;
     39import org.openstreetmap.josm.gui.layer.RawGpsLayer;
     40import org.openstreetmap.josm.gui.layer.RawGpsLayer.GpsPoint;
     41import org.openstreetmap.josm.io.GpxWriter;
    3742import org.openstreetmap.josm.io.OsmReader;
    3843import org.openstreetmap.josm.io.OsmWriter;
    … …  
    5560
    5661        private final class ExecuteToolRunner extends PleaseWaitRunnable {
    57         private final Process p;
    58         private DataSet dataSet;
    59         private DataSet fromDataSet;
    60         private ExecuteToolRunner(String msg, Process p) {
    61                 super(msg);
    62                 this.p = p;
    63                 currentAction.setText(tr("Executing {0}",getValue(NAME)));
    64         }
    65    
    66         @Override protected void realRun() throws SAXException, IOException {
    67                 if (!input.isEmpty()) {
    68                         fromDataSet = new DataSet();
    69                         AddVisitor adder = new AddVisitor(fromDataSet, flags.contains("include_references"));
    70                         if (input.contains("selection")) {
    71                                 Collection<OsmPrimitive> sel = Main.ds.getSelected();
    72                                 for (OsmPrimitive osm : sel)
    73                                         osm.visit(adder);
    74                                 if (flags.contains("include_back_references")) {
    75                                         CollectBackReferencesVisitor v = new CollectBackReferencesVisitor(Main.ds);
    76                                         for (OsmPrimitive osm : sel)
    77                                                 osm.visit(v);
    78                                         AddVisitor a = new AddVisitor(fromDataSet);
    79                                         for (OsmPrimitive osm : v.data)
    80                                                 osm.visit(a);
    81                                 }
    82                         }
    83                         if (input.contains("all"))
    84                                 for (OsmPrimitive osm : Main.ds.allPrimitives())
    85                                         osm.visit(adder);
    86                         if (input.contains("screen")) {
    87                                 if (Main.map == null) {
    88                                         errorMessage = tr("The Tool requires some data to be loaded.");
    89                                         cancel();
    90                                         return;
    91                                 }
    92                                 LatLon bottomLeft = Main.map.mapView.getLatLon(0,Main.map.mapView.getHeight());
    93                                 LatLon topRight = Main.map.mapView.getLatLon(Main.map.mapView.getWidth(), 0);
    94                                 Bounds b = new Bounds(bottomLeft, topRight);
    95                                 Collection<Node> nodes = new HashSet<Node>();
    96                                 for (Node n : Main.ds.nodes) {
    97                                         if (n.coor.isWithin(b)) {
    98                                                 n.visit(adder);
    99                                                 nodes.add(n);
    100                                         }
    101                                 }
    102                                 Collection<Segment> segments = new HashSet<Segment>();
    103                                 for (Segment s : Main.ds.segments) {
    104                                         if (nodes.contains(s.from) || nodes.contains(s.to)) {
    105                                                 s.visit(adder);
    106                                                 segments.add(s);
    107                                         }
    108                                 }
    109                                 for (Way w : Main.ds.ways) {
    110                                         for (Segment s : w.segments) {
    111                                                 if (segments.contains(s)) {
    112                                                         w.visit(adder);
    113                                                         break;
    114                                                 }
    115                                         }
    116                                 }
    117                         }
    118                         OutputStream out = p.getOutputStream();
    119                         OsmWriter.output(out, fromDataSet, false);
    120                         out.close();
    121                 }
    122                 if (output != null)
    123                         dataSet = OsmReader.parseDataSet(p.getInputStream(), currentAction, progress);
    124         }
    125    
    126         @Override protected void cancel() {
    127                 p.destroy();
    128         }
    129    
    130         @Override protected void finish() {
    131                 if (dataSet == null || output == null || output.equals("discard"))
    132                         return; // user cancelled or no stdout to process
    133                 Collection<OsmPrimitive> allNew = dataSet.allPrimitives();
    134                 Collection<OsmPrimitive> allOld = fromDataSet.allPrimitives();
    135                 if (output.equals("replace")) {
    136                         Command cmd = createCommand(allOld, allNew);
    137                         if (cmd != null) {
    138                                 Main.main.editLayer().add(cmd);
    139                                 Main.ds.clearSelection();
    140                         }
    141                 } else if (output.equals("selection")) {
    142                         Collection<OsmPrimitive> sel = new LinkedList<OsmPrimitive>();
    143                         for (OsmPrimitive osm : Main.ds.allPrimitives())
    144                                 if (allNew.contains(osm))
    145                                         sel.add(osm);
    146                         Main.ds.setSelected(sel);
    147                 }
    148         }
    149    
    150         /**
    151          * Create a command that replaces all objects in from with those in to. The lists will be
    152          * changed by createCommand.
    153          */
    154         private Command createCommand(Collection<OsmPrimitive> from, Collection<OsmPrimitive> to) {
    155                 // remove all objects in from/to, that are present in both lists.
    156                 for (Iterator<OsmPrimitive> toIt = to.iterator(); toIt.hasNext();) {
    157                         OsmPrimitive osm = toIt.next();
    158                         for (Iterator<OsmPrimitive> fromIt = from.iterator(); fromIt.hasNext();) {
    159                                 if (fromIt.next().realEqual(osm)) {
    160                                         toIt.remove();
    161                                         fromIt.remove();
    162                                         break;
    163                                 }
    164                         }
    165                 }
    166    
    167                 Collection<Command> cmd = new LinkedList<Command>();
    168    
    169                 // extract all objects that have changed
    170                 for (Iterator<OsmPrimitive> toIt = to.iterator(); toIt.hasNext();) {
    171                         OsmPrimitive toOsm = toIt.next();
    172                         for (Iterator<OsmPrimitive> fromIt = from.iterator(); fromIt.hasNext();) {
    173                                 OsmPrimitive fromOsm = fromIt.next();
    174                                 if (fromOsm.equals(toOsm)) {
    175                                         toIt.remove();
    176                                         fromIt.remove();
    177                                         cmd.add(new ChangeCommand(fromOsm, toOsm));
    178                                         break;
    179                                 }
    180                         }
    181                 }
    182                 for (OsmPrimitive fromOsm : Main.ds.allPrimitives()) {
    183                         for (Iterator<OsmPrimitive> it = to.iterator(); it.hasNext();) {
    184                                 OsmPrimitive toOsm = it.next();
    185                                 if (fromOsm.equals(toOsm)) {
    186                                         it.remove();
    187                                         cmd.add(new ChangeCommand(fromOsm, toOsm));
    188                                         break;
    189                                 }
    190                         }
    191                 }
    192    
    193                 // extract all added objects
    194                 for (OsmPrimitive osm : to)
    195                         cmd.add(new AddCommand(osm));
    196    
    197                 // extract all deleted objects. Delete references as well.
    198                 CollectBackReferencesVisitor v = new CollectBackReferencesVisitor(Main.ds);
    199                 for (OsmPrimitive osm : from)
    200                         osm.visit(v);
    201                 v.data.addAll(from);
    202                 if (!v.data.isEmpty())
    203                         cmd.add(new DeleteCommand(v.data));
    204    
    205                 if (cmd.isEmpty())
    206                         return null;
    207                 return new SequenceCommand(tr("Executing {0}",getValue(NAME)), cmd);
    208         }
    209     }
     62                private final Process p;
     63                private DataSet dataSet;
     64                private DataSet fromDataSet;
     65                private ExecuteToolRunner(String msg, Process p) {
     66                        super(msg);
     67                        this.p = p;
     68                        currentAction.setText(tr("Executing {0}",getValue(NAME)));
     69                }
     70
     71                @Override protected void realRun() throws SAXException, IOException {
     72                        if (!input.isEmpty()) {
     73                                fromDataSet = new DataSet();
     74                                final Collection<GpsPoint> gpxPoints = new LinkedList<GpsPoint>();
     75                                final boolean addOsm = !flags.contains("noosm");
     76                                final boolean addGpx = flags.contains("gpx");
     77
     78                                AddVisitor adder = new AddVisitor(fromDataSet, flags.contains("include_references"));
     79                                if (input.contains("selection")) {
     80                                        Collection<OsmPrimitive> sel = Main.ds.getSelected();
     81                                        if (addOsm) {
     82                                                for (OsmPrimitive osm : sel)
     83                                                        osm.visit(adder);
     84                                                if (flags.contains("include_back_references")) {
     85                                                        CollectBackReferencesVisitor v = new CollectBackReferencesVisitor(Main.ds);
     86                                                        for (OsmPrimitive osm : sel)
     87                                                                osm.visit(v);
     88                                                        AddVisitor a = new AddVisitor(fromDataSet);
     89                                                        for (OsmPrimitive osm : v.data)
     90                                                                osm.visit(a);
     91                                                }
     92                                        }
     93                                        if (addGpx) {
     94                                                AllNodesVisitor v = new AllNodesVisitor();
     95                                                for (OsmPrimitive osm : sel)
     96                                                        osm.visit(v);
     97                                                Bounds b = new Bounds();
     98                                                for (Node n : v.nodes)
     99                                                        b.extend(n.coor);
     100                                                for (Layer l : Main.map.mapView.getAllLayers()) {
     101                                                        if (!(l instanceof RawGpsLayer))
     102                                                                continue;
     103                                                        RawGpsLayer layer = (RawGpsLayer)l;
     104                                                        for (Collection<GpsPoint> c : layer.data)
     105                                                                for (GpsPoint p : c)
     106                                                                        if (p.latlon.isWithin(b))
     107                                                                                gpxPoints.add(p);
     108                                                }
     109                                        }
     110                                }
     111                                if (input.contains("all")) {
     112                                        if (addOsm)
     113                                                for (OsmPrimitive osm : Main.ds.allPrimitives())
     114                                                        osm.visit(adder);
     115                                        for (Layer l : Main.map.mapView.getAllLayers())
     116                                                if (l instanceof RawGpsLayer)
     117                                                        for (Collection<GpsPoint> c : ((RawGpsLayer)l).data)
     118                                                                for (GpsPoint p : c)
     119                                                                        gpxPoints.add(p);
     120                                }
     121                                if (input.contains("screen")) {
     122                                        if (Main.map == null) {
     123                                                errorMessage = tr("The Tool requires some data to be loaded.");
     124                                                cancel();
     125                                                return;
     126                                        }
     127                                        LatLon bottomLeft = Main.map.mapView.getLatLon(0,Main.map.mapView.getHeight());
     128                                        LatLon topRight = Main.map.mapView.getLatLon(Main.map.mapView.getWidth(), 0);
     129                                        Bounds b = new Bounds(bottomLeft, topRight);
     130                                        if (addOsm) {
     131                                                Collection<Node> nodes = new HashSet<Node>();
     132                                                for (Node n : Main.ds.nodes) {
     133                                                        if (n.coor.isWithin(b)) {
     134                                                                n.visit(adder);
     135                                                                nodes.add(n);
     136                                                        }
     137                                                }
     138                                                Collection<Segment> segments = new HashSet<Segment>();
     139                                                for (Segment s : Main.ds.segments) {
     140                                                        if (nodes.contains(s.from) || nodes.contains(s.to)) {
     141                                                                s.visit(adder);
     142                                                                segments.add(s);
     143                                                        }
     144                                                }
     145                                                for (Way w : Main.ds.ways) {
     146                                                        for (Segment s : w.segments) {
     147                                                                if (segments.contains(s)) {
     148                                                                        w.visit(adder);
     149                                                                        break;
     150                                                                }
     151                                                        }
     152                                                }
     153                                        }
     154                                        if (addGpx) {
     155                                                for (Layer l : Main.map.mapView.getAllLayers())
     156                                                        if (l instanceof RawGpsLayer)
     157                                                                for (Collection<GpsPoint> c : ((RawGpsLayer)l).data)
     158                                                                        for (GpsPoint p : c)
     159                                                                                if (p.latlon.isWithin(b))
     160                                                                                        gpxPoints.add(p);
     161                                        }
     162                                }
     163                                OsmWriter.output(p.getOutputStream(), new OsmWriter.Osm(){
     164                                        public void write(PrintWriter out) {
     165                                                if (addOsm)
     166                                                        new OsmWriter.All(fromDataSet, false).write(out);
     167                                                if (addGpx) {
     168                                                        Collection<Collection<GpsPoint>> c = new LinkedList<Collection<GpsPoint>>();
     169                                                        c.add(gpxPoints);
     170                                                        GpxWriter.Trk writer = new GpxWriter.Trk(c);
     171                                                        writer.header(out);
     172                                                        if (!gpxPoints.isEmpty())
     173                                                                writer.write(out);
     174                                                        writer.footer(out);
     175                                                }
     176                                        }
     177                                });
     178                        }
     179                        if (output != null)
     180                                dataSet = OsmReader.parseDataSet(p.getInputStream(), currentAction, progress);
     181                }
     182
     183                @Override protected void cancel() {
     184                        p.destroy();
     185                }
     186
     187                @Override protected void finish() {
     188                        if (dataSet == null || output == null || output.equals("discard"))
     189                                return; // user cancelled or no stdout to process
     190                        Collection<OsmPrimitive> allNew = dataSet.allPrimitives();
     191                        Collection<OsmPrimitive> allOld = fromDataSet.allPrimitives();
     192                        if (output.equals("replace")) {
     193                                Command cmd = createCommand(allOld, allNew);
     194                                if (cmd != null) {
     195                                        Main.main.editLayer().add(cmd);
     196                                        Main.ds.clearSelection();
     197                                }
     198                        } else if (output.equals("selection")) {
     199                                Collection<OsmPrimitive> sel = new LinkedList<OsmPrimitive>();
     200                                for (OsmPrimitive osm : Main.ds.allPrimitives())
     201                                        if (allNew.contains(osm))
     202                                                sel.add(osm);
     203                                Main.ds.setSelected(sel);
     204                        }
     205                }
     206
     207                /**
     208                 * Create a command that replaces all objects in from with those in to. The lists will be
     209                 * changed by createCommand.
     210                 */
     211                private Command createCommand(Collection<OsmPrimitive> from, Collection<OsmPrimitive> to) {
     212                        // remove all objects in from/to, that are present in both lists.
     213                        for (Iterator<OsmPrimitive> toIt = to.iterator(); toIt.hasNext();) {
     214                                OsmPrimitive osm = toIt.next();
     215                                for (Iterator<OsmPrimitive> fromIt = from.iterator(); fromIt.hasNext();) {
     216                                        if (fromIt.next().realEqual(osm)) {
     217                                                toIt.remove();
     218                                                fromIt.remove();
     219                                                break;
     220                                        }
     221                                }
     222                        }
     223
     224                        Collection<Command> cmd = new LinkedList<Command>();
     225
     226                        // extract all objects that have changed
     227                        for (Iterator<OsmPrimitive> toIt = to.iterator(); toIt.hasNext();) {
     228                                OsmPrimitive toOsm = toIt.next();
     229                                for (Iterator<OsmPrimitive> fromIt = from.iterator(); fromIt.hasNext();) {
     230                                        OsmPrimitive fromOsm = fromIt.next();
     231                                        if (fromOsm.equals(toOsm)) {
     232                                                toIt.remove();
     233                                                fromIt.remove();
     234                                                cmd.add(new ChangeCommand(fromOsm, toOsm));
     235                                                break;
     236                                        }
     237                                }
     238                        }
     239                        for (OsmPrimitive fromOsm : Main.ds.allPrimitives()) {
     240                                for (Iterator<OsmPrimitive> it = to.iterator(); it.hasNext();) {
     241                                        OsmPrimitive toOsm = it.next();
     242                                        if (fromOsm.equals(toOsm)) {
     243                                                it.remove();
     244                                                cmd.add(new ChangeCommand(fromOsm, toOsm));
     245                                                break;
     246                                        }
     247                                }
     248                        }
     249
     250                        // extract all added objects
     251                        for (OsmPrimitive osm : to)
     252                                cmd.add(new AddCommand(osm));
     253
     254                        // extract all deleted objects. Delete references as well.
     255                        CollectBackReferencesVisitor v = new CollectBackReferencesVisitor(Main.ds);
     256                        for (OsmPrimitive osm : from)
     257                                osm.visit(v);
     258                        v.data.addAll(from);
     259                        if (!v.data.isEmpty())
     260                                cmd.add(new DeleteCommand(v.data));
     261
     262                        if (cmd.isEmpty())
     263                                return null;
     264                        return new SequenceCommand(tr("Executing {0}",getValue(NAME)), cmd);
     265                }
     266        }
    210267
    211268        public ExternalToolsAction(String name, String[] exec, String[] flags, String[] input, String output) {
    … …  
    242299                        @Override public void startDocument() {
    243300                                current.push(main);
    244             }
     301                        }
    245302                        @Override public void startElement(String ns, String lname, String qname, Attributes a) throws SAXException {
    246303                                if (qname.equals("group")) {

  • src/org/openstreetmap/josm/actions/GpxExportAction.java

    r113 r143  
    3030import org.openstreetmap.josm.gui.layer.RawGpsLayer;
    3131import org.openstreetmap.josm.io.GpxWriter;
     32import org.openstreetmap.josm.io.XmlWriter;
    3233import org.openstreetmap.josm.tools.GBC;
    3334
    … …  
    117118                        Main.pref.put("lastCopyright", copyright.getText());
    118119               
    119                 try {
    120                         GpxWriter w = new GpxWriter(new FileOutputStream(file), layer.name, desc.getText(),
     120                XmlWriter.OsmWriterInterface w;
     121                if (layer instanceof RawGpsLayer)
     122                        w = new GpxWriter.Trk(((RawGpsLayer)layer).data);
     123                else
     124                        w = new GpxWriter.All(Main.ds, layer.name, desc.getText(),
    121125                                        authorName.getText(), email.getText(), copyright.getText(),
    122126                                        copyrightYear.getText(), keywords.getText());
    123                         if (layer instanceof RawGpsLayer)
    124                                 w.output(((RawGpsLayer)layer).data);
    125                         else
    126                                 w.output(Main.ds);
    127                         w.close();
     127                try {
     128                        XmlWriter.output(new FileOutputStream(file), w);
    128129                } catch (IOException x) {
    129130                        x.printStackTrace();

  • src/org/openstreetmap/josm/actions/SaveAction.java

    r142 r143  
    5454                                GpxExportAction.exportGpx(file, layer);
    5555                        } else if (ExtensionFileFilter.filters[ExtensionFileFilter.OSM].acceptName(file.getPath())) {
    56                                 OsmWriter.output(new FileOutputStream(file), Main.ds, false);
     56                                OsmWriter.output(new FileOutputStream(file), new OsmWriter.All(Main.ds, false));
    5757                        } else if (ExtensionFileFilter.filters[ExtensionFileFilter.CSV].acceptName(file.getPath())) {
    5858                                JOptionPane.showMessageDialog(Main.parent, tr("CSV output not supported yet."));

  • src/org/openstreetmap/josm/data/osm/visitor/Visitor.java

    r86 r143  
    11package org.openstreetmap.josm.data.osm.visitor;
    22
     3import org.openstreetmap.josm.data.osm.Node;
    34import org.openstreetmap.josm.data.osm.Segment;
    4 import org.openstreetmap.josm.data.osm.Node;
    55import org.openstreetmap.josm.data.osm.Way;
    66

  • src/org/openstreetmap/josm/gui/dialogs/HistoryDialog.java

    r129 r143  
    7777         */
    7878        private JTable history = new JTable(data);
     79        private JScrollPane historyPane = new JScrollPane(history);
    7980
    8081        private Map<OsmPrimitive, List<HistoryItem>> cache = new HashMap<OsmPrimitive, List<HistoryItem>>();
    … …  
    8586        public HistoryDialog() {
    8687                super(tr("History"), "history", tr("Display the history of all selected items."), KeyEvent.VK_H, 150);
    87                 history.setVisible(false);
     88                historyPane.setVisible(false);
    8889                notLoaded.setVisible(true);
    8990
    … …  
    115116                JPanel centerPanel = new JPanel(new GridBagLayout());
    116117                centerPanel.add(notLoaded, GBC.eol().fill(GBC.BOTH));
    117                 centerPanel.add(new JScrollPane(history), GBC.eol().fill(GBC.BOTH));
     118                centerPanel.add(historyPane, GBC.eol().fill(GBC.BOTH));
    118119                add(centerPanel, BorderLayout.CENTER);
    119120
    … …  
    160161                Collection<OsmPrimitive> sel = Main.ds.getSelected();
    161162                if (!cache.keySet().containsAll(sel)) {
    162                         history.setVisible(false);
     163                        historyPane.setVisible(false);
    163164                        notLoaded.setVisible(true);
    164165                } else {
    … …  
    169170                        for (HistoryItem i : orderedHistory)
    170171                                data.addRow(new Object[]{i.osm, i.osm.timestamp, i.visible});
    171                         history.setVisible(true);
     172                        historyPane.setVisible(true);
    172173                        notLoaded.setVisible(false);
    173174                }

  • src/org/openstreetmap/josm/io/GpxWriter.java

    r103 r143  
    11package org.openstreetmap.josm.io;
    22
    3 import java.io.OutputStream;
    4 import java.io.OutputStreamWriter;
    53import java.io.PrintWriter;
    6 import java.io.UnsupportedEncodingException;
    74import java.util.Collection;
    85import java.util.LinkedList;
    … …  
    1613import org.openstreetmap.josm.data.osm.Way;
    1714import org.openstreetmap.josm.gui.layer.RawGpsLayer.GpsPoint;
    18 import org.openstreetmap.josm.tools.XmlWriter;
    1915
    2016/**
    … …  
    2824 * @author imi
    2925 */
    30 public class GpxWriter {
    31 
    32         /**
    33          * This is the output writer to store the resulting data in.
    34          */
    35         private PrintWriter out;
    36 
    37         public GpxWriter(OutputStream os, String name, String desc, String author, String email, String copyright, String year, String keywords) {
    38                 try {
    39                         out = new PrintWriter(new OutputStreamWriter(os, "UTF-8"));
    40                 } catch (UnsupportedEncodingException e) {
    41                         throw new RuntimeException(e);
    42                 }
    43                 out.println(XmlWriter.header());
    44                 out.println("<gpx version='1.1' creator='JOSM' xmlns='http://www.topografix.com/GPX/1/1'>");
    45                 out.println("  <metadata>");
    46                 if (!name.equals(""))
    47                         out.println("    <name>"+XmlWriter.encode(name)+"</name>");
    48                 if (!desc.equals(""))
    49                         out.println("    <desc>"+XmlWriter.encode(desc)+"</desc>");
    50                 if (!author.equals("")) {
    51                         out.println("    <author>");
    52                         out.println("      <name>"+XmlWriter.encode(author)+"</name>");
    53                         if (!email.equals(""))
    54                                 out.println("      <email>"+XmlWriter.encode(email)+"</email>");
    55                         out.println("    </author>");
    56                         if (!copyright.equals("")) {
    57                                 out.println("    <copyright author='"+XmlWriter.encode(author)+"'>");
    58                                 if (!year.equals(""))
    59                                         out.println("      <year>"+XmlWriter.encode(year)+"</year>");
    60                                 out.println("      <license>"+XmlWriter.encode(copyright)+"</license>");
    61                                 out.println("    </copyright>");
    62                         }
    63                 }
    64                 if (!keywords.equals("")) {
    65                         out.println("    <keywords>"+XmlWriter.encode(keywords)+"</keywords>");
    66                 }
    67                 // don't finish here, to give output functions the chance to add <bounds>
     26public class GpxWriter extends XmlWriter {
     27
     28        public GpxWriter(PrintWriter out) {
     29                super(out);
    6830        }
    6931
    … …  
    7537         * all remaining nodes are added as wpt.
    7638         */
    77         public void output(DataSet data) {
    78                 Collection<OsmPrimitive> all = data.allNonDeletedPrimitives();
    79                 if (all.isEmpty()) {
     39        public static final class All implements XmlWriter.OsmWriterInterface {
     40                private final DataSet data;
     41                private final String name;
     42                private final String desc;
     43                private final String author;
     44                private final String email;
     45                private final String copyright;
     46                private final String year;
     47                private final String keywords;
     48                private boolean metadataClosed = false;
     49
     50                public All(DataSet data, String name, String desc, String author, String email, String copyright, String year, String keywords) {
     51                        this.data = data;
     52                        this.name = name;
     53                        this.desc = desc;
     54                        this.author = author;
     55                        this.email = email;
     56                        this.copyright = copyright;
     57                        this.year = year;
     58                        this.keywords = keywords;
     59                }
     60
     61                public void header(PrintWriter out) {
     62                        out.println("<gpx version='1.1' creator='JOSM' xmlns='http://www.topografix.com/GPX/1/1'>");
     63                        out.println("  <metadata>");
     64                        if (!name.equals(""))
     65                                out.println("    <name>"+XmlWriter.encode(name)+"</name>");
     66                        if (!desc.equals(""))
     67                                out.println("    <desc>"+XmlWriter.encode(desc)+"</desc>");
     68                        if (!author.equals("")) {
     69                                out.println("    <author>");
     70                                out.println("      <name>"+XmlWriter.encode(author)+"</name>");
     71                                if (!email.equals(""))
     72                                        out.println("      <email>"+XmlWriter.encode(email)+"</email>");
     73                                out.println("    </author>");
     74                                if (!copyright.equals("")) {
     75                                        out.println("    <copyright author='"+XmlWriter.encode(author)+"'>");
     76                                        if (!year.equals(""))
     77                                                out.println("      <year>"+XmlWriter.encode(year)+"</year>");
     78                                        out.println("      <license>"+XmlWriter.encode(copyright)+"</license>");
     79                                        out.println("    </copyright>");
     80                                }
     81                        }
     82                        if (!keywords.equals("")) {
     83                                out.println("    <keywords>"+XmlWriter.encode(keywords)+"</keywords>");
     84                        }
     85                        // don't finish here, to give output functions the chance to add <bounds>
     86                }
     87
     88                public void write(PrintWriter out) {
     89                        Collection<OsmPrimitive> all = data.allNonDeletedPrimitives();
     90                        if (all.isEmpty())
     91                                return;
     92                        GpxWriter writer = new GpxWriter(out);
     93                        // calculate bounds
     94                        Bounds b = new Bounds(new LatLon(Double.MAX_VALUE, Double.MAX_VALUE), new LatLon(Double.MIN_VALUE, Double.MIN_VALUE));
     95                        for (Node n : data.nodes)
     96                                if (!n.deleted)
     97                                        b.extend(n.coor);
     98                        out.println("    <bounds minlat='"+b.min.lat()+"' minlon='"+b.min.lon()+"' maxlat='"+b.max.lat()+"' maxlon='"+b.max.lon()+"' />");
    8099                        out.println("  </metadata>");
     100                        metadataClosed = true;
     101
     102                        // add ways
     103                        for (Way w : data.ways) {
     104                                if (w.deleted)
     105                                        continue;
     106                                out.println("  <trk>");
     107                                Segment oldLs = null;
     108                                for (Segment ls : w.segments) {
     109                                        if (ls.incomplete)
     110                                                continue;
     111                                        // end old segemnt, if no longer match a chain
     112                                        if (oldLs != null && !oldLs.to.coor.equals(ls.from.coor)) {
     113                                                out.println("    </trkseg>");
     114                                                writer.outputNode(oldLs.to, false);
     115                                                all.remove(oldLs.to);
     116                                                oldLs = null;
     117                                        }
     118                                        // start new segment if necessary
     119                                        if (oldLs == null)
     120                                                out.println("    <trkseg>");
     121                                        writer.outputNode(ls.from, false);
     122                                        all.remove(ls.from);
     123                                        oldLs = ls;
     124                                        all.remove(ls);
     125                                }
     126                                // write last node if there
     127                                if (oldLs != null) {
     128                                        writer.outputNode(oldLs.to, false);
     129                                        all.remove(oldLs.to);
     130                                        out.println("    </trkseg>");
     131                                }
     132                                out.println("  </trk>");
     133                                all.remove(w);
     134                        }
     135
     136                        // add remaining segments
     137                        Collection<Segment> segments = new LinkedList<Segment>();
     138                        for (OsmPrimitive osm : all)
     139                                if (osm instanceof Segment && !((Segment)osm).incomplete)
     140                                        segments.add((Segment)osm);
     141                        if (!segments.isEmpty()) {
     142                                out.println("  <trk>");
     143                                for (Segment ls : segments) {
     144                                        out.println("    <trkseg>");
     145                                        writer.outputNode(ls.from, false);
     146                                        all.remove(ls.from);
     147                                        writer.outputNode(ls.to, false);
     148                                        all.remove(ls.to);
     149                                        out.println("    </trkseg>");
     150                                        all.remove(ls);
     151                                }
     152                                out.println("  </trk>");
     153                        }
     154
     155                        // finally add the remaining nodes
     156                        for (OsmPrimitive osm : all)
     157                                if (osm instanceof Node)
     158                                        writer.outputNode((Node)osm, true);
     159                }
     160
     161                public void footer(PrintWriter out) {
     162                        if (!metadataClosed)
     163                                out.println("  </metadata>");
    81164                        out.println("</gpx>");
    82                         return;
    83                 }
    84                 // calculate bounds
    85                 Bounds b = new Bounds(new LatLon(Double.MAX_VALUE, Double.MAX_VALUE), new LatLon(Double.MIN_VALUE, Double.MIN_VALUE));
    86                 for (Node n : data.nodes)
    87                         if (!n.deleted)
    88                                 b.extend(n.coor);
    89                 out.println("    <bounds minlat='"+b.min.lat()+"' minlon='"+b.min.lon()+"' maxlat='"+b.max.lat()+"' maxlon='"+b.max.lon()+"' />");
    90                 out.println("  </metadata>");
    91 
    92                 // add ways
    93                 for (Way w : data.ways) {
    94                         if (w.deleted)
    95                                 continue;
    96                         out.println("  <trk>");
    97                         Segment oldLs = null;
    98                         for (Segment ls : w.segments) {
    99                                 if (ls.incomplete)
    100                                         continue;
    101                                 // end old segemnt, if no longer match a chain
    102                                 if (oldLs != null && !oldLs.to.coor.equals(ls.from.coor)) {
    103                                         out.println("    </trkseg>");
    104                                         outputNode(oldLs.to, false);
    105                                         all.remove(oldLs.to);
    106                                         oldLs = null;
    107                                 }
    108                                 // start new segment if necessary
    109                                 if (oldLs == null)
    110                                         out.println("    <trkseg>");
    111                                 outputNode(ls.from, false);
    112                                 all.remove(ls.from);
    113                                 oldLs = ls;
    114                                 all.remove(ls);
    115                         }
    116                         // write last node if there
    117                         if (oldLs != null) {
    118                                 outputNode(oldLs.to, false);
    119                                 all.remove(oldLs.to);
    120                                 out.println("    </trkseg>");
    121                         }
    122                         out.println("  </trk>");
    123                         all.remove(w);
    124                 }
    125 
    126                 // add remaining segments
    127                 Collection<Segment> segments = new LinkedList<Segment>();
    128                 for (OsmPrimitive osm : all)
    129                         if (osm instanceof Segment && !((Segment)osm).incomplete)
    130                                 segments.add((Segment)osm);
    131                 if (!segments.isEmpty()) {
    132                         out.println("  <trk>");
    133                         for (Segment ls : segments) {
    134                                 out.println("    <trkseg>");
    135                                 outputNode(ls.from, false);
    136                                 all.remove(ls.from);
    137                                 outputNode(ls.to, false);
    138                                 all.remove(ls.to);
    139                                 out.println("    </trkseg>");
    140                                 all.remove(ls);
    141                         }
    142                         out.println("  </trk>");
    143                 }
    144 
    145                 // finally add the remaining nodes
    146                 for (OsmPrimitive osm : all)
    147                         if (osm instanceof Node)
    148                                 outputNode((Node)osm, true);
    149 
    150                 out.println("</gpx>");
     165                }
    151166        }
    152167
    … …  
    156171         * trk with as many trkseg as there are collections in the outer collection.
    157172         */
    158         public void output(Collection<Collection<GpsPoint>> data) {
    159                 if (data.size() == 0) {
     173        public static final class Trk implements XmlWriter.OsmWriterInterface {
     174                private final Collection<Collection<GpsPoint>> data;
     175                public Trk(Collection<Collection<GpsPoint>> data) {
     176                        this.data = data;
     177                }
     178
     179                public void header(PrintWriter out) {
     180                        out.println("<gpx version='1.1' creator='JOSM' xmlns='http://www.topografix.com/GPX/1/1'>");
     181                }
     182
     183                public void write(PrintWriter out) {
     184                        if (data.size() == 0)
     185                                return;
     186                        // calculate bounds
     187                        Bounds b = new Bounds(new LatLon(Double.MAX_VALUE, Double.MAX_VALUE), new LatLon(Double.MIN_VALUE, Double.MIN_VALUE));
     188                        for (Collection<GpsPoint> c : data)
     189                                for (GpsPoint p : c)
     190                                        b.extend(p.latlon);
    160191                        out.println("  </metadata>");
     192                        out.println("    <bounds minlat='"+b.min.lat()+"' minlon='"+b.min.lon()+"' maxlat='"+b.max.lat()+"' maxlon='"+b.max.lon()+"' />");
     193                        out.println("  </metadata>");
     194
     195                        out.println("  <trk>");
     196                        for (Collection<GpsPoint> c : data) {
     197                                out.println("    <trkseg>");
     198                                LatLon last = null;
     199                                for (GpsPoint p : c) {
     200                                        // skip double entries
     201                                        if (p.latlon.equals(last))
     202                                                continue;
     203                                        last =  p.latlon;
     204                                        LatLon ll = p.latlon;
     205                                        out.print("      <trkpt lat='"+ll.lat()+"' lon='"+ll.lon()+"'");
     206                                        if (p.time != null && p.time.length()!=0) {
     207                                                out.println(">");
     208                                                out.println("        <time>"+p.time+"</time>");
     209                                                out.println("      </trkpt>");
     210                                        } else
     211                                                out.println(" />");
     212                                }
     213                                out.println("    </trkseg>");
     214                        }
     215                        out.println("  </trk>");
     216                }
     217
     218                public void footer(PrintWriter out) {
    161219                        out.println("</gpx>");
    162                         return;
    163                 }
    164                 // calculate bounds
    165                 Bounds b = new Bounds(new LatLon(Double.MAX_VALUE, Double.MAX_VALUE), new LatLon(Double.MIN_VALUE, Double.MIN_VALUE));
    166                 for (Collection<GpsPoint> c : data)
    167                         for (GpsPoint p : c)
    168                                 b.extend(p.latlon);
    169                 out.println("    <bounds minlat='"+b.min.lat()+"' minlon='"+b.min.lon()+"' maxlat='"+b.max.lat()+"' maxlon='"+b.max.lon()+"' />");
    170                 out.println("  </metadata>");
    171 
    172                 out.println("  <trk>");
    173                 for (Collection<GpsPoint> c : data) {
    174                         out.println("    <trkseg>");
    175                         LatLon last = null;
    176                         for (GpsPoint p : c) {
    177                                 // skip double entries
    178                                 if (p.latlon.equals(last))
    179                                         continue;
    180                                 last =  p.latlon;
    181                                 LatLon ll = p.latlon;
    182                                 out.print("      <trkpt lat='"+ll.lat()+"' lon='"+ll.lon()+"'");
    183                                 if (p.time != null && p.time.length()!=0) {
    184                                         out.println(">");
    185                                         out.println("        <time>"+p.time+"</time>");
    186                                         out.println("      </trkpt>");
    187                                 } else
    188                                         out.println(" />");
    189                         }
    190                         out.println("    </trkseg>");
    191                 }
    192                 out.println("  </trk>");
    193                 out.println("</gpx>");
     220        }
    194221        }
    195222
    … …  
    224251                        out.println(" />");
    225252        }
    226 
    227         public void close() {
    228                 out.flush();
    229                 out.close();
    230         }
    231253}

  • src/org/openstreetmap/josm/io/OsmServerWriter.java

    r113 r143  
    164164                        if (addBody) {
    165165                                OutputStream out = activeConnection.getOutputStream();
    166                                 OsmWriter.outputSingle(out, osm, true);
     166                                OsmWriter.output(out, new OsmWriter.Single(osm, true));
    167167                                out.close();
    168168                        }
    … …  
    178178                        if (retCode != 200) {
    179179                                ByteArrayOutputStream o = new ByteArrayOutputStream();
    180                                 OsmWriter.outputSingle(o, osm, true);
     180                                OsmWriter.output(o, new OsmWriter.Single(osm, true));
    181181                                System.out.println(new String(o.toByteArray(), "UTF-8").toString());
    182182                                throw new RuntimeException(retCode+" "+retMsg);

  • src/org/openstreetmap/josm/io/OsmWriter.java

    r103 r143  
    11package org.openstreetmap.josm.io;
    22
    3 import java.io.OutputStream;
    4 import java.io.OutputStreamWriter;
    53import java.io.PrintWriter;
    6 import java.io.UnsupportedEncodingException;
    74import java.util.HashMap;
    85import java.util.Map.Entry;
    … …  
    1411import org.openstreetmap.josm.data.osm.Way;
    1512import org.openstreetmap.josm.data.osm.visitor.Visitor;
    16 import org.openstreetmap.josm.tools.XmlWriter;
    1713
    1814/**
    … …  
    2117 * @author imi
    2218 */
    23 public class OsmWriter implements Visitor {
    24 
    25         /**
    26          * The output writer to save the values to.
    27          */
    28         private PrintWriter out;
     19public class OsmWriter extends XmlWriter implements Visitor {
    2920
    3021        /**
    … …  
    4031        private final boolean osmConform;
    4132
     33        public abstract static class Osm implements OsmWriterInterface {
     34                public void header(PrintWriter out) {
     35                        out.println("<osm version='0.3' generator='JOSM'>");
     36                }
     37                public void footer(PrintWriter out) {
     38                        out.println("</osm>");
     39                }
     40        }
     41       
    4242        /**
    43          * Output the data to the stream
    44          * @param osmConform <code>true</code>, if the xml should be 100% osm conform. In this
    45          *              case, not all information can be retrieved later (as example, modified state
    46          *              is lost and id's remain 0 instead of decrementing from -1)
     43         * An output writer for function output that writes everything of the given dataset into
     44         * the xml
    4745         */
    48         public static void output(OutputStream out, DataSet ds, boolean osmConform) {
    49                 OsmWriter writer = new OsmWriter(out, osmConform);
    50                 writer.out.println("<?xml version='1.0' encoding='UTF-8'?>");
    51                 writer.out.println("<osm version='0.3' generator='JOSM'>");
    52                 for (Node n : ds.nodes)
    53                         writer.visit(n);
    54                 for (Segment ls : ds.segments)
    55                         writer.visit(ls);
    56                 for (Way w : ds.ways)
    57                         writer.visit(w);
    58                 writer.out.println("</osm>");
    59                 writer.close();
     46        public static final class All extends Osm {
     47                private final DataSet ds;
     48                private final boolean osmConform;
     49
     50                /**
     51                 * Construct an writer function
     52                 * @param osmConform <code>true</code>, if the xml should be 100% osm conform. In this
     53                 *              case, not all information can be retrieved later (as example, modified state
     54                 *              is lost and id's remain 0 instead of decrementing from -1)
     55                 */
     56                public All(DataSet ds, boolean osmConform) {
     57                        this.ds = ds;
     58                        this.osmConform = osmConform;
     59                }
     60
     61                public void write(PrintWriter out) {
     62                        Visitor writer = new OsmWriter(out, osmConform);
     63                        for (Node n : ds.nodes)
     64                                writer.visit(n);
     65                        for (Segment ls : ds.segments)
     66                                writer.visit(ls);
     67                        for (Way w : ds.ways)
     68                                writer.visit(w);
     69        }
    6070        }
    6171
    62         public static void outputSingle(OutputStream out, OsmPrimitive osm, boolean osmConform) {
    63                 OsmWriter writer = new OsmWriter(out, osmConform);
    64                 writer.out.println(XmlWriter.header());
    65                 writer.out.println("<osm version='0.3' generator='JOSM'>");
    66                 osm.visit(writer);
    67                 writer.out.println("</osm>");
    68                 writer.close();
     72        /**
     73         * An output writer for functino output that writes only one specific primitive into
     74         * the xml
     75         */
     76        public static final class Single extends Osm {
     77                private final OsmPrimitive osm;
     78                private final boolean osmConform;
     79
     80                public Single(OsmPrimitive osm, boolean osmConform) {
     81                        this.osm = osm;
     82                        this.osmConform = osmConform;
     83                }
     84
     85                public void write(PrintWriter out) {
     86                        osm.visit(new OsmWriter(out, osmConform));
     87        }
    6988        }
    7089
    71         private OsmWriter(OutputStream out, boolean osmConform) {
    72                 try {
    73                 this.out = new PrintWriter(new OutputStreamWriter(out, "UTF-8"));
    74         } catch (UnsupportedEncodingException e) {
    75                 throw new RuntimeException(e);
    76         }
     90        private OsmWriter(PrintWriter out, boolean osmConform) {
     91                super(out);
    7792                this.osmConform = osmConform;
    7893        }
    … …  
    146161                }
    147162        }
    148 
    149         public void close() {
    150             out.close();
    151     }
    152163}

  • src/org/openstreetmap/josm/io/XmlWriter.java

    r141 r143  
    1 package org.openstreetmap.josm.tools;
     1package org.openstreetmap.josm.io;
    22
     3import java.io.OutputStream;
     4import java.io.OutputStreamWriter;
     5import java.io.PrintWriter;
     6import java.io.UnsupportedEncodingException;
    37import java.util.HashMap;
    48
    … …  
    913 */
    1014public class XmlWriter {
     15
     16        /**
     17         * The interface to write the data into an Osm stream
     18         * @author immanuel.scholz
     19         */
     20        public static interface OsmWriterInterface {
     21                void header(PrintWriter out);
     22                void write(PrintWriter out);
     23                void footer(PrintWriter out);
     24        }
     25
     26
     27        protected XmlWriter(PrintWriter out) {
     28                this.out = out;
     29        }
    1130
    1231        /**
    … …  
    2948
    3049        /**
    31          * @return The standard XML1.0 header. Encoding is utf-8
     50         * Write the header and start tag, then call the runnable to add all real tags and finally
     51         * "closes" the xml by writing the footer.
    3252         */
    33         public static String header() {
    34                 return "<?xml version='1.0' encoding='UTF-8'?>";
     53        public static void output(OutputStream outStream, OsmWriterInterface outputWriter) {
     54                PrintWriter out;
     55                try {
     56                        out = new PrintWriter(new OutputStreamWriter(outStream, "UTF-8"));
     57                } catch (UnsupportedEncodingException e) {
     58                        throw new RuntimeException(e);
     59                }
     60                out.println("<?xml version='1.0' encoding='UTF-8'?>");
     61                outputWriter.header(out);
     62                outputWriter.write(out);
     63                outputWriter.footer(out);
     64                out.flush();
     65                out.close();
    3566        }
    3667
    37        
    38        
     68
     69
     70        /**
     71         * The output writer to save the values to.
     72         */
     73        protected final PrintWriter out;
    3974        final private static HashMap<Character, String> encoding = new HashMap<Character, String>();
    4075        static {

  • test/org/openstreetmap/josm/data/osm/visitor/MergeVisitorTest.java

    r135 r143  
    1111import org.openstreetmap.josm.data.osm.Segment;
    1212import org.openstreetmap.josm.data.osm.Way;
    13 import org.openstreetmap.josm.data.osm.visitor.MergeVisitor;
    1413import org.openstreetmap.josm.testframework.Bug;
    1514import org.openstreetmap.josm.testframework.DataSetTestCaseHelper;
    … …  
    267266        /**
    268267         * Deleted segments should be deleted when merged over unchanged segments.
    269          * Deleted segments should also raise an conflict when merged over changed segments.
    270          */
    271         //TODO
    272 
     268         */
     269        public void testMergeDeletedOverUnchangedDeletes() {
     270                DataSet ds = new DataSet();
     271                Segment oldSegment = createSegment(ds, false, false, 23);
     272                Segment s = createSegment(null, false, true, 23);
     273               
     274                MergeVisitor v = new MergeVisitor(ds);
     275                v.visit(s);
     276                v.fixReferences();
     277               
     278                assertEquals(true, oldSegment.deleted);
     279        }
     280       
     281
     282        /**
     283         * Deleted segments should raise an conflict when merged over changed segments.
     284         */
     285        public void testMergeDeletedOverChangedConflict() {
     286                DataSet ds = new DataSet();
     287                createSegment(ds, false, false, 23).modified = true;
     288                Segment s = createSegment(null, false, true, 23);
     289               
     290                MergeVisitor v = new MergeVisitor(ds);
     291                v.visit(s);
     292                v.fixReferences();
     293               
     294                assertEquals(1, v.conflicts.size());
     295        }
     296
     297
     298        private Segment createSegment(DataSet ds, boolean incomplete, boolean deleted, int id) {
     299                Node n1 = DataSetTestCaseHelper.createNode(ds);
     300                Node n2 = DataSetTestCaseHelper.createNode(ds);
     301                Segment s = DataSetTestCaseHelper.createSegment(ds, n1, n2);
     302                s.incomplete = incomplete;
     303                s.id = id;
     304                s.deleted = deleted;
     305                return s;
     306        }
     307       
    273308        /**
    274309         * Create that amount of nodes and add them to the dataset. The id will be 1,2,3,4...

  • test/org/openstreetmap/josm/testframework/DataSetTestCaseHelper.java

    r135 r143  
    4444                Way t = new Way();
    4545                t.segments.addAll(Arrays.asList(segments));
    46                 ds.ways.add(t);
     46                if (ds != null)
     47                        ds.ways.add(t);
    4748                return t;
    4849        }
    … …  
    5354        public static Segment createSegment(DataSet ds, Node n1, Node n2) {
    5455                Segment ls = new Segment(n1, n2);
    55                 ds.segments.add(ls);
     56                if (ds != null)
     57                        ds.segments.add(ls);
    5658                return ls;
    5759        }
Note: See TracChangeset for help on using the changeset viewer.