Ignore:
Timestamp:
2015-06-12T12:39:14+02:00 (9 years ago)
Author:
nokutu
Message:

New mode to jump to images that have signalson them

Location:
applications/editors/josm/plugins/mapillary
Files:
3 added
11 edited

Legend:

Unmodified
Added
Removed

  • applications/editors/josm/plugins/mapillary/src/org/openstreetmap/josm/plugins/mapillary/MapillaryData.java

    r31259 r31261  
    66import org.openstreetmap.josm.data.cache.ICachedLoaderListener;
    77import org.openstreetmap.josm.plugins.mapillary.cache.MapillaryCache;
    8 import org.openstreetmap.josm.plugins.mapillary.gui.MapillaryToggleDialog;
    98
    109import java.util.ArrayList;
    … …  
    2625        private MapillaryAbstractImage selectedImage;
    2726        private final List<MapillaryAbstractImage> multiSelectedImages;
     27       
     28        private List<MapillaryDataListener> listeners= new ArrayList<>();
    2829
    2930        public MapillaryData() {
    … …  
    6364                }
    6465                dataUpdated();
     66        }
     67       
     68        public void addListener(MapillaryDataListener lis) {
     69                listeners.add(lis);
     70        }
     71       
     72        public void removeListener(MapillaryDataListener lis) {
     73                listeners.remove(lis);
    6574        }
    6675
    … …  
    156165        public void setSelectedImage(MapillaryAbstractImage image) {
    157166                selectedImage = image;
    158                 if (image instanceof MapillaryImage)
    159                         System.out.println(((MapillaryImage) image).getLocation());
    160167                multiSelectedImages.clear();
    161168                multiSelectedImages.add(image);
    162169                if (image != null) {
    163                         MapillaryToggleDialog.getInstance().setImage(selectedImage);
    164                         MapillaryToggleDialog.getInstance().updateImage();
    165170                        if (image instanceof MapillaryImage) {
    166171                                MapillaryImage mapillaryImage = (MapillaryImage) image;
    … …  
    186191                        Main.map.mapView.repaint();
    187192                }
     193                fireSelectedImageChanged();
     194        }
     195       
     196        private void fireSelectedImageChanged() {
     197                if (listeners.isEmpty())
     198                        return;
     199                for (MapillaryDataListener lis : listeners)
     200                        lis.selectedImageChanged();
    188201        }
    189202

  • applications/editors/josm/plugins/mapillary/src/org/openstreetmap/josm/plugins/mapillary/MapillaryImportedImage.java

    r31256 r31261  
    1919                return ImageIO.read(file);
    2020        }
     21       
     22        public File getFile() {
     23                return file;
     24        }
    2125
    2226        @Override

  • applications/editors/josm/plugins/mapillary/src/org/openstreetmap/josm/plugins/mapillary/MapillaryLayer.java

    r31259 r31261  
    5454        public final static int SEQUENCE_MAX_JUMP_DISTANCE = 100;
    5555
    56         public static Boolean INSTANCED = false;
    5756        public static MapillaryLayer INSTANCE;
    5857        public static CacheAccess<String, BufferedImageCacheEntry> CACHE;
    … …  
    7978         */
    8079        private void init() {
    81                 INSTANCED = true;
    8280                MapillaryLayer.INSTANCE = this;
    8381                startMouseAdapter();
    … …  
    110108                }
    111109                MapillaryPlugin.setMenuEnabled(MapillaryPlugin.EXPORT_MENU, true);
     110                MapillaryPlugin.setMenuEnabled(MapillaryPlugin.SIGNAL_MENU, true);
    112111                download();
    113112                Main.map.mapView.setActiveLayer(this);
    … …  
    156155                MapillaryToggleDialog.getInstance().mapillaryImageDisplay
    157156                                .setImage(null);
    158                 INSTANCED = false;
    159157                MapillaryLayer.INSTANCE = null;
    160158                MapillaryPlugin.setMenuEnabled(MapillaryPlugin.EXPORT_MENU, false);
     159                MapillaryPlugin.setMenuEnabled(MapillaryPlugin.SIGNAL_MENU, false);
    161160                MapillaryData.INSTANCE = null;
    162161                Main.map.mapView.removeMouseListener(mouseAdapter);

  • applications/editors/josm/plugins/mapillary/src/org/openstreetmap/josm/plugins/mapillary/MapillaryPlugin.java

    r31259 r31261  
    5050        private final MapillaryExportAction exportAction;
    5151        private final MapillaryImportAction importAction;
     52        private final MapillarySignalAction signalAction;
    5253
    5354        public static JMenuItem DOWNLOAD_MENU;
    5455        public static JMenuItem EXPORT_MENU;
    5556        public static JMenuItem IMPORT_MENU;
     57        public static JMenuItem SIGNAL_MENU;
    5658
    5759        public MapillaryPlugin(PluginInformation info) {
    … …  
    6062                exportAction = new MapillaryExportAction();
    6163                importAction = new MapillaryImportAction();
     64                signalAction = new MapillarySignalAction();
    6265
    6366                DOWNLOAD_MENU = MainMenu.add(Main.main.menu.imageryMenu,
    … …  
    6770                IMPORT_MENU = MainMenu.add(Main.main.menu.fileMenu, importAction,
    6871                                false, 14);
     72                SIGNAL_MENU = MainMenu.add(Main.main.menu.dataMenu, signalAction,
     73                                false);
    6974
    7075                EXPORT_MENU.setEnabled(false);
    7176                DOWNLOAD_MENU.setEnabled(false);
    7277                IMPORT_MENU.setEnabled(false);
     78                SIGNAL_MENU.setEnabled(false);
    7379
    7480                MapView.addEditLayerChangeListener(this);

  • applications/editors/josm/plugins/mapillary/src/org/openstreetmap/josm/plugins/mapillary/actions/MapillaryExportAction.java

    r31260 r31261  
    66import java.awt.event.ActionEvent;
    77import java.awt.event.KeyEvent;
     8import java.io.IOException;
    89import java.util.ArrayList;
    910import java.util.List;
    … …  
    6768                        } else if (dialog.group.isSelected(dialog.selected.getModel())) {
    6869                                export(MapillaryData.getInstance().getMultiSelectedImages());
    69                         } else if (dialog.group.isSelected(dialog.rewrite.getModel())) {
    70                                 ArrayList<MapillaryAbstractImage> images = new ArrayList<>();
    71                                 for (MapillaryAbstractImage image : MapillaryData.getInstance().getMultiSelectedImages())
    72                                         if (image instanceof MapillaryImportedImage) {
    73                                                 images.addAll(((MapillaryImage) image).getSequence().getImages());
    74                                         }
    75                                         else
    76                                                 images.add(image);
    77                                 export(images);
     70                        }
     71                 } else if (dialog.group.isSelected(dialog.rewrite.getModel())) {
     72                        ArrayList<MapillaryImportedImage> images = new ArrayList<>();
     73                        for (MapillaryAbstractImage image : MapillaryData.getInstance().getImages())
     74                                if (image instanceof MapillaryImportedImage) {
     75                                        images.add(((MapillaryImportedImage) image));
     76                                }
     77                        try {
     78                                Main.worker.submit(new Thread(new MapillaryExportManager(images)));
     79                        } catch (IOException e1) {
     80                                Main.error(e1);
    7881                        }
    7982                }

  • applications/editors/josm/plugins/mapillary/src/org/openstreetmap/josm/plugins/mapillary/actions/MapillaryImportAction.java

    r31256 r31261  
    3939                                                tr("Import pictures into Mapillary layer"),
    4040                                                KeyEvent.VK_M, Shortcut.NONE), false,
    41                                 "mapillaryDownload", false);
     41                                "mapillaryImport", false);
    4242        }
    4343

  • applications/editors/josm/plugins/mapillary/src/org/openstreetmap/josm/plugins/mapillary/downloads/MapillaryExportManager.java

    r31256 r31261  
    4848                this.path = path;
    4949        }
     50       
     51        /**
     52         * Constructor used to rewrite imported images.
     53         * @param images
     54         * @throws IOException
     55         */
     56        public MapillaryExportManager(List<MapillaryImportedImage> images) throws IOException {
     57                super(tr("Downloading") + "...", new PleaseWaitProgressMonitor(
     58                                "Exporting Mapillary Images"), true);
     59                queue = new ArrayBlockingQueue<>(10);
     60                queueImages = new ArrayBlockingQueue<>(10);
     61                for (MapillaryImportedImage image : images) {
     62                        queue.add(image.getImage());
     63                        queueImages.add(image);
     64                }
     65        }
    5066
    5167        @Override
    … …  
    5773        protected void realRun() throws SAXException, IOException,
    5874                        OsmTransferException {
     75               
    5976                // Starts a writer thread in order to write the pictures on the disk.
    6077                Thread writer = new Thread(new MapillaryExportWriterThread(path, queue,
    61                                 queueImages, images.size(), this.getProgressMonitor()));
     78                                queueImages, queue.size(), this.getProgressMonitor()));
    6279                writer.start();
     80                if (path == null) {
     81                        try {
     82                                writer.join();
     83                        } catch (InterruptedException e) {
     84                                Main.error(e);
     85                        }
     86                        return;
     87                }
    6388                ThreadPoolExecutor ex = new ThreadPoolExecutor(20, 35, 25,
    6489                                TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));

  • applications/editors/josm/plugins/mapillary/src/org/openstreetmap/josm/plugins/mapillary/downloads/MapillaryExportWriterThread.java

    r31256 r31261  
    2323import org.openstreetmap.josm.plugins.mapillary.MapillaryAbstractImage;
    2424import org.openstreetmap.josm.plugins.mapillary.MapillaryImage;
     25import org.openstreetmap.josm.plugins.mapillary.MapillaryImportedImage;
    2526
    2627/**
    … …  
    6061                                img = queue.take();
    6162                                mimg = queueImages.take();
    62                                 if (mimg instanceof MapillaryImage)
     63                                if (path == null && mimg instanceof MapillaryImportedImage) {
     64                                        String path = ((MapillaryImportedImage) mimg).getFile().getPath();
     65                                        finalPath = path.substring(0, path.lastIndexOf('.'));
     66                                }
     67                                else if (mimg instanceof MapillaryImage)
    6368                                        finalPath = path + "/" + ((MapillaryImage) mimg).getKey();
    6469                                else

  • applications/editors/josm/plugins/mapillary/src/org/openstreetmap/josm/plugins/mapillary/downloads/MapillarySignalDownloaderThread.java

    r31260 r31261  
    4848                                        for (MapillaryAbstractImage image : MapillaryData
    4949                                                        .getInstance().getImages()) {
    50                                                 if (((MapillaryImage) image).getKey().equals(key)) {
    51                                                         if (image instanceof MapillaryImage) {
     50                                                if (image instanceof MapillaryImage) {
     51                                                        if (((MapillaryImage) image).getKey().equals(key)) {
    5252                                                                if (((MapillaryImage) image).getKey().equals(
    5353                                                                                key)) {

  • applications/editors/josm/plugins/mapillary/src/org/openstreetmap/josm/plugins/mapillary/downloads/MapillarySquareDownloadManagerThread.java

    r31259 r31261  
    4040                        downloadSequences();
    4141                        completeImages();
     42                        Main.map.statusLine.setHelpText("Downloading signals information");
    4243                        downloadSignals();
    4344                } catch (InterruptedException e) {

  • applications/editors/josm/plugins/mapillary/src/org/openstreetmap/josm/plugins/mapillary/gui/MapillaryToggleDialog.java

    r31256 r31261  
    44
    55import java.awt.event.ActionEvent;
     6import java.awt.event.KeyEvent;
    67import java.awt.image.BufferedImage;
    78import java.awt.BorderLayout;
    … …  
    2324import org.openstreetmap.josm.plugins.mapillary.MapillaryAbstractImage;
    2425import org.openstreetmap.josm.plugins.mapillary.MapillaryData;
     26import org.openstreetmap.josm.plugins.mapillary.MapillaryDataListener;
    2527import org.openstreetmap.josm.plugins.mapillary.MapillaryImage;
    2628import org.openstreetmap.josm.plugins.mapillary.MapillaryImportedImage;
    2729import org.openstreetmap.josm.plugins.mapillary.MapillaryLayer;
    2830import org.openstreetmap.josm.plugins.mapillary.cache.MapillaryCache;
     31import org.openstreetmap.josm.tools.Shortcut;
    2932
    3033import javax.imageio.ImageIO;
    … …  
    4043 */
    4144public class MapillaryToggleDialog extends ToggleDialog implements
    42                 ICachedLoaderListener {
     45                ICachedLoaderListener, MapillaryDataListener {
    4346
    4447        public static MapillaryToggleDialog INSTANCE;
    … …  
    4649        public volatile MapillaryAbstractImage image;
    4750
    48         final SideButton nextButton = new SideButton(new nextPictureAction());
    49         final SideButton previousButton = new SideButton(
     51        public final SideButton nextButton = new SideButton(new nextPictureAction());
     52        public final SideButton previousButton = new SideButton(
    5053                        new previousPictureAction());
    5154        public final SideButton redButton = new SideButton(new redAction());
    5255        public final SideButton blueButton = new SideButton(new blueAction());
     56        private List<SideButton> normalMode;
     57
     58        public final SideButton nextSignalButton = new SideButton(
     59                        new NextSignalAction());
     60        public final SideButton previousSignalButton = new SideButton(
     61                        new PreviousSignalAction());
     62        private List<SideButton> signalMode;
     63        // TODO change to enum
     64        private int mode;
     65
     66        public final static int NORMAL_MODE = 0;
     67        public final static int SIGNAL_MODE = 0;
    5368
    5469        private JPanel buttonsPanel;
    … …  
    6277        public MapillaryToggleDialog() {
    6378                super(tr("Mapillary image"), "mapillary.png",
    64                                 tr("Open Mapillary window"), null, 200);
     79                                tr("Open Mapillary window"), Shortcut.registerShortcut(
     80                                                tr("Mapillary dialog"),
     81                                                tr("Open Mapillary main dialog"), KeyEvent.VK_M,
     82                                                Shortcut.NONE), 200);
     83                MapillaryData.getInstance().addListener(this);
     84
    6585                mapillaryImageDisplay = new MapillaryImageDisplay();
    6686
    … …  
    6888                redButton.setForeground(Color.RED);
    6989
     90                normalMode = Arrays.asList(new SideButton[] { blueButton,
     91                                previousButton, nextButton, redButton });
     92                signalMode = Arrays.asList(new SideButton[] { previousSignalButton,
     93                                nextSignalButton });
     94
     95                mode = NORMAL_MODE;
    7096                this.setLayout(new BorderLayout());
    7197                top = new JPanel();
    7298                top.setLayout(new BorderLayout());
    7399                top.add(titleBar, BorderLayout.NORTH);
    74 
    75                 createLayout(
    76                                 mapillaryImageDisplay,
    77                                 Arrays.asList(new SideButton[] { blueButton, previousButton,
    78                                                 nextButton, redButton }),
     100                createLayout(mapillaryImageDisplay, normalMode,
    79101                                Main.pref.getBoolean("mapillary.reverse-buttons"));
    80102        }
    … …  
    88110        public static void destroyInstance() {
    89111                INSTANCE = null;
     112        }
     113
     114        public void switchMode() {
     115                this.removeAll();
     116                List<SideButton> list = null;
     117                if (mode == NORMAL_MODE) {
     118                        list = signalMode;
     119                        mode = SIGNAL_MODE;
     120                } else if (mode == SIGNAL_MODE) {
     121                        list = normalMode;
     122                        mode = NORMAL_MODE;
     123                }
     124                this.setLayout(new BorderLayout());
     125                top = new JPanel();
     126                top.setLayout(new BorderLayout());
     127                top.add(titleBar, BorderLayout.NORTH);
     128                createLayout(mapillaryImageDisplay, list,
     129                                Main.pref.getBoolean("mapillary.reverse-buttons"));
    90130        }
    91131
    … …  
    103143                        });
    104144                } else {
    105                         if (MapillaryLayer.INSTANCED == false) {
     145                        if (MapillaryLayer.INSTANCE == null) {
    106146                                return;
    107147                        }
    … …  
    109149                                return;
    110150                        if (image instanceof MapillaryImage) {
    111                                 this.nextButton.setEnabled(true);
    112                                 this.previousButton.setEnabled(true);
    113151                                MapillaryImage mapillaryImage = (MapillaryImage) this.image;
    114                                 if (mapillaryImage.next() == null)
    115                                         this.nextButton.setEnabled(false);
    116                                 if (mapillaryImage.previous() == null)
    117                                         this.previousButton.setEnabled(false);
     152                                if (mode == NORMAL_MODE) {
     153                                        this.nextButton.setEnabled(true);
     154                                        this.previousButton.setEnabled(true);
     155                                        if (mapillaryImage.next() == null)
     156                                                this.nextButton.setEnabled(false);
     157                                        if (mapillaryImage.previous() == null)
     158                                                this.previousButton.setEnabled(false);
     159                                } else if (mode == SIGNAL_MODE) {
     160                                        previousSignalButton.setEnabled(true);
     161                                        nextSignalButton.setEnabled(true);
     162                                        int i = MapillaryData
     163                                                        .getInstance()
     164                                                        .getImages()
     165                                                        .indexOf(
     166                                                                        MapillaryData.getInstance()
     167                                                                                        .getSelectedImage());
     168                                        int first = -1;
     169                                        int last = -1;
     170                                        int c = 0;
     171                                        for (MapillaryAbstractImage img : MapillaryData
     172                                                        .getInstance().getImages()) {
     173                                                if (img instanceof MapillaryImage)
     174                                                        if (!((MapillaryImage) img).getSignals().isEmpty()) {
     175                                                                if (first == -1)
     176                                                                        first = c;
     177                                                                last = c;
     178                                                        }
     179                                                c++;
     180                                        }
     181                                        if (first >= i) {
     182                                                previousSignalButton.setEnabled(false);
     183                                        }
     184                                        if (last <= i) {
     185                                                nextSignalButton.setEnabled(false);
     186                                        }
     187                                }
    118188
    119189                                mapillaryImageDisplay.hyperlink.setURL(mapillaryImage.getKey());
    … …  
    130200                                                MapillaryCache.Type.FULL_IMAGE);
    131201                                imageCache.submit(this, false);
    132                         }
    133                         else if (image instanceof MapillaryImportedImage) {
     202                        } else if (image instanceof MapillaryImportedImage) {
    134203                                this.nextButton.setEnabled(false);
    135204                                this.previousButton.setEnabled(false);
    … …  
    314383                add(top, BorderLayout.NORTH);
    315384        }
     385
     386        @Override
     387        public void selectedImageChanged() {
     388                setImage(MapillaryData.getInstance().getSelectedImage());
     389                updateImage();
     390        }
     391
     392        class NextSignalAction extends AbstractAction {
     393                public NextSignalAction() {
     394                        putValue(NAME, tr("Next Signal"));
     395                        putValue(SHORT_DESCRIPTION,
     396                                        tr("Jumps to the next picture that contains a siganl"));
     397                }
     398
     399                @Override
     400                public void actionPerformed(ActionEvent e) {
     401                        if (MapillaryToggleDialog.getInstance().getImage() != null) {
     402                                int i = MapillaryData
     403                                                .getInstance()
     404                                                .getImages()
     405                                                .indexOf(MapillaryData.getInstance().getSelectedImage());
     406                                for (int j = i + 1; j < MapillaryData.getInstance().getImages()
     407                                                .size(); j++) {
     408                                        MapillaryAbstractImage img = MapillaryData.getInstance()
     409                                                        .getImages().get(j);
     410                                        if (img instanceof MapillaryImage)
     411                                                if (!((MapillaryImage) img).getSignals().isEmpty()) {
     412                                                        MapillaryData.getInstance().setSelectedImage(img);
     413                                                        return;
     414                                                }
     415                                }
     416                        }
     417                }
     418        }
     419
     420        class PreviousSignalAction extends AbstractAction {
     421                public PreviousSignalAction() {
     422                        putValue(NAME, tr("Previous Signal"));
     423                        putValue(SHORT_DESCRIPTION,
     424                                        tr("Jumps to the previous picture that contains a siganl"));
     425                }
     426
     427                @Override
     428                public void actionPerformed(ActionEvent e) {
     429                        if (MapillaryToggleDialog.getInstance().getImage() != null) {
     430                                int i = MapillaryData
     431                                                .getInstance()
     432                                                .getImages()
     433                                                .indexOf(MapillaryData.getInstance().getSelectedImage());
     434                                for (int j = i - 1; j >= 0; j--) {
     435                                        MapillaryAbstractImage img = MapillaryData.getInstance()
     436                                                        .getImages().get(j);
     437                                        if (img instanceof MapillaryImage)
     438                                                if (!((MapillaryImage) img).getSignals().isEmpty()) {
     439                                                        MapillaryData.getInstance().setSelectedImage(img);
     440                                                        return;
     441                                                }
     442                                }
     443                        }
     444                }
     445        }
    316446}
Note: See TracChangeset for help on using the changeset viewer.