Index: /applications/editors/josm/plugins/ColumbusCSV/.classpath =================================================================== --- /applications/editors/josm/plugins/ColumbusCSV/.classpath (revision 23708) +++ /applications/editors/josm/plugins/ColumbusCSV/.classpath (revision 23708) @@ -0,0 +1,7 @@ + + + + + + + Index: /applications/editors/josm/plugins/ColumbusCSV/.externalToolBuilders/ColumbusCSVAnt.launch =================================================================== --- /applications/editors/josm/plugins/ColumbusCSV/.externalToolBuilders/ColumbusCSVAnt.launch (revision 23708) +++ /applications/editors/josm/plugins/ColumbusCSV/.externalToolBuilders/ColumbusCSVAnt.launch (revision 23708) @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + Index: /applications/editors/josm/plugins/ColumbusCSV/LICENSE =================================================================== --- /applications/editors/josm/plugins/ColumbusCSV/LICENSE (revision 23708) +++ /applications/editors/josm/plugins/ColumbusCSV/LICENSE (revision 23708) @@ -0,0 +1,345 @@ + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc. + 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. This +General Public License applies to most of the Free Software +Foundation's software and to any other program whose authors commit to +using it. (Some other Free Software Foundation software is covered by +the GNU Library General Public License instead.) You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +this service if you wish), that you receive source code or can get it +if you want it, that you can change the software or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must show them these terms so they know their +rights. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that redistributors of a free +program will individually obtain patent licenses, in effect making the +program proprietary. To prevent this, we have made it clear that any +patent must be licensed for everyone's free use or not licensed at all. + + The precise terms and conditions for copying, distribution and +modification follow. + + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains +a notice placed by the copyright holder saying it may be distributed +under the terms of this General Public License. The "Program", below, +refers to any such program or work, and a "work based on the Program" +means either the Program or any derivative work under copyright law: +that is to say, a work containing the Program or a portion of it, +either verbatim or with modifications and/or translated into another +language. (Hereinafter, translation is included without limitation in +the term "modification".) Each licensee is addressed as "you". + +Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running the Program is not restricted, and the output from the Program +is covered only if its contents constitute a work based on the +Program (independent of having been made by running the Program). +Whether that is true depends on what the Program does. + + 1. You may copy and distribute verbatim copies of the Program's +source code as you receive it, in any medium, provided that you +conspicuously and appropriately publish on each copy an appropriate +copyright notice and disclaimer of warranty; keep intact all the +notices that refer to this License and to the absence of any warranty; +and give any other recipients of the Program a copy of this License +along with the Program. + +You may charge a fee for the physical act of transferring a copy, and +you may at your option offer warranty protection in exchange for a fee. + + 2. You may modify your copy or copies of the Program or any portion +of it, thus forming a work based on the Program, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + + c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but + does not normally print such an announcement, your work based on + the Program is not required to print an announcement.) + + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Program, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Program, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Program. + +In addition, mere aggregation of another work not based on the Program +with the Program (or with a work based on the Program) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, +under Section 2) in object code or executable form under the terms of +Sections 1 and 2 above provided that you also do one of the following: + + a) Accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of Sections + 1 and 2 above on a medium customarily used for software interchange; or, + + b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + +The source code for a work means the preferred form of the work for +making modifications to it. For an executable work, complete source +code means all the source code for all modules it contains, plus any +associated interface definition files, plus the scripts used to +control compilation and installation of the executable. However, as a +special exception, the source code distributed need not include +anything that is normally distributed (in either source or binary +form) with the major components (compiler, kernel, and so on) of the +operating system on which the executable runs, unless that component +itself accompanies the executable. + +If distribution of executable or object code is made by offering +access to copy from a designated place, then offering equivalent +access to copy the source code from the same place counts as +distribution of the source code, even though third parties are not +compelled to copy the source along with the object code. + + + 4. You may not copy, modify, sublicense, or distribute the Program +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense or distribute the Program is +void, and will automatically terminate your rights under this License. +However, parties who have received copies, or rights, from you under +this License will not have their licenses terminated so long as such +parties remain in full compliance. + + 5. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Program or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Program (or any work based on the +Program), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the +original licensor to copy, distribute or modify the Program subject to +these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 7. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Program at all. For example, if a patent +license would not permit royalty-free redistribution of the Program by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Program. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended to +apply and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system, which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + + 8. If the distribution and/or use of the Program is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Program under this License +may add an explicit geographical distribution limitation excluding +those countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 9. The Free Software Foundation may publish revised and/or new versions +of the General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of this License which applies to it and "any +later version", you have the option of following the terms and conditions +either of that version or of any later version published by the Free +Software Foundation. If the Program does not specify a version number of +this License, you may choose any version ever published by the Free Software +Foundation. + + 10. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the author +to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes +make exceptions for this. Our decision will be guided by the two goals +of preserving the free status of all derivatives of our free software and +of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. + + 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + + END OF TERMS AND CONDITIONS + + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) year name of author + Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, the commands you use may +be called something other than `show w' and `show c'; they could even be +mouse-clicks or menu items--whatever suits your program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the program + `Gnomovision' (which makes passes at compilers) written by James Hacker. + + , 1 April 1989 + Ty Coon, President of Vice + +This General Public License does not permit incorporating your program into +proprietary programs. If your program is a subroutine library, you may +consider it more useful to permit linking proprietary applications with the +library. If this is what you want to do, use the GNU Library General +Public License instead of this License. Index: /applications/editors/josm/plugins/ColumbusCSV/README =================================================================== --- /applications/editors/josm/plugins/ColumbusCSV/README (revision 23708) +++ /applications/editors/josm/plugins/ColumbusCSV/README (revision 23708) @@ -0,0 +1,44 @@ +README +====== + +PURPOSE +------- +This plugin allows to import the proprietary CSV format used by the Columbus V-900 data logger. + +Two modes are supported +a) Simple mode (default) +b) Professional or extended mode - logs additional GPS values like VDOP, HDOP, Fixing. This can + be accomplished by putting a file named config.txt onto the microSD card shipped with the V-900 + logger. The contents of my file looks as follows: + + --- BEGIN config.txt --- + 1,000,001, + notes: + 1 Professional mode + 000 Over-speed tag + 001 Spy mode timer + --- END config.txt --- + + Please refer to the manual for details. + +Way points and tracks are transformed into the GPX format. Way points may be either plain position entries or +may reference an audio file recorded during the logging session. In this case, the way point shows up with +a flag - pressing it play the recorded audio. + + + +OPTIONS +------- +This plugin offers some options predominately to change the import behavior. All settings are accessible via the +JOSM preferences dialog and starts with the prefix 'columbuscsv'. + +The options are +* Show summary after import (Boolean), default: true +* Ignore audio files (Boolean), default: false +* Ignore hdop/vdop/pdop entries (Boolean), default: false +* Warn on missing audio files (Boolean), default: true +* Warn on conversion errors (Boolean), default: true + +I hope that this plugin is useful. + +Please report bugs to mailto:oliverwieland@me.com. Index: /applications/editors/josm/plugins/ColumbusCSV/build.xml =================================================================== --- /applications/editors/josm/plugins/ColumbusCSV/build.xml (revision 23708) +++ /applications/editors/josm/plugins/ColumbusCSV/build.xml (revision 23708) @@ -0,0 +1,151 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Index: /applications/editors/josm/plugins/ColumbusCSV/src/org/openstreetmap/josm/plugins/columbusCSV/ColumbusCSVImporter.java =================================================================== --- /applications/editors/josm/plugins/ColumbusCSV/src/org/openstreetmap/josm/plugins/columbusCSV/ColumbusCSVImporter.java (revision 23708) +++ /applications/editors/josm/plugins/ColumbusCSV/src/org/openstreetmap/josm/plugins/columbusCSV/ColumbusCSVImporter.java (revision 23708) @@ -0,0 +1,108 @@ +/** + * This program is free software: you can redistribute it and/or modify it under + * the terms of the GNU General Public License as published by the + * Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; + * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along with this program. + * If not, see . + */ + +package org.openstreetmap.josm.plugins.columbusCSV; + +import static org.openstreetmap.josm.tools.I18n.tr; + +import java.io.File; +import java.io.IOException; +import org.openstreetmap.josm.Main; +import org.openstreetmap.josm.actions.AutoScaleAction; +import org.openstreetmap.josm.actions.ExtensionFileFilter; +import org.openstreetmap.josm.data.gpx.GpxData; +import org.openstreetmap.josm.gui.layer.GpxLayer; +import org.openstreetmap.josm.gui.layer.markerlayer.MarkerLayer; +import org.openstreetmap.josm.gui.progress.NullProgressMonitor; +import org.openstreetmap.josm.gui.progress.ProgressMonitor; +import org.openstreetmap.josm.io.FileImporter; +import org.openstreetmap.josm.io.IllegalDataException; + +/** + * + * @author Oliver + * + */ +public class ColumbusCSVImporter extends FileImporter { + public static final String COLUMBUS_FILE_EXT = "csv"; + public static final String COLUMBUS_FILE_EXT_DOT = "." + COLUMBUS_FILE_EXT; + + public ColumbusCSVImporter() { + super(new ExtensionFileFilter(COLUMBUS_FILE_EXT, COLUMBUS_FILE_EXT, + tr("Columbus V-900 CSV Files") + " (*" + COLUMBUS_FILE_EXT_DOT + + ")")); + } + + @Override + public void importData(File file, ProgressMonitor progressMonitor) + throws IOException, IllegalDataException { + String fn = file.getPath(); + + if (progressMonitor == null) { // make sure that there is a progress + // monitor... + progressMonitor = NullProgressMonitor.INSTANCE; + } + + progressMonitor.beginTask(String.format("Importing CSV file %s...", + file.getName(), 4)); + progressMonitor.setTicksCount(1); + + if (fn.toLowerCase().endsWith(COLUMBUS_FILE_EXT_DOT)) { + try { + ColumbusCSVReader r = new ColumbusCSVReader(); + + // transform CSV into GPX + GpxData gpxData = r.transformColumbusCSV(fn); + progressMonitor.setTicksCount(1); + + r.dropBufferLists(); + + progressMonitor.setTicksCount(2); + + GpxLayer gpxLayer = new GpxLayer(gpxData, file.getName()); + + // add layer to show way points + Main.main.addLayer(gpxLayer); + + progressMonitor.setTicksCount(3); + + // ... and scale view appropriately - if wished by user + if (!ColumbusCSVPreferences.dontZoom()) { + AutoScaleAction action = new AutoScaleAction("data"); + action.autoScale(); + } + progressMonitor.setTicksCount(4); + + if (Main.pref.getBoolean("marker.makeautomarkers", true)) { + MarkerLayer ml = new MarkerLayer(gpxData, tr( + "Markers from {0}", file.getName()), file, gpxLayer); + if (ml.data.size() > 0) { + Main.main.addLayer(ml); + } + } + } catch (Exception e) { + // catch and forward exception + throw new IllegalDataException(e); + } finally { // take care of monitor... + progressMonitor.finishTask(); + } + } else { + throw new IOException( + tr(String + .format( + "Unsupported file extension (file '%s' does not end with '%s')!", + file.getName(), COLUMBUS_FILE_EXT))); + } + } +} Index: /applications/editors/josm/plugins/ColumbusCSV/src/org/openstreetmap/josm/plugins/columbusCSV/ColumbusCSVPlugin.java =================================================================== --- /applications/editors/josm/plugins/ColumbusCSV/src/org/openstreetmap/josm/plugins/columbusCSV/ColumbusCSVPlugin.java (revision 23708) +++ /applications/editors/josm/plugins/ColumbusCSV/src/org/openstreetmap/josm/plugins/columbusCSV/ColumbusCSVPlugin.java (revision 23708) @@ -0,0 +1,49 @@ +/** + * This program is free software: you can redistribute it and/or modify it under + * the terms of the GNU General Public License as published by the + * Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; + * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along with this program. + * If not, see . + */ + +package org.openstreetmap.josm.plugins.columbusCSV; + +import org.openstreetmap.josm.actions.ExtensionFileFilter; +import org.openstreetmap.josm.gui.preferences.PreferenceSetting; +import org.openstreetmap.josm.plugins.Plugin; +import org.openstreetmap.josm.plugins.PluginInformation; + +/** + * Plugin class to import Columbus V-900 CSV files into JOSM. + * + * @author Oliver Wieland + * + */ +public class ColumbusCSVPlugin extends Plugin { + private static PreferenceSetting columbusSettings; + /* + * Plugin constructor (adds menu entry to file menu). + */ + public ColumbusCSVPlugin(PluginInformation info) { + super(info); + + ExtensionFileFilter.importers.add(new ColumbusCSVImporter()); + } + + /** + * Called in the preferences dialog to create a preferences page for the plugin, + * if any available. + */ + public PreferenceSetting getPreferenceSetting() { + if (columbusSettings == null) { + columbusSettings = new ColumbusCSVPreferences(); + } + return columbusSettings; + } +} Index: /applications/editors/josm/plugins/ColumbusCSV/src/org/openstreetmap/josm/plugins/columbusCSV/ColumbusCSVPreferences.java =================================================================== --- /applications/editors/josm/plugins/ColumbusCSV/src/org/openstreetmap/josm/plugins/columbusCSV/ColumbusCSVPreferences.java (revision 23708) +++ /applications/editors/josm/plugins/ColumbusCSV/src/org/openstreetmap/josm/plugins/columbusCSV/ColumbusCSVPreferences.java (revision 23708) @@ -0,0 +1,177 @@ +/** + * This program is free software: you can redistribute it and/or modify it under + * the terms of the GNU General Public License as published by the + * Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; + * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along with this program. + * If not, see . + */ +package org.openstreetmap.josm.plugins.columbusCSV; + +import static org.openstreetmap.josm.tools.I18n.tr; + +import java.awt.event.ItemEvent; +import java.awt.event.ItemListener; + +import javax.swing.ButtonGroup; +import javax.swing.JCheckBox; + +import org.openstreetmap.josm.Main; +import org.openstreetmap.josm.gui.preferences.PreferenceDialog; +import org.openstreetmap.josm.gui.preferences.PreferenceSetting; +import org.openstreetmap.josm.gui.preferences.PreferenceTabbedPane; + +/** + * Implements the preferences dialog for this plugin. + * @author Oliver + */ +public class ColumbusCSVPreferences implements PreferenceSetting, ItemListener { + public static final String PREFIX = "columbuscsv."; + + /** + * Show summary after import. + */ + public static final String SHOW_SUMMARY = PREFIX + "import.showSummary"; + /** + * Disable auto zoom after import. + */ + public static final String DONT_ZOOM_AFTER_IMPORT = PREFIX + "import.dontZoomAfterImport"; + /** + * If true, all DOP values (hdop, vdop, pdop) are ignored. If the V-900 runs in simple mode, + * this setting has no effect. + */ + public static final String IGNORE_VDOP = PREFIX + "import.ignoreVDOP"; + /** + * Issue warning on missing audio files. + */ + public static final String WARN_MISSING_AUDIO = PREFIX + "warn.missingAudio"; + /** + * Issue warning on conversion errors. + */ + public static final String WARN_CONVERSION_ERRORS = PREFIX + "warn.conversionErrors"; + + /** + * Ui elements for each flag. + */ + private JCheckBox colCSVShowSummary = new JCheckBox(tr("Show summary after import")); + private JCheckBox colCSVDontZoomAfterImport = new JCheckBox(tr("Do not zoom after import")); + private JCheckBox colCSVIgnoreVDOP = new JCheckBox(tr("Ignore hdop/vdop/pdop entries")); + private JCheckBox colCSVWarnMissingAudio = new JCheckBox(tr("Warn on missing audio files")); + private JCheckBox colCSVWarnConversionErrors = new JCheckBox(tr("Warn on conversion errors")); + + /** + * Creates a new preferences instance. + */ + public ColumbusCSVPreferences() { + super(); + + } + + /** + * Applies the (new) settings after settings dialog has been closed successfully. + */ + public boolean ok() { + Main.pref.put(SHOW_SUMMARY, colCSVShowSummary.isSelected()); + Main.pref.put(DONT_ZOOM_AFTER_IMPORT, colCSVDontZoomAfterImport.isSelected()); + Main.pref.put(IGNORE_VDOP, colCSVIgnoreVDOP.isSelected()); + Main.pref.put(WARN_CONVERSION_ERRORS, colCSVWarnConversionErrors.isSelected()); + Main.pref.put(WARN_MISSING_AUDIO, colCSVWarnMissingAudio.isSelected()); + return false; + } + + /** + * Handles state changes of check buttons + */ + public void itemStateChanged(ItemEvent itemEv) { + /* + if (itemEv.getSource() == colCSVShowSummary) { + colCSVWarnMissingAudio.setEnabled(colCSVIgnoreAudio.isSelected()); + }*/ + } + + /** + * If true, a summary dialog is shown after import. Default is true. + * @return + */ + public static boolean showSummary() { + return Main.pref.getBoolean(SHOW_SUMMARY, true); + } + + /** + * If true, a the bounding box will not be scaled to the imported data. + * @return + */ + public static boolean dontZoom() { + return Main.pref.getBoolean(DONT_ZOOM_AFTER_IMPORT, true); + } + + /** + * If true, all DOP values (hdop, vdop, pdop) are ignored. If the V-900 runs in simple mode, + * this setting has no effect. + * Default is false. + * @return + */ + public static boolean ignoreDOP() { + return Main.pref.getBoolean(IGNORE_VDOP, false); + } + + /** + * If true, the plugin issues warnings if either date or position errors have been occurred. + * Default is true. + * @return + */ + public static boolean warnConversion() { + return Main.pref.getBoolean(WARN_CONVERSION_ERRORS, false); + } + + /** + * If true, the plugin issues a warning if a referenced audio file is missing. + * Default is true. + * @return + */ + public static boolean warnMissingAudio() { + return Main.pref.getBoolean(WARN_MISSING_AUDIO, false); + } + + /** + * Populates the UI with our settings. + * @param gui The dialog to populate. + */ + public void addGui(PreferenceDialog gui) { + addPrefs(); + } + + /** + * Populates the UI with our settings. + * @param gui The pane to populate. + */ + public void addGui(PreferenceTabbedPane gui) { + addPrefs(); + } + + private void addPrefs() { + // Import settings + ButtonGroup gpsImportGroup = new ButtonGroup(); + gpsImportGroup.add(colCSVShowSummary); + gpsImportGroup.add(colCSVDontZoomAfterImport); + gpsImportGroup.add(colCSVIgnoreVDOP); + + // Warning settings + ButtonGroup gpsWarningsGroup = new ButtonGroup(); + gpsWarningsGroup.add(colCSVWarnMissingAudio); + gpsWarningsGroup.add(colCSVWarnConversionErrors); + + // Apply settings + colCSVShowSummary.setSelected(Main.pref.getBoolean(SHOW_SUMMARY, true)); + colCSVDontZoomAfterImport.setSelected(Main.pref.getBoolean(DONT_ZOOM_AFTER_IMPORT, true)); + colCSVIgnoreVDOP.setSelected(Main.pref.getBoolean(IGNORE_VDOP, false)); + colCSVWarnConversionErrors.setSelected(Main.pref.getBoolean(WARN_CONVERSION_ERRORS, true)); + colCSVWarnMissingAudio.setSelected(Main.pref.getBoolean(WARN_MISSING_AUDIO, true)); + } + +} Index: /applications/editors/josm/plugins/ColumbusCSV/src/org/openstreetmap/josm/plugins/columbusCSV/ColumbusCSVReader.java =================================================================== --- /applications/editors/josm/plugins/ColumbusCSV/src/org/openstreetmap/josm/plugins/columbusCSV/ColumbusCSVReader.java (revision 23708) +++ /applications/editors/josm/plugins/ColumbusCSV/src/org/openstreetmap/josm/plugins/columbusCSV/ColumbusCSVReader.java (revision 23708) @@ -0,0 +1,604 @@ +/** + * This program is free software: you can redistribute it and/or modify it under + * the terms of the GNU General Public License as published by the + * Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; + * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along with this program. + * If not, see . + */ +package org.openstreetmap.josm.plugins.columbusCSV; + +import static org.openstreetmap.josm.tools.I18n.tr; + +import java.io.BufferedReader; +import java.io.DataInputStream; +import java.io.File; +import java.io.FileInputStream; +import java.io.IOException; +import java.io.InputStreamReader; +import java.text.ParseException; +import java.text.SimpleDateFormat; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.Date; +import java.util.HashMap; +import java.util.List; +import java.util.StringTokenizer; +import java.util.zip.DataFormatException; + +import org.openstreetmap.josm.data.coor.LatLon; +import org.openstreetmap.josm.data.gpx.GpxData; +import org.openstreetmap.josm.data.gpx.GpxLink; +import org.openstreetmap.josm.data.gpx.GpxTrack; +import org.openstreetmap.josm.data.gpx.ImmutableGpxTrack; +import org.openstreetmap.josm.data.gpx.WayPoint; +import org.openstreetmap.josm.io.IllegalDataException; + +/** + * This class reads a native CSV of the Columbus V-900 data logger and converts + * them into a GPX data layer. This class supports as well the simple as the + * extended mode. By default, the V-900 runs in simple mode, which contains the + * most important data like + *
    + *
  1. Position (Longitude and Latitude) + *
  2. Date & Time + *
  3. Speed + *
  4. Heading + *
