Changeset 31322 in osm for applications/editors


Ignore:
Timestamp:
2015-07-01T11:52:00+02:00 (9 years ago)
Author:
nokutu
Message:

Fixed bug when downloading several sets of images and now it doesn't block other OSM API queries

Location:
applications/editors/josm/plugins/mapillary/src/org/openstreetmap/josm/plugins/mapillary
Files:
6 edited

Legend:

Unmodified
Added
Removed

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

    r31284 r31322  
    1212 */
    1313public class MapillaryImage extends MapillaryAbstractImage {
    14     /** Unique identifier of the object */
    15     private final String key;
    16     /** Sequence of pictures containing this object */
    17     private MapillarySequence sequence;
     14        /** Unique identifier of the object */
     15        private final String key;
     16        /** Sequence of pictures containing this object */
     17        private MapillarySequence sequence;
    1818
    19     /** Epoch time when the image was taken. */
    20     /** The user that made the image */
    21     private String user;
    22     /** Set of traffic signs in the image */
    23     private List<String> signs;
    24     private String location;
     19        /** Epoch time when the image was taken. */
     20        /** The user that made the image */
     21        private String user;
     22        /** Set of traffic signs in the image */
     23        private List<String> signs;
     24        private String location;
    2525
    26     public String getLocation() {
    27         return location;
    28     }
     26        public String getLocation() {
     27                return location;
     28        }
    2929
    30     public void setLocation(String location) {
    31         this.location = location;
    32     }
     30        public void setLocation(String location) {
     31                this.location = location;
     32        }
    3333
    34     /**
    35     * Main contructor of the class MapillaryImage
    36     *
    37     * @param key
    38     *            The unique identifier of the image.
    39     * @param lat
    40     *            The latitude where it is positioned.
    41     * @param lon
    42     *            The longitude where it is positioned.
    43     * @param ca
    44     *            The direction of the images in degrees, meaning 0 north.
    45     */
    46     public MapillaryImage(String key, double lat, double lon, double ca) {
    47         super(lat, lon, ca);
    48         this.key = key;
    49         this.signs = new ArrayList<>();
    50     }
     34        /**
     35        * Main contructor of the class MapillaryImage
     36        *
     37        * @param key
     38        *            The unique identifier of the image.
     39        * @param lat
     40        *            The latitude where it is positioned.
     41        * @param lon
     42        *            The longitude where it is positioned.
     43        * @param ca
     44        *            The direction of the images in degrees, meaning 0 north.
     45        */
     46        public MapillaryImage(String key, double lat, double lon, double ca) {
     47                super(lat, lon, ca);
     48                this.key = key;
     49                this.signs = new ArrayList<>();
     50        }
    5151
    52     /**
    53     * Returns the unique identifier of the object.
    54     *
    55     * @return A String containing the unique identifier of the object.
    56     */
    57     public String getKey() {
    58         return this.key;
    59     }
     52        /**
     53        * Returns the unique identifier of the object.
     54        *
     55        * @return A String containing the unique identifier of the object.
     56        */
     57        public String getKey() {
     58                return this.key;
     59        }
    6060
    61     /**
    62     * Adds a new sign to the set of signs.
    63     *
    64     * @param sign
    65     */
    66     public void addSign(String sign) {
    67         signs.add(sign);
    68     }
     61        /**
     62        * Adds a new sign to the set of signs.
     63        *
     64        * @param sign
     65        */
     66        public void addSign(String sign) {
     67                signs.add(sign);
     68        }
    6969
    70     public List<String> getSigns() {
    71         return signs;
    72     }
     70        public List<String> getSigns() {
     71                return signs;
     72        }
    7373
    74     public void setUser(String user) {
    75         this.user = user;
    76     }
     74        public void setUser(String user) {
     75                this.user = user;
     76        }
    7777
    78     public String getUser() {
    79         return user;
    80     }
     78        public String getUser() {
     79                return user;
     80        }
    8181
    82     /**
    83     * Sets the MapillarySequence object which contains the MapillaryImage.
    84     *
    85     * @param sequence
    86     *            The MapillarySequence that contains the MapillaryImage.
    87     */
    88     public void setSequence(MapillarySequence sequence) {
    89         this.sequence = sequence;
    90     }
     82        /**
     83        * Sets the MapillarySequence object which contains the MapillaryImage.
     84        *
     85        * @param sequence
     86        *            The MapillarySequence that contains the MapillaryImage.
     87        */
     88        public void setSequence(MapillarySequence sequence) {
     89                this.sequence = sequence;
     90        }
    9191
    92     /**
    93     * Returns the sequence which contains this image.
    94     *
    95     * @return The MapillarySequence object that contains this MapillaryImage.
    96     */
    97     public MapillarySequence getSequence() {
    98         return this.sequence;
    99     }
     92        /**
     93        * Returns the sequence which contains this image.
     94        *
     95        * @return The MapillarySequence object that contains this MapillaryImage.
     96        */
     97        public MapillarySequence getSequence() {
     98                return this.sequence;
     99        }
    100100
    101     public String toString() {
    102         return "Image[key=" + this.key + ";lat=" + this.latLon.lat() + ";lon="
    103                 + this.latLon.lon() + ";ca=" + this.ca + "]";
    104     }
     101        public String toString() {
     102                return "Image[key=" + this.key + ";lat=" + this.latLon.lat() + ";lon="
     103                                + this.latLon.lon() + ";ca=" + this.ca + "]";
     104        }
    105105
    106     /**
    107     * If the MapillaryImage belongs to a MapillarySequence, returns the next
    108     * MapillarySequence in it.
    109     *
    110     * @return The following MapillaryImage, or null if there is none.
    111     */
    112     public MapillaryImage next() {
    113         if (this.getSequence() == null)
    114             return null;
    115         return this.getSequence().next(this);
    116     }
     106        /**
     107        * If the MapillaryImage belongs to a MapillarySequence, returns the next
     108        * MapillarySequence in it.
     109        *
     110        * @return The following MapillaryImage, or null if there is none.
     111        */
     112        public MapillaryImage next() {
     113                if (this.getSequence() == null)
     114                        return null;
     115                return this.getSequence().next(this);
     116        }
    117117
    118     /**
    119     * If the MapillaryImage belongs to a MapillarySequence, returns the
    120     * previous MapillarySequence in it.
    121     *
    122     * @return The previous MapillaryImage, or null if there is none.
    123     */
    124     public MapillaryImage previous() {
    125         if (this.getSequence() == null)
    126             return null;
    127         return this.getSequence().previous(this);
    128     }
     118        /**
     119        * If the MapillaryImage belongs to a MapillarySequence, returns the
     120        * previous MapillarySequence in it.
     121        *
     122        * @return The previous MapillaryImage, or null if there is none.
     123        */
     124        public MapillaryImage previous() {
     125                if (this.getSequence() == null)
     126                        return null;
     127                return this.getSequence().previous(this);
     128        }
    129129
    130     @Override
    131     public boolean equals(Object object) {
    132         if (object instanceof MapillaryImage)
    133             return this.key.equals(((MapillaryImage) object).getKey());
    134         return false;
    135     }
     130        @Override
     131        public boolean equals(Object object) {
     132                if (object instanceof MapillaryImage)
     133                        return this.key.equals(((MapillaryImage) object).getKey());
     134                return false;
     135        }
    136136
    137     @Override
    138     public int hashCode() {
    139         return this.key.hashCode();
    140     }
     137        @Override
     138        public int hashCode() {
     139                return this.key.hashCode();
     140        }
    141141}

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

    r31319 r31322  
    255255         */
    256256        @Override
    257         public void paint(Graphics2D g, MapView mv, Bounds box) {
    258                 synchronized (this) {
    259                         if (Main.map.mapView.getActiveLayer() == this) {
    260                                 Rectangle b = mv.getBounds();
    261                                 // on some platforms viewport bounds seem to be offset from the
    262                                 // left,
    263                                 // over-grow it just to be sure
    264                                 b.grow(100, 100);
    265                                 Area a = new Area(b);
    266                                 // now successively subtract downloaded areas
    267                                 for (Bounds bounds : this.bounds) {
    268                                         Point p1 = mv.getPoint(bounds.getMin());
    269                                         Point p2 = mv.getPoint(bounds.getMax());
    270                                         Rectangle r = new Rectangle(Math.min(p1.x, p2.x), Math.min(
    271                                                         p1.y, p2.y), Math.abs(p2.x - p1.x), Math.abs(p2.y
    272                                                         - p1.y));
    273                                         a.subtract(new Area(r));
     257        public synchronized void paint(Graphics2D g, MapView mv, Bounds box) {
     258                if (Main.map.mapView.getActiveLayer() == this) {
     259                        Rectangle b = mv.getBounds();
     260                        // on some platforms viewport bounds seem to be offset from the
     261                        // left,
     262                        // over-grow it just to be sure
     263                        b.grow(100, 100);
     264                        Area a = new Area(b);
     265                        // now successively subtract downloaded areas
     266                        for (Bounds bounds : this.bounds) {
     267                                Point p1 = mv.getPoint(bounds.getMin());
     268                                Point p2 = mv.getPoint(bounds.getMax());
     269                                Rectangle r = new Rectangle(Math.min(p1.x, p2.x), Math.min(
     270                                                p1.y, p2.y), Math.abs(p2.x - p1.x), Math.abs(p2.y
     271                                                - p1.y));
     272                                a.subtract(new Area(r));
     273                        }
     274                        // paint remainder
     275                        g.setPaint(hatched);
     276                        g.fill(a);
     277                }
     278
     279                // Draw colored lines
     280                MapillaryLayer.BLUE = null;
     281                MapillaryLayer.RED = null;
     282                MapillaryToggleDialog.getInstance().blueButton.setEnabled(false);
     283                MapillaryToggleDialog.getInstance().redButton.setEnabled(false);
     284
     285                // Sets blue and red lines and enables/disables the buttons
     286                if (data.getSelectedImage() != null) {
     287                        MapillaryImage[] closestImages = getClosestImagesFromDifferentSequences();
     288                        Point selected = mv.getPoint(data.getSelectedImage().getLatLon());
     289                        if (closestImages[0] != null) {
     290                                MapillaryLayer.BLUE = closestImages[0];
     291                                g.setColor(Color.BLUE);
     292                                g.drawLine(mv.getPoint(closestImages[0].getLatLon()).x,
     293                                                mv.getPoint(closestImages[0].getLatLon()).y,
     294                                                selected.x, selected.y);
     295                                MapillaryToggleDialog.getInstance().blueButton.setEnabled(true);
     296                        }
     297                        if (closestImages[1] != null) {
     298                                MapillaryLayer.RED = closestImages[1];
     299                                g.setColor(Color.RED);
     300                                g.drawLine(mv.getPoint(closestImages[1].getLatLon()).x,
     301                                                mv.getPoint(closestImages[1].getLatLon()).y,
     302                                                selected.x, selected.y);
     303                                MapillaryToggleDialog.getInstance().redButton.setEnabled(true);
     304                        }
     305                }
     306                g.setColor(Color.WHITE);
     307                for (MapillaryAbstractImage imageAbs : data.getImages()) {
     308                        if (!imageAbs.isVisible())
     309                                continue;
     310                        Point p = mv.getPoint(imageAbs.getLatLon());
     311                        if (imageAbs instanceof MapillaryImage) {
     312                                MapillaryImage image = (MapillaryImage) imageAbs;
     313                                Point nextp = null;
     314                                // Draw sequence line
     315                                if (image.getSequence() != null) {
     316                                        MapillaryImage tempImage = image;
     317                                        while (tempImage.next() != null) {
     318                                                tempImage = tempImage.next();
     319                                                if (tempImage.isVisible()) {
     320                                                        nextp = mv.getPoint(tempImage.getLatLon());
     321                                                        break;
     322                                                }
     323                                        }
     324                                        if (nextp != null)
     325                                                g.drawLine(p.x, p.y, nextp.x, nextp.y);
    274326                                }
    275                                 // paint remainder
    276                                 g.setPaint(hatched);
    277                                 g.fill(a);
    278                         }
    279 
    280                         // Draw colored lines
    281                         MapillaryLayer.BLUE = null;
    282                         MapillaryLayer.RED = null;
    283                         MapillaryToggleDialog.getInstance().blueButton.setEnabled(false);
    284                         MapillaryToggleDialog.getInstance().redButton.setEnabled(false);
    285 
    286                         // Sets blue and red lines and enables/disables the buttons
    287                         if (data.getSelectedImage() != null) {
    288                                 MapillaryImage[] closestImages = getClosestImagesFromDifferentSequences();
    289                                 Point selected = mv.getPoint(data.getSelectedImage()
    290                                                 .getLatLon());
    291                                 if (closestImages[0] != null) {
    292                                         MapillaryLayer.BLUE = closestImages[0];
    293                                         g.setColor(Color.BLUE);
    294                                         g.drawLine(mv.getPoint(closestImages[0].getLatLon()).x,
    295                                                         mv.getPoint(closestImages[0].getLatLon()).y,
    296                                                         selected.x, selected.y);
    297                                         MapillaryToggleDialog.getInstance().blueButton
    298                                                         .setEnabled(true);
     327
     328                                ImageIcon icon;
     329                                if (!data.getMultiSelectedImages().contains(image))
     330                                        icon = MapillaryPlugin.MAP_ICON;
     331                                else
     332                                        icon = MapillaryPlugin.MAP_ICON_SELECTED;
     333                                draw(g, image, icon, p);
     334                                if (!image.getSigns().isEmpty()) {
     335                                        g.drawImage(MapillaryPlugin.MAP_SIGN.getImage(),
     336                                                        p.x + icon.getIconWidth() / 2,
     337                                                        p.y - icon.getIconHeight() / 2, Main.map.mapView);
    299338                                }
    300                                 if (closestImages[1] != null) {
    301                                         MapillaryLayer.RED = closestImages[1];
    302                                         g.setColor(Color.RED);
    303                                         g.drawLine(mv.getPoint(closestImages[1].getLatLon()).x,
    304                                                         mv.getPoint(closestImages[1].getLatLon()).y,
    305                                                         selected.x, selected.y);
    306                                         MapillaryToggleDialog.getInstance().redButton
    307                                                         .setEnabled(true);
    308                                 }
    309                         }
    310                         g.setColor(Color.WHITE);
    311                         for (MapillaryAbstractImage imageAbs : data.getImages()) {
    312                                 if (!imageAbs.isVisible())
    313                                         continue;
    314                                 Point p = mv.getPoint(imageAbs.getLatLon());
    315                                 if (imageAbs instanceof MapillaryImage) {
    316                                         MapillaryImage image = (MapillaryImage) imageAbs;
    317                                         Point nextp = null;
    318                                         // Draw sequence line
    319                                         if (image.getSequence() != null) {
    320                                                 MapillaryImage tempImage = image;
    321                                                 while (tempImage.next() != null) {
    322                                                         tempImage = tempImage.next();
    323                                                         if (tempImage.isVisible()) {
    324                                                                 nextp = mv.getPoint(tempImage.getLatLon());
    325                                                                 break;
    326                                                         }
    327                                                 }
    328                                                 if (nextp != null)
    329                                                         g.drawLine(p.x, p.y, nextp.x, nextp.y);
    330                                         }
    331 
    332                                         ImageIcon icon;
    333                                         if (!data.getMultiSelectedImages().contains(image))
    334                                                 icon = MapillaryPlugin.MAP_ICON;
    335                                         else
    336                                                 icon = MapillaryPlugin.MAP_ICON_SELECTED;
    337                                         draw(g, image, icon, p);
    338                                         if (!image.getSigns().isEmpty()) {
    339                                                 g.drawImage(MapillaryPlugin.MAP_SIGN.getImage(), p.x
    340                                                                 + icon.getIconWidth() / 2,
    341                                                                 p.y - icon.getIconHeight() / 2,
    342                                                                 Main.map.mapView);
    343                                         }
    344                                 } else if (imageAbs instanceof MapillaryImportedImage) {
    345                                         MapillaryImportedImage image = (MapillaryImportedImage) imageAbs;
    346                                         ImageIcon icon;
    347                                         if (!data.getMultiSelectedImages().contains(image))
    348                                                 icon = MapillaryPlugin.MAP_ICON_IMPORTED;
    349                                         else
    350                                                 icon = MapillaryPlugin.MAP_ICON_SELECTED;
    351                                         draw(g, image, icon, p);
    352                                 }
     339                        } else if (imageAbs instanceof MapillaryImportedImage) {
     340                                MapillaryImportedImage image = (MapillaryImportedImage) imageAbs;
     341                                ImageIcon icon;
     342                                if (!data.getMultiSelectedImages().contains(image))
     343                                        icon = MapillaryPlugin.MAP_ICON_IMPORTED;
     344                                else
     345                                        icon = MapillaryPlugin.MAP_ICON_SELECTED;
     346                                draw(g, image, icon, p);
    353347                        }
    354348                }

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

    r31319 r31322  
    77
    88import java.util.concurrent.ConcurrentHashMap;
     9import java.util.concurrent.Executor;
     10import java.util.concurrent.Executors;
    911
    1012/**
    … …  
    1618public class MapillaryDownloader {
    1719
    18     public final static String BASE_URL = "https://a.mapillary.com/v2/";
    19     public final static String CLIENT_ID = "NzNRM2otQkR2SHJzaXJmNmdQWVQ0dzo1YTA2NmNlODhlNWMwOTBm";
     20        public final static String BASE_URL = "https://a.mapillary.com/v2/";
     21        public final static String CLIENT_ID = "NzNRM2otQkR2SHJzaXJmNmdQWVQ0dzo1YTA2NmNlODhlNWMwOTBm";
     22        public final static Executor EXECUTOR = Executors.newSingleThreadExecutor();
    2023
    21     private String[] parameters = { "lat", "lon", "distance", "limit",
    22             "min_lat", "min_lon", "max_lat", "max_lon" };
     24        private String[] parameters = { "lat", "lon", "distance", "limit",
     25                        "min_lat", "min_lon", "max_lat", "max_lon" };
    2326
    24     public MapillaryDownloader() {
    25     }
     27        public MapillaryDownloader() {
     28        }
    2629
    27     /**
    28     * Gets all the images in a square. It downloads all the images of all the
    29     * sequences that pass through the given rectangle.
    30     *
    31     * @param minLatLon
    32     *            The minimum latitude and longitude of the rectangle.
    33     * @param maxLatLon
    34     *            The maximum latitude and longitude of the rectangle
    35     */
    36     public void getImages(LatLon minLatLon, LatLon maxLatLon) {
    37         String url1 = BASE_URL;
    38         String url2 = BASE_URL;
    39         String url3 = BASE_URL;
    40         url1 += "search/im/";
    41         url2 += "search/s/";
    42         url3 += "search/im/or";
    43         ConcurrentHashMap<String, Double> hash = new ConcurrentHashMap<>();
    44         hash.put("min_lat", minLatLon.lat());
    45         hash.put("min_lon", minLatLon.lon());
    46         hash.put("max_lat", maxLatLon.lat());
    47         hash.put("max_lon", maxLatLon.lon());
    48         url1 += buildParameters(hash);
    49         url2 += buildParameters(hash);
    50         url3 += buildParameters(hash);
     30        /**
     31        * Gets all the images in a square. It downloads all the images of all the
     32        * sequences that pass through the given rectangle.
     33        *
     34        * @param minLatLon
     35        *            The minimum latitude and longitude of the rectangle.
     36        * @param maxLatLon
     37        *            The maximum latitude and longitude of the rectangle
     38        */
     39        public void getImages(LatLon minLatLon, LatLon maxLatLon) {
     40                String url1 = BASE_URL;
     41                String url2 = BASE_URL;
     42                String url3 = BASE_URL;
     43                url1 += "search/im/";
     44                url2 += "search/s/";
     45                url3 += "search/im/or";
     46                ConcurrentHashMap<String, Double> hash = new ConcurrentHashMap<>();
     47                hash.put("min_lat", minLatLon.lat());
     48                hash.put("min_lon", minLatLon.lon());
     49                hash.put("max_lat", maxLatLon.lat());
     50                hash.put("max_lon", maxLatLon.lon());
     51                url1 += buildParameters(hash);
     52                url2 += buildParameters(hash);
     53                url3 += buildParameters(hash);
    5154
    52         try {
    53             Main.info("GET " + url2 + " (Mapillary plugin)");
    54             Main.worker.submit(new MapillarySquareDownloadManagerThread(url1,
    55                     url2, url3, MapillaryLayer.getInstance()));
    56         } catch (Exception e) {
    57             Main.error(e);
    58         }
    59     }
     55                try {
     56                        Main.info("GET " + url2 + " (Mapillary plugin)");
     57                        EXECUTOR.execute(new MapillarySquareDownloadManagerThread(url1, url2,
     58                                        url3, MapillaryLayer.getInstance()));
     59                } catch (Exception e) {
     60                        Main.error(e);
     61                }
     62        }
    6063
    61     public void getImages(Bounds bounds) {
    62         getImages(bounds.getMin(), bounds.getMax());
    63     }
     64        public void getImages(Bounds bounds) {
     65                getImages(bounds.getMin(), bounds.getMax());
     66        }
    6467
    65     private String buildParameters(ConcurrentHashMap<String, Double> hash) {
    66         String ret = "?client_id=" + CLIENT_ID;
    67         for (int i = 0; i < parameters.length; i++)
    68             if (hash.get(parameters[i]) != null)
    69                 ret += "&" + parameters[i] + "=" + hash.get(parameters[i]);
    70         return ret;
    71     }
     68        private String buildParameters(ConcurrentHashMap<String, Double> hash) {
     69                String ret = "?client_id=" + CLIENT_ID;
     70                for (int i = 0; i < parameters.length; i++)
     71                        if (hash.get(parameters[i]) != null)
     72                                ret += "&" + parameters[i] + "=" + hash.get(parameters[i]);
     73                return ret;
     74        }
    7275}

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

    r31319 r31322  
    9191                                boolean imagesAdded = false;
    9292                                for (MapillaryImage img : finalImages) {
    93                                         if (layer.data.getImages().contains(img))
     93                                        if (layer.data.getImages().contains(img)) {
    9494                                                ((MapillaryImage) layer.data.getImages().get(
    9595                                                                layer.data.getImages().indexOf(img)))
    9696                                                                .setSequence(sequence);
     97                                                finalImages.set(
     98                                                                finalImages.indexOf(img),
     99                                                                (MapillaryImage) layer.data.getImages().get(
     100                                                                                layer.data.getImages().indexOf(img)));
     101                                        }
     102
    97103                                        else {
    98104                                                img.setSequence(sequence);
    … …  
    101107                                }
    102108                                manager.imagesAdded = imagesAdded;
    103                                 layer.data.addWithoutUpdate(
    104                                                 new ArrayList<MapillaryAbstractImage>(finalImages));
     109                                layer.data
     110                                                .addWithoutUpdate(new ArrayList<MapillaryAbstractImage>(
     111                                                                finalImages));
    105112                                sequence.add(finalImages);
    106113                        }

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

    r31319 r31322  
    1414/**
    1515 * This Class is needed to create an indeterminate amount of downloads, because
    16  * the Mapillary API has a param page which is needed when the amount of
     16 * the Mapillary API has a paramameter called page which is needed when the amount of
    1717 * requested images is quite big.
    1818 *
    … …  
    2828        private final MapillaryLayer layer;
    2929        public boolean imagesAdded = false;
    30 
     30       
    3131        public MapillarySquareDownloadManagerThread(String urlImages,
    3232                        String urlSequences, String urlSigns, MapillaryLayer layer) {

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

    r31319 r31322  
    7070                Shortcut.registerShortcut(tr("Mapillary dialog"),
    7171                        tr("Open Mapillary main dialog"), KeyEvent.VK_M,
    72                         Shortcut.NONE), 200);
     72                        Shortcut.NONE), 200, false, MapillaryPreferenceSetting.class);
    7373        MapillaryData.getInstance().addListener(this);
    7474        addShortcuts();
    … …  
    146146                    title += " -- " + mapillaryImage.getDate();
    147147                setTitle(title);
     148                // Enables/disables next/previous buttons
    148149                this.nextButton.setEnabled(false);
    149150                this.previousButton.setEnabled(false);
    150                 // Enables/disables next/previous buttons
    151151                if (((MapillaryImage) image).getSequence() != null) {
    152152                    MapillaryImage tempImage = (MapillaryImage) image;
Note: See TracChangeset for help on using the changeset viewer.