Changeset 31252 in osm for applications/editors


Ignore:
Timestamp:
2015-06-08T21:52:34+02:00 (9 years ago)
Author:
nokutu
Message:

Started with importing local pictures

Location:
applications/editors/josm/plugins/mapillary
Files:
4 added
16 edited

Legend:

Unmodified
Added
Removed

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

    r31249 r31252  
    2323        public volatile static MapillaryData INSTANCE;
    2424
    25         private final List<MapillaryImage> images;
    26         private MapillaryImage selectedImage;
    27         private final List<MapillaryImage> multiSelectedImages;
     25        private final List<MapillaryAbstractImage> images;
     26        private MapillaryAbstractImage selectedImage;
     27        private final List<MapillaryAbstractImage> multiSelectedImages;
    2828
    2929        public MapillaryData() {
    … …  
    4646         *            The set of images to be added.
    4747         */
    48         public synchronized void add(List<MapillaryImage> images) {
    49                 for (MapillaryImage image : images) {
     48        public synchronized void add(List<MapillaryAbstractImage> images) {
     49                for (MapillaryAbstractImage image : images) {
    5050                        add(image);
    5151                }
    … …  
    5858         *            The image to be added.
    5959         */
    60         public synchronized void add(MapillaryImage image) {
     60        public synchronized void add(MapillaryAbstractImage image) {
    6161                if (!images.contains(image)) {
    6262                        this.images.add(image);
    … …  
    7272         *            The set of images to be added.
    7373         */
    74         public synchronized void addWithoutUpdate(List<MapillaryImage> images) {
    75                 for (MapillaryImage image : images) {
     74        public synchronized void addWithoutUpdate(
     75                        List<MapillaryAbstractImage> images) {
     76                for (MapillaryAbstractImage image : images) {
    7677                        addWithoutUpdate(image);
    7778                }
    … …  
    8586         *            The image to be added.
    8687         */
    87         public synchronized void addWithoutUpdate(MapillaryImage image) {
     88        public synchronized void addWithoutUpdate(MapillaryAbstractImage image) {
    8889                if (!images.contains(image)) {
    8990                        this.images.add(image);
    … …  
    103104         * @return A List object containing all images.
    104105         */
    105         public List<MapillaryImage> getImages() {
     106        public List<MapillaryAbstractImage> getImages() {
    106107                return images;
    107108        }
    … …  
    112113         * @return The selected MapillaryImage object.
    113114         */
    114         public MapillaryImage getSelectedImage() {
     115        public MapillaryAbstractImage getSelectedImage() {
    115116                return selectedImage;
    116117        }
    … …  
    122123         */
    123124        public void selectNext() {
    124                 if (getSelectedImage() == null)
    125                         return;
    126                 if (getSelectedImage().getSequence() == null)
    127                         return;
    128                 setSelectedImage(getSelectedImage().next());
     125                if (getSelectedImage() instanceof MapillaryImage) {
     126                        if (getSelectedImage() == null)
     127                                return;
     128                        if (((MapillaryImage) getSelectedImage()).getSequence() == null)
     129                                return;
     130                        setSelectedImage(((MapillaryImage) getSelectedImage()).next());
     131                }
    129132        }
    130133
    … …  
    134137         */
    135138        public void selectPrevious() {
    136                 if (getSelectedImage() == null)
    137                         return;
    138                 if (getSelectedImage().getSequence() == null)
    139                         throw new IllegalStateException();
    140                 setSelectedImage(getSelectedImage().previous());
     139                if (getSelectedImage() instanceof MapillaryImage) {
     140                        if (getSelectedImage() == null)
     141                                return;
     142                        if (((MapillaryImage) getSelectedImage()).getSequence() == null)
     143                                throw new IllegalStateException();
     144                        setSelectedImage(((MapillaryImage) getSelectedImage()).previous());
     145                }
    141146        }
    142147
    … …  
    149154         *            The MapillaryImage which is going to be selected
    150155         */
    151         public void setSelectedImage(MapillaryImage image) {
     156        public void setSelectedImage(MapillaryAbstractImage image) {
    152157                selectedImage = image;
    153158                multiSelectedImages.clear();
    … …  
    156161                        MapillaryToggleDialog.getInstance().setImage(selectedImage);
    157162                        MapillaryToggleDialog.getInstance().updateImage();
    158                         if (image.next() != null) {
    159                                 new MapillaryCache(image.next().getKey(),
    160                                                 MapillaryCache.Type.THUMBNAIL).submit(this, false);
    161                                 if (image.next().next() != null)
    162                                         new MapillaryCache(image.next().next().getKey(),
     163                        if (image instanceof MapillaryImage) {
     164                                MapillaryImage mapillaryImage = (MapillaryImage) image;
     165                                if (mapillaryImage.next() != null) {
     166                                        new MapillaryCache(mapillaryImage.next().getKey(),
    163167                                                        MapillaryCache.Type.THUMBNAIL).submit(this, false);
    164                         }
    165                         if (image.previous() != null) {
    166                                 new MapillaryCache(image.previous().getKey(),
    167                                                 MapillaryCache.Type.THUMBNAIL).submit(this, false);
    168                                 if (image.previous().previous() != null)
    169                                         new MapillaryCache(image.previous().previous().getKey(),
     168                                        if (mapillaryImage.next().next() != null)
     169                                                new MapillaryCache(mapillaryImage.next().next()
     170                                                                .getKey(), MapillaryCache.Type.THUMBNAIL)
     171                                                                .submit(this, false);
     172                                }
     173                                if (mapillaryImage.previous() != null) {
     174                                        new MapillaryCache(mapillaryImage.previous().getKey(),
    170175                                                        MapillaryCache.Type.THUMBNAIL).submit(this, false);
     176                                        if (mapillaryImage.previous().previous() != null)
     177                                                new MapillaryCache(mapillaryImage.previous().previous()
     178                                                                .getKey(), MapillaryCache.Type.THUMBNAIL)
     179                                                                .submit(this, false);
     180                                }
    171181                        }
    172182                }
    … …  
    183193         *            The MapillaryImage object to be added.
    184194         */
    185         public void addMultiSelectedImage(MapillaryImage image) {
     195        public void addMultiSelectedImage(MapillaryAbstractImage image) {
    186196                if (!this.multiSelectedImages.contains(image)) {
    187197                        if (this.getSelectedImage() != null)
    … …  
    198208         * @param images
    199209         */
    200         public void addMultiSelectedImage(List<MapillaryImage> images) {
    201                 for (MapillaryImage image : images)
     210        public void addMultiSelectedImage(List<MapillaryAbstractImage> images) {
     211                for (MapillaryAbstractImage image : images)
    202212                        if (!this.multiSelectedImages.contains(image)) {
    203213                                if (this.getSelectedImage() != null)
    … …  
    215225         * @return
    216226         */
    217         public List<MapillaryImage> getMultiSelectedImages() {
     227        public List<MapillaryAbstractImage> getMultiSelectedImages() {
    218228                return multiSelectedImages;
    219229        }

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

    r31222 r31252  
    11package org.openstreetmap.josm.plugins.mapillary;
    22
    3 import org.openstreetmap.josm.data.coor.LatLon;
    43
    54/**
    … …  
    109 * @see MapillaryData
    1110 */
    12 public class MapillaryImage {
     11public class MapillaryImage extends MapillaryAbstractImage {
    1312        /** Unique identifier of the object */
    1413        private final String key;
    15         /** Postion of the picture */
    16         public final LatLon latLon;
    17         /** Direction of the picture */
    18         private final double ca;
    1914        /** Sequence of pictures containing this */
    2015        private MapillarySequence sequence;
    21 
    22         private boolean isModified = false;
    23         /** Temporal position of the picture until it is uplaoded */
    24         public LatLon tempLatLon;
    25         /**
    26          * When the object is being dragged in the map, the temporal position is
    27          * stored here
    28          */
    29         public LatLon movingLatLon;
    30         /** Temporal direction of the picture until it is uplaoded */
    31         private double tempCa;
    32         /**
    33          * When the object direction is being moved in the map, the temporal
    34          * direction is stored here
    35          */
    36         private double movingCa;
    3716
    3817        /**
    … …  
    4928         */
    5029        public MapillaryImage(String key, double lat, double lon, double ca) {
     30                super(lat, lon, ca);
    5131                this.key = key;
    52                 this.latLon = new LatLon(lat, lon);
    53                 this.tempLatLon = this.latLon;
    54                 this.movingLatLon = this.latLon;
    55                 this.ca = ca;
    56                 this.tempCa = ca;
    57                 this.movingCa = ca;
    58         }
    59 
    60         /**
    61          * Returns whether the object has been modified or not.
    62          *
    63          * @return true if the object has been modified; false otherwise.
    64          */
    65         public boolean isModified() {
    66                 return this.isModified;
    67         }
    68 
    69         /**
    70          * Returns a LatLon object containing the coordintes of the object.
    71          *
    72          * @return The LatLon object with the position of the object.
    73          */
    74         public LatLon getLatLon() {
    75                 return movingLatLon;
    76         }
    77        
    78         public LatLon getTempLatLon() {
    79                 return tempLatLon;
    80         }
    81 
    82         /**
    83          * Moves the image temporally to another position
    84          *
    85          * @param pos
    86          */
    87         public void move(double x, double y) {
    88                 this.movingLatLon = new LatLon(this.tempLatLon.getY() + y,
    89                                 this.tempLatLon.getX() + x);
    90                 this.isModified = true;
    91         }
    92 
    93         /**
    94          * Turns the image direction.
    95          *
    96          * @param ca
    97          */
    98         public void turn(double ca) {
    99                 this.movingCa = this.tempCa + ca;
    100                 this.isModified = true;
    101         }
    102 
    103         /**
    104          * Called when the mouse button is released, meaning that the picture has
    105          * stopped being dragged.
    106          */
    107         public void stopMoving() {
    108                 this.tempLatLon = this.movingLatLon;
    109                 this.tempCa = this.movingCa;
    110         }
    111 
    112         /**
    113          * Returns the direction towards the image has been taken.
    114          *
    115          * @return The direction of the image (0 means north and goes clockwise).
    116          */
    117         public double getCa() {
    118                 return movingCa;
    119         }
    120 
    121         /**
    122          * Returns the last fixed direction of the object.
    123          * @return
    124          */
    125         public double getTempCa() {
    126                 return tempCa;
    12732        }
    12833

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

    r31249 r31252  
    107107                download();
    108108                Main.map.mapView.setActiveLayer(this);
     109                Main.map.repaint();
    109110        }
    110111
    … …  
    125126                                                .getInstance())
    126127                                        return;
    127                                 MapillaryImage closest = getClosest(e.getPoint());
    128                                 if (e.getClickCount() == 2
    129                                                 && mapillaryData.getSelectedImage() != null
    130                                                 && closest != null) {
    131                                         for (MapillaryImage img : closest.getSequence().getImages()) {
    132                                                 mapillaryData.addMultiSelectedImage(img);
     128                                MapillaryAbstractImage closestTemp = getClosest(e.getPoint());
     129                                if (closestTemp instanceof MapillaryImage || closestTemp == null) {
     130                                        MapillaryImage closest = (MapillaryImage) closestTemp;
     131                                        if (e.getClickCount() == 2
     132                                                        && mapillaryData.getSelectedImage() != null
     133                                                        && closest != null) {
     134                                                for (MapillaryAbstractImage img : closest.getSequence()
     135                                                                .getImages()) {
     136                                                        mapillaryData.addMultiSelectedImage(img);
     137                                                }
    133138                                        }
    134                                 }
    135                                 this.start = e.getPoint();
    136                                 this.lastClicked = this.closest;
    137                                 this.closest = closest;
    138                                 if (mapillaryData.getMultiSelectedImages().contains(closest))
    139                                         return;
    140                                 if (e.getModifiers() == (MouseEvent.BUTTON1_MASK | MouseEvent.CTRL_MASK)
    141                                                 && closest != null)
    142                                         mapillaryData.addMultiSelectedImage(closest);
    143                                 else if (e.getModifiers() == (MouseEvent.BUTTON1_MASK | MouseEvent.SHIFT_MASK)) {
    144                                         if (this.closest != null
    145                                                         && this.lastClicked != null
    146                                                         && this.closest.getSequence() == this.lastClicked
    147                                                                         .getSequence()) {
    148                                                 int i = this.closest.getSequence().getImages()
    149                                                                 .indexOf(this.closest);
    150                                                 int j = this.lastClicked.getSequence().getImages()
    151                                                                 .indexOf(this.lastClicked);
    152                                                 if (i < j)
    153                                                         mapillaryData.addMultiSelectedImage(this.closest
    154                                                                         .getSequence().getImages()
    155                                                                         .subList(i, j + 1));
    156                                                 else
    157                                                         mapillaryData.addMultiSelectedImage(this.closest
    158                                                                         .getSequence().getImages()
    159                                                                         .subList(j, i + 1));
    160                                         }
    161                                 } else
    162                                         mapillaryData.setSelectedImage(closest);
    163                         }
    164 
    165                         private MapillaryImage getClosest(Point clickPoint) {
     139                                        this.start = e.getPoint();
     140                                        this.lastClicked = this.closest;
     141                                        this.closest = closest;
     142                                        if (mapillaryData.getMultiSelectedImages()
     143                                                        .contains(closest))
     144                                                return;
     145                                        if (e.getModifiers() == (MouseEvent.BUTTON1_MASK | MouseEvent.CTRL_MASK)
     146                                                        && closest != null)
     147                                                mapillaryData.addMultiSelectedImage(closest);
     148                                        else if (e.getModifiers() == (MouseEvent.BUTTON1_MASK | MouseEvent.SHIFT_MASK)) {
     149                                                if (this.closest != null
     150                                                                && this.lastClicked != null
     151                                                                && this.closest.getSequence() == this.lastClicked
     152                                                                                .getSequence()) {
     153                                                        int i = this.closest.getSequence().getImages()
     154                                                                        .indexOf(this.closest);
     155                                                        int j = this.lastClicked.getSequence().getImages()
     156                                                                        .indexOf(this.lastClicked);
     157                                                        if (i < j)
     158                                                                mapillaryData
     159                                                                                .addMultiSelectedImage(new ArrayList<MapillaryAbstractImage>(
     160                                                                                                this.closest.getSequence()
     161                                                                                                                .getImages()
     162                                                                                                                .subList(i, j + 1)));
     163                                                        else
     164                                                                mapillaryData
     165                                                                                .addMultiSelectedImage(new ArrayList<MapillaryAbstractImage>(
     166                                                                                                this.closest.getSequence()
     167                                                                                                                .getImages()
     168                                                                                                                .subList(j, i + 1)));
     169                                                }
     170                                        } else
     171                                                mapillaryData.setSelectedImage(closest);
     172                                }
     173                        }
     174
     175                        private MapillaryAbstractImage getClosest(Point clickPoint) {
    166176                                double snapDistance = 10;
    167177                                double minDistance = Double.MAX_VALUE;
    168                                 MapillaryImage closest = null;
    169                                 for (MapillaryImage image : mapillaryData.getImages()) {
     178                                MapillaryAbstractImage closest = null;
     179                                for (MapillaryAbstractImage image : mapillaryData.getImages()) {
    170180                                        Point imagePoint = Main.map.mapView.getPoint(image
    171181                                                        .getLatLon());
    … …  
    193203                                                LatLon from = Main.map.mapView.getLatLon(start.getX(),
    194204                                                                start.getY());
    195                                                 for (MapillaryImage img : MapillaryData.getInstance()
    196                                                                 .getMultiSelectedImages()) {
     205                                                for (MapillaryAbstractImage img : MapillaryData
     206                                                                .getInstance().getMultiSelectedImages()) {
    197207                                                        img.move(to.getX() - from.getX(),
    198208                                                                        to.getY() - from.getY());
    … …  
    204214                                                                (e.getX() - start.x), -(e.getY() - start.y)))
    205215                                                                - closest.getTempCa());
    206                                                 for (MapillaryImage img : MapillaryData.getInstance()
    207                                                                 .getMultiSelectedImages()) {
     216                                                for (MapillaryAbstractImage img : MapillaryData
     217                                                                .getInstance().getMultiSelectedImages()) {
    208218                                                        img.turn(Math.toDegrees(Math.atan2(
    209219                                                                        (e.getX() - start.x), -(e.getY() - start.y)))
    … …  
    234244                                                        to.getY() - from.getY()));
    235245                                }
    236                                 for (MapillaryImage img : mapillaryData
     246                                for (MapillaryAbstractImage img : mapillaryData
    237247                                                .getMultiSelectedImages()) {
    238248                                        if (img != null)
    … …  
    285295                MapillaryData.INSTANCE = null;
    286296                Main.map.mapView.removeMouseListener(mouseAdapter);
     297                Main.map.mapView.removeMouseMotionListener(mouseAdapter);
    287298                MapView.removeEditLayerChangeListener(this);
    288299                if (Main.map.mapView.getEditLayer() != null)
    … …  
    296307        @Override
    297308        public boolean isModified() {
    298                 for (MapillaryImage image : mapillaryData.getImages())
     309                for (MapillaryAbstractImage image : mapillaryData.getImages())
    299310                        if (image.isModified())
    300311                                return true;
    … …  
    337348                        }
    338349                        g.setColor(Color.WHITE);
    339                         for (MapillaryImage image : mapillaryData.getImages()) {
    340                                 Point p = mv.getPoint(image.getLatLon());
    341                                 Point nextp;
    342                                 if (image.getSequence() != null
    343                                                 && image.getSequence().next(image) != null) {
    344                                         nextp = mv.getPoint(image.getSequence().next(image)
    345                                                         .getLatLon());
    346                                         g.drawLine(p.x, p.y, nextp.x, nextp.y);
    347                                 }
    348                                 ImageIcon icon;
    349                                 if (!mapillaryData.getMultiSelectedImages().contains(image))
    350                                         icon = MapillaryPlugin.MAP_ICON;
    351                                 else
    352                                         icon = MapillaryPlugin.MAP_ICON_SELECTED;
    353                                 Image imagetemp = icon.getImage();
    354                                 BufferedImage bi = (BufferedImage) imagetemp;
    355                                 int width = icon.getIconWidth();
    356                                 int height = icon.getIconHeight();
    357 
    358                                 // Rotate the image
    359                                 double rotationRequired = Math.toRadians(image.getCa());
    360                                 double locationX = width / 2;
    361                                 double locationY = height / 2;
    362                                 AffineTransform tx = AffineTransform.getRotateInstance(
    363                                                 rotationRequired, locationX, locationY);
    364                                 AffineTransformOp op = new AffineTransformOp(tx,
    365                                                 AffineTransformOp.TYPE_BILINEAR);
    366 
    367                                 g.drawImage(op.filter(bi, null), p.x - (width / 2), p.y
    368                                                 - (height / 2), Main.map.mapView);
     350                        for (MapillaryAbstractImage imageAbs : mapillaryData.getImages()) {
     351                                Point p = mv.getPoint(imageAbs.getLatLon());
     352                                if (imageAbs instanceof MapillaryImage) {
     353                                        MapillaryImage image = (MapillaryImage) imageAbs;
     354                                        Point nextp;
     355                                        if (image.getSequence() != null
     356                                                        && image.getSequence().next(image) != null) {
     357                                                nextp = mv.getPoint(image.getSequence().next(image)
     358                                                                .getLatLon());
     359                                                g.drawLine(p.x, p.y, nextp.x, nextp.y);
     360                                        }
     361                                        ImageIcon icon;
     362                                        if (!mapillaryData.getMultiSelectedImages().contains(image))
     363                                                icon = MapillaryPlugin.MAP_ICON;
     364                                        else
     365                                                icon = MapillaryPlugin.MAP_ICON_SELECTED;
     366                                        Image imagetemp = icon.getImage();
     367                                        BufferedImage bi = (BufferedImage) imagetemp;
     368                                        int width = icon.getIconWidth();
     369                                        int height = icon.getIconHeight();
     370
     371                                        // Rotate the image
     372                                        double rotationRequired = Math.toRadians(image.getCa());
     373                                        double locationX = width / 2;
     374                                        double locationY = height / 2;
     375                                        AffineTransform tx = AffineTransform.getRotateInstance(
     376                                                        rotationRequired, locationX, locationY);
     377                                        AffineTransformOp op = new AffineTransformOp(tx,
     378                                                        AffineTransformOp.TYPE_BILINEAR);
     379
     380                                        g.drawImage(op.filter(bi, null), p.x - (width / 2), p.y
     381                                                        - (height / 2), Main.map.mapView);
     382                                } else if (imageAbs instanceof MapillaryImportedImage) {
     383                                        MapillaryImportedImage image = (MapillaryImportedImage) imageAbs;
     384                                        ImageIcon icon;
     385                                        if (!mapillaryData.getMultiSelectedImages().contains(image))
     386                                                icon = MapillaryPlugin.MAP_ICON_IMPORTED;
     387                                        else
     388                                                icon = MapillaryPlugin.MAP_ICON_SELECTED;
     389                                        Image imagetemp = icon.getImage();
     390                                        BufferedImage bi = (BufferedImage) imagetemp;
     391                                        int width = icon.getIconWidth();
     392                                        int height = icon.getIconHeight();
     393
     394                                        // Rotate the image
     395                                        double rotationRequired = Math.toRadians(image.getCa());
     396                                        double locationX = width / 2;
     397                                        double locationY = height / 2;
     398                                        AffineTransform tx = AffineTransform.getRotateInstance(
     399                                                        rotationRequired, locationX, locationY);
     400                                        AffineTransformOp op = new AffineTransformOp(tx,
     401                                                        AffineTransformOp.TYPE_BILINEAR);
     402
     403                                        g.drawImage(op.filter(bi, null), p.x - (width / 2), p.y
     404                                                        - (height / 2), Main.map.mapView);
     405                                }
    369406                        }
    370407                }
    … …  
    397434
    398435        private MapillaryImage[] getClosestImagesFromDifferentSequences() {
     436                if (!(mapillaryData.getSelectedImage() instanceof MapillaryImage))
     437                        return new MapillaryImage[2];
     438                MapillaryImage selected = (MapillaryImage) mapillaryData
     439                                .getSelectedImage();
    399440                MapillaryImage[] ret = new MapillaryImage[2];
    400441                double[] distances = { SEQUENCE_MAX_JUMP_DISTANCE,
    401442                                SEQUENCE_MAX_JUMP_DISTANCE };
    402443                LatLon selectedCoords = mapillaryData.getSelectedImage().getLatLon();
    403                 for (MapillaryImage image : mapillaryData.getImages()) {
     444                for (MapillaryAbstractImage imagePrev : mapillaryData.getImages()) {
     445                        if (!(imagePrev instanceof MapillaryImage))
     446                                continue;
     447                        MapillaryImage image = (MapillaryImage) imagePrev;
    404448                        if (image.getLatLon().greatCircleDistance(selectedCoords) < SEQUENCE_MAX_JUMP_DISTANCE
    405                                         && mapillaryData.getSelectedImage().getSequence() != image
    406                                                         .getSequence()) {
     449                                        && selected.getSequence() != image.getSequence()) {
    407450                                if ((ret[0] == null && ret[1] == null)
    408451                                                || (image.getLatLon().greatCircleDistance(
    … …  
    516559        @Override
    517560        public void activeLayerChange(Layer oldLayer, Layer newLayer) {
    518                 if (newLayer == this)
    519                         Main.map.statusLine.setHelpText("Total images: "
    520                                         + MapillaryData.getInstance().getImages().size());
     561                if (newLayer == this) {
     562                        if (MapillaryData.getInstance().getImages().size() > 0)
     563                                Main.map.statusLine.setHelpText(tr("Total images: ")
     564                                                + MapillaryData.getInstance().getImages().size());
     565                        else
     566                                Main.map.statusLine.setHelpText(tr("No images found"));
     567                }
     568
    521569        }
    522570

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

    r31251 r31252  
    2929 *
    3030 */
    31 public class MapillaryPlugin extends Plugin implements EditLayerChangeListener{
     31public class MapillaryPlugin extends Plugin implements EditLayerChangeListener {
    3232
    3333        public static final ImageIcon ICON24 = new ImageProvider("icon24.png")
    … …  
    3939        public static final ImageIcon MAP_ICON_SELECTED = new ImageProvider(
    4040                        "mapiconselected.png").get();
     41        public static final ImageIcon MAP_ICON_IMPORTED = new ImageProvider(
     42                        "mapiconimported.png").get();
    4143        public static final int ICON_SIZE = 24;
    4244
    … …  
    4547        private final MapillaryDownloadAction downloadAction;
    4648        private final MapillaryExportAction exportAction;
     49        private final MapillaryImportAction importAction;
    4750
    4851        public static JMenuItem DOWNLOAD_MENU;
    4952        public static JMenuItem EXPORT_MENU;
     53        public static JMenuItem IMPORT_MENU;
    5054
    5155        public MapillaryPlugin(PluginInformation info) {
    … …  
    5357                downloadAction = new MapillaryDownloadAction();
    5458                exportAction = new MapillaryExportAction();
     59                importAction = new MapillaryImportAction();
    5560
    5661                DOWNLOAD_MENU = MainMenu.add(Main.main.menu.imageryMenu,
    … …  
    5863                EXPORT_MENU = MainMenu.add(Main.main.menu.fileMenu, exportAction,
    5964                                false, 14);
     65                IMPORT_MENU = MainMenu.add(Main.main.menu.fileMenu, importAction,
     66                                false, 14);
     67
    6068                EXPORT_MENU.setEnabled(false);
    6169                DOWNLOAD_MENU.setEnabled(false);
    62                
     70                IMPORT_MENU.setEnabled(false);
     71
    6372                MapView.addEditLayerChangeListener(this);
    6473                try {
    … …  
    8594                menu.setEnabled(value);
    8695        }
    87        
     96
    8897        @Override
    8998        public PreferenceSetting getPreferenceSetting() {
    … …  
    93102        @Override
    94103        public void editLayerChanged(OsmDataLayer oldLayer, OsmDataLayer newLayer) {
    95                 if (oldLayer == null && newLayer != null)
    96                         DOWNLOAD_MENU.setEnabled(true);         
    97                 else if (oldLayer != null && newLayer == null)
     104                if (oldLayer == null && newLayer != null) {
     105                        DOWNLOAD_MENU.setEnabled(true);
     106                        IMPORT_MENU.setEnabled(true);
     107                } else if (oldLayer != null && newLayer == null) {
    98108                        DOWNLOAD_MENU.setEnabled(false);
     109                        IMPORT_MENU.setEnabled(false);
     110                }
    99111        }
    100112}

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

    r31251 r31252  
    2727        public MapillaryDownloadAction() {
    2828                super(tr("Mapillary"), new ImageProvider("icon24.png"),
    29                                 tr("Create Mapillary layer."), Shortcut.registerShortcut(
    30                                                 "menu:Mapillary", tr("Menu: {0}", tr("Mapillary")),
     29                                tr("Create Mapillary layer"), Shortcut.registerShortcut(
     30                                                "Mapillary", tr("Start Mapillary layer"),
    3131                                                KeyEvent.VK_M, Shortcut.ALT_CTRL_SHIFT), false,
    3232                                "mapillaryDownload", false);

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

    r31251 r31252  
    55import java.awt.Dimension;
    66import java.awt.event.ActionEvent;
     7import java.awt.event.KeyEvent;
    78import java.util.ArrayList;
    89import java.util.List;
    … …  
    1314import org.openstreetmap.josm.Main;
    1415import org.openstreetmap.josm.actions.JosmAction;
     16import org.openstreetmap.josm.plugins.mapillary.MapillaryAbstractImage;
    1517import org.openstreetmap.josm.plugins.mapillary.MapillaryData;
    1618import org.openstreetmap.josm.plugins.mapillary.MapillaryImage;
    … …  
    1820import org.openstreetmap.josm.plugins.mapillary.gui.MapillaryExportDialog;
    1921import org.openstreetmap.josm.tools.ImageProvider;
     22import org.openstreetmap.josm.tools.Shortcut;
    2023
    2124/**
    … …  
    3033
    3134        public MapillaryExportAction() {
    32                 super(tr("Export images"), new ImageProvider("icon24.png"),
    33                                 tr("Export images."), null, false, "mapillaryExport", false);
     35                super(tr("Export pictures"), new ImageProvider("icon24.png"),
     36                                tr("Export pictures"), Shortcut.registerShortcut(
     37                                                "Export Mapillary", tr("Export Mapillary pictures"),
     38                                                KeyEvent.VK_M, Shortcut.NONE), false, "mapillaryExport", false);
    3439        }
    3540
    … …  
    5055                                export(MapillaryData.getInstance().getImages());
    5156                        } else if (dialog.group.isSelected(dialog.sequence.getModel())) {
    52                                 ArrayList<MapillaryImage> images = new ArrayList<>();
    53                                 for (MapillaryImage image : MapillaryData.getInstance().getMultiSelectedImages())
    54                                         if (!images.contains(image))
    55                                                 images.addAll(image.getSequence().getImages());
     57                                ArrayList<MapillaryAbstractImage> images = new ArrayList<>();
     58                                for (MapillaryAbstractImage image : MapillaryData.getInstance().getMultiSelectedImages())
     59                                        if (image instanceof MapillaryImage) {
     60                                                if (!images.contains(image))
     61                                                        images.addAll(((MapillaryImage) image).getSequence().getImages());
     62                                        }
     63                                        else
     64                                                images.add(image);
    5665                                export(images);
    5766                        } else if (dialog.group.isSelected(dialog.selected.getModel())) {
    … …  
    6574         * Exports the given images from the database.
    6675         */
    67         public void export(List<MapillaryImage> images) {
     76        public void export(List<MapillaryAbstractImage> images) {
    6877                Main.worker.submit(new Thread(new MapillaryExportManager(images,
    6978                                dialog.chooser.getSelectedFile().toString())));

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

    r31245 r31252  
    55
    66import org.openstreetmap.josm.Main;
    7 import org.openstreetmap.josm.plugins.mapillary.MapillaryImage;
     7import org.openstreetmap.josm.plugins.mapillary.MapillaryAbstractImage;
    88
    99/**
    … …  
    1414 */
    1515public class CommandMoveImage extends MapillaryCommand {
    16         private List<MapillaryImage> images;
     16        private List<MapillaryAbstractImage> images;
    1717        private double x;
    1818        private double y;
    1919
    20         public CommandMoveImage(List<MapillaryImage> images, double x, double y) {
     20        public CommandMoveImage(List<MapillaryAbstractImage> images, double x, double y) {
    2121                this.images = new ArrayList<>(images);
    2222                this.x = x;
    … …  
    2626        @Override
    2727        public void undo() {
    28                 for (MapillaryImage image : images) {
     28                for (MapillaryAbstractImage image : images) {
    2929                        image.move(-x, -y);
    3030                        image.stopMoving();
    … …  
    3535        @Override
    3636        public void redo() {
    37                 for (MapillaryImage image : images) {
     37                for (MapillaryAbstractImage image : images) {
    3838                        image.move(x, y);
    3939                        image.stopMoving();

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

    r31245 r31252  
    55
    66import org.openstreetmap.josm.Main;
    7 import org.openstreetmap.josm.plugins.mapillary.MapillaryImage;
     7import org.openstreetmap.josm.plugins.mapillary.MapillaryAbstractImage;
    88
    99/**
    … …  
    1414 */
    1515public class CommandTurnImage extends MapillaryCommand {
    16         private List<MapillaryImage> images;
     16        private List<MapillaryAbstractImage> images;
    1717        private double ca;
    1818
    19         public CommandTurnImage(List<MapillaryImage> images, double ca) {
     19        public CommandTurnImage(List<MapillaryAbstractImage> images, double ca) {
    2020                this.images = new ArrayList<>(images);
    2121                this.ca = ca;
    … …  
    2424        @Override
    2525        public void undo() {
    26                 for (MapillaryImage image : images) {
     26                for (MapillaryAbstractImage image : images) {
    2727                        image.turn(-ca);
    2828                        image.stopMoving();
    … …  
    3333        @Override
    3434        public void redo() {
    35                 for (MapillaryImage image : images) {
     35                for (MapillaryAbstractImage image : images) {
    3636                        image.turn(ca);
    3737                        image.stopMoving();

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

    r31185 r31252  
    1313import org.openstreetmap.josm.data.cache.ICachedLoaderListener;
    1414import org.openstreetmap.josm.gui.progress.ProgressMonitor;
     15import org.openstreetmap.josm.plugins.mapillary.MapillaryAbstractImage;
    1516import org.openstreetmap.josm.plugins.mapillary.MapillaryImage;
    1617import org.openstreetmap.josm.plugins.mapillary.cache.MapillaryCache;
    … …  
    2829        String url;
    2930        ArrayBlockingQueue<BufferedImage> queue;
    30         ArrayBlockingQueue<MapillaryImage> queueImages;
     31        ArrayBlockingQueue<MapillaryAbstractImage> queueImages;
    3132
    3233        ProgressMonitor monitor;
    … …  
    3536        public MapillaryExportDownloadThread(MapillaryImage image,
    3637                        ArrayBlockingQueue<BufferedImage> queue,
    37                         ArrayBlockingQueue<MapillaryImage> queueImages) {
     38                        ArrayBlockingQueue<MapillaryAbstractImage> queueImages) {
    3839                url = "https://d1cuyjsrcm0gby.cloudfront.net/" + image.getKey()
    3940                                + "/thumb-2048.jpg";

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

    r31177 r31252  
    22
    33import static org.openstreetmap.josm.tools.I18n.tr;
     4
    45import java.awt.image.BufferedImage;
    56import java.io.IOException;
    … …  
    1314import org.openstreetmap.josm.gui.progress.PleaseWaitProgressMonitor;
    1415import org.openstreetmap.josm.io.OsmTransferException;
     16import org.openstreetmap.josm.plugins.mapillary.MapillaryAbstractImage;
    1517import org.openstreetmap.josm.plugins.mapillary.MapillaryImage;
    1618import org.xml.sax.SAXException;
    … …  
    3032
    3133        ArrayBlockingQueue<BufferedImage> queue;
    32         ArrayBlockingQueue<MapillaryImage> queueImages;
     34        ArrayBlockingQueue<MapillaryAbstractImage> queueImages;
    3335
    34         List<MapillaryImage> images;
     36        List<MapillaryAbstractImage> images;
    3537        String path;
    3638
    37         public MapillaryExportManager(List<MapillaryImage> images, String path) {
     39        public MapillaryExportManager(List<MapillaryAbstractImage> images, String path) {
    3840                super(tr("Downloading") + "...", new PleaseWaitProgressMonitor(
    3941                                "Exporting Mapillary Images"), true);
    … …  
    5961                ThreadPoolExecutor ex = new ThreadPoolExecutor(20, 35, 25,
    6062                                TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
    61                 for (MapillaryImage image : images) {
    62                         try {
    63                                 ex.execute(new MapillaryExportDownloadThread(image, queue,
    64                                                 queueImages));
    65                         } catch (Exception e) {
    66                                 Main.error(e);
     63                for (MapillaryAbstractImage image : images) {
     64                        if (image instanceof MapillaryImage) {
     65                                try {
     66                                        ex.execute(new MapillaryExportDownloadThread((MapillaryImage) image, queue,
     67                                                        queueImages));
     68                                } catch (Exception e) {
     69                                        Main.error(e);
     70                                }
     71                                try {
     72                                        // If the queue is full, waits for it to have more space
     73                                        // available before executing anything else.
     74                                        while (ex.getQueue().remainingCapacity() == 0)
     75                                                Thread.sleep(100);
     76                                } catch (Exception e) {
     77                                        Main.error(e);
     78                                }
    6779                        }
    68                         try {
    69                                 // If the queue is full, waits for it to have more space
    70                                 // available before executing anything else.
    71                                 while (ex.getQueue().remainingCapacity() == 0)
    72                                         Thread.sleep(100);
    73                         } catch (Exception e) {
    74                                 Main.error(e);
     80                        else {
     81                                //TODO
    7582                        }
    7683                }

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

    r31183 r31252  
    1818import org.apache.commons.imaging.formats.tiff.write.TiffOutputDirectory;
    1919import org.apache.commons.imaging.formats.tiff.write.TiffOutputSet;
    20 
    2120import org.openstreetmap.josm.Main;
    2221import org.openstreetmap.josm.gui.progress.PleaseWaitProgressMonitor;
    2322import org.openstreetmap.josm.gui.progress.ProgressMonitor;
     23import org.openstreetmap.josm.plugins.mapillary.MapillaryAbstractImage;
    2424import org.openstreetmap.josm.plugins.mapillary.MapillaryImage;
    2525
    … …  
    3434        private final String path;
    3535        private final ArrayBlockingQueue<BufferedImage> queue;
    36         private final ArrayBlockingQueue<MapillaryImage> queueImages;
     36        private final ArrayBlockingQueue<MapillaryAbstractImage> queueImages;
    3737        private final int amount;
    3838        private final ProgressMonitor monitor;
    … …  
    4040        public MapillaryExportWriterThread(String path,
    4141                        ArrayBlockingQueue<BufferedImage> queue,
    42                         ArrayBlockingQueue<MapillaryImage> queueImages, int amount,
     42                        ArrayBlockingQueue<MapillaryAbstractImage> queueImages, int amount,
    4343                        ProgressMonitor monitor) {
    4444                this.path = path;
    … …  
    5454                File tempFile = null;
    5555                BufferedImage img;
    56                 MapillaryImage mimg = null;
     56                MapillaryAbstractImage mimg = null;
    5757                String finalPath = "";
    5858                for (int i = 0; i < amount; i++) {
    … …  
    6060                                img = queue.take();
    6161                                mimg = queueImages.take();
    62                                 finalPath = path + "/" + mimg.getKey();
     62                                if (mimg instanceof MapillaryImage)
     63                                        finalPath = path + "/" + ((MapillaryImage) mimg).getKey();
     64                                else
     65                                        finalPath = path + "/" + i;
    6366                                // Creates a temporal file that is going to be deleted after
    6467                                // writing the EXIF tags.

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

    r31245 r31252  
    1616import org.openstreetmap.josm.Main;
    1717import org.openstreetmap.josm.data.Bounds;
     18import org.openstreetmap.josm.plugins.mapillary.MapillaryAbstractImage;
    1819import org.openstreetmap.josm.plugins.mapillary.MapillaryData;
    1920import org.openstreetmap.josm.plugins.mapillary.MapillaryImage;
    … …  
    7879                                        break;
    7980                                MapillarySequence sequence = new MapillarySequence(jsonobj.getString("key"), jsonobj.getJsonNumber("captured_at").intValue());
    80                                 for (MapillaryImage mimage : MapillaryData.getInstance().getImages())
    81                                         if (mimage.getSequence().getKey().equals(sequence.getKey()))
     81                                for (MapillaryAbstractImage mimage : MapillaryData.getInstance().getImages())
     82                                        if (mimage instanceof MapillaryImage
     83                                                        && ((MapillaryImage) mimage).getSequence().getKey().equals(sequence.getKey()))
    8284                                                break;
    8385                                int first = -1;
    … …  
    8789                                // Here it gets only those images which are in the downloaded
    8890                                // area.
    89                                 for (MapillaryImage img : images) {
     91                                for (MapillaryAbstractImage img : images) {
    9092                                        if (first == -1 && bounds.contains(img.getLatLon()))
    9193                                                first = pos;
    … …  
    106108                                        img.setSequence(sequence);
    107109                                }
    108                                 MapillaryData.getInstance().addWithoutUpdate(finalImages);
     110                                MapillaryData.getInstance().addWithoutUpdate(new ArrayList<MapillaryAbstractImage>(finalImages));
    109111                                sequence.add(finalImages);
    110112                        }

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

    r31248 r31252  
    11package org.openstreetmap.josm.plugins.mapillary.downloads;
     2
     3import static org.openstreetmap.josm.tools.I18n.tr;
    24
    35import java.util.concurrent.ThreadPoolExecutor;
    … …  
    3436                Main.map.statusLine.setHelpText("Downloading images from Mapillary");
    3537                downloadSequences();
    36                 Main.map.statusLine.setHelpText("Total images: " + MapillaryData.getInstance().getImages().size());
     38                if (MapillaryData.getInstance().getImages().size() > 0)
     39                        Main.map.statusLine.setHelpText(tr("Total images: ")
     40                                        + MapillaryData.getInstance().getImages().size());
     41                else
     42                        Main.map.statusLine.setHelpText(tr("No images found"));
    3743        }
    3844

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

    r31176 r31252  
    1313
    1414import org.openstreetmap.josm.Main;
     15import org.openstreetmap.josm.plugins.mapillary.MapillaryAbstractImage;
    1516import org.openstreetmap.josm.plugins.mapillary.MapillaryData;
    1617import org.openstreetmap.josm.plugins.mapillary.MapillaryImage;
    … …  
    4243                        }
    4344                        JsonArray jsonarr = jsonobj.getJsonArray("ims");
    44                         ArrayList<MapillaryImage> images = new ArrayList<>();
     45                        ArrayList<MapillaryAbstractImage> images = new ArrayList<>();
    4546                        JsonObject image;
    4647                        for (int i = 0; i < jsonarr.size(); i++) {

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

    r31251 r31252  
    1717
    1818import org.openstreetmap.josm.plugins.mapillary.MapillaryData;
     19import org.openstreetmap.josm.plugins.mapillary.MapillaryImage;
    1920
    2021/**
    … …  
    5354                // Some options are disabled depending on the circumstances
    5455                if (MapillaryData.getInstance().getSelectedImage() == null
    55                                 || MapillaryData.getInstance().getSelectedImage().getSequence() == null) {
     56                                || (MapillaryData.getInstance().getSelectedImage() instanceof MapillaryImage && ((MapillaryImage) MapillaryData
     57                                                .getInstance().getSelectedImage()).getSequence() == null)) {
    5658                        sequence.setEnabled(false);
    5759                }

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

    r31251 r31252  
    2121import org.openstreetmap.josm.gui.dialogs.ToggleDialog;
    2222import org.openstreetmap.josm.gui.SideButton;
     23import org.openstreetmap.josm.plugins.mapillary.MapillaryAbstractImage;
    2324import org.openstreetmap.josm.plugins.mapillary.MapillaryData;
    2425import org.openstreetmap.josm.plugins.mapillary.MapillaryImage;
    … …  
    4243        public static MapillaryToggleDialog INSTANCE;
    4344
    44         public volatile MapillaryImage image;
     45        public volatile MapillaryAbstractImage image;
    4546
    4647        final SideButton nextButton = new SideButton(new nextPictureAction());
    … …  
    108109                        if (this.image == null)
    109110                                return;
    110                         this.nextButton.setEnabled(true);
    111                         this.previousButton.setEnabled(true);
    112                         if (this.image.next() == null)
    113                                 this.nextButton.setEnabled(false);
    114                         if (this.image.previous() == null)
    115                                 this.previousButton.setEnabled(false);
    116 
    117                         mapillaryImageDisplay.hyperlink.setURL(image.getKey());
    118                         this.mapillaryImageDisplay.setImage(null);
    119                         if (thumbnailCache != null)
    120                                 thumbnailCache.cancelOutstandingTasks();
    121                         thumbnailCache = new MapillaryCache(image.getKey(),
    122                                         MapillaryCache.Type.THUMBNAIL);
    123                         thumbnailCache.submit(this, false);
    124 
    125                         if (imageCache != null)
    126                                 imageCache.cancelOutstandingTasks();
    127                         imageCache = new MapillaryCache(image.getKey(),
    128                                         MapillaryCache.Type.FULL_IMAGE);
    129                         imageCache.submit(this, false);
    130 
     111                        if (image instanceof MapillaryImage) {
     112                                this.nextButton.setEnabled(true);
     113                                this.previousButton.setEnabled(true);
     114                                MapillaryImage mapillaryImage = (MapillaryImage) this.image;
     115                                if (mapillaryImage.next() == null)
     116                                        this.nextButton.setEnabled(false);
     117                                if (mapillaryImage.previous() == null)
     118                                        this.previousButton.setEnabled(false);
     119
     120                                mapillaryImageDisplay.hyperlink.setURL(mapillaryImage.getKey());
     121                                this.mapillaryImageDisplay.setImage(null);
     122                                if (thumbnailCache != null)
     123                                        thumbnailCache.cancelOutstandingTasks();
     124                                thumbnailCache = new MapillaryCache(mapillaryImage.getKey(),
     125                                                MapillaryCache.Type.THUMBNAIL);
     126                                thumbnailCache.submit(this, false);
     127
     128                                if (imageCache != null)
     129                                        imageCache.cancelOutstandingTasks();
     130                                imageCache = new MapillaryCache(mapillaryImage.getKey(),
     131                                                MapillaryCache.Type.FULL_IMAGE);
     132                                imageCache.submit(this, false);
     133                        }
    131134                }
    132135        }
    … …  
    137140         * @param image
    138141         */
    139         public synchronized void setImage(MapillaryImage image) {
     142        public synchronized void setImage(MapillaryAbstractImage image) {
    140143                this.image = image;
    141144        }
    … …  
    146149         * @return
    147150         */
    148         public synchronized MapillaryImage getImage() {
     151        public synchronized MapillaryAbstractImage getImage() {
    149152                return this.image;
    150153        }
    … …  
    201204                public redAction() {
    202205                        putValue(NAME, tr("Jump to red"));
    203                         putValue(SHORT_DESCRIPTION,
     206                        putValue(
     207                                        SHORT_DESCRIPTION,
    204208                                        tr("Jumps to the picture at the other side of the red line"));
    205209                }
    … …  
    222226                public blueAction() {
    223227                        putValue(NAME, tr("Jump to blue"));
    224                         putValue(SHORT_DESCRIPTION,
     228                        putValue(
     229                                        SHORT_DESCRIPTION,
    225230                                        tr("Jumps to the picture at the other side of the blue line"));
    226231                }
Note: See TracChangeset for help on using the changeset viewer.