+ * Audio recordings are way points which references the audio file (.wav file). + * Make sure that all audio files are in the same folder as the CSV file. + * + * The extended mode contains additional data regarding GPS data quality like + * all DOP and GPS mode. + * + * To activate the extended mode, just put a file named config.txt on + * the microSD card which has been shipped with the device. + * + * Then change the content of the config.txt to + * 1,000,001, +notes: +1 Professional mode +000 Over-speed tag +001 Spy mode timer + * + * + * @author Oliver + * + */ +public class ColumbusCSVReader { + public static final String AUDIO_WAV_LINK = "audio/wav"; + /* GPX tags not provided by the GPXReader class */ + private static final String VDOP_TAG = "vdop"; + private static final String HDOP_TAG = "hdop"; + private static final String PDOP_TAG = "pdop"; + private static final String ELEVATIONHEIGHT_TAG = "ele"; + private static final String TIME_TAG = "time"; + private static final String COMMENT_TAG = "cmt"; + private static final String DESC_TAG = "desc"; + private static final String FIX_TAG = "fix"; + private static final String TYPE_TAG = "columbus:type"; + + private static String[] EMPTY_LINE = new String[] {}; + private static final String SEPS = ","; + + private int dopConversionErrors = 0; + private int dateConversionErrors = 0; + + private int firstVoxNumber = -1, lastVoxNumber = -1; + + private HashMap voxFiles = new HashMap(); + private Collection> allTrackPts = new ArrayList>(); + private List trackPts = new ArrayList(); + private List allWpts = new ArrayList(); + private String fileDir; + + /** + * Transforms a Columbus V-900 CSV file into a JOSM GPX layer. + * + * @param fileName + * @return + * @throws IOException + * @throws DataFormatException + */ + public GpxData transformColumbusCSV(String fileName) throws IOException, + IllegalDataException { + if (fileName == null || fileName.length() == 0) { + throw new IllegalArgumentException( + "File name must not be null or empty"); + } + + // GPX data structures + GpxData gpxData = new GpxData(); + + File f = new File(fileName); + fileDir = f.getParent(); + FileInputStream fstream = new FileInputStream(fileName); + // Get the object of DataInputStream + DataInputStream in = new DataInputStream(fstream); + BufferedReader br = new BufferedReader(new InputStreamReader(in)); + String strLine; + // Initial values + int line = 1; + initImport(); + dropBufferLists(); + + int waypts = 0, trkpts = 0, audiopts = 0, missaudio = 0, rescaudio = 0; + try { + // Read File Line By Line + while ((strLine = br.readLine()) != null) { + String[] csvFields = getCSVLine(strLine); // Get the columns of the current line + if (csvFields.length == 0 || line <= 1) { // Skip, if line is header or contains no data + ++line; + continue; + } + + try { + WayPoint wpt = createWayPoint(csvFields, fileDir); + String wptType = (String) wpt.attr.get(TYPE_TAG); + String oldWptType = csvFields[1]; + + if ("T".equals(wptType)) { // point of track (T) + trackPts.add(wpt); + trkpts++; + } else { // way point (C) / have voice file: V) + if (!wptType.equals(oldWptType)) { // type changed? + if ("V".equals(oldWptType)) { // missing audiofile + missaudio++; + } + if ("C".equals(oldWptType)) { // rescued audiofile + rescaudio++; + } + } else { + if ("V".equals(wptType)) { // wpt with vox + audiopts++; + } + } + + gpxData.waypoints.add(wpt); // add the waypoint to the track + waypts++; + } + + allWpts.add(wpt); + + wpt.attr.remove(TYPE_TAG); + } catch (Exception ex) { + throw new IllegalDataException(tr("Error in line " + line + + ": " + ex.toString())); + } + ++line; + } + } finally { + // Close the input stream + in.close(); + } + + // do some sanity checks + assert (trackPts.size() == trkpts); + assert (gpxData.waypoints.size() == waypts); + assert (firstVoxNumber <= lastVoxNumber); + + rescaudio += searchForLostAudioFiles(gpxData); + + // compose the track + allTrackPts.add(trackPts); + GpxTrack trk = new ImmutableGpxTrack(allTrackPts, Collections + . emptyMap()); + gpxData.tracks.add(trk); + + assert (gpxData.routes.size() == 1); + + // Issue conversion warning, if needed + if (ColumbusCSVPreferences.warnConversion() + && (dateConversionErrors > 0 || dopConversionErrors > 0)) { + String message = String.format( + "%d date conversion faults and %d DOP conversion errors", + dateConversionErrors, dopConversionErrors); + ColumbusCSVUtils.showWarningMessage(tr(message)); + } + // Show summary + if (ColumbusCSVPreferences.showSummary()) { + showSummary(waypts, trkpts, audiopts, missaudio, rescaudio); + } + + String desc = String.format("Converted by ColumbusCSV plugin from track file '%s'", f.getName()); + gpxData.attr.put(GpxData.META_DESC, desc); + return gpxData; + } + + /** + * Searches for unlinked audio files and tries to link them with the closest + * way point. This requires that the file date of the wav files is kept - + * there is no other way to assign the audio files to way points. + * + * @param reader + * @return + */ + private int searchForLostAudioFiles(GpxData gpx) { + HashMap voxFiles = getVoxFileMap(); + + int first, last; + first = getFirstVoxNumber(); + last = getLastVoxNumber(); + + int rescuedFiles = 0; + + for (int i = first; i < last; i++) { + String voxFile = String.format("vox%05d", i); + String nextVoxFile = String.format("vox%05d", i+1); + if (!voxFiles.containsKey(voxFile)) { + System.out.println("Found lost vox file " + voxFile); + + File f = getVoxFilePath(voxFile); + WayPoint nearestWpt = null; + List wpts = getAllWayPoints(); + // Attach recording to the way point right before the next vox file + if (voxFiles.containsKey(nextVoxFile)) { + WayPoint nextWpt = voxFiles.get(nextVoxFile); + int idx = getAllWayPoints().indexOf(nextWpt) - 5; + if (idx >= 0) { + nearestWpt = wpts.get(idx); + } else { + nearestWpt = wpts.get(0); + } + } else { // attach to last way point + nearestWpt = wpts.get(wpts.size() - 1); + } + + // Add link to found way point + if (nearestWpt != null) { + if (addLinkToWayPoint(nearestWpt, "*" + voxFile + "*", f)) { + System.out.println(String.format( + "Linked file %s to position %s", voxFile, + nearestWpt.getCoor().toDisplayString())); + // Add linked way point to way point list of GPX; otherwise + // it would not be shown correctly + gpx.waypoints.add(nearestWpt); + rescuedFiles++; + } else { + System.err + .println(String + .format( + "Could not link vox file %s due to invalid parameters.", + voxFile)); + } + } + } + } + + return rescuedFiles; + } + + /** + * + */ + private void initImport() { + dateConversionErrors = 0; + dopConversionErrors = 0; + firstVoxNumber = Integer.MAX_VALUE; + lastVoxNumber = Integer.MIN_VALUE; + } + + /** + * Clears all temporary buffers. + */ + void dropBufferLists() { + allTrackPts.clear(); + trackPts.clear(); + voxFiles.clear(); + } + + /** + * Shows the summary to the user. + * @param waypts The number of imported way points + * @param trkpts The number of imported track points + * @param audiopts The number of imported way points with vox + * @param missaudio The number of missing audio files + * @param rescaudio The number of rescued audio files + */ + private void showSummary(int waypts, int trkpts, int audiopts, + int missaudio, int rescaudio) { + String message = ""; + if (missaudio > 0) { + message = String + .format( + "Imported %d track points and %d way points (%d with audio, %d rescued).\nNote: %d audio files could not be found, please check marker comments!", + trkpts, waypts, audiopts, rescaudio, missaudio); + } else { + message = String + .format( + "Imported %d track points and %d way points (%d with audio, %d rescued).", + trkpts, waypts, audiopts, rescaudio); + } + ColumbusCSVUtils.showInfoMessage(tr(message)); + } + + /** + * Creates a GPX way point from a tokenized CSV line. The attributes of the + * way point depends on whether the Columbus logger runs in simple or + * professional mode. + * + * @param csvLine The columns of a single CSV line. + * @return The corresponding way point instance. + * @throws DataFormatException + */ + private WayPoint createWayPoint(String[] csvLine, String fileDir) + throws IOException { + // Sample line in simple mode + // INDEX,TAG,DATE,TIME,LATITUDE N/S,LONGITUDE + // E/W,HEIGHT,SPEED,HEADING,VOX + // 1,T,090430,194134,48.856330N,009.089779E,318,20,0, + + // Sample line in extended mode + // INDEX,TAG,DATE,TIME,LATITUDE N/S,LONGITUDE + // E/W,HEIGHT,SPEED,HEADING,FIX MODE,VALID,PDOP,HDOP,VDOP,VOX + // 1,T,090508,191448,48.856928N,009.091153E,330,3,0,3D,SPS ,1.4,1.2,0.8, + if (csvLine.length != 10 && csvLine.length != 15) + throw new IOException("Invalid number of tokens: " + csvLine.length); + boolean isExtMode = csvLine.length > 10; + + // Extract latitude/longitude first + String lat = csvLine[4]; + double latVal = Double.parseDouble(lat.substring(0, lat.length() - 1)); + if (lat.endsWith("S")) { + latVal = -latVal; + } + + String lon = csvLine[5]; + double lonVal = Double.parseDouble(lon.substring(0, lon.length() - 1)); + if (lon.endsWith("W")) { + lonVal = -lonVal; + } + LatLon pos = new LatLon(latVal, lonVal); + WayPoint wpt = new WayPoint(pos); + + // set wpt type + wpt.attr.put(TYPE_TAG, csvLine[1]); + + // Check for audio file and link it, if present + String voxFile = null; + if (isExtMode) { + voxFile = csvLine[14].toLowerCase(); + } else { + voxFile = csvLine[9].toLowerCase(); + } + + if (!ColumbusCSVUtils.isStringNullOrEmpty(voxFile)) { + File file = getVoxFilePath(fileDir, voxFile); + if (file.exists()) { + int voxNum = getNumberOfVoxfile(voxFile); + lastVoxNumber = Math.max(voxNum, lastVoxNumber); + firstVoxNumber = Math.min(voxNum, firstVoxNumber); + + addLinkToWayPoint(wpt, voxFile, file); + + if (!"V".equals(csvLine[1])) { + System.out.println("Rescued unlinked audio file " + voxFile); + } + voxFiles.put(voxFile, wpt); + + // set type to way point with vox + wpt.attr.put(TYPE_TAG, "V"); + } else { // audio file not found -> issue warning + System.err.println("File " + voxFile + " not found!"); + String warnMsg = tr("Missing audio file") + ": " + voxFile; + System.err.println(warnMsg); + if (ColumbusCSVPreferences.warnMissingAudio()) { + ColumbusCSVUtils.showInfoMessage(warnMsg); + } + wpt.attr.put(ColumbusCSVReader.COMMENT_TAG, warnMsg); + // set type to ordinary way point + wpt.attr.put(TYPE_TAG, "C"); + } + + } + + // Extract date/time + SimpleDateFormat sdf = new java.text.SimpleDateFormat("yyMMdd/HHmmss"); + Date d = null; + + try { + + d = sdf.parse(csvLine[2] + "/" + csvLine[3]); + // format date according to GPX + SimpleDateFormat f = new SimpleDateFormat( + "yyyy-MM-dd'T'HH:mm:ss'Z'"); + + wpt.attr.put(ColumbusCSVReader.TIME_TAG, f.format(d).toString()); + wpt.setTime(); + } catch (ParseException ex) { + dateConversionErrors++; + System.err.println(ex); + } + + // Add further attributes + // Elevation height (altitude provided by GPS signal) + wpt.attr.put(ColumbusCSVReader.ELEVATIONHEIGHT_TAG, csvLine[6]); + + // Add data of extended mode, if applicable + if (isExtMode && !ColumbusCSVPreferences.ignoreDOP()) { + addExtendedGPSData(csvLine, wpt); + } + + return wpt; + } + + /** + * Gets the full path of the audio file. Same as getVoxFilePath(getWorkingDirOfImport(), voxFile). + * @param voxFile The name of the audio file without dir and extension. + * @return + * + */ + public File getVoxFilePath(String voxFile) { + return getVoxFilePath(getWorkingDirOfImport(), voxFile); + } + + /** + * Gets the full path of the audio file. + * @param fileDir The directory containing the audio file. + * @param voxFile The name of the audio file without dir and extension. + * @return + */ + public File getVoxFilePath(String fileDir, String voxFile) { + File file = new File(fileDir + File.separator + voxFile + ".wav"); + return file; + } + + /** + * Adds extended GPS data (*DOP and fix mode) to the way point + * @param csvLine + * @param wpt + */ + private void addExtendedGPSData(String[] csvLine, WayPoint wpt) { + // Fix mode + wpt.attr.put(FIX_TAG, csvLine[9].toLowerCase()); + + Float f; + // Position errors (dop = dilution of position) + f = ColumbusCSVUtils.floatFromString(csvLine[11]); + if (f != Float.NaN) { + wpt.attr.put(ColumbusCSVReader.PDOP_TAG, f); + } else { + dopConversionErrors++; + } + + f = ColumbusCSVUtils.floatFromString(csvLine[12]); + if (f != Float.NaN) { + wpt.attr.put(ColumbusCSVReader.HDOP_TAG, f); + } else { + dopConversionErrors++; + } + + f = ColumbusCSVUtils.floatFromString(csvLine[13]); + if (f != Float.NaN) { + wpt.attr.put(ColumbusCSVReader.VDOP_TAG, f); + } else { + dopConversionErrors++; + } + } + + /** + * Adds a link to a way point. + * @param wpt The way point to add the link to. + * @param voxFile + * @param file + * @return True, if link has been added; otherwise false + */ + public boolean addLinkToWayPoint(WayPoint wpt, String voxFile, File file) { + if (file == null || wpt == null || voxFile == null) return false; + + GpxLink lnk = new GpxLink(file.toURI().toString()); + lnk.type = ColumbusCSVReader.AUDIO_WAV_LINK; + lnk.text = voxFile; + + // JOSM expects a collection of links here... + Collection linkList = new ArrayList(1); + linkList.add(lnk); + + wpt.attr.put(GpxData.META_LINKS, linkList); + wpt.attr.put(ColumbusCSVReader.COMMENT_TAG, "Audio recording"); + wpt.attr.put(ColumbusCSVReader.DESC_TAG, voxFile); + return true; + } + + /** + * Splits a line of the CSV files into it's tokens. + * + * @param line + * @return Array containing the tokens of the CSV file. + */ + private String[] getCSVLine(String line) { + if (line == null || line.length() == 0) + return EMPTY_LINE; + + StringTokenizer st = new StringTokenizer(line, SEPS, false); + int n = st.countTokens(); + + String[] res = new String[n]; + for (int i = 0; i < n; i++) { + res[i] = st.nextToken().trim(); + } + return res; + } + + /** + * Extracts the number from a VOX file name, e. g. for a + * file named "VOX01524" this method will return 1524. + * @param fileName The vox file name. + * @return The number of the vox file or -1; if the given name was not valid. + */ + private int getNumberOfVoxfile(String fileName) { + if (fileName == null) return -1; + + try { + String num = fileName.substring(3); + int val = Integer.parseInt(num); + return val; + } catch (NumberFormatException e) { + return -1; + } + } + + /** + * Return the number of date conversion errors. + * + * @return + */ + public int getNumberOfDateConversionErrors() { + return dateConversionErrors; + } + + /** + * Return the number of pdop/vdop/hdop conversion errors. + * + * @return + */ + public int getNumberOfDOPConversionErrors() { + return dopConversionErrors; + } + + /** + * Gets the number of first vox file. + * @return + */ + public int getFirstVoxNumber() { + return firstVoxNumber; + } + + /** + * Gets the number of last vox file. + * @return + */ + public int getLastVoxNumber() { + return lastVoxNumber; + } + + /** + * Gets the map containing the vox files with their associated way point. + * @return + */ + public HashMap getVoxFileMap() { + return voxFiles; + } + + /** + * Gets the list containing all imported track and way points. + * @return + */ + public List getAllWayPoints() { + return allWpts; + } + + /** + * Gets the import directory. + * @return + */ + public String getWorkingDirOfImport() { + return fileDir; + } +} Index: /applications/editors/josm/plugins/ColumbusCSV/src/org/openstreetmap/josm/plugins/columbusCSV/ColumbusCSVUtils.java =================================================================== --- /applications/editors/josm/plugins/ColumbusCSV/src/org/openstreetmap/josm/plugins/columbusCSV/ColumbusCSVUtils.java (revision 23708) +++ /applications/editors/josm/plugins/ColumbusCSV/src/org/openstreetmap/josm/plugins/columbusCSV/ColumbusCSVUtils.java (revision 23708) @@ -0,0 +1,94 @@ +/** + * This program is free software: you can redistribute it and/or modify it under + * the terms of the GNU General Public License as published by the + * Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; + * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along with this program. + * If not, see . + */ +package org.openstreetmap.josm.plugins.columbusCSV; + +import static org.openstreetmap.josm.tools.I18n.tr; + +import javax.swing.JOptionPane; + +import org.openstreetmap.josm.Main; + +public class ColumbusCSVUtils { + /** + * Private constructor for the utility class. + */ + private ColumbusCSVUtils() { + + } + + /** + * Shows an error message. + * @param txt Message to show. + */ + public static void showErrorMessage(String txt) { + showMessage(txt, tr("Error"), JOptionPane.ERROR_MESSAGE); + } + + /** + * Shows an information message. + * @param txt Message to show. + */ + public static void showInfoMessage(String txt) { + showMessage(txt, tr("Information"), JOptionPane.INFORMATION_MESSAGE); + } + + /** + * Shows a warning message. + * @param txt Message to show. + */ + public static void showWarningMessage(String txt) { + showMessage(txt, tr("Warning"), JOptionPane.WARNING_MESSAGE); + } + + /** + * Generic method to show a message. + * @param txt Message to show + * @param caption Title of message box + * @param icon Icon to show (question, warning,...) + */ + public static void showMessage(String txt, String caption, int icon) { + if (isStringNullOrEmpty(txt)) return; + + JOptionPane.showMessageDialog(Main.parent, tr(txt), caption, icon); + } + + /** + * Check, if a string is either null or empty. + * + * @param txt + * . The text to check for. + * @return True, if given text is either null or empty. + */ + public static boolean isStringNullOrEmpty(String txt) { + return txt == null || txt.length() == 0; + } + + /** + * Parses a float number from a string. + * @param txt + * @return The corresponding float instance or Float.NaN, if txt was empty or contained an invalid float number. + */ + public static Float floatFromString(String txt) { + Float f; + + if (isStringNullOrEmpty(txt)) return Float.NaN; + + try { + f = Float.parseFloat(txt); + } catch (NumberFormatException nex) { + f = Float.NaN; + } + return f; + } +} Index: /applications/editors/josm/plugins/ColumbusCSV/src/org/openstreetmap/josm/plugins/columbusCSV/WayPointHelper.java =================================================================== --- /applications/editors/josm/plugins/ColumbusCSV/src/org/openstreetmap/josm/plugins/columbusCSV/WayPointHelper.java (revision 23708) +++ /applications/editors/josm/plugins/ColumbusCSV/src/org/openstreetmap/josm/plugins/columbusCSV/WayPointHelper.java (revision 23708) @@ -0,0 +1,145 @@ +/** + * This program is free software: you can redistribute it and/or modify it under + * the terms of the GNU General Public License as published by the + * Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; + * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along with this program. + * If not, see . + */ + +package org.openstreetmap.josm.plugins.columbusCSV; + +import static java.lang.Math.asin; +import static java.lang.Math.cos; +import static java.lang.Math.sin; +import static java.lang.Math.sqrt; +import static java.lang.Math.toDegrees; +import static java.lang.Math.toRadians; + +import java.util.ArrayList; +import java.util.List; + +import org.openstreetmap.josm.data.coor.LatLon; +import org.openstreetmap.josm.data.gpx.WayPoint; + +/** + * @author Oliver Provides several static methods to access way point + * attributes. + */ +public class WayPointHelper { + /** + * The name of the elevation height of a way point. + */ + public static final String HEIGHT_ATTRIBUTE = "ele"; + + + /** + * Gets the elevation (Z coordinate) of a JOSM way point. + * + * @param wpt + * The way point instance. + * @return The x coordinate or 0, if the given way point is null or contains + * not height attribute. + */ + public static double getElevation(WayPoint wpt) { + if (wpt != null) { + if (!wpt.attr.containsKey(HEIGHT_ATTRIBUTE)) { + return 0; + } + + String height = wpt.getString(WayPointHelper.HEIGHT_ATTRIBUTE); + try { + double z = Double.parseDouble(height); + + return z; + } catch (NumberFormatException e) { + System.err.println(String.format( + "Cannot parse double from '%s': %s", height, e + .getMessage())); + return 0; + } + } else { + return 0; + } + } + + public static double getLonDist(WayPoint w1, WayPoint w2) { + LatLon ll = new LatLon(w1.getCoor().lat(), w2.getCoor().lon()); + return w1.getCoor().greatCircleDistance(ll); + } + + public static double getLatDist(WayPoint w1, WayPoint w2) { + LatLon ll = new LatLon(w2.getCoor().lat(), w1.getCoor().lon()); + return w1.getCoor().greatCircleDistance(ll); + } + + /** + * Moves a given lat/lon coordinate by a given amount of meters in + * x and y direction. + * @param src The original lat/lon coordinate. + * @param dlat The distance in latitude direction in meters + * @param dlon The distance in longitude direction in meters + * @return + */ + public static LatLon moveLatLon(LatLon src, double dlat, double dlon) { + final double R = 6378135; + + double lat1 = toRadians(src.lat()); + double lon1 = toRadians(src.lon()); + + double dlonsin2 = sin(dlon/2 / R); + double dlatsin2 = sin(dlat/2 / R); + double dlatcos = cos(lon1); + + double lon2rad = 2 * asin(sqrt(dlonsin2 * dlonsin2 / dlatcos/dlatcos)) + lon1; + double lat2rad = 2 * asin(dlatsin2) + lat1; + + double lon2 = toDegrees(lon2rad); + double lat2 = toDegrees(lat2rad); + + LatLon llmoved = new LatLon(lat2, lon2); + + //double d2 = llmoved.greatCircleDistance(src); + + return llmoved; + } + + /** + * Reduces a given list of way points to the specified target size. + * + * @param origList + * The original list containing the way points. + * @param targetSize + * The desired target size of the list. The resulting list may + * contain fewer items, so targetSize should be considered as + * maximum. + * @return A list containing the reduced list. + */ + public static List downsampleWayPoints(List origList, + int targetSize) { + if (origList == null) + return null; + if (targetSize <= 0) + throw new IllegalArgumentException( + "targetSize must be greater than zero"); + + int origSize = origList.size(); + if (origSize <= targetSize) { + return origList; + } + + int delta = (int) Math.max(Math.ceil(origSize / targetSize), 2); + + List res = new ArrayList(targetSize); + for (int i = 0; i < origSize; i += delta) { + res.add(origList.get(i)); + } + + return res; + } +}