Changeset 36194 for applications/editors/josm/plugins/MicrosoftStreetside/src/org – JOSM

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/StreetsideAbstractImage.java

-              r34577
+              r36194
  */
 public abstract class StreetsideAbstractImage implements Comparable<StreetsideAbstractImage> {
+        /**
+         * If two values for field cd differ by less than EPSILON both values are
+         * considered equal.
+         */
+        private static final float EPSILON = 1e-5f;
+        protected String id;
+        // Image id of next image in sequence (decimal)
+        private long ne;
+    //Image id of previous image in sequence (decimal)
+    private long pr;
+        /** Sequence of pictures containing this object. */
+        private StreetsideSequence sequence;
+        /** Position of the picture. */
+        protected LatLon latLon;
+        /** Direction of the picture in degrees from true north. */
+        protected double he;
+        /** Temporal position of the picture until it is uploaded. */
+        private LatLon tempLatLon;
+        /**
+         * When the object is being dragged in the map, the temporal position is stored
+         * here.
+         */
+        private LatLon movingLatLon;
+        /** Temporal direction of the picture until it is uploaded */
+        private double tempHe;
+        /**
+         * When the object direction is being moved in the map, the temporal direction
+         * is stored here
+         */
+        protected double movingHe;
+        /** Whether the image must be drown in the map or not */
+        private boolean visible;
+        /**
+         * Creates a new object in the given position and with the given direction.
+         * {@link LatLon}
+         *
+         * @param id - the Streetside image id
+         *
+         * @param latLon
+         *            The latitude and longitude of the image.
+         * @param he
+         *            The direction of the picture (0 means north im Mapillary
+         *            camera direction is not yet supported in the Streetside plugin).
+         */
+        protected StreetsideAbstractImage(final String id, final LatLon latLon, final double he) {
+                this.id = id;
+                this.latLon = latLon;
+                tempLatLon = this.latLon;
+                movingLatLon = this.latLon;
+                this.he = he;
+                tempHe = he;
+                movingHe = he;
+                visible = true;
+        }
+        /**
+         * Creates a new object with the given id.
+         *
+         * @param id - the image id (All images require ids in Streetside)
+         */
+        protected StreetsideAbstractImage(final String id) {
+                this.id = id;
+                visible = true;
+        }
+        /**
+         * @return the id
+         */
+        public String getId() {
+                return id;
+        }
+        /**
+         * @param id
+         *            the id to set
+         */
+        public void setId(String id) {
+                this.id = id;
+        }
+        /**
+         * Returns the original direction towards the image has been taken.
+         *
+         * @return The direction of the image (0 means north and goes clockwise).
+         */
+        public double getHe() {
+                return he;
+        }
+        /**
+         * Returns a LatLon object containing the original coordinates of the object.
+         *
+         * @return The LatLon object with the position of the object.
+         */
+        public LatLon getLatLon() {
+                return latLon;
+        }
+        /**
+         * Returns the direction towards the image has been taken.
+         *
+         * @return The direction of the image (0 means north and goes clockwise).
+         */
+        public double getMovingHe() {
+                return movingHe;
+        }
+        /**
+         * Returns a LatLon object containing the current coordinates of the object.
+         * When you are dragging the image this changes.
+         *
+         * @return The LatLon object with the position of the object.
+         */
+        public LatLon getMovingLatLon() {
+                return movingLatLon;
+        }
+        /**
+         * Returns the sequence which contains this image. Never null.
+         *
+         * @return The StreetsideSequence object that contains this StreetsideImage.
+         */
+        public StreetsideSequence getSequence() {
+                synchronized (this) {
+                        if (sequence == null) {
+                                sequence = new StreetsideSequence();
+                                sequence.add(this);
+                        }
+                        return sequence;
+                }
+        }
+        /**
+         * Returns the last fixed direction of the object.
+         *
+         * @return The last fixed direction of the object. 0 means north.
+         */
+        public double getTempHe() {
+                return tempHe;
+        }
+        /**
+         * Returns the last fixed coordinates of the object.
+         *
+         * @return A LatLon object containing.
+         */
+        public LatLon getTempLatLon() {
+                return tempLatLon;
+        }
+        /**
+         * Returns whether the object has been modified or not.
+         *
+         * @return true if the object has been modified; false otherwise.
+         */
+        public boolean isModified() {
+                return !getMovingLatLon().equals(latLon) || Math.abs(getMovingHe() - he) > EPSILON;
+        }
+        /**
+         * Returns whether the image is visible on the map or not.
+         *
+         * @return True if the image is visible; false otherwise.
+         */
+        public boolean isVisible() {
+                return visible;
+        }
+        /**
+         * Moves the image temporally to another position
+         *
+         * @param x
+         *            The movement of the image in longitude units.
+         * @param y
+         *            The movement of the image in latitude units.
+         */
+        public void move(final double x, final double y) {
+                movingLatLon = new LatLon(tempLatLon.getY() + y, tempLatLon.getX() + x);
+        }
+        /**
+         * If the StreetsideImage belongs to a StreetsideSequence, returns the next
+         * image in the sequence.
+         *
+         * @return The following StreetsideImage, or null if there is none.
+         */
+        public StreetsideAbstractImage next() {
+                synchronized (this) {
+                        return getSequence().next(this);
+                }
+        }
+        /**
+         * If the StreetsideImage belongs to a StreetsideSequence, returns the previous
+         * image in the sequence.
+         *
+         * @return The previous StreetsideImage, or null if there is none.
+         */
+        public StreetsideAbstractImage previous() {
+                synchronized (this) {
+                        return getSequence().previous(this);
+                }
+        }
+        public void setHe(final double he) {
+                this.he = he;
+        }
+        public void setLatLon(final LatLon latLon) {
+                if (latLon != null) {
+                        this.latLon = latLon;
+                }
+        }
+        /**
+         * Sets the StreetsideSequence object which contains the StreetsideImage.
+         *
+         * @param sequence
+         *            The StreetsideSequence that contains the StreetsideImage.
+         * @throws IllegalArgumentException
+         *             if the image is not already part of the
+         *             {@link StreetsideSequence}. Call
+         *             {@link StreetsideSequence#add(StreetsideAbstractImage)} first.
+         */
+        public void setSequence(final StreetsideSequence sequence) {
+                synchronized (this) {
+                        if (sequence != null && !sequence.getImages().contains(this)) {
+                                throw new IllegalArgumentException();
+                        }
+                        this.sequence = sequence;
+                }
+        }
+        /**
+         * Set's whether the image should be visible on the map or not.
+         *
+         * @param visible
+         *            true if the image is set to be visible; false otherwise.
+         */
+        public void setVisible(final boolean visible) {
+                this.visible = visible;
+        }
+        /**
+         * Called when the mouse button is released, meaning that the picture has
+         * stopped being dragged, so the temporal values are saved.
+         */
+        public void stopMoving() {
+                tempLatLon = movingLatLon;
+                tempHe = movingHe;
+        }
+        /**
+         * Turns the image direction.
+         *
+         * @param he
+         *            The angle the image is moving.
+         */
+        public void turn(final double he) {
+                movingHe = tempHe + he;
+        }
+        /**
+  /**
+   * If two values for field cd differ by less than EPSILON both values are
+   * considered equal.
+   */
+  private static final float EPSILON = 1e-5f;
+  protected String id;
+  /**
+   * Position of the picture.
+   */
+  protected LatLon latLon;
+  //Image id of previous image in sequence (decimal)
+  private long pr;
+  /**
+   * Direction of the picture in degrees from true north.
+   */
+  protected double he;
+  /**
+   * When the object direction is being moved in the map, the temporal direction
+   * is stored here
+   */
+  protected double movingHe;
+  // Image id of next image in sequence (decimal)
+  private long ne;
+  /**
+   * Sequence of pictures containing this object.
+   */
+  private StreetsideSequence sequence;
+  /**
+   * Temporal position of the picture until it is uploaded.
+   */
+  private LatLon tempLatLon;
+  /**
+   * When the object is being dragged in the map, the temporal position is stored
+   * here.
+   */
+  private LatLon movingLatLon;
+  /**
+   * Temporal direction of the picture until it is uploaded
+   */
+  private double tempHe;
+  /**
+   * Whether the image must be drown in the map or not
+   */
+  private boolean visible;
+  /**
+   * Creates a new object in the given position and with the given direction.
+   * {@link LatLon}
+   *
+   * @param id   - the Streetside image id
+   * @param latLon The latitude and longitude of the image.
+   * @param he   The direction of the picture (0 means north im Mapillary
+   *         camera direction is not yet supported in the Streetside plugin).
+   */
+  protected StreetsideAbstractImage(final String id, final LatLon latLon, final double he) {
+    this.id = id;
+    this.latLon = latLon;
+    tempLatLon = this.latLon;
+    movingLatLon = this.latLon;
+    this.he = he;
+    tempHe = he;
+    movingHe = he;
+    visible = true;
+  }
+  /**
+   * Creates a new object with the given id.
+   *
+   * @param id - the image id (All images require ids in Streetside)
+   */
+  protected StreetsideAbstractImage(final String id) {
+    this.id = id;
+    visible = true;
+  }
+  /**
+   * @return the id
+   */
+  public String getId() {
+    return id;
+  }
+  /**
+   * @param id the id to set
+   */
+  public void setId(String id) {
+    this.id = id;
+  }
+  /**
+   * Returns the original direction towards the image has been taken.
+   *
+   * @return The direction of the image (0 means north and goes clockwise).
+   */
+  public double getHe() {
+    return he;
+  }
+  public void setHe(final double he) {
+    this.he = he;
+  }
+  /**
+   * Returns a LatLon object containing the original coordinates of the object.
+   *
+   * @return The LatLon object with the position of the object.
+   */
+  public LatLon getLatLon() {
+    return latLon;
+  }
+  public void setLatLon(final LatLon latLon) {
+    if (latLon != null) {
+      this.latLon = latLon;
+    }
+  }
+  /**
+   * Returns the direction towards the image has been taken.
+   *
+   * @return The direction of the image (0 means north and goes clockwise).
+   */
+  public double getMovingHe() {
+    return movingHe;
+  }
+  /**
+   * Returns a LatLon object containing the current coordinates of the object.
+   * When you are dragging the image this changes.
+   *
+   * @return The LatLon object with the position of the object.
+   */
+  public LatLon getMovingLatLon() {
+    return movingLatLon;
+  }
+  /**
+   * Returns the sequence which contains this image. Never null.
+   *
+   * @return The StreetsideSequence object that contains this StreetsideImage.
+   */
+  public StreetsideSequence getSequence() {
+    synchronized (this) {
+      if (sequence == null) {
+        sequence = new StreetsideSequence();
+        sequence.add(this);
+      }
+      return sequence;
+    }
+  }
+  /**
+   * Sets the StreetsideSequence object which contains the StreetsideImage.
+   *
+   * @param sequence
+   *      The StreetsideSequence that contains the StreetsideImage.
+   * @throws IllegalArgumentException
+   *       if the image is not already part of the
+   *       {@link StreetsideSequence}. Call
+   *       {@link StreetsideSequence#add(StreetsideAbstractImage)} first.
+   */
+  public void setSequence(final StreetsideSequence sequence) {
+    synchronized (this) {
+      if (sequence != null && !sequence.getImages().contains(this)) {
+        throw new IllegalArgumentException();
+      }
+      this.sequence = sequence;
+    }
+  }
+  /**
+   * Returns the last fixed direction of the object.
+   *
+   * @return The last fixed direction of the object. 0 means north.
+   */
+  public double getTempHe() {
+    return tempHe;
+  }
+  /**
+   * Returns the last fixed coordinates of the object.
+   *
+   * @return A LatLon object containing.
+   */
+  public LatLon getTempLatLon() {
+    return tempLatLon;
+  }
+  /**
+   * Returns whether the object has been modified or not.
+   *
+   * @return true if the object has been modified; false otherwise.
+   */
+  public boolean isModified() {
+    return !getMovingLatLon().equals(latLon) || Math.abs(getMovingHe() - he) > EPSILON;
+  }
+  /**
+   * Returns whether the image is visible on the map or not.
+   *
+   * @return True if the image is visible; false otherwise.
+   */
+  public boolean isVisible() {
+    return visible;
+  }
+  /**
+   * Set's whether the image should be visible on the map or not.
+   *
+   * @param visible
+   *      true if the image is set to be visible; false otherwise.
+   */
+  public void setVisible(final boolean visible) {
+    this.visible = visible;
+  }
+  /**
+   * Moves the image temporally to another position
+   *
+   * @param x The movement of the image in longitude units.
+   * @param y The movement of the image in latitude units.
+   */
+  public void move(final double x, final double y) {
+    movingLatLon = new LatLon(tempLatLon.getY() + y, tempLatLon.getX() + x);
+  }
+  /**
+   * If the StreetsideImage belongs to a StreetsideSequence, returns the next
+   * image in the sequence.
+   *
+   * @return The following StreetsideImage, or null if there is none.
+   */
+  public StreetsideAbstractImage next() {
+    synchronized (this) {
+      return getSequence().next(this);
+    }
+  }
+  /**
+   * If the StreetsideImage belongs to a StreetsideSequence, returns the previous
+   * image in the sequence.
+   *
+   * @return The previous StreetsideImage, or null if there is none.
+   */
+  public StreetsideAbstractImage previous() {
+    synchronized (this) {
+      return getSequence().previous(this);
+    }
+  }
+  /**
+   * Called when the mouse button is released, meaning that the picture has
+   * stopped being dragged, so the temporal values are saved.
+   */
+  public void stopMoving() {
+    tempLatLon = movingLatLon;
+    tempHe = movingHe;
+  }
+  /**
+   * Turns the image direction.
+   *
+   * @param he
+   *      The angle the image is moving.
+   */
+  public void turn(final double he) {
+    movingHe = tempHe + he;
+  }
+  /**
    * @return the ne
    */

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/StreetsideCubemap.java

-              r34399
+              r36194
 public class StreetsideCubemap extends StreetsideAbstractImage {
         /**
         * If two values for field cd differ by less than EPSILON both values are considered equal.
         */
         @SuppressWarnings("unused")
         private static final float EPSILON = 1e-5f;
+  /**
+   * If two values for field cd differ by less than EPSILON both values are considered equal.
+   */
+  @SuppressWarnings("unused")
+  private static final float EPSILON = 1e-5f;
+        /**
+         * Main constructor of the class StreetsideCubemap
+         *
+         * @param quadId
+         *            The Streetside id of the base frontal image of the cubemap
+         *            in quternary
+         * @param latLon
+         *            The latitude and longitude where it is positioned.
+         * @param he
+         *            The direction of the images in degrees, meaning 0 north (camera
+         *            direction is not yet supported in the Streetside plugin).
+         */
+   public StreetsideCubemap(String quadId, LatLon latLon, double he) {
+           super(quadId, latLon, he);
+         }
+  /**
+   * Main constructor of the class StreetsideCubemap
+   *
+   * @param quadId The Streetside id of the base frontal image of the cubemap
+   *         in quternary
+   * @param latLon The latitude and longitude where it is positioned.
+   * @param he   The direction of the images in degrees, meaning 0 north (camera
+   *         direction is not yet supported in the Streetside plugin).
+   */
+  public StreetsideCubemap(String quadId, LatLon latLon, double he) {
+    super(quadId, latLon, he);
+  }
         /**
          * Comparison method for the StreetsideCubemap object.
+         *
          * @param image
          *            - a StreetsideAbstract image object
+         *
          *            StreetsideCubemaps are considered equal if they are associated
          *            with the same image id - only one cubemap may be displayed at a
          *            time. If the image selection changes, the cubemap changes.
+         *
          * @return result of the hashcode comparison.
          * @see org.openstreetmap.josm.plugins.streetside.StreetsideAbstractImage
          */
         @Override
         public int compareTo(StreetsideAbstractImage image) {
                 if (image instanceof StreetsideImage) {
                         return id.compareTo(((StreetsideImage) image).getId());
+                }
                 return hashCode() - image.hashCode();
+        }
+  /**
+   * Comparison method for the StreetsideCubemap object.
+   *
+   * @param image
+   *      - a StreetsideAbstract image object
+   *
+   *      StreetsideCubemaps are considered equal if they are associated
+   *      with the same image id - only one cubemap may be displayed at a
+   *      time. If the image selection changes, the cubemap changes.
+   *
+   * @return result of the hashcode comparison.
+   * @see org.openstreetmap.josm.plugins.streetside.StreetsideAbstractImage
+   */
+  @Override
+  public int compareTo(StreetsideAbstractImage image) {
+    if (image instanceof StreetsideImage) {
+      return id.compareTo(image.getId());
+    }
+    return hashCode() - image.hashCode();
+  }
         /**
          * HashCode StreetsideCubemap object.
+         *
          * @return int hashCode
          * @see org.openstreetmap.josm.plugins.streetside.StreetsideAbstractImage
          */
     @Override
         public int hashCode() {
                 return id.hashCode();
+        }
+  /**
+   * HashCode StreetsideCubemap object.
+   *
+   * @return int hashCode
+   * @see org.openstreetmap.josm.plugins.streetside.StreetsideAbstractImage
+   */
+  @Override
+  public int hashCode() {
+    return id.hashCode();
+  }
         /**
          * stops ImageDisplay WalkAction (not currently supported by Streetside)
+         *
          * @see org.openstreetmap.josm.plugins.streetside.actions.StreetsideWalkAction
          */
         @Override
         public void stopMoving() {
                 super.stopMoving();
+        }
+  /**
+   * stops ImageDisplay WalkAction (not currently supported by Streetside)
+   *
+   * @see org.openstreetmap.josm.plugins.streetside.actions.StreetsideWalkAction
+   */
+  @Override
+  public void stopMoving() {
+    super.stopMoving();
+  }
         /**
          * turns ImageDisplay WalkAction (not currently supported by Streetside)
+         *
          * @param he - the direction the camera is facing (heading)
+         *
          * @see org.openstreetmap.josm.plugins.streetside.actions.StreetsideWalkAction
          */
         @Override
         public void turn(double he) {
                 super.turn(he);
+        }
+  /**
+   * turns ImageDisplay WalkAction (not currently supported by Streetside)
+   *
+   * @param he - the direction the camera is facing (heading)
+   *
+   * @see org.openstreetmap.josm.plugins.streetside.actions.StreetsideWalkAction
+   */
+  @Override
+  public void turn(double he) {
+    super.turn(he);
+  }
         /**
          * @return the height of an assembled cubemap face for 16-tiled or 4-tiled imagery
+         *
          * @see org.openstreetmap.josm.plugins.streetside.actions.StreetsideWalkAction
          */
         public int getHeight() {
                 return StreetsideProperties.SHOW_HIGH_RES_STREETSIDE_IMAGERY.get().booleanValue()?1016:510;
+        }
+  /**
+   * @return the height of an assembled cubemap face for 16-tiled or 4-tiled imagery
+   *
+   * @see org.openstreetmap.josm.plugins.streetside.actions.StreetsideWalkAction
+   */
+  public int getHeight() {
+    return Boolean.TRUE.equals(StreetsideProperties.SHOW_HIGH_RES_STREETSIDE_IMAGERY.get()) ? 1016 : 510;
+  }
+}

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/StreetsideData.java

-              r35601
+              r36194
   private final Set<StreetsideAbstractImage> images = ConcurrentHashMap.newKeySet();
   /**
+   * All the images selected, can be more than one.
+   */
+  private final Set<StreetsideAbstractImage> multiSelectedImages = ConcurrentHashMap.newKeySet();
+  /**
+   * Listeners of the class.
+   */
+  private final List<StreetsideDataListener> listeners = new CopyOnWriteArrayList<>();
+  /**
+   * The bounds of the areas for which the pictures have been downloaded.
+   */
+  private final List<Bounds> bounds;
+  /**
    * The image currently selected, this is the one being shown.
    */
 …
    */
   private StreetsideAbstractImage highlightedImage;
-  /**
-   * All the images selected, can be more than one.
-   */
-  private final Set<StreetsideAbstractImage> multiSelectedImages = ConcurrentHashMap.newKeySet();
-  /**
-   * Listeners of the class.
-   */
-  private final List<StreetsideDataListener> listeners = new CopyOnWriteArrayList<>();
-  /**
-   * The bounds of the areas for which the pictures have been downloaded.
-   */
-  private final List<Bounds> bounds;
   /**
 …
     bounds = new CopyOnWriteArrayList<>();
+  // Adds the basic set of listeners.
+  Arrays.stream(StreetsidePlugin.getStreetsideDataListeners()).forEach(this::addListener);
+      addListener(StreetsideViewerDialog.getInstance().getStreetsideViewerPanel());
+      addListener(StreetsideMainDialog.getInstance());
+      addListener(ImageInfoPanel.getInstance());
+    // Adds the basic set of listeners.
+    Arrays.stream(StreetsidePlugin.getStreetsideDataListeners()).forEach(this::addListener);
+    addListener(StreetsideViewerDialog.getInstance().getStreetsideViewerPanel());
+    addListener(StreetsideMainDialog.getInstance());
+    addListener(ImageInfoPanel.getInstance());
+  }
+  /**
+   * Downloads surrounding images of this mapillary image in background threads
+   *
+   * @param streetsideImage the image for which the surrounding images should be downloaded
+   */
+  private static void downloadSurroundingImages(StreetsideImage streetsideImage) {
+    MainApplication.worker.execute(() -> {
+      final int prefetchCount = StreetsideProperties.PRE_FETCH_IMAGE_COUNT.get();
+      CacheAccess<String, BufferedImageCacheEntry> imageCache = Caches.ImageCache.getInstance().getCache();
+      StreetsideAbstractImage nextImage = streetsideImage.next();
+      StreetsideAbstractImage prevImage = streetsideImage.previous();
+      for (int i = 0; i < prefetchCount; i++) {
+        if (nextImage != null) {
+          if (nextImage instanceof StreetsideImage && imageCache.get(nextImage.getId()) == null) {
+            CacheUtils.downloadPicture((StreetsideImage) nextImage);
+          }
+          nextImage = nextImage.next();
+        }
+        if (prevImage != null) {
+          if (prevImage instanceof StreetsideImage && imageCache.get(prevImage.getId()) == null) {
+            CacheUtils.downloadPicture((StreetsideImage) prevImage);
+          }
+          prevImage = prevImage.previous();
+        }
+      }
+    });
+  }
+  /**
+   * Downloads surrounding images of this mapillary image in background threads
+   *
+   * @param streetsideImage the image for which the surrounding images should be downloaded
+   */
+  public static void downloadSurroundingCubemaps(StreetsideImage streetsideImage) {
+    MainApplication.worker.execute(() -> {
+      final int prefetchCount = StreetsideProperties.PRE_FETCH_IMAGE_COUNT.get();
+      CacheAccess<String, BufferedImageCacheEntry> imageCache = Caches.ImageCache.getInstance().getCache();
+      StreetsideAbstractImage nextImage = streetsideImage.next();
+      StreetsideAbstractImage prevImage = streetsideImage.previous();
+      for (int i = 0; i < prefetchCount; i++) {
+        if (nextImage != null) {
+          if (nextImage instanceof StreetsideImage && imageCache.get(nextImage.getId()) == null) {
+            CacheUtils.downloadCubemap((StreetsideImage) nextImage);
+          }
+          nextImage = nextImage.next();
+        }
+        if (prevImage != null) {
+          if (prevImage instanceof StreetsideImage && imageCache.get(prevImage.getId()) == null) {
+            CacheUtils.downloadCubemap((StreetsideImage) prevImage);
+          }
+          prevImage = prevImage.previous();
+        }
+      }
+    });
+  }
 …
    * @param image  The image to be added.
    * @param update Whether the map must be updated or not
    *        (updates are currently unsupported by Streetside).
+   *         (updates are currently unsupported by Streetside).
    */
   public void add(StreetsideAbstractImage image, boolean update) {
         images.add(image);
         if (update) {
                 StreetsideLayer.invalidateInstance();
+        }
         fireImagesAdded();
+    images.add(image);
+    if (update) {
+      StreetsideLayer.invalidateInstance();
+    }
+    fireImagesAdded();
+  }
 …
+   *
    * @param newImages The set of images to be added.
    * @param update Whether the map must be updated or not.
+   * @param update  Whether the map must be updated or not.
    */
   public void addAll(Collection<? extends StreetsideAbstractImage> newImages, boolean update) {
 …
+  }
  /**
+  /**
    * Adds a new listener.
+   *
 …
   /**
+   * Returns the image under the mouse cursor.
+   *
+   * @return The image under the mouse cursor.
+   */
+  public StreetsideAbstractImage getHighlightedImage() {
+    return highlightedImage;
+  }
+  /**
    * Highlights the image under the cursor.
+   *
 …
   /**
-   * Returns the image under the mouse cursor.
+   *
-   * @return The image under the mouse cursor.
-   */
-  public StreetsideAbstractImage getHighlightedImage() {
-    return highlightedImage;
+  }
-  /**
    * Returns a Set containing all images.
+   *
 …
   /**
+   * Sets a new {@link Collection} object as the used set of images.
+   * Any images that are already present, are removed.
+   *
+   * @param newImages the new image list (previously set images are completely replaced)
+   */
+  public void setImages(Collection<StreetsideAbstractImage> newImages) {
+    synchronized (this) {
+      images.clear();
+      images.addAll(newImages);
+    }
+  }
+  /**
    * Returns a Set of all sequences, that the images are part of.
+   *
    * @return all sequences that are contained in the Streetside data
    */
 …
   public StreetsideAbstractImage getSelectedImage() {
     return selectedImage;
+  }
+  /**
+   * Selects a new image.If the user does ctrl + click, this isn't triggered.
+   *
+   * @param image The StreetsideImage which is going to be selected
+   */
+  public void setSelectedImage(StreetsideAbstractImage image) {
+    setSelectedImage(image, false);
+  }
 …
+   *
    * @throws IllegalStateException if the selected image is null or the selected image doesn't
    *                               belong to a sequence.
+   *                 belong to a sequence.
    */
   public void selectNext() {
 …
    * @param moveToPicture True if the view must me moved to the next picture.
    * @throws IllegalStateException if the selected image is null or the selected image doesn't
    *                               belong to a sequence.
+   *                 belong to a sequence.
    */
   public void selectNext(boolean moveToPicture) {
 …
+   *
    * @throws IllegalStateException if the selected image is null or the selected image doesn't
    *                               belong to a sequence.
+   *                 belong to a sequence.
    */
   public void selectPrevious() {
 …
    * @param moveToPicture True if the view must me moved to the previous picture.
    * @throws IllegalStateException if the selected image is null or the selected image doesn't
    *                               belong to a sequence.
+   *                 belong to a sequence.
    */
   public void selectPrevious(boolean moveToPicture) {
 …
+      }
+    }
+  }
-  /**
-   * Selects a new image.If the user does ctrl + click, this isn't triggered.
+   *
-   * @param image The StreetsideImage which is going to be selected
-   */
-  public void setSelectedImage(StreetsideAbstractImage image) {
-    setSelectedImage(image, false);
+  }
 …
+  }
-  /**
-   * Downloads surrounding images of this mapillary image in background threads
-   * @param streetsideImage the image for which the surrounding images should be downloaded
-   */
-  private static void downloadSurroundingImages (StreetsideImage streetsideImage) {
-    MainApplication.worker.execute(() -> {
-      final int prefetchCount = StreetsideProperties.PRE_FETCH_IMAGE_COUNT.get();
-      CacheAccess <String, BufferedImageCacheEntry> imageCache = Caches.ImageCache.getInstance().getCache();
-      StreetsideAbstractImage nextImage = streetsideImage.next();
-      StreetsideAbstractImage prevImage = streetsideImage.previous();
-      for (int i = 0; i < prefetchCount; i++) {
-        if (nextImage != null) {
-          if (nextImage instanceof StreetsideImage &&
-            imageCache.get(((StreetsideImage) nextImage).getId()) == null) {
-            CacheUtils.downloadPicture((StreetsideImage) nextImage);
+          }
-          nextImage = nextImage.next();
+        }
-        if (prevImage != null) {
-          if (prevImage instanceof StreetsideImage &&
-            imageCache.get(((StreetsideImage) prevImage).getId()) == null) {
-            CacheUtils.downloadPicture((StreetsideImage) prevImage);
+          }
-          prevImage = prevImage.previous();
+        }
+      }
-    });
+  }
-  /**
-   * Downloads surrounding images of this mapillary image in background threads
-   * @param streetsideImage the image for which the surrounding images should be downloaded
-   */
-  public static void downloadSurroundingCubemaps(StreetsideImage streetsideImage) {
-      MainApplication.worker.execute(() -> {
-        final int prefetchCount = StreetsideProperties.PRE_FETCH_IMAGE_COUNT.get();
-        CacheAccess<String, BufferedImageCacheEntry> imageCache = Caches.ImageCache.getInstance().getCache();
-        StreetsideAbstractImage nextImage = streetsideImage.next();
-        StreetsideAbstractImage prevImage = streetsideImage.previous();
-        for (int i = 0; i < prefetchCount; i++) {
-          if (nextImage != null) {
-            if (nextImage instanceof StreetsideImage && imageCache.get(((StreetsideImage) nextImage).getId()) == null) {
-              CacheUtils.downloadCubemap((StreetsideImage) nextImage);
+            }
-            nextImage = nextImage.next();
+          }
-          if (prevImage != null) {
-            if (prevImage instanceof StreetsideImage && imageCache.get(((StreetsideImage) prevImage).getId()) == null) {
-              CacheUtils.downloadCubemap((StreetsideImage) prevImage);
+            }
-            prevImage = prevImage.previous();
+          }
+        }
-      });
+  }
   private void fireSelectedImageChanged(StreetsideAbstractImage oldImage, StreetsideAbstractImage newImage) {
         listeners.stream().filter(Objects::nonNull).forEach(lis -> lis.selectedImageChanged(oldImage, newImage));
+    listeners.stream().filter(Objects::nonNull).forEach(lis -> lis.selectedImageChanged(oldImage, newImage));
+  }
 …
+  }
-  /**
-   * Sets a new {@link Collection} object as the used set of images.
-   * Any images that are already present, are removed.
+   *
-   * @param newImages the new image list (previously set images are completely replaced)
-   */
-  public void setImages(Collection<StreetsideAbstractImage> newImages) {
-    synchronized (this) {
-      images.clear();
-      images.addAll(newImages);
+    }
+  }
   @Override
   public Collection<DataSource> getDataSources() {
         return Collections.emptyList();
+    return Collections.emptyList();
+  }
+}

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/StreetsideDataListener.java

-              r34317
+              r36194
    * manually clicking on the icon.
+   *
+   * @param oldImage
+   *          Old selected {@link StreetsideAbstractImage}
+   * @param newImage
+   *          New selected {@link StreetsideAbstractImage}
+   * @param oldImage Old selected {@link StreetsideAbstractImage}
+   * @param newImage New selected {@link StreetsideAbstractImage}
    */
+  void selectedImageChanged(StreetsideAbstractImage oldImage,
+      StreetsideAbstractImage newImage);
+  void selectedImageChanged(StreetsideAbstractImage oldImage, StreetsideAbstractImage newImage);
+}

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/StreetsideImage.java

-              r34429
+              r36194
  */
 public class StreetsideImage extends StreetsideAbstractImage {
-  /**
-   * Rn is a Bing Streetside image attribute - currently not
-   * used, mapped or supported in the Streetside plugin -
-   * left out initially because it's an unrequired complex object.
-   */
-  public static class Rn {
-          // placeholder for Rn attribute (undocumented streetside complex inner type)
+  }
   // latitude of the Streetside image
   private double la;
   //longitude of the Streetside image
   private double lo;
   // The bubble altitude, in meters above the WGS84 ellipsoid
   private double al;
   // Roll
   private double ro;
   // Pitch
   private double pi;
   // Blurring instructions - not currently used by the plugin
   private String bl;
   // Undocumented Attributes
   private int ml;
 …
    * Main constructor of the class StreetsideImage
+   *
    * @param id     The unique identifier of the image.
+   * @param id   The unique identifier of the image.
    * @param latLon The latitude and longitude where it is positioned.
    * @param he     The direction of the images in degrees, meaning 0 north.
+   * @param he   The direction of the images in degrees, meaning 0 north.
    */
   public StreetsideImage(String id, LatLon latLon, double he) {
 …
   public StreetsideImage(String id, double la, double lo) {
     super(id, new LatLon(la,lo), 0.0);
+    super(id, new LatLon(la, lo), 0.0);
+  }
   public StreetsideImage(String id) {
             super(id);
+    super(id);
+  }
 …
    */
   @Override
 public String getId() {
+  public String getId() {
     return String.valueOf(id);
+  }
+  /**
+   * @param id the id to set
+   */
+  @Override
+  public void setId(String id) {
+    this.id = id;
+  }
   public UserProfile getUser() {
             return getSequence().getUser();
+    return getSequence().getUser();
+  }
   @Override
   public String toString() {
+    return String.format(
+      "Image[id=%s,lat=%f,lon=%f,he=%f,user=%s]",
+      id, latLon.lat(), latLon.lon(), he, "null"//, cd
+    return String.format("Image[id=%s,lat=%f,lon=%f,he=%f,user=%s]", id, latLon.lat(), latLon.lon(), he, "null"//, cd
     );
+  }
 …
   public int compareTo(StreetsideAbstractImage image) {
     if (image instanceof StreetsideImage) {
       return id.compareTo(((StreetsideImage) image).getId());
+      return id.compareTo(image.getId());
+    }
     return hashCode() - image.hashCode();
 …
   /**
-   * @param id the id to set
-   */
-  @Override
-public void setId(String id) {
-    this.id = id;
+  }
-  /**
    * @return the rn
    */
 …
     this.rn = rn;
+  }
+  /**
+   * Rn is a Bing Streetside image attribute - currently not
+   * used, mapped or supported in the Streetside plugin -
+   * left out initially because it's an unrequired complex object.
+   */
+  public static class Rn {
+    // placeholder for Rn attribute (undocumented streetside complex inner type)
+  }
+}

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/StreetsideLayer.java

-              r35978
+              r36194
 import java.util.IntSummaryStatistics;
 import java.util.Optional;
+import java.util.logging.Logger;
 import javax.swing.Action;
 import javax.swing.Icon;
-import org.apache.log4j.Logger;
 import org.openstreetmap.josm.data.Bounds;
 import org.openstreetmap.josm.data.coor.ILatLon;
 …
 import org.openstreetmap.josm.tools.I18n;
 import org.openstreetmap.josm.tools.ImageProvider.ImageSizes;
+import org.openstreetmap.josm.tools.Logging;
 /**
 …
  * @author nokutu
  */
+public final class StreetsideLayer extends AbstractModifiableLayer implements
+ActiveLayerChangeListener, StreetsideDataListener {
+  final static Logger logger = Logger.getLogger(StreetsideLayer.class);
+  /** The radius of the image marker */
+public final class StreetsideLayer extends AbstractModifiableLayer
+    implements ActiveLayerChangeListener, StreetsideDataListener {
+  private static final Logger LOGGER = Logger.getLogger(StreetsideLayer.class.getCanonicalName());
+  /**
+   * The radius of the image marker
+   */
   private static final int IMG_MARKER_RADIUS = 7;
+  /** The radius of the circular sector that indicates the camera angle */
+  /**
+   * The radius of the circular sector that indicates the camera angle
+   */
   private static final int CA_INDICATOR_RADIUS = 15;
+  /** The angle of the circular sector that indicates the camera angle */
+  /**
+   * The angle of the circular sector that indicates the camera angle
+   */
   private static final int CA_INDICATOR_ANGLE = 40;
+        private static final DataSetListenerAdapter DATASET_LISTENER =
+                        new DataSetListenerAdapter(e -> {
+                                if (e instanceof DataChangedEvent && StreetsideDownloader.getMode() == DOWNLOAD_MODE.OSM_AREA) {
+                                        // When more data is downloaded, a delayed update is thrown, in order to
+                                        // wait for the data bounds to be set.
+                                        MainApplication.worker.execute(StreetsideDownloader::downloadOSMArea);
+                                }
+                        });
+        /** Unique instance of the class. */
+        private static StreetsideLayer instance;
+        /** The nearest images to the selected image from different sequences sorted by distance from selection. */
+        private StreetsideImage[] nearestImages = {};
+        /** {@link StreetsideData} object that stores the database. */
+        private final StreetsideData data;
+        /** Mode of the layer. */
+        public AbstractMode mode;
+        private volatile TexturePaint hatched;
+        private StreetsideLayer() {
+                super(I18n.tr("Microsoft Streetside Images"));
+                data = new StreetsideData();
+                data.addListener(this);
+        }
+  /**
+   * Unique instance of the class.
+   */
+  private static StreetsideLayer instance;
+  private static final DataSetListenerAdapter DATASET_LISTENER = new DataSetListenerAdapter(e -> {
+    if (e instanceof DataChangedEvent && StreetsideDownloader.getMode() == DOWNLOAD_MODE.OSM_AREA) {
+      // When more data is downloaded, a delayed update is thrown, in order to
+      // wait for the data bounds to be set.
+      MainApplication.worker.execute(StreetsideDownloader::downloadOSMArea);
+    }
+  });
+  /**
+   * {@link StreetsideData} object that stores the database.
+   */
+  private final StreetsideData data;
+  /**
+   * Mode of the layer.
+   */
+  public AbstractMode mode;
+  /**
+   * The nearest images to the selected image from different sequences sorted by distance from selection.
+   */
+  private StreetsideImage[] nearestImages = {};
+  private volatile TexturePaint hatched;
+  private StreetsideLayer() {
+    super(I18n.tr("Microsoft Streetside Images"));
+    data = new StreetsideData();
+    data.addListener(this);
+  }
+  public static void invalidateInstance() {
+    if (hasInstance()) {
+      getInstance().invalidate();
+    }
+  }
+  private static synchronized void clearInstance() {
+    instance = null;
+  }
+  /**
+   * Returns the unique instance of this class.
+   *
+   * @return The unique instance of this class.
+   */
+  public static synchronized StreetsideLayer getInstance() {
+    if (instance != null) {
+      return instance;
+    }
+    final StreetsideLayer layer = new StreetsideLayer();
+    layer.init();
+    instance = layer; // Only set instance field after initialization is complete
+    return instance;
+  }
+  /**
+   * @return if the unique instance of this layer is currently instantiated
+   */
+  public static boolean hasInstance() {
+    return instance != null;
+  }
   /**
 …
     if (StreetsidePlugin.getMapView() != null) {
       StreetsideMainDialog.getInstance().streetsideImageDisplay.repaint();
+                }
+                createHatchTexture();
+                invalidate();
+        }
+  public static void invalidateInstance() {
+    if (hasInstance()) {
+      getInstance().invalidate();
+    }
+    }
+    createHatchTexture();
+    invalidate();
+  }
 …
+  }
+  private static synchronized void clearInstance() {
+    instance = null;
+  }
+  /**
+   * Returns the unique instance of this class.
+  /**
+   * Returns the {@link StreetsideData} object, which acts as the database of the
+   * Layer.
+   *
+   * @return The unique instance of this class.
+   */
+  public static synchronized StreetsideLayer getInstance() {
+    if (instance != null) {
+      return instance;
+    }
+    final StreetsideLayer layer = new StreetsideLayer();
+    layer.init();
+    instance = layer; // Only set instance field after initialization is complete
+    return instance;
+  }
+  /**
+   * @return if the unique instance of this layer is currently instantiated
+   */
+  public static boolean hasInstance() {
+    return instance != null;
+  }
+        /**
+         * Returns the {@link StreetsideData} object, which acts as the database of the
+         * Layer.
+         *
+         * @return The {@link StreetsideData} object that stores the database.
+         */
+        @Override
+        public StreetsideData getData() {
+                return data;
+        }
+   * @return The {@link StreetsideData} object that stores the database.
+   */
+  @Override
+  public StreetsideData getData() {
+    return data;
+  }
   /**
 …
    * The "n-nearest image" is picked from the list of one image from every sequence that is nearest to the currently
    * selected image, excluding the sequence to which the selected image belongs.
+   *
    * @param n the index for picking from the list of "nearest images", beginning from 1
    * @return the n-nearest image to the currently selected image
 …
+      }
     } catch (IllegalArgumentException e) {
+      Logging.trace(e);
       // TODO: It would be ideal, to fix this properly. But for the moment let's catch this, for when a listener has already been removed.
+    }
 …
+  }
+        @Override
+  @Override
   public boolean isModified() {
     return data.getImages().parallelStream().anyMatch(StreetsideAbstractImage::isModified);
 …
     for (StreetsideSequence seq : getData().getSequences()) {
       if (seq.getImages().contains(selectedImage)) {
         g.setColor(
           seq.getId() == null ? StreetsideColorScheme.SEQ_IMPORTED_SELECTED : StreetsideColorScheme.SEQ_SELECTED
         );
+    g.setColor(
+      seq.getId() == null ? StreetsideColorScheme.SEQ_IMPORTED_SELECTED : StreetsideColorScheme.SEQ_SELECTED
+    );
       } else {
         g.setColor(
           seq.getId() == null ? StreetsideColorScheme.SEQ_IMPORTED_UNSELECTED : StreetsideColorScheme.SEQ_UNSELECTED
         );
+    g.setColor(
+      seq.getId() == null ? StreetsideColorScheme.SEQ_IMPORTED_UNSELECTED : StreetsideColorScheme.SEQ_UNSELECTED
+    );
+      }
       g.draw(MapViewGeometryUtil.getSequencePath(mv, seq));
 …
   /**
    * Draws an image marker onto the given Graphics context.
+   * @param g the Graphics context
+   *
+   * @param g   the Graphics context
    * @param img the image to be drawn onto the Graphics context
    */
   private void drawImageMarker(final Graphics2D g, final StreetsideAbstractImage img) {
     if (img == null || img.getLatLon() == null) {
       logger.warn("An image is not painted, because it is null or has no LatLon!");
+      LOGGER.warning("An image is not painted, because it is null or has no LatLon!");
       return;
+    }
 …
       markerC = StreetsideColorScheme.SEQ_HIGHLIGHTED;
       directionC = StreetsideColorScheme.SEQ_HIGHLIGHTED_CA;
+    } else if (selectedImg != null && selectedImg.getSequence() != null && selectedImg.getSequence().equals(img.getSequence())) {
+    } else if (selectedImg != null && selectedImg.getSequence() != null
+        && selectedImg.getSequence().equals(img.getSequence())) {
       markerC = StreetsideColorScheme.SEQ_SELECTED;
       directionC = StreetsideColorScheme.SEQ_SELECTED_CA;
 …
     float alpha = 0.75f;
     int type = AlphaComposite.SRC_OVER;
+    AlphaComposite composite =
+      AlphaComposite.getInstance(type, alpha);
+    AlphaComposite composite = AlphaComposite.getInstance(type, alpha);
     g.setComposite(composite);
     g.setColor(directionC);
+    g.fillArc(p.x - CA_INDICATOR_RADIUS, p.y - CA_INDICATOR_RADIUS, 2 * CA_INDICATOR_RADIUS, 2 * CA_INDICATOR_RADIUS, (int) (90 - /*img.getMovingHe()*/img.getHe() - CA_INDICATOR_ANGLE / 2d), CA_INDICATOR_ANGLE);
+    g.fillArc(p.x - CA_INDICATOR_RADIUS, p.y - CA_INDICATOR_RADIUS, 2 * CA_INDICATOR_RADIUS,
+* CA_INDICATOR_RADIUS, (int) (90 - /*img.getMovingHe()*/img.getHe() - CA_INDICATOR_ANGLE / 2d),
+        CA_INDICATOR_ANGLE);
     // Paint image marker
     g.setColor(markerC);
 …
       g.drawOval(p.x - IMG_MARKER_RADIUS, p.y - IMG_MARKER_RADIUS, 2 * IMG_MARKER_RADIUS, 2 * IMG_MARKER_RADIUS);
+    }
+        }
+  }
   @Override
 …
   @Override
   public void mergeFrom(Layer from) {
+    throw new UnsupportedOperationException(
+      "This layer does not support merging yet");
+    throw new UnsupportedOperationException("This layer does not support merging yet");
+  }
   @Override
   public Action[] getMenuEntries() {
+    return new Action[]{
+      LayerListDialog.getInstance().createShowHideLayerAction(),
+      LayerListDialog.getInstance().createDeleteLayerAction(),
+      new LayerListPopup.InfoAction(this)
+    };
+    return new Action[] { LayerListDialog.getInstance().createShowHideLayerAction(),
+        LayerListDialog.getInstance().createDeleteLayerAction(), new LayerListPopup.InfoAction(this) };
+  }
   @Override
   public Object getInfoComponent() {
+    IntSummaryStatistics seqSizeStats = getData().getSequences().stream().mapToInt(seq -> seq.getImages().size()).summaryStatistics();
+    return new StringBuilder(I18n.tr("Streetside layer"))
+      .append('\n')
+      .append(I18n.tr(
+        "{0} sequences, each containing between {1} and {2} images (ø {3})",
+        getData().getSequences().size(),
+        seqSizeStats.getCount() <= 0 ? 0 : seqSizeStats.getMin(),
+        seqSizeStats.getCount() <= 0 ? 0 : seqSizeStats.getMax(),
+        seqSizeStats.getAverage()
+      ))
+      .append("\n\n")
+      .append("\n+ ")
+      .append(I18n.tr(
+        "{0} downloaded images",
+        getData().getImages().stream().filter(i -> i instanceof StreetsideImage).count()
+      ))
+      .append("\n= ")
+      .append(I18n.tr(
+        "{0} images in total",
+        getData().getImages().size()
+      )).toString();
+    IntSummaryStatistics seqSizeStats = getData().getSequences().stream().mapToInt(seq -> seq.getImages().size())
+        .summaryStatistics();
+    return I18n.tr("Streetside layer") + '\n'
+        + I18n.tr("{0} sequences, each containing between {1} and {2} images (ø {3})",
+            getData().getSequences().size(), seqSizeStats.getCount() <= 0 ? 0 : seqSizeStats.getMin(),
+            seqSizeStats.getCount() <= 0 ? 0 : seqSizeStats.getMax(), seqSizeStats.getAverage())
+        + "\n\n" + "\n+ "
+        + I18n.tr("{0} downloaded images",
+            getData().getImages().stream().filter(i -> i instanceof StreetsideImage).count())
+        + "\n= " + I18n.tr("{0} images in total", getData().getImages().size());
+  }
 …
+   *
    * @param target the image for which you want to find the nearest other images
    * @param limit the maximum length of the returned array
+   * @param limit  the maximum length of the returned array
    * @return An array containing the closest images belonging to different sequences sorted by distance from target.
    */
   private StreetsideImage[] getNearestImagesFromDifferentSequences(StreetsideAbstractImage target, int limit) {
     return data.getSequences().parallelStream()
+      .filter(seq -> seq.getId() != null && !seq.getId().equals(target.getSequence().getId()))
+      .map(seq -> { // Maps sequence to image from sequence that is nearest to target
+        Optional<StreetsideAbstractImage> resImg = seq.getImages().parallelStream()
+          .filter(img -> img instanceof StreetsideImage && img.isVisible())
+          .min(new NearestImgToTargetComparator(target));
+        return resImg.orElse(null);
+      })
+      .filter(img -> // Filters out images too far away from target
+        img != null &&
+        img.getMovingLatLon().greatCircleDistance((ILatLon) target.getMovingLatLon())
+          < StreetsideProperties.SEQUENCE_MAX_JUMP_DISTANCE.get()
+       )
+      .sorted(new NearestImgToTargetComparator(target))
+      .limit(limit)
+      .toArray(StreetsideImage[]::new);
+        .filter(seq -> seq.getId() != null && !seq.getId().equals(target.getSequence().getId())).map(seq -> { // Maps sequence to image from sequence that is nearest to target
+          Optional<StreetsideAbstractImage> resImg = seq.getImages().parallelStream()
+              .filter(img -> img instanceof StreetsideImage && img.isVisible())
+              .min(new NearestImgToTargetComparator(target));
+          return resImg.orElse(null);
+        }).filter(img -> // Filters out images too far away from target
+        img != null && img.getMovingLatLon().greatCircleDistance(
+            (ILatLon) target.getMovingLatLon()) < StreetsideProperties.SEQUENCE_MAX_JUMP_DISTANCE.get())
+        .sorted(new NearestImgToTargetComparator(target)).limit(limit).toArray(StreetsideImage[]::new);
+  }
 …
       this.target = target;
+    }
     /* (non-Javadoc)
      * @see java.util.Comparator#compare(java.lang.Object, java.lang.Object)
 …
     @Override
     public int compare(StreetsideAbstractImage img1, StreetsideAbstractImage img2) {
+      return (int) Math.signum(
+        img1.getMovingLatLon().greatCircleDistance((ILatLon) target.getMovingLatLon()) -
+        img2.getMovingLatLon().greatCircleDistance((ILatLon) target.getMovingLatLon())
+      );
+    }
+  }
+      return (int) Math.signum(img1.getMovingLatLon().greatCircleDistance((ILatLon) target.getMovingLatLon())
+          - img2.getMovingLatLon().greatCircleDistance((ILatLon) target.getMovingLatLon()));
+    }
+  }
+}

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/StreetsidePlugin.java

-              r36065
+              r36194
   public static final ImageProvider LOGO = new ImageProvider("streetside-logo");
+  /** Zoom action */
+  /**
+   * Zoom action
+   */
   private static final StreetsideZoomAction ZOOM_ACTION = new StreetsideZoomAction();
+  /** Walk action */
+  /**
+   * Walk action
+   */
   private static final StreetsideWalkAction WALK_ACTION = new StreetsideWalkAction();
 …
    * Main constructor.
+   *
+   * @param info
+   *          Required information of the plugin. Obtained from the jar file.
+   * @param info Required information of the plugin. Obtained from the jar file.
    */
   public StreetsidePlugin(PluginInformation info) {
 …
   static StreetsideDataListener[] getStreetsideDataListeners() {
         return new StreetsideDataListener[]{WALK_ACTION, ZOOM_ACTION, CubemapBuilder.getInstance()};
+    return new StreetsideDataListener[] { WALK_ACTION, ZOOM_ACTION, CubemapBuilder.getInstance() };
+  }
   /**
 …
   public static StreetsideWalkAction getStreetsideWalkAction() {
     return WALK_ACTION;
+  }
+  /**
+   * @return the current {@link MapView} without throwing a {@link NullPointerException}
+   */
+  public static MapView getMapView() {
+    final MapFrame mf = MainApplication.getMap();
+    if (mf != null) {
+      return mf.mapView;
+    }
+    return null;
+  }
 …
       MainApplication.getMap().addToggleDialog(StreetsideMainDialog.getInstance(), false);
       StreetsideMainDialog.getInstance().setImageInfoHelp(new ImageInfoHelpPopup(
+          MainApplication.getMap().addToggleDialog(ImageInfoPanel.getInstance(), false)
+      ));
+          MainApplication.getMap().addToggleDialog(ImageInfoPanel.getInstance(), false)));
       MainApplication.getMap().addToggleDialog(StreetsideViewerDialog.getInstance(), false);
+    }
 …
     return new StreetsidePreferenceSetting();
+  }
-  /**
-   * @return the current {@link MapView} without throwing a {@link NullPointerException}
-   */
-  public static MapView getMapView() {
-    final MapFrame mf = MainApplication.getMap();
-    if (mf != null) {
-      return mf.mapView;
+    }
-    return null;
+  }
+}

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/StreetsideSequence.java

-              r34399
+              r36194
 public class StreetsideSequence {
+  /**
+   * The images in the sequence.
+   */
+  private final List<StreetsideAbstractImage> images;
   /**
    * Unique identifier. Used only for {@link StreetsideImage} sequences.
 …
   private String id;
   private UserProfile user;
   private double la;
   private double lo;
   /**
    * Epoch time when the sequence was created
 …
   private long cd;
-  /**
-   * The images in the sequence.
-   */
-  private List<StreetsideAbstractImage> images;
   public StreetsideSequence(String id, Long ca) {
         this.id = id;
+    this.id = id;
     cd = ca;
     images = new CopyOnWriteArrayList<>();
 …
    */
   public StreetsideSequence() {
           images = new CopyOnWriteArrayList<>();
+    images = new CopyOnWriteArrayList<>();
+  }
   public StreetsideSequence(String id, double la, double lo, long ca) {
         this.id = id;
         this.la = la;
         this.lo = lo;
         cd = ca;
         images = new CopyOnWriteArrayList<>();
+}
 public StreetsideSequence(String id) {
         this.id = id;
         images = new CopyOnWriteArrayList<>();
+}
+    this.id = id;
+    this.la = la;
+    this.lo = lo;
+    cd = ca;
+    images = new CopyOnWriteArrayList<>();
+  }
+  public StreetsideSequence(String id) {
+    this.id = id;
+    images = new CopyOnWriteArrayList<>();
+  }
   /**
 …
+   *
    * @param image The {@link StreetsideAbstractImage} object whose next image is
+   * going to be returned.
+   *
+   *        going to be returned.
    * @return The next {@link StreetsideAbstractImage} object in the sequence.
+   *
    * @throws IllegalArgumentException if the given {@link StreetsideAbstractImage} object doesn't belong
    * the this sequence.
+   *                  in this sequence.
    */
   public StreetsideAbstractImage next(StreetsideAbstractImage image) {
 …
+   *
    * @param image The {@link StreetsideAbstractImage} object whose previous image is
+   * going to be returned.
+   *
+   *        going to be returned.
    * @return The previous {@link StreetsideAbstractImage} object in the sequence.
+   *
    * @throws IllegalArgumentException if the given {@link StreetsideAbstractImage} object doesn't belong
    * the this sequence.
+   *                  the this sequence.
    */
   public StreetsideAbstractImage previous(StreetsideAbstractImage image) {
 …
   /**
-   * @param id the id to set
-   */
-  public void setId(String id) {
-    this.id = id;
+  }
-  /**
    * @return the la
    */
 …
+  }
+  /**
+   * @param id the id to set
+   */
+  public void setId(String id) {
+    this.id = id;
+  }
   public UserProfile getUser() {
         return user;
+    return user;
+  }
+}

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/actions/ImageReloadAction.java

-              r34400
+              r36194
 public class ImageReloadAction extends AbstractAction {
         private static final long serialVersionUID = 7987479726049238315L;
+  private static final long serialVersionUID = 7987479726049238315L;
         public ImageReloadAction(final String name) {
                  super(name, ImageProvider.get("reload", ImageSizes.SMALLICON));
+        }
+  public ImageReloadAction(final String name) {
+    super(name, ImageProvider.get("reload", ImageSizes.SMALLICON));
+  }
         @Override
         public void actionPerformed(ActionEvent arg0) {
                 if(StreetsideMainDialog.getInstance().getImage()!=null){
                         CubemapBuilder.getInstance().reload(CubemapBuilder.getInstance().getCubemap().getId());
+                }
+        }
+  @Override
+  public void actionPerformed(ActionEvent arg0) {
+    if (StreetsideMainDialog.getInstance().getImage() != null) {
+      CubemapBuilder.getInstance().reload(CubemapBuilder.getInstance().getCubemap().getId());
+    }
+  }
+}

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/actions/StreetsideDownloadAction.java

-              r34399
+              r36194
 import java.awt.event.ActionEvent;
 import java.awt.event.KeyEvent;
+import java.util.logging.Level;
+import java.util.logging.Logger;
-import org.apache.log4j.Logger;
 import org.openstreetmap.josm.actions.JosmAction;
 import org.openstreetmap.josm.gui.MainApplication;
 …
 public class StreetsideDownloadAction extends JosmAction {
+  public static final Shortcut SHORTCUT = Shortcut.registerShortcut("Streetside", "Open Streetside layer",
+      KeyEvent.VK_COMMA, Shortcut.SHIFT);
   private static final long serialVersionUID = 4426446157849005029L;
+  public static final Shortcut SHORTCUT = Shortcut.registerShortcut("Streetside", "Open Streetside layer", KeyEvent.VK_COMMA, Shortcut.SHIFT);
+  final static Logger logger = Logger.getLogger(StreetsideDownloadAction.class);
+  private static final Logger LOGGER = Logger.getLogger(StreetsideDownloadAction.class.getCanonicalName());
   /**
 …
    */
   public StreetsideDownloadAction() {
+    super(
+        tr("Streetside"),
+        new ImageProvider(StreetsidePlugin.LOGO).setSize(ImageSizes.DEFAULT),
+        tr("Open Streetside layer"),
+        SHORTCUT,
+        false,
+        "streetsideDownload",
+        false
+    );
+    super(tr("Streetside"), new ImageProvider(StreetsidePlugin.LOGO).setSize(ImageSizes.DEFAULT),
+        tr("Open Streetside layer"), SHORTCUT, false, "streetsideDownload", false);
+  }
   @Override
   public void actionPerformed(ActionEvent ae) {
+    if (!StreetsideLayer.hasInstance() || !MainApplication.getLayerManager().containsLayer(StreetsideLayer.getInstance())) {
+    if (!StreetsideLayer.hasInstance()
+        || !MainApplication.getLayerManager().containsLayer(StreetsideLayer.getInstance())) {
       MainApplication.getLayerManager().addLayer(StreetsideLayer.getInstance());
       return;
 …
     } catch (IllegalArgumentException e) {
       // If the StreetsideLayer is not managed by LayerManager but you try to set it as active layer
       logger.warn(e);
+      LOGGER.log(Level.WARNING, e.getMessage(), e);
+    }
+  }

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/actions/StreetsideDownloadViewAction.java

-              r34349
+              r36194
    */
   public StreetsideDownloadViewAction() {
+    super(
+      I18n.tr(DESCRIPTION),
+      new ImageProvider(StreetsidePlugin.LOGO).setSize(ImageSizes.DEFAULT),
+      I18n.tr(DESCRIPTION),
+      Shortcut.registerShortcut("Streetside area", I18n.tr(DESCRIPTION), KeyEvent.VK_PERIOD, Shortcut.SHIFT),
+      false,
+      "streetsideArea",
+      true
+    );
+    super(I18n.tr(DESCRIPTION), new ImageProvider(StreetsidePlugin.LOGO).setSize(ImageSizes.DEFAULT),
+        I18n.tr(DESCRIPTION),
+        Shortcut.registerShortcut("Streetside area", I18n.tr(DESCRIPTION), KeyEvent.VK_PERIOD, Shortcut.SHIFT),
+        false, "streetsideArea", true);
     StreetsideProperties.DOWNLOAD_MODE.addListener(this);
     initEnabledState();
 …
   protected void updateEnabledState() {
     super.updateEnabledState();
+    setEnabled(
+      StreetsideLayer.hasInstance() && (
+        StreetsideDownloader.getMode() == StreetsideDownloader.DOWNLOAD_MODE.OSM_AREA
+        || StreetsideDownloader.getMode() == StreetsideDownloader.DOWNLOAD_MODE.MANUAL_ONLY
+      )
+    );
+    setEnabled(StreetsideLayer.hasInstance()
+        && (StreetsideDownloader.getMode() == StreetsideDownloader.DOWNLOAD_MODE.OSM_AREA
+            || StreetsideDownloader.getMode() == StreetsideDownloader.DOWNLOAD_MODE.MANUAL_ONLY));
+  }

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/actions/StreetsideExportAction.java

-              r34577
+              r36194
 import javax.swing.JOptionPane;
-import org.apache.log4j.Logger;
 import org.openstreetmap.josm.actions.JosmAction;
 import org.openstreetmap.josm.gui.MainApplication;
 …
   private static final long serialVersionUID = 6131359489725632369L;
-  final static Logger logger = Logger.getLogger(StreetsideExportAction.class);
   private StreetsideExportDialog dialog;
 …
     super(tr("Export Streetside images"), new ImageProvider(StreetsidePlugin.LOGO).setSize(ImageSizes.DEFAULT),
         tr("Export Streetside images"), Shortcut.registerShortcut("Export Streetside",
             tr("Export Streetside images"), KeyEvent.CHAR_UNDEFINED,
             Shortcut.NONE), false, "streetsideExport", true);
+            tr("Export Streetside images"), KeyEvent.CHAR_UNDEFINED, Shortcut.NONE),
+        false, "streetsideExport", true);
     setEnabled(false);
+  }
 …
     dialog = new StreetsideExportDialog(ok);
     pane.setMessage(dialog);
     pane.setOptions(new JButton[] {ok, cancel});
+    pane.setOptions(new JButton[] { ok, cancel });
     JDialog dlg = pane.createDialog(MainApplication.getMainFrame(), tr("Export Streetside images"));
 …
     // Checks if the inputs are correct and starts the export process.
+    if (pane.getValue() != null
+        && (int) pane.getValue() == JOptionPane.OK_OPTION
+        && dialog.chooser != null) {
+    if (pane.getValue() != null && (int) pane.getValue() == JOptionPane.OK_OPTION && dialog.chooser != null) {
       if (dialog.group.isSelected(dialog.all.getModel())) {
         export(StreetsideLayer.getInstance().getData().getImages());
 …
    * Exports the given images from the database.
+   *
+   * @param images
+   *          The set of images to be exported.
+   * @param images The set of images to be exported.
    */
   public void export(Set<StreetsideAbstractImage> images) {
     MainApplication.worker.execute(new StreetsideExportManager(images,
         dialog.chooser.getSelectedFile().toString()));
+    MainApplication.worker
+        .execute(new StreetsideExportManager(images, dialog.chooser.getSelectedFile().toString()));
+  }

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/actions/StreetsideWalkAction.java

-              r34577
+              r36194
   private static final long serialVersionUID = 3454223919402245818L;
+  private final List<WalkListener> listeners = new ArrayList<>();
   private WalkThread thread;
-  private final List<WalkListener> listeners = new ArrayList<>();
   /**
 …
    */
   public StreetsideWalkAction() {
+    super(tr("Walk mode"), new ImageProvider(StreetsidePlugin.LOGO).setSize(ImageSizes.DEFAULT),
+        tr("Walk mode"), null,
+        false, "streetsideWalk", true);
+    super(tr("Walk mode"), new ImageProvider(StreetsidePlugin.LOGO).setSize(ImageSizes.DEFAULT), tr("Walk mode"),
+        null, false, "streetsideWalk", true);
+  }
 …
   public void actionPerformed(ActionEvent arg0) {
     StreetsideWalkDialog dialog = new StreetsideWalkDialog();
+    JOptionPane pane = new JOptionPane(dialog, JOptionPane.PLAIN_MESSAGE,
+        JOptionPane.OK_CANCEL_OPTION);
+    JOptionPane pane = new JOptionPane(dialog, JOptionPane.PLAIN_MESSAGE, JOptionPane.OK_CANCEL_OPTION);
     JDialog dlg = pane.createDialog(MainApplication.getMainFrame(), tr("Walk mode"));
     dlg.setMinimumSize(new Dimension(400, 150));
     dlg.setVisible(true);
+    if (pane.getValue() != null
+        && (int) pane.getValue() == JOptionPane.OK_OPTION) {
+      thread = new WalkThread((int) dialog.spin.getValue(),
+          dialog.waitForPicture.isSelected(),
+    if (pane.getValue() != null && (int) pane.getValue() == JOptionPane.OK_OPTION) {
+      thread = new WalkThread((int) dialog.spin.getValue(), dialog.waitForPicture.isSelected(),
           dialog.followSelection.isSelected(), dialog.goForward.isSelected());
       fireWalkStarted();
 …
    * Adds a listener.
+   *
+   * @param lis
+   *          The listener to be added.
+   * @param lis The listener to be added.
    */
   public void addListener(WalkListener lis) {
 …
+   *
    * @param lis
    *          The listener to be added.
+   *      The listener to be added.
    */
   public void removeListener(WalkListener lis) {

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/actions/StreetsideZoomAction.java

-              r34400
+              r36194
    */
   public StreetsideZoomAction() {
+    super(
+      tr("Zoom to selected image"),
+      new ImageProvider(StreetsidePlugin.LOGO).setSize(ImageSizes.DEFAULT),
+      tr("Zoom to the currently selected Streetside image"),
+      null,
+      false,
+      "mapillaryZoom",
+      true
+    );
+    super(tr("Zoom to selected image"), new ImageProvider(StreetsidePlugin.LOGO).setSize(ImageSizes.DEFAULT),
+        tr("Zoom to the currently selected Streetside image"), null, false, "mapillaryZoom", true);
+  }
 …
       throw new IllegalStateException();
+    }
     MainApplication.getMap().mapView.zoomTo(StreetsideLayer.getInstance().getData()
         .getSelectedImage().getMovingLatLon());
+    MainApplication.getMap().mapView
+        .zoomTo(StreetsideLayer.getInstance().getData().getSelectedImage().getMovingLatLon());
+  }
 …
+  }
     @Override
+  @Override
   protected boolean listenToSelectionChange() {
     return false;

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/actions/WalkThread.java

-              r34416
+              r36194
 import java.awt.image.BufferedImage;
 import java.text.MessageFormat;
+import java.util.logging.Logger;
 import javax.swing.SwingUtilities;
-import org.apache.log4j.Logger;
 import org.openstreetmap.josm.plugins.streetside.StreetsideAbstractImage;
 import org.openstreetmap.josm.plugins.streetside.StreetsideData;
 …
 import org.openstreetmap.josm.plugins.streetside.gui.StreetsideMainDialog;
 import org.openstreetmap.josm.plugins.streetside.utils.StreetsideProperties;
+import org.openstreetmap.josm.tools.Logging;
 /**
 …
  */
 public class WalkThread extends Thread implements StreetsideDataListener {
+  private static final Logger LOGGER = Logger.getLogger(WalkThread.class.getCanonicalName());
   private final int interval;
   private final StreetsideData data;
-  private boolean end;
   private final boolean waitForFullQuality;
   private final boolean followSelected;
   private final boolean goForward;
+  private boolean end;
   private BufferedImage lastImage;
   private volatile boolean paused;
-  final static Logger logger = Logger.getLogger(WalkThread.class);
   /**
    * Main constructor.
+   *
    * @param interval How often the images switch.
+   * @param interval     How often the images switch.
    * @param waitForPicture If it must wait for the full resolution picture or just the
    * thumbnail.
+   *             thumbnail.
    * @param followSelected Zoom to each image that is selected.
    * @param goForward true to go forward; false to go backwards.
+   * @param goForward    true to go forward; false to go backwards.
    */
+  public WalkThread(int interval, boolean waitForPicture,
+                    boolean followSelected, boolean goForward) {
+  public WalkThread(int interval, boolean waitForPicture, boolean followSelected, boolean goForward) {
     this.interval = interval;
     waitForFullQuality = waitForPicture;
 …
     data = StreetsideLayer.getInstance().getData();
     data.addListener(this);
+  }
+  /**
+   * Downloads n images into the cache beginning from the supplied start-image (including the start-image itself).
+   *
+   * @param startImage the image to start with (this and the next n-1 images in the same sequence are downloaded)
+   * @param n      the number of images to download
+   * @param type     the quality of the image (full or thumbnail)
+   */
+  private static void preDownloadImages(StreetsideImage startImage, int n, CacheUtils.PICTURE type) {
+    if (n >= 1 && startImage != null) {
+      CacheUtils.downloadPicture(startImage, type);
+      if (startImage.next() instanceof StreetsideImage && n >= 2) {
+        preDownloadImages((StreetsideImage) startImage.next(), n - 1, type);
+      }
+    }
+  }
 …
           // Predownload next 10 thumbnails.
           preDownloadImages((StreetsideImage) image.next(), 10, CacheUtils.PICTURE.THUMBNAIL);
           if(StreetsideProperties.PREDOWNLOAD_CUBEMAPS.get()) {
+          if (Boolean.TRUE.equals(StreetsideProperties.PREDOWNLOAD_CUBEMAPS.get())) {
             preDownloadCubemaps((StreetsideImage) image.next(), 10);
+          }
 …
             // Start downloading 3 next full images.
             StreetsideAbstractImage currentImage = image.next();
                   preDownloadImages((StreetsideImage) currentImage, 3, CacheUtils.PICTURE.FULL_IMAGE);
+            preDownloadImages((StreetsideImage) currentImage, 3, CacheUtils.PICTURE.FULL_IMAGE);
+          }
+        }
         try {
           // Waits for full quality picture.
+          final BufferedImage displayImage = StreetsideMainDialog.getInstance().getStreetsideImageDisplay().getImage();
+          final BufferedImage displayImage = StreetsideMainDialog.getInstance().getStreetsideImageDisplay()
+              .getImage();
           if (waitForFullQuality && image instanceof StreetsideImage) {
             while (displayImage == lastImage || displayImage == null || displayImage.getWidth() < 2048) {
 …
+      }
     } catch (NullPointerException e) {
       if(StreetsideProperties.DEBUGING_ENABLED.get()) {
         logger.debug(MessageFormat.format("Exception thrown in WalkThread: {0}", e.getMessage()));
         e.printStackTrace();
+      if (Boolean.TRUE.equals(StreetsideProperties.DEBUGING_ENABLED.get())) {
+        LOGGER.log(Logging.LEVEL_DEBUG,
+            MessageFormat.format("Exception thrown in WalkThread: {0}", e.getMessage()), e);
+      }
       return;
 …
   private void preDownloadCubemaps(StreetsideImage startImage, int n) {
           if (n >= 1 && startImage != null) {
+    if (n >= 1 && startImage != null) {
                   for (int i = 0; i < 6; i++) {
                                 for (int j = 0; j < 4; j++) {
                                         for (int k = 0; k < 4; k++) {
+      for (int i = 0; i < 6; i++) {
+        for (int j = 0; j < 4; j++) {
+          for (int k = 0; k < 4; k++) {
+                                                CacheUtils.downloadPicture(startImage, CacheUtils.PICTURE.CUBEMAP);
+                                                if (startImage.next() instanceof StreetsideImage && n >= 2) {
+                                                        preDownloadCubemaps((StreetsideImage) startImage.next(), n - 1);
+                                                }
+                                        }
+                                }
+                  }
+          }
+  }
+/**
+   * Downloads n images into the cache beginning from the supplied start-image (including the start-image itself).
+   *
+   * @param startImage the image to start with (this and the next n-1 images in the same sequence are downloaded)
+   * @param n the number of images to download
+   * @param type the quality of the image (full or thumbnail)
+   */
+  private static void preDownloadImages(StreetsideImage startImage, int n, CacheUtils.PICTURE type) {
+    if (n >= 1 && startImage != null) {
+      CacheUtils.downloadPicture(startImage, type);
+      if (startImage.next() instanceof StreetsideImage && n >= 2) {
+        preDownloadImages((StreetsideImage) startImage.next(), n - 1, type);
+            CacheUtils.downloadPicture(startImage, CacheUtils.PICTURE.CUBEMAP);
+            if (startImage.next() instanceof StreetsideImage && n >= 2) {
+              preDownloadCubemaps((StreetsideImage) startImage.next(), n - 1);
+            }
+          }
+        }
+      }
+    }

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/cache/CacheUtils.java

-              r34399
+              r36194
 package org.openstreetmap.josm.plugins.streetside.cache;
+import java.io.IOException;
+import java.util.logging.Logger;
-import java.io.IOException;
-import org.apache.log4j.Logger;
 import org.openstreetmap.josm.data.cache.CacheEntry;
 import org.openstreetmap.josm.data.cache.CacheEntryAttributes;
 …
 import org.openstreetmap.josm.plugins.streetside.StreetsideImage;
 import org.openstreetmap.josm.plugins.streetside.cubemap.CubemapBuilder;
+import org.openstreetmap.josm.tools.Logging;
 /**
 …
 public final class CacheUtils {
 final static Logger logger = Logger.getLogger(CacheUtils.class);
+  private static final Logger LOGGER = Logger.getLogger(CacheUtils.class.getCanonicalName());
 private static IgnoreDownload ignoreDownload = new IgnoreDownload();
+  private static final IgnoreDownload ignoreDownload = new IgnoreDownload();
+/** Picture quality */
+public enum PICTURE {
+ /** Thumbnail quality picture (320 p) */
+ THUMBNAIL,
+ /** Full quality picture (2048 p) */
+ FULL_IMAGE,
+ /** Both of them */
+ BOTH,
+ /** Streetside cubemap */
+ CUBEMAP
+}
+  private CacheUtils() {
+    // Private constructor to avoid instantiation
+  }
+private CacheUtils() {
+ // Private constructor to avoid instantiation
+}
+  /**
+   * Downloads the the thumbnail and the full resolution picture of the given
+   * image. Does nothing if it is already in cache.
+   *
+   * @param img The image whose picture is going to be downloaded.
+   */
+  public static void downloadPicture(StreetsideImage img) {
+    downloadPicture(img, PICTURE.BOTH);
+  }
+/**
+* Downloads the the thumbnail and the full resolution picture of the given
+* image. Does nothing if it is already in cache.
+*
+* @param img
+*          The image whose picture is going to be downloaded.
+*/
+public static void downloadPicture(StreetsideImage img) {
+ downloadPicture(img, PICTURE.BOTH);
+}
+  /**
+   * Downloads the the thumbnail and the full resolution picture of the given
+   * image. Does nothing if it is already in cache.
+   *
+   * @param cm The image whose picture is going to be downloaded.
+   */
+  public static void downloadCubemap(StreetsideImage cm) {
+    downloadPicture(cm, PICTURE.CUBEMAP);
+  }
+/**
+* Downloads the the thumbnail and the full resolution picture of the given
+* image. Does nothing if it is already in cache.
+*
+* @param cm
+*          The image whose picture is going to be downloaded.
+*/
+public static void downloadCubemap(StreetsideImage cm) {
+        downloadPicture(cm, PICTURE.CUBEMAP);
+}
+  /**
+   * Downloads the picture of the given image. Does nothing when it is already
+   * in cache.
+   *
+   * @param img The image to be downloaded.
+   * @param pic The picture type to be downloaded (full quality, thumbnail or
+   *      both.)
+   */
+  public static void downloadPicture(StreetsideImage img, PICTURE pic) {
+    switch (pic) {
+    case BOTH:
+      if (new StreetsideCache(img.getId(), StreetsideCache.Type.THUMBNAIL).get() == null)
+        submit(img.getId(), StreetsideCache.Type.THUMBNAIL, ignoreDownload);
+      if (new StreetsideCache(img.getId(), StreetsideCache.Type.FULL_IMAGE).get() == null)
+        submit(img.getId(), StreetsideCache.Type.FULL_IMAGE, ignoreDownload);
+      break;
+    case THUMBNAIL:
+      submit(img.getId(), StreetsideCache.Type.THUMBNAIL, ignoreDownload);
+      break;
+    case FULL_IMAGE:
+      // not used (relic from Mapillary)
+      break;
+    case CUBEMAP:
+      if (img.getId() == null) {
+        LOGGER.log(Logging.LEVEL_ERROR, "Download cancelled. Image id is null.");
+      } else {
+        CubemapBuilder.getInstance().downloadCubemapImages(img.getId());
+      }
+      break;
+    default:
+      submit(img.getId(), StreetsideCache.Type.FULL_IMAGE, ignoreDownload);
+      break;
+    }
+  }
+/**
+* Downloads the picture of the given image. Does nothing when it is already
+* in cache.
+*
+* @param img
+*          The image to be downloaded.
+* @param pic
+*          The picture type to be downloaded (full quality, thumbnail or
+*          both.)
+*/
+public static void downloadPicture(StreetsideImage img, PICTURE pic) {
+ switch (pic) {
+   case BOTH:
+     if (new StreetsideCache(img.getId(), StreetsideCache.Type.THUMBNAIL).get() == null)
+       submit(img.getId(), StreetsideCache.Type.THUMBNAIL, ignoreDownload);
+     if (new StreetsideCache(img.getId(), StreetsideCache.Type.FULL_IMAGE).get() == null)
+       submit(img.getId(), StreetsideCache.Type.FULL_IMAGE, ignoreDownload);
+     break;
+   case THUMBNAIL:
+     submit(img.getId(), StreetsideCache.Type.THUMBNAIL, ignoreDownload);
+     break;
+   case FULL_IMAGE:
+     // not used (relic from Mapillary)
+     break;
+   case CUBEMAP:
+           if(img.getId()==null) {
+                   logger.error("Download cancelled. Image id is null.");
+           } else {
+                   CubemapBuilder.getInstance().downloadCubemapImages(img.getId());
+           }
+           break;
+   default:
+     submit(img.getId(), StreetsideCache.Type.FULL_IMAGE, ignoreDownload);
+     break;
+ }
+}
+  /**
+   * Requests the picture with the given key and quality and uses the given
+   * listener.
+   *
+   * @param key  The key of the picture to be requested.
+   * @param type The quality of the picture to be requested.
+   * @param lis  The listener that is going to receive the picture.
+   */
+  public static void submit(String key, StreetsideCache.Type type, ICachedLoaderListener lis) {
+    try {
+      new StreetsideCache(key, type).submit(lis, false);
+    } catch (IOException e) {
+      LOGGER.log(Logging.LEVEL_ERROR, e.getMessage(), e);
+    }
+  }
+/**
+* Requests the picture with the given key and quality and uses the given
+* listener.
+*
+* @param key
+*          The key of the picture to be requested.
+* @param type
+*          The quality of the picture to be requested.
+* @param lis
+*          The listener that is going to receive the picture.
+*/
+public static void submit(String key, StreetsideCache.Type type,
+   ICachedLoaderListener lis) {
+ try {
+   new StreetsideCache(key, type).submit(lis, false);
+ } catch (IOException e) {
+   logger.error(e);
+ }
+}
+  /**
+   * Picture quality
+   */
+  public enum PICTURE {
+    /**
+     * Thumbnail quality picture (320 p)
+     */
+    THUMBNAIL,
+    /**
+     * Full quality picture (2048 p)
+     */
+    FULL_IMAGE,
+    /**
+     * Both of them
+     */
+    BOTH,
+    /**
+     * Streetside cubemap
+     */
+    CUBEMAP
+  }
   private static class IgnoreDownload implements ICachedLoaderListener {

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/cache/Caches.java

-              r35466
+              r36194
 import java.io.IOException;
 import java.io.Serializable;
+import java.util.logging.Logger;
 import javax.swing.ImageIcon;
 …
 import org.apache.commons.jcs3.access.CacheAccess;
 import org.apache.commons.jcs3.engine.behavior.IElementAttributes;
-import org.apache.log4j.Logger;
 import org.openstreetmap.josm.data.Preferences;
 import org.openstreetmap.josm.data.cache.BufferedImageCacheEntry;
 …
 public final class Caches {
   final static Logger logger = Logger.getLogger(Caches.class);
+  private static final Logger LOGGER = Logger.getLogger(Caches.class.getCanonicalName());
         private Caches() {
                 // Private constructor to avoid instantiation
+        }
+  private Caches() {
+    // Private constructor to avoid instantiation
+  }
         public static File getCacheDirectory() {
                 final File f = new File(Preferences.main().getPluginsDirectory().getPath() + "/MicrosoftStreetside/cache");
                 if (!f.exists()) {
                         f.mkdirs();
+                }
                 return f;
+        }
+  public static File getCacheDirectory() {
+    final File f = new File(Preferences.main().getPluginsDirectory().getPath() + "/MicrosoftStreetside/cache");
+    if (!f.exists()) {
+      f.mkdirs();
+    }
+    return f;
+  }
         public abstract static class CacheProxy<K, V extends Serializable> {
                 private final CacheAccess<K, V> cache;
+  public abstract static class CacheProxy<K, V extends Serializable> {
+    private final CacheAccess<K, V> cache;
                 public CacheProxy() {
                         CacheAccess<K, V> c;
                         try {
                                 c = createNewCache();
                         } catch (IOException e) {
                                 logger.warn("Could not initialize cache for " + getClass().getName(), e);
                                 c = null;
+                        }
                         cache = c;
+                }
+    protected CacheProxy() {
+      CacheAccess<K, V> c;
+      try {
+        c = createNewCache();
+      } catch (IOException e) {
+        LOGGER.log(Logging.LEVEL_WARN, e, () -> "Could not initialize cache for " + getClass().getName());
+        c = null;
+      }
+      cache = c;
+    }
                 protected abstract CacheAccess<K, V> createNewCache() throws IOException;
+    protected abstract CacheAccess<K, V> createNewCache() throws IOException;
                 public V get(final K key) {
                         return cache == null ? null : cache.get(key);
+                }
+    public V get(final K key) {
+      return cache == null ? null : cache.get(key);
+    }
                 public void put(final K key, final V value) {
                         if (cache != null) {
                                 cache.put(key, value);
+                        }
+                }
+        }
+    public void put(final K key, final V value) {
+      if (cache != null) {
+        cache.put(key, value);
+      }
+    }
+  }
         public static class ImageCache {
                 private static ImageCache instance;
                 private final CacheAccess<String, BufferedImageCacheEntry> cache;
+  public static class ImageCache {
+    private static ImageCache instance;
+    private final CacheAccess<String, BufferedImageCacheEntry> cache;
                 public ImageCache() {
                         CacheAccess<String, BufferedImageCacheEntry> c;
                         try {
                                 c = JCSCacheManager.getCache("streetside", 10, 10000, Caches.getCacheDirectory().getPath());
                         } catch (Exception e) {
                                 Logging.log(Logging.LEVEL_WARN, "Could not initialize the Streetside image cache.", e);
                                 c = null;
+                        }
                         cache = c;
+                }
+    public ImageCache() {
+      CacheAccess<String, BufferedImageCacheEntry> c;
+      try {
+        c = JCSCacheManager.getCache("streetside", 10, 10000, Caches.getCacheDirectory().getPath());
+      } catch (Exception e) {
+        Logging.log(Logging.LEVEL_WARN, "Could not initialize the Streetside image cache.", e);
+        c = null;
+      }
+      cache = c;
+    }
+                public CacheAccess<String, BufferedImageCacheEntry> getCache() {
+                        return cache;
+                }
+    public static ImageCache getInstance() {
+      synchronized (ImageCache.class) {
+        if (ImageCache.instance == null) {
+          ImageCache.instance = new ImageCache();
+        }
+        return ImageCache.instance;
+      }
+    }
+                public static ImageCache getInstance() {
+                        synchronized (ImageCache.class) {
+                                if (ImageCache.instance == null) {
+                                        ImageCache.instance = new ImageCache();
+                                }
+                                return ImageCache.instance;
+                        }
+                }
+        }
+    public CacheAccess<String, BufferedImageCacheEntry> getCache() {
+      return cache;
+    }
+  }
         public static class CubemapCache {
                 private static CubemapCache instance;
                 private final CacheAccess<String, BufferedImageCacheEntry> cache;
+  public static class CubemapCache {
+    private static CubemapCache instance;
+    private final CacheAccess<String, BufferedImageCacheEntry> cache;
                 public CubemapCache() {
                         CacheAccess<String, BufferedImageCacheEntry> c;
                         try {
                                 c = JCSCacheManager.getCache("streetside", 10, 10000, Caches.getCacheDirectory().getPath());
                         } catch (Exception e) {
                                 logger.warn("Could not initialize the Streetside cubemap cache.", e);
                                 c = null;
+                        }
                         cache = c;
+                }
+    public CubemapCache() {
+      CacheAccess<String, BufferedImageCacheEntry> c;
+      try {
+        c = JCSCacheManager.getCache("streetside", 10, 10000, Caches.getCacheDirectory().getPath());
+      } catch (Exception e) {
+        LOGGER.log(Logging.LEVEL_WARN, "Could not initialize the Streetside cubemap cache.", e);
+        c = null;
+      }
+      cache = c;
+    }
+                public CacheAccess<String, BufferedImageCacheEntry> getCache() {
+                        return cache;
+                }
+    public static CubemapCache getInstance() {
+      synchronized (CubemapCache.class) {
+        if (CubemapCache.instance == null) {
+          CubemapCache.instance = new CubemapCache();
+        }
+        return CubemapCache.instance;
+      }
+    }
+                public static CubemapCache getInstance() {
+                        synchronized (CubemapCache.class) {
+                                if (CubemapCache.instance == null) {
+                                        CubemapCache.instance = new CubemapCache();
+                                }
+                                return CubemapCache.instance;
+                        }
+                }
+        }
+    public CacheAccess<String, BufferedImageCacheEntry> getCache() {
+      return cache;
+    }
+  }
         public static class MapObjectIconCache extends CacheProxy<String, ImageIcon> {
                 private static CacheProxy<String, ImageIcon> instance;
+  public static class MapObjectIconCache extends CacheProxy<String, ImageIcon> {
+    private static CacheProxy<String, ImageIcon> instance;
                 public static CacheProxy<String, ImageIcon> getInstance() {
                         synchronized (MapObjectIconCache.class) {
                                 if (MapObjectIconCache.instance == null) {
                                         MapObjectIconCache.instance = new MapObjectIconCache();
+                                }
                                 return MapObjectIconCache.instance;
+                        }
+                }
+    public static CacheProxy<String, ImageIcon> getInstance() {
+      synchronized (MapObjectIconCache.class) {
+        if (MapObjectIconCache.instance == null) {
+          MapObjectIconCache.instance = new MapObjectIconCache();
+        }
+        return MapObjectIconCache.instance;
+      }
+    }
                 @Override
                 protected CacheAccess<String, ImageIcon> createNewCache() throws IOException {
                         return JCSCacheManager.getCache("streetsideObjectIcons", 100, 1000, Caches.getCacheDirectory().getPath());
+                }
+        }
+    @Override
+    protected CacheAccess<String, ImageIcon> createNewCache() throws IOException {
+      return JCSCacheManager.getCache("streetsideObjectIcons", 100, 1000, Caches.getCacheDirectory().getPath());
+    }
+  }
         public static class UserProfileCache extends CacheProxy<String, UserProfile> {
                 private static CacheProxy<String, UserProfile> instance;
+  public static class UserProfileCache extends CacheProxy<String, UserProfile> {
+    private static CacheProxy<String, UserProfile> instance;
                 public static CacheProxy<String, UserProfile> getInstance() {
                         synchronized (UserProfileCache.class) {
                                 if (UserProfileCache.instance == null) {
                                         UserProfileCache.instance = new UserProfileCache();
+                                }
                                 return UserProfileCache.instance;
+                        }
+                }
+    public static CacheProxy<String, UserProfile> getInstance() {
+      synchronized (UserProfileCache.class) {
+        if (UserProfileCache.instance == null) {
+          UserProfileCache.instance = new UserProfileCache();
+        }
+        return UserProfileCache.instance;
+      }
+    }
                 @Override
                 protected CacheAccess<String, UserProfile> createNewCache() throws IOException {
+                        CacheAccess<String, UserProfile> cache =
                                         JCSCacheManager.getCache("userProfile", 100, 1000, Caches.getCacheDirectory().getPath());
                         IElementAttributes atts = cache.getDefaultElementAttributes();
                         atts.setMaxLife(604_800_000); // Sets lifetime to 7 days (604800000=1000*60*60*24*7)
                         cache.setDefaultElementAttributes(atts);
                         return cache;
+                }
+        }
+    @Override
+    protected CacheAccess<String, UserProfile> createNewCache() throws IOException {
+      CacheAccess<String, UserProfile> cache = JCSCacheManager.getCache("userProfile", 100, 1000,
+          Caches.getCacheDirectory().getPath());
+      IElementAttributes atts = cache.getDefaultElementAttributes();
+      atts.setMaxLife(604_800_000); // Sets lifetime to 7 days (604800000=1000*60*60*24*7)
+      cache.setDefaultElementAttributes(atts);
+      return cache;
+    }
+  }
+}

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/cache/StreetsideCache.java

-              r34412
+              r36194
 public class StreetsideCache extends JCSCachedTileLoaderJob<String, BufferedImageCacheEntry> {
         private final URL url;
         private final String id;
+  private final URL url;
+  private final String id;
+        /**
+         * Types of images.
+         *
+         * @author nokutu
+         */
+        public enum Type {
+                /** Full quality image */
+                FULL_IMAGE,
+                /** Low quality image */
+                THUMBNAIL
+        }
+  /**
+   * Main constructor.
+   *
+   * @param id   The id of the image.
+   * @param type The type of image that must be downloaded (THUMBNAIL or
+   *       FULL_IMAGE).
+   */
+  public StreetsideCache(final String id, final Type type) {
+    super(Caches.ImageCache.getInstance().getCache(), new TileJobOptions(50000, 50000, new HashMap<>(), 50000L));
+        /**
+         * Main constructor.
+         *
+         * @param id
+         *          The id of the image.
+         * @param type
+         *          The type of image that must be downloaded (THUMBNAIL or
+         *          FULL_IMAGE).
+         */
+        public StreetsideCache(final String id, final Type type) {
+                super(Caches.ImageCache.getInstance().getCache(),new TileJobOptions(50000, 50000, new HashMap<String,String>(),50000l));
+    if (id == null || type == null) {
+      this.id = null;
+      url = null;
+    } else {
+      this.id = id;
+      url = VirtualEarth.streetsideTile(id, type == Type.THUMBNAIL);
+    }
+  }
+                if (id == null || type == null) {
+                        this.id = null;
+                        url = null;
+                } else {
+                        this.id = id;
+                        url = VirtualEarth.streetsideTile(id, type == Type.THUMBNAIL);
+                }
+        }
+  @Override
+  public String getCacheKey() {
+    return id;
+  }
         @Override
         public String getCacheKey() {
                 return id;
+        }
+  @Override
+  public URL getUrl() {
+    return url;
+  }
         @Override
         public URL getUrl() {
                 return url;
+        }
+  @Override
+  protected BufferedImageCacheEntry createCacheEntry(byte[] content) {
+    return new BufferedImageCacheEntry(content);
+  }
+        @Override
+        protected BufferedImageCacheEntry createCacheEntry(byte[] content) {
+                return new BufferedImageCacheEntry(content);
+        }
+  @Override
+  protected boolean isObjectLoadable() {
+    if (cacheData == null) {
+      return false;
+    }
+    final byte[] content = cacheData.getContent();
+    return content != null && content.length > 0;
+  }
+        @Override
+        protected boolean isObjectLoadable() {
+                if (cacheData == null) {
+                        return false;
+                }
+                final byte[] content = cacheData.getContent();
+                return content != null && content.length > 0;
+        }
+  /**
+   * Types of images.
+   *
+   * @author nokutu
+   */
+  public enum Type {
+    /**
+     * Full quality image
+     */
+    FULL_IMAGE,
+    /**
+     * Low quality image
+     */
+    THUMBNAIL
+  }
+}

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/cubemap/CameraTransformer.java

r34416	r36194
11	11	public class CameraTransformer extends Group {
12	12
13		~~public enum RotateOrder {~~
14		~~XYZ, XZY, YXZ, YZX, ZXY, ZYX~~
15		}
16
17	13	public Translate t = new Translate();
18	14	public Translate p = new Translate();
19	15	public Translate ip = new Translate();
20	16	public Rotate rx = new Rotate();
	17	public Rotate ry = new Rotate();
	18	public Rotate rz = new Rotate();
	19	public Scale s = new Scale();
	20
21	21	{
22	22	rx.setAxis(Rotate.X_AXIS);
23	23	}
24		public Rotate ry = new Rotate();
	24
25	25	{
26	26	ry.setAxis(Rotate.Y_AXIS);
27	27	}
28		public Rotate rz = new Rotate();
	28
29	29	{
30	30	rz.setAxis(Rotate.Z_AXIS);
31	31	}
32		~~public Scale s = new Scale();~~
33	32
34	33	public CameraTransformer() {
…	…
179	178	ip.setZ(0.0);
180	179	}
	180
	181	public enum RotateOrder {
	182	XYZ, XZY, YXZ, YZX, ZXY, ZYX
	183	}
181	184	}

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/cubemap/CubemapBox.java

-              r34428
+              r36194
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+// License: GPL. For details, see LICENSE file.
 package org.openstreetmap.josm.plugins.streetside.cubemap;
 …
 public class CubemapBox extends Group {
-  public enum CubemapBoxImageType {
-    MULTIPLE, SINGLE
+  }
   private final Affine affine = new Affine();
+  private final ImageView front = new ImageView(), right = new ImageView(), back = new ImageView(),
+    left = new ImageView(), up = new ImageView(), down = new ImageView();
+  private final ImageView front = new ImageView();
+  private final ImageView right = new ImageView();
+  private final ImageView back = new ImageView();
+  private final ImageView left = new ImageView();
+  private final ImageView up = new ImageView();
+  private final ImageView down = new ImageView();
+  private final ImageView[] views = new ImageView[] { front, right, back, left, up, down };
+  private final Image frontImg;
+  private final Image rightImg;
+  private final Image backImg;
+  private final Image leftImg;
+  private final Image upImg;
+  private final Image downImg;
+  private final PerspectiveCamera camera;
+  private final CubemapBoxImageType imageType;
+  private Image singleImg;
+  private AnimationTimer timer;
+  {
 …
+  }
+  private final ImageView[] views = new ImageView[] { front, right, back, left, up, down };
+  private Image frontImg, rightImg, backImg, leftImg, upImg, downImg, singleImg;
+  private final PerspectiveCamera camera;
+  private AnimationTimer timer;
+  private final CubemapBoxImageType imageType;
+ public CubemapBox(
+    Image frontImg, Image rightImg, Image backImg, Image leftImg, Image upImg, Image downImg, double size,
+    PerspectiveCamera camera) {
+  public CubemapBox(Image frontImg, Image rightImg, Image backImg, Image leftImg, Image upImg, Image downImg,
+      double size, PerspectiveCamera camera) {
     super();
 …
   private void loadSingleImageViewports() {
     layoutViews();
+    double width = singleImg.getWidth(), height = singleImg.getHeight();
+    double width = singleImg.getWidth();
+    double height = singleImg.getHeight();
     // simple check to see if cells will be square
 …
     recalculateSize(cellSize);
+    double topx = cellSize, topy = 0,
+      botx = cellSize, boty = cellSize * 2,
+      leftx = 0, lefty = cellSize,
+      rightx = cellSize * 2, righty = cellSize,
+      fwdx = cellSize, fwdy = cellSize,
+      backx = cellSize * 3, backy = cellSize;
+    double topx = cellSize;
+    double topy = 0;
+    double botx = cellSize;
+    double boty = cellSize * 2;
+    double leftx = 0;
+    double lefty = cellSize;
+    double rightx = cellSize * 2;
+    double righty = cellSize;
+    double fwdx = cellSize;
+    double fwdy = cellSize;
+    double backx = cellSize * 3;
+    double backy = cellSize;
     // add top padding x+, y+, width-, height
 …
+  }
+  /*
+   * Properties
+   */
+  public final double getSize() {
+    return size.get();
+  }
+  public final void setSize(double value) {
+    size.set(value);
+  } /*
+    * Properties
+    */
   private final DoubleProperty size = new SimpleDoubleProperty() {
     @Override
 …
   };
-  public final double getSize() {
-    return size.get();
+  }
-  public final void setSize(double value) {
-    size.set(value);
+  }
   public DoubleProperty sizeProperty() {
     return size;
 …
     return views;
+  }
+  public enum CubemapBoxImageType {
+    MULTIPLE, SINGLE
+  }
+}

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/cubemap/CubemapBuilder.java

-              r36065
+              r36194
 import java.util.Map;
 import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ExecutionException;
-import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.Future;
+import org.apache.log4j.Logger;
+import java.util.logging.Logger;
 import org.openstreetmap.josm.gui.MainApplication;
-import java.util.concurrent.ExecutionException;
 import org.openstreetmap.josm.plugins.streetside.StreetsideAbstractImage;
 import org.openstreetmap.josm.plugins.streetside.StreetsideCubemap;
 …
 import org.openstreetmap.josm.plugins.streetside.utils.GraphicsUtils;
 import org.openstreetmap.josm.plugins.streetside.utils.StreetsideProperties;
+import org.openstreetmap.josm.tools.Logging;
 import javafx.scene.image.Image;
 …
 public class CubemapBuilder implements ITileDownloadingTaskListener, StreetsideDataListener {
+  final static Logger logger = Logger.getLogger(CubemapBuilder.class);
+        private static CubemapBuilder instance;
+        private StreetsideCubemap cubemap;
+        protected boolean isBuilding;
+  private static final Logger LOGGER = Logger.getLogger(CubemapBuilder.class.getCanonicalName());
+  private static CubemapBuilder instance;
+  protected boolean isBuilding;
+  private StreetsideCubemap cubemap;
   private long startTime;
         private Map<String, BufferedImage> tileImages = new ConcurrentHashMap<>();
+  private Map<String, BufferedImage> tileImages = new ConcurrentHashMap<>();
   private ExecutorService pool;
+        private int currentTileCount = 0;
+  private int currentTileCount = 0;
+  private CubemapBuilder() {
+    // private constructor to avoid instantiation
+  }
+  public static CubemapBuilder getInstance() {
+    if (instance == null) {
+      instance = new CubemapBuilder();
+    }
+    return instance;
+  }
+  /**
+   * @return true, iff the singleton instance is present
+   */
+  public static boolean hasInstance() {
+    return CubemapBuilder.instance != null;
+  }
+  /**
+   * Destroys the unique instance of the class.
+   */
+  public static synchronized void destroyInstance() {
+    CubemapBuilder.instance = null;
+  }
   /**
 …
+  }
+  private CubemapBuilder() {
+                // private constructor to avoid instantiation
+        }
+        /**
+  /**
    * Fired when any image is added to the database.
    */
   @Override
         public void imagesAdded() {
                 // Not implemented by the CubemapBuilder
+        }
         /**
+  public void imagesAdded() {
+    // Not implemented by the CubemapBuilder
+  }
+  /**
    * Fired when the selected image is changed by something different from
    * manually clicking on the icon.
+   *
+   * @param oldImage
+   *          Old selected {@link StreetsideAbstractImage}
+   * @param newImage
+   *          New selected {@link StreetsideAbstractImage}
+   *
+   * @param oldImage Old selected {@link StreetsideAbstractImage}
+   * @param newImage New selected {@link StreetsideAbstractImage}
    * @see StreetsideDataListener
    */
 …
   public void selectedImageChanged(StreetsideAbstractImage oldImage, StreetsideAbstractImage newImage) {
     startTime = System.currentTimeMillis();
+                if (newImage != null) {
+                        cubemap = null;
+                        cubemap = new StreetsideCubemap(newImage.getId(), newImage.getLatLon(), newImage.getHe());
+                        currentTileCount = 0;
+                        resetTileImages();
+                        // download cubemap images in different threads and then subsequently
+                        // set the cubeface images in JavaFX
+                        downloadCubemapImages(cubemap.getId());
+                        long runTime = (System.currentTimeMillis()-startTime)/1000;
+                        if(StreetsideProperties.DEBUGING_ENABLED.get()) {
+                          logger.debug(MessageFormat.format("Completed downloading tiles for {0} in {1} seconds.", newImage.getId() , runTime));
+                        }
+                }
+        }
+        public void reload(String imageId) {
+                if (cubemap != null && imageId.equals(cubemap.getId())) {
+                        tileImages = new HashMap<>();
+                  downloadCubemapImages(imageId);
+                }
+        }
+        public void downloadCubemapImages(String imageId) {
+      ThreeSixtyDegreeViewerPanel panel360 = StreetsideViewerPanel.getThreeSixtyDegreeViewerPanel();
+      if (panel360 != null && panel360.getScene() != panel360.getLoadingScene()) {
+        panel360.setScene(panel360.getLoadingScene());
+          }
+          final int maxThreadCount = StreetsideProperties.DOWNLOAD_CUBEFACE_TILES_TOGETHER.get()?6:6 * CubemapUtils.getMaxCols() * CubemapUtils.getMaxRows();
+                int fails = 0;
+    if (newImage != null) {
+      cubemap = null;
+      cubemap = new StreetsideCubemap(newImage.getId(), newImage.getLatLon(), newImage.getHe());
+      currentTileCount = 0;
+      resetTileImages();
+      // download cubemap images in different threads and then subsequently
+      // set the cubeface images in JavaFX
+      downloadCubemapImages(cubemap.getId());
+      long runTime = (System.currentTimeMillis() - startTime) / 1000;
+      if (Boolean.TRUE.equals(StreetsideProperties.DEBUGING_ENABLED.get())) {
+        LOGGER.log(Logging.LEVEL_DEBUG, MessageFormat
+            .format("Completed downloading tiles for {0} in {1} seconds.", newImage.getId(), runTime));
+      }
+    }
+  }
+  public void reload(String imageId) {
+    if (cubemap != null && imageId.equals(cubemap.getId())) {
+      tileImages = new HashMap<>();
+      downloadCubemapImages(imageId);
+    }
+  }
+  public void downloadCubemapImages(String imageId) {
+    ThreeSixtyDegreeViewerPanel panel360 = StreetsideViewerPanel.getThreeSixtyDegreeViewerPanel();
+    if (panel360 != null && panel360.getScene() != panel360.getLoadingScene()) {
+      panel360.setScene(panel360.getLoadingScene());
+    }
+    final int maxThreadCount = Boolean.TRUE.equals(StreetsideProperties.DOWNLOAD_CUBEFACE_TILES_TOGETHER.get()) ? 6
+        : 6 * CubemapUtils.getMaxCols() * CubemapUtils.getMaxRows();
+    int fails = 0;
     // TODO: message for progress bar
 …
     long startTime = System.currentTimeMillis();
     if(CubemapBuilder.getInstance().getTileImages().keySet().size() > 0) {
+    if (!CubemapBuilder.getInstance().getTileImages().keySet().isEmpty()) {
       pool.shutdownNow();
       CubemapBuilder.getInstance().resetTileImages();
 …
       List<Callable<List<String>>> tasks = new ArrayList<>(maxThreadCount);
       if (StreetsideProperties.DOWNLOAD_CUBEFACE_TILES_TOGETHER.get()) {
+      if (Boolean.TRUE.equals(StreetsideProperties.DOWNLOAD_CUBEFACE_TILES_TOGETHER.get())) {
         EnumSet.allOf(CubemapUtils.CubemapFaces.class).forEach(face -> {
           String tileId = String.valueOf(imageId + face.getValue());
+          String tileId = imageId + face.getValue();
           tasks.add(new TileDownloadingTask(tileId));
         });
 …
         // launch 4-tiled (low-res) downloading tasks . . .
         if (!StreetsideProperties.SHOW_HIGH_RES_STREETSIDE_IMAGERY.get()) {
+        if (Boolean.FALSE.equals(StreetsideProperties.SHOW_HIGH_RES_STREETSIDE_IMAGERY.get())) {
           // download all imagery for each cubeface at once
 …
               for (int k = 0; k < CubemapUtils.getMaxRows(); k++) {
+                String tileId = String
+                  .valueOf(imageId + CubemapUtils.getFaceNumberForCount(i) + Integer.valueOf(tileNr++).toString());
+                String tileId = imageId + CubemapUtils.getFaceNumberForCount(i) + tileNr++;
                 tasks.add(new TileDownloadingTask(tileId));
+              }
+            }
+          }
         // launch 16-tiled (high-res) downloading tasks
         } else if (StreetsideProperties.SHOW_HIGH_RES_STREETSIDE_IMAGERY.get()) {
+          // launch 16-tiled (high-res) downloading tasks
+        } else if (Boolean.TRUE.equals(StreetsideProperties.SHOW_HIGH_RES_STREETSIDE_IMAGERY.get())) {
           for (int i = 0; i < CubemapUtils.NUM_SIDES; i++) {
 …
               for (int k = 0; k < CubemapUtils.getMaxRows(); k++) {
+                String tileId = String
+                  .valueOf(imageId + CubemapUtils.getFaceNumberForCount(i) + String.valueOf(Integer.valueOf(j).toString() + Integer.valueOf(k).toString()));
+                String tileId = imageId + CubemapUtils.getFaceNumberForCount(i) + j + k;
                 tasks.add(new TileDownloadingTask(tileId));
+              }
 …
       // execute tasks
                         MainApplication.worker.submit(() -> {
                           try {
+      MainApplication.worker.submit(() -> {
+        try {
           List<Future<List<String>>> results = pool.invokeAll(tasks);
           if(StreetsideProperties.DEBUGING_ENABLED.get() && results != null) {
+          if (Boolean.TRUE.equals(StreetsideProperties.DEBUGING_ENABLED.get()) && results != null) {
             for (Future<List<String>> ff : results) {
               try {
+                logger.debug(MessageFormat.format("Completed tile downloading task {0} in {1} seconds.",ff.get().toString(),
+                  (System.currentTimeMillis() - startTime)/1000));
+                LOGGER.log(Logging.LEVEL_DEBUG,
+                    MessageFormat.format("Completed tile downloading task {0} in {1} seconds.",
+                        ff.get().toString(), (System.currentTimeMillis() - startTime) / 1000));
               } catch (ExecutionException e) {
                 logger.error(e);
+                LOGGER.log(Logging.LEVEL_ERROR, e.getMessage(), e);
+              }
+            }
+          }
         } catch (InterruptedException e) {
          logger.error(e);
+        }
                         });
+          LOGGER.log(Logging.LEVEL_ERROR, e.getMessage(), e);
+        }
+      });
     } catch (Exception ee) {
       fails++;
+      logger.error("Error loading tile for image " + imageId);
+      ee.printStackTrace();
+      LOGGER.log(Logging.LEVEL_ERROR, ee, () -> "Error loading tile for image " + imageId);
+    }
 …
     long runTime = stopTime - startTime;
+    if (StreetsideProperties.DEBUGING_ENABLED.get()) {
+      logger.debug(MessageFormat.format("Tile imagery downloading tasks completed in {0} seconds.", runTime / 1000));
+    if (Boolean.TRUE.equals(StreetsideProperties.DEBUGING_ENABLED.get())) {
+      LOGGER.log(Logging.LEVEL_DEBUG,
+          MessageFormat.format("Tile imagery downloading tasks completed in {0} seconds.", runTime / 1000));
+    }
     if (fails > 0) {
       logger.error(Integer.valueOf(fails) + " downloading tasks failed!");
+      LOGGER.log(Logging.LEVEL_ERROR, fails + " downloading tasks failed!");
+    }
+  }
 …
+   *
    * @param tileId
    *          the complete quadKey of the imagery tile, including cubeface and row/column in quaternary.
+   *      the complete quadKey of the imagery tile, including cubeface and row/column in quaternary.
    * @see TileDownloadingTask
    */
 …
     // and set the views in the cubemap box.
     if(!tileId.startsWith(cubemap.getId())) {
+    if (!tileId.startsWith(cubemap.getId())) {
       return;
+    }
 …
     if (currentTileCount == (CubemapUtils.NUM_SIDES * CubemapUtils.getMaxCols() * CubemapUtils.getMaxRows())) {
       if (StreetsideProperties.DEBUGING_ENABLED.get()) {
+      if (Boolean.TRUE.equals(StreetsideProperties.DEBUGING_ENABLED.get())) {
         long endTime = System.currentTimeMillis();
         long runTime = (endTime - startTime) / 1000;
+        logger.debug(
+          MessageFormat.format(
+            "{0} tile images ready for building cumbemap faces for cubemap {1} in {2} seconds.", currentTileCount,
+            CubemapBuilder.getInstance().getCubemap().getId(), Long.toString(runTime))
+          );
+        LOGGER.log(Logging.LEVEL_DEBUG, MessageFormat.format(
+            "{0} tile images ready for building cumbemap faces for cubemap {1} in {2} seconds.",
+            currentTileCount, CubemapBuilder.getInstance().getCubemap().getId(), Long.toString(runTime)));
+      }
 …
    * then the ImageViews of the cubemap are set with the new imagery.
+   *
    * @see         StreetsideCubemap
    */
    private void buildCubemapFaces() {
                 CubemapBox cmb = StreetsideViewerDialog.getInstance().getStreetsideViewerPanel().getCubemapBox();
                 ImageView[] views = cmb.getViews();
+                Image finalImages[] = new Image[CubemapUtils.NUM_SIDES];
+                // build 4-tiled cubemap faces and crop buffers
+                if (!StreetsideProperties.SHOW_HIGH_RES_STREETSIDE_IMAGERY.get()) {
                         for (int i = 0; i < CubemapUtils.NUM_SIDES; i++) {
+                                BufferedImage[] faceTileImages = new BufferedImage[CubemapUtils.getMaxCols() * CubemapUtils.getMaxRows()];
+                                for (int j = 0; j < (CubemapUtils.getMaxCols() * CubemapUtils.getMaxRows()); j++) {
+                                        String tileId = String.valueOf(getCubemap().getId() + CubemapUtils.getFaceNumberForCount(i)
+                                                        + Integer.valueOf(j).toString());
                                         BufferedImage currentTile = tileImages.get(tileId);
+                                        faceTileImages[j] = currentTile;
+                                }
+                                BufferedImage finalImg = GraphicsUtils.buildMultiTiledCubemapFaceImage(faceTileImages);
+                                // rotate top cubeface 180 degrees - misalignment workaround
+                                if (i == 4) {
+                                  finalImg = GraphicsUtils.rotateImage(finalImg);
+                                }
+                                finalImages[i] = GraphicsUtils.convertBufferedImage2JavaFXImage(finalImg);
+                        }
+                        // build 16-tiled cubemap faces and crop buffers
+                } else if (StreetsideProperties.SHOW_HIGH_RES_STREETSIDE_IMAGERY.get()) {
                         for (int i = 0; i < CubemapUtils.NUM_SIDES; i++) {
+                                int tileCount = 0;
+                                BufferedImage[] faceTileImages = new BufferedImage[StreetsideProperties.SHOW_HIGH_RES_STREETSIDE_IMAGERY
+                                                .get() ? 16 : 4];
+                                for (int j = 0; j < CubemapUtils.getMaxCols(); j++) {
                                         for (int k = 0; k < CubemapUtils.getMaxRows(); k++) {
+                                                String tileId = String.valueOf(getCubemap().getId() + CubemapUtils.getFaceNumberForCount(i)
+                                                                + CubemapUtils.convertDoubleCountNrto16TileNr(
                                                                                 String.valueOf(Integer.valueOf(j).toString() + Integer.valueOf(k).toString())));
                                                 BufferedImage currentTile = tileImages.get(tileId);
                                                 faceTileImages[tileCount++] = currentTile;
+                                        }
+                                }
                                 BufferedImage finalImg = GraphicsUtils.buildMultiTiledCubemapFaceImage(faceTileImages);
                                 // rotate top cubeface 180 degrees - misalignment workaround
                                 if (i == 4) {
                                         finalImg = GraphicsUtils.rotateImage(finalImg);
+                                }
                                 finalImages[i] = GraphicsUtils.convertBufferedImage2JavaFXImage(finalImg);
+                        }
+                }
                 for (int i = 0; i < CubemapUtils.NUM_SIDES; i++) {
                         views[i].setImage(finalImages[i]);
+                }
+   * @see     StreetsideCubemap
+   */
+  private void buildCubemapFaces() {
+    StreetsideViewerDialog.getInstance();
+    CubemapBox cmb = StreetsideViewerPanel.getCubemapBox();
+    ImageView[] views = cmb.getViews();
+    Image[] finalImages = new Image[CubemapUtils.NUM_SIDES];
+    // build 4-tiled cubemap faces and crop buffers
+    if (Boolean.FALSE.equals(StreetsideProperties.SHOW_HIGH_RES_STREETSIDE_IMAGERY.get())) {
+      for (int i = 0; i < CubemapUtils.NUM_SIDES; i++) {
+        BufferedImage[] faceTileImages = new BufferedImage[CubemapUtils.getMaxCols()
+            * CubemapUtils.getMaxRows()];
+        for (int j = 0; j < (CubemapUtils.getMaxCols() * CubemapUtils.getMaxRows()); j++) {
+          String tileId = getCubemap().getId() + CubemapUtils.getFaceNumberForCount(i) + j;
+          BufferedImage currentTile = tileImages.get(tileId);
+          faceTileImages[j] = currentTile;
+        }
+        BufferedImage finalImg = GraphicsUtils.buildMultiTiledCubemapFaceImage(faceTileImages);
+        // rotate top cubeface 180 degrees - misalignment workaround
+        if (i == 4) {
+          finalImg = GraphicsUtils.rotateImage(finalImg);
+        }
+        finalImages[i] = GraphicsUtils.convertBufferedImage2JavaFXImage(finalImg);
+      }
+      // build 16-tiled cubemap faces and crop buffers
+    } else if (Boolean.TRUE.equals(StreetsideProperties.SHOW_HIGH_RES_STREETSIDE_IMAGERY.get())) {
+      for (int i = 0; i < CubemapUtils.NUM_SIDES; i++) {
+        int tileCount = 0;
+        BufferedImage[] faceTileImages = new BufferedImage[Boolean.TRUE
+            .equals(StreetsideProperties.SHOW_HIGH_RES_STREETSIDE_IMAGERY.get()) ? 16 : 4];
+        for (int j = 0; j < CubemapUtils.getMaxCols(); j++) {
+          for (int k = 0; k < CubemapUtils.getMaxRows(); k++) {
+            String tileId = getCubemap().getId() + CubemapUtils.getFaceNumberForCount(i)
+                + CubemapUtils.convertDoubleCountNrto16TileNr(j + Integer.toString(k));
+            BufferedImage currentTile = tileImages.get(tileId);
+            faceTileImages[tileCount++] = currentTile;
+          }
+        }
+        BufferedImage finalImg = GraphicsUtils.buildMultiTiledCubemapFaceImage(faceTileImages);
+        // rotate top cubeface 180 degrees - misalignment workaround
+        if (i == 4) {
+          finalImg = GraphicsUtils.rotateImage(finalImg);
+        }
+        finalImages[i] = GraphicsUtils.convertBufferedImage2JavaFXImage(finalImg);
+      }
+    }
+    for (int i = 0; i < CubemapUtils.NUM_SIDES; i++) {
+      views[i].setImage(finalImages[i]);
+    }
     StreetsideViewerDialog.getInstance().getStreetsideViewerPanel().revalidate();
 …
     StreetsideViewerPanel.getThreeSixtyDegreeViewerPanel()
                 .setScene(StreetsideViewerPanel.getThreeSixtyDegreeViewerPanel().getCubemapScene());
+        .setScene(StreetsideViewerPanel.getThreeSixtyDegreeViewerPanel().getCubemapScene());
     StreetsideViewerPanel.getThreeSixtyDegreeViewerPanel().revalidate();
 …
     long runTime = (endTime - startTime) / 1000;
+    String message = MessageFormat.format("Completed downloading, assembling and setting cubemap imagery for cubemap {0} in  {1} seconds.", cubemap.getId(),
+      runTime);
+    if (StreetsideProperties.DEBUGING_ENABLED.get()) {
+      logger.debug(message);
+    String message = MessageFormat.format(
+        "Completed downloading, assembling and setting cubemap imagery for cubemap {0} in  {1} seconds.",
+        cubemap.getId(), runTime);
+    if (Boolean.TRUE.equals(StreetsideProperties.DEBUGING_ENABLED.get())) {
+      LOGGER.log(Logging.LEVEL_DEBUG, message);
+    }
 …
     currentTileCount = 0;
     isBuilding = false;
+        }
         private void resetTileImages() {
+  }
+  private void resetTileImages() {
     tileImages = new HashMap<>();
+  }
   /**
+         * @return the cubemap
+         */
+        public synchronized StreetsideCubemap getCubemap() {
+                return cubemap;
+        }
+        /**
+         * @param cubemap
+         *            the cubemap to set
+         */
+        public static void setCubemap(StreetsideCubemap cubemap) {
+                CubemapBuilder.getInstance().cubemap = cubemap;
+        }
+        public static CubemapBuilder getInstance() {
+                if (instance == null) {
+                        instance = new CubemapBuilder();
+                }
+                return instance;
+        }
+        /**
+         * @return true, iff the singleton instance is present
+         */
+        public static boolean hasInstance() {
+                return CubemapBuilder.instance != null;
+        }
+        /**
+   * @return the cubemap
+   */
+  public synchronized StreetsideCubemap getCubemap() {
+    return cubemap;
+  }
+  /**
+   * @param cubemap
+   *      the cubemap to set
+   */
+  public static void setCubemap(StreetsideCubemap cubemap) {
+    CubemapBuilder.getInstance().cubemap = cubemap;
+  }
+  /**
    * @return the isBuilding
    */
 …
     return isBuilding;
+  }
-        /**
-         * Destroys the unique instance of the class.
-         */
-        public static synchronized void destroyInstance() {
-                CubemapBuilder.instance = null;
+        }
+}

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/cubemap/CubemapUtils.java

-              r36065
+              r36194
 import java.util.HashMap;
 import java.util.Map;
+import java.util.logging.Logger;
 import java.util.stream.Stream;
-import org.apache.log4j.Logger;
 import org.openstreetmap.josm.plugins.streetside.utils.StreetsideProperties;
+import org.openstreetmap.josm.tools.Logging;
 public class CubemapUtils {
+  final static Logger logger = Logger.getLogger(CubemapUtils.class);
+  public static final String TEST_IMAGE_ID = "00000000";
+  public static final int NUM_SIDES = 6;
+  private static final Logger LOGGER = Logger.getLogger(CubemapUtils.class.getCanonicalName());
+  // numerical base for decimal conversion (quaternary in the case of Streetside)
+  private static final int NUM_BASE = 4;
+  public static Map<String[], String> directionConversion = new HashMap<>();
+  public static Map<String, String> rowCol2StreetsideCellAddressMap = null;
+  // Intialize utility map for storing row to Streetside cell number conversions
+  static {
+    CubemapUtils.rowCol2StreetsideCellAddressMap = new HashMap<>();
+    CubemapUtils.rowCol2StreetsideCellAddressMap.put("00", "00");
+    CubemapUtils.rowCol2StreetsideCellAddressMap.put("01", "01");
+    CubemapUtils.rowCol2StreetsideCellAddressMap.put("02", "10");
+    CubemapUtils.rowCol2StreetsideCellAddressMap.put("03", "11");
+    CubemapUtils.rowCol2StreetsideCellAddressMap.put("10", "02");
+    CubemapUtils.rowCol2StreetsideCellAddressMap.put("11", "03");
+    CubemapUtils.rowCol2StreetsideCellAddressMap.put("12", "12");
+    CubemapUtils.rowCol2StreetsideCellAddressMap.put("13", "13");
+    CubemapUtils.rowCol2StreetsideCellAddressMap.put("20", "20");
+    CubemapUtils.rowCol2StreetsideCellAddressMap.put("21", "21");
+    CubemapUtils.rowCol2StreetsideCellAddressMap.put("22", "30");
+    CubemapUtils.rowCol2StreetsideCellAddressMap.put("23", "31");
+    CubemapUtils.rowCol2StreetsideCellAddressMap.put("30", "22");
+    CubemapUtils.rowCol2StreetsideCellAddressMap.put("31", "23");
+    CubemapUtils.rowCol2StreetsideCellAddressMap.put("32", "32");
+    CubemapUtils.rowCol2StreetsideCellAddressMap.put("33", "33");
+  }
   private CubemapUtils() {
 …
+  }
+        public enum CubefaceType {
+                    ONE(1),
+                    FOUR(4),
+                    SIXTEEN(16);
+                    private final int value;
+                    private static Map<Integer, CubefaceType> map = new HashMap<>();
+                    private CubefaceType(int value) {
+                        this.value = value;
+                    }
+                    static {
+                        for (CubefaceType cubefaceType : CubefaceType.values()) {
+                            map.put(cubefaceType.value, cubefaceType);
+                        }
+                    }
+                    public static CubefaceType valueOf(int cubefaceType) {
+                        return map.get(cubefaceType);
+                    }
+                    public int getValue() {
+                        return value;
+                    }
+                }
+        public static enum CubemapFaces {
+                FRONT("01"),
+                RIGHT("02"),
+                BACK("03"),
+                LEFT("10"),
+                UP("11"),
+                DOWN("12");
+                public static Stream<CubemapFaces> stream() {
+                        return Stream.of(CubemapFaces.values());
+                }
+                private final String value;
+                CubemapFaces(String value) {
+                        this.value = value;
+                }
+                public String getValue() {
+                        return value;
+                }
+        }
+        public static Map<String[],String> directionConversion = new HashMap<>();
+        // numerical base for decimal conversion (quaternary in the case of Streetside)
+        private static final int NUM_BASE = 4;
+        public static final String TEST_IMAGE_ID = "00000000";
+        public static final int NUM_SIDES = 6;
+        public static Map<String,String> rowCol2StreetsideCellAddressMap = null;
+        // Intialize utility map for storing row to Streetside cell number conversions
+        static {
+                CubemapUtils.rowCol2StreetsideCellAddressMap = new HashMap<>();
+                CubemapUtils.rowCol2StreetsideCellAddressMap.put("00","00");
+                CubemapUtils.rowCol2StreetsideCellAddressMap.put("01","01");
+                CubemapUtils.rowCol2StreetsideCellAddressMap.put("02","10");
+                CubemapUtils.rowCol2StreetsideCellAddressMap.put("03","11");
+                CubemapUtils.rowCol2StreetsideCellAddressMap.put("10","02");
+                CubemapUtils.rowCol2StreetsideCellAddressMap.put("11","03");
+                CubemapUtils.rowCol2StreetsideCellAddressMap.put("12","12");
+                CubemapUtils.rowCol2StreetsideCellAddressMap.put("13","13");
+                CubemapUtils.rowCol2StreetsideCellAddressMap.put("20","20");
+                CubemapUtils.rowCol2StreetsideCellAddressMap.put("21","21");
+                CubemapUtils.rowCol2StreetsideCellAddressMap.put("22","30");
+                CubemapUtils.rowCol2StreetsideCellAddressMap.put("23","31");
+                CubemapUtils.rowCol2StreetsideCellAddressMap.put("30","22");
+                CubemapUtils.rowCol2StreetsideCellAddressMap.put("31","23");
+                CubemapUtils.rowCol2StreetsideCellAddressMap.put("32","32");
+                CubemapUtils.rowCol2StreetsideCellAddressMap.put("33","33");
+        }
+        public static int getMaxCols() {
+          return StreetsideProperties.SHOW_HIGH_RES_STREETSIDE_IMAGERY.get()?4:2;
+        }
+        public static int getMaxRows() {
+          return getMaxCols();
+        }
+        public static String convertDecimal2Quaternary(long inputNum) {
+                String res = null;
+                final StringBuilder sb = new StringBuilder();
+                if (StreetsideProperties.DEBUGING_ENABLED.get()) {
+      logger.debug(MessageFormat.format("convertDecimal2Quaternary input: {0}", Long.toString(inputNum)));
+                }
+                while (inputNum > 0) {
+                        sb.append(inputNum % CubemapUtils.NUM_BASE);
+                        inputNum /= CubemapUtils.NUM_BASE;
+                }
+                res = sb.reverse().toString();
+                if (StreetsideProperties.DEBUGING_ENABLED.get()) {
+      logger.debug(MessageFormat.format("convertDecimal2Quaternary output: {0}", res));
+                }
+                return res;
+        }
+        public static String convertQuaternary2Decimal(String inputNum) {
+          final String res;
+          if (StreetsideProperties.DEBUGING_ENABLED.get()) {
+      logger.debug(MessageFormat.format("convertQuaternary2Decimal input: {0}", inputNum));
+    }
+          int len = inputNum.length();
+  public static int getMaxCols() {
+    return Boolean.TRUE.equals(StreetsideProperties.SHOW_HIGH_RES_STREETSIDE_IMAGERY.get()) ? 4 : 2;
+  }
+  public static int getMaxRows() {
+    return getMaxCols();
+  }
+  public static String convertDecimal2Quaternary(long inputNum) {
+    String res = null;
+    final StringBuilder sb = new StringBuilder();
+    if (Boolean.TRUE.equals(StreetsideProperties.DEBUGING_ENABLED.get())) {
+      LOGGER.log(Logging.LEVEL_DEBUG,
+          MessageFormat.format("convertDecimal2Quaternary input: {0}", Long.toString(inputNum)));
+    }
+    while (inputNum > 0) {
+      sb.append(inputNum % CubemapUtils.NUM_BASE);
+      inputNum /= CubemapUtils.NUM_BASE;
+    }
+    res = sb.reverse().toString();
+    if (Boolean.TRUE.equals(StreetsideProperties.DEBUGING_ENABLED.get())) {
+      LOGGER.log(Logging.LEVEL_DEBUG, MessageFormat.format("convertDecimal2Quaternary output: {0}", res));
+    }
+    return res;
+  }
+  public static String convertQuaternary2Decimal(String inputNum) {
+    final String res;
+    if (Boolean.TRUE.equals(StreetsideProperties.DEBUGING_ENABLED.get())) {
+      LOGGER.log(Logging.LEVEL_DEBUG, MessageFormat.format("convertQuaternary2Decimal input: {0}", inputNum));
+    }
+    int len = inputNum.length();
     int power = 1;
     int num = 0;
     int i;
+    for (i = len - 1; i >= 0; i--)
+    {
+        if (Integer.parseInt(inputNum.substring(i,i+1)) >= CubemapUtils.NUM_BASE)
+        {
+           logger.error("Error converting quadkey " + inputNum + " to decimal.");
+           return "000000000";
+        }
+        num += Integer.parseInt(inputNum.substring(i,i+1)) * power;
+        power = power * CubemapUtils.NUM_BASE;
+    }
+                res = Integer.toString(num);
+                if (StreetsideProperties.DEBUGING_ENABLED.get()) {
+      logger.debug(MessageFormat.format("convertQuaternary2Decimal output: {0}", res));
+    }
+                return res;
+        }
+        public static String getFaceNumberForCount(int count) {
+                final String res;
+                switch (count) {
+                case 0:
+                        res = CubemapFaces.FRONT.getValue();
+                        break;
+                case 1:
+                        res = CubemapFaces.RIGHT.getValue();
+                        break;
+                case 2:
+                        res = CubemapFaces.BACK.getValue();
+                        break;
+                case 3:
+                        res = CubemapFaces.LEFT.getValue();
+                        break;
+                case 4:
+                        res = CubemapFaces.UP.getValue();
+                        break;
+                case 5:
+                        res = CubemapFaces.DOWN.getValue();
+                        break;
+                default:
+                        res = null;
+                        break;
+                }
+                return res;
+        }
+        public static int getTileWidth() {
+                // 4-tiled cubemap imagery has a 2-pixel overlap; 16-tiled has a 1-pixel
+                // overlap
+                if (!StreetsideProperties.SHOW_HIGH_RES_STREETSIDE_IMAGERY.get()) {
+                        return 255;
+                } else {
+                        return 254;
+                }
+        }
+        public static int getTileHeight() {
+                // 4-tiled cubemap imagery has a 2-pixel overlap; 16-tiled has a 1-pixel
+                // overlap
+                if(!StreetsideProperties.SHOW_HIGH_RES_STREETSIDE_IMAGERY.get()) {
+                        return 255;
+                } else {
+                        return 254;
+                }
+        }
+        public static int getCount4FaceNumber(String faceString) {
+                final int tileAddress;
+                switch (faceString) {
+        // back
+                case "03":  tileAddress = 0;
+                 break;
+        // down
+        case "12":  tileAddress = 1;
+                 break;
+        // front
+        case "01":  tileAddress = 2;
+                 break;
+        // left
+        case "10":  tileAddress = 3;
+                 break;
+        // right
+        case "02":  tileAddress = 4;
+                 break;
+        // up
+        case "11":  tileAddress = 5;
+                 break;
+        default: tileAddress = 6;
+                 break;
+                }
+                return tileAddress;
+        }
+        public static String getFaceIdFromTileId(String tileId) {
+                // magic numbers - the face id is contained in the 16th and 17th positions
+                return tileId.substring(16, 18);
+        }
+        public static String convertDoubleCountNrto16TileNr(String countNr) {
+                String tileAddress;
+                switch (countNr) {
+        case "00":  tileAddress = "00";
+                 break;
+        case "01":  tileAddress = "01";
+                 break;
+        case "02":  tileAddress = "10";
+                 break;
+        case "03":  tileAddress = "11";
+                 break;
+        case "10":  tileAddress = "02";
+                 break;
+        case "11":  tileAddress = "03";
+                 break;
+        case "12":  tileAddress = "12";
+                 break;
+        case "13":  tileAddress = "13";
+                 break;
+        case "20":  tileAddress = "20";
+                 break;
+        case "21":  tileAddress = "21";
+                 break;
+        case "22":  tileAddress = "30";
+                 break;
+        case "23":  tileAddress = "31";
+                        break;
+        case "30":  tileAddress = "22";
+           break;
+        case "31":  tileAddress = "23";
+           break;
+        case "32":  tileAddress = "32";
+           break;
+        case "33":  tileAddress = "33";
+           break;
+        // shouldn't happen
+        default: tileAddress = null;
+                 break;
+                }
+                return tileAddress;
+        }
+    for (i = len - 1; i >= 0; i--) {
+      if (Integer.parseInt(inputNum.substring(i, i + 1)) >= CubemapUtils.NUM_BASE) {
+        LOGGER.log(Logging.LEVEL_ERROR, "Error converting quadkey " + inputNum + " to decimal.");
+        return "000000000";
+      }
+      num += Integer.parseInt(inputNum.substring(i, i + 1)) * power;
+      power = power * CubemapUtils.NUM_BASE;
+    }
+    res = Integer.toString(num);
+    if (Boolean.TRUE.equals(StreetsideProperties.DEBUGING_ENABLED.get())) {
+      LOGGER.log(Logging.LEVEL_DEBUG, MessageFormat.format("convertQuaternary2Decimal output: {0}", res));
+    }
+    return res;
+  }
+  public static String getFaceNumberForCount(int count) {
+    final String res;
+    switch (count) {
+    case 0:
+      res = CubemapFaces.FRONT.getValue();
+      break;
+    case 1:
+      res = CubemapFaces.RIGHT.getValue();
+      break;
+    case 2:
+      res = CubemapFaces.BACK.getValue();
+      break;
+    case 3:
+      res = CubemapFaces.LEFT.getValue();
+      break;
+    case 4:
+      res = CubemapFaces.UP.getValue();
+      break;
+    case 5:
+      res = CubemapFaces.DOWN.getValue();
+      break;
+    default:
+      res = null;
+      break;
+    }
+    return res;
+  }
+  public static int getTileWidth() {
+    // 4-tiled cubemap imagery has a 2-pixel overlap; 16-tiled has a 1-pixel
+    // overlap
+    if (Boolean.FALSE.equals(StreetsideProperties.SHOW_HIGH_RES_STREETSIDE_IMAGERY.get())) {
+      return 255;
+    } else {
+      return 254;
+    }
+  }
+  public static int getTileHeight() {
+    // 4-tiled cubemap imagery has a 2-pixel overlap; 16-tiled has a 1-pixel
+    // overlap
+    if (Boolean.FALSE.equals(StreetsideProperties.SHOW_HIGH_RES_STREETSIDE_IMAGERY.get())) {
+      return 255;
+    } else {
+      return 254;
+    }
+  }
+  public static int getCount4FaceNumber(String faceString) {
+    final int tileAddress;
+    switch (faceString) {
+    // back
+    case "03":
+      tileAddress = 0;
+      break;
+    // down
+    case "12":
+      tileAddress = 1;
+      break;
+    // front
+    case "01":
+      tileAddress = 2;
+      break;
+    // left
+    case "10":
+      tileAddress = 3;
+      break;
+    // right
+    case "02":
+      tileAddress = 4;
+      break;
+    // up
+    case "11":
+      tileAddress = 5;
+      break;
+    default:
+      tileAddress = 6;
+      break;
+    }
+    return tileAddress;
+  }
+  public static String getFaceIdFromTileId(String tileId) {
+    // magic numbers - the face id is contained in the 16th and 17th positions
+    return tileId.substring(16, 18);
+  }
+  public static String convertDoubleCountNrto16TileNr(String countNr) {
+    String tileAddress;
+    switch (countNr) {
+    case "00":
+      tileAddress = "00";
+      break;
+    case "01":
+      tileAddress = "01";
+      break;
+    case "02":
+      tileAddress = "10";
+      break;
+    case "03":
+      tileAddress = "11";
+      break;
+    case "10":
+      tileAddress = "02";
+      break;
+    case "11":
+      tileAddress = "03";
+      break;
+    case "12":
+      tileAddress = "12";
+      break;
+    case "13":
+      tileAddress = "13";
+      break;
+    case "20":
+      tileAddress = "20";
+      break;
+    case "21":
+      tileAddress = "21";
+      break;
+    case "22":
+      tileAddress = "30";
+      break;
+    case "23":
+      tileAddress = "31";
+      break;
+    case "30":
+      tileAddress = "22";
+      break;
+    case "31":
+      tileAddress = "23";
+      break;
+    case "32":
+      tileAddress = "32";
+      break;
+    case "33":
+      tileAddress = "33";
+      break;
+    // shouldn't happen
+    default:
+      tileAddress = null;
+      break;
+    }
+    return tileAddress;
+  }
+  public enum CubefaceType {
+    ONE(1), FOUR(4), SIXTEEN(16);
+    private static final Map<Integer, CubefaceType> map = new HashMap<>();
+    static {
+      for (CubefaceType cubefaceType : CubefaceType.values()) {
+        map.put(cubefaceType.value, cubefaceType);
+      }
+    }
+    private final int value;
+    CubefaceType(int value) {
+      this.value = value;
+    }
+    public static CubefaceType valueOf(int cubefaceType) {
+      return map.get(cubefaceType);
+    }
+    public int getValue() {
+      return value;
+    }
+  }
+  public enum CubemapFaces {
+    FRONT("01"), RIGHT("02"), BACK("03"), LEFT("10"), UP("11"), DOWN("12");
+    private final String value;
+    CubemapFaces(String value) {
+      this.value = value;
+    }
+    public static Stream<CubemapFaces> stream() {
+      return Stream.of(CubemapFaces.values());
+    }
+    public String getValue() {
+      return value;
+    }
+  }
+}

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/cubemap/ITileDownloadingTaskListener.java

-              r34428
+              r36194
 //License: GPL. For details, see LICENSE file.
+// License: GPL. For details, see LICENSE file.
 package org.openstreetmap.josm.plugins.streetside.cubemap;
 …
 public interface ITileDownloadingTaskListener {
+ /**
+ * Fired when a cubemap tile image is downloaded by a download worker.
+ * @param imageId image id
+ */
+ void tileAdded(String imageId);
+  /**
+   * Fired when a cubemap tile image is downloaded by a download worker.
+   *
+   * @param imageId image id
+   */
+  void tileAdded(String imageId);
+}

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/cubemap/TileDownloadingTask.java

-              r34428
+              r36194
 import java.util.concurrent.Callable;
 import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.logging.Logger;
 import javax.imageio.ImageIO;
-import org.apache.log4j.Logger;
 import org.openstreetmap.josm.plugins.streetside.cache.StreetsideCache;
 import org.openstreetmap.josm.plugins.streetside.utils.StreetsideProperties;
 import org.openstreetmap.josm.plugins.streetside.utils.StreetsideURL;
+import us.monoid.web.Resty;
+import org.openstreetmap.josm.tools.Logging;
 public class TileDownloadingTask implements Callable<List<String>> {
+  final static Logger logger = Logger.getLogger(TileDownloadingTask.class);
+  private static final Logger LOGGER = Logger.getLogger(TileDownloadingTask.class.getCanonicalName());
+  /**
+   * Listeners of the class.
+   */
+  private final List<ITileDownloadingTaskListener> listeners = new CopyOnWriteArrayList<>();
+  protected CubemapBuilder cb;
+  boolean cancelled;
+  private String tileId;
+  private StreetsideCache cache;
+        private String tileId;
+        private StreetsideCache cache;
+        protected CubemapBuilder cb;
+  public TileDownloadingTask(String id) {
+    tileId = id;
+    cb = CubemapBuilder.getInstance();
+    addListener(CubemapBuilder.getInstance());
+  }
+        /**
+           * Listeners of the class.
+           */
+    private final List<ITileDownloadingTaskListener> listeners = new CopyOnWriteArrayList<>();
+  /**
+   * Adds a new listener.
+   *
+   * @param lis Listener to be added.
+   */
+  public final void addListener(final ITileDownloadingTaskListener lis) {
+    listeners.add(lis);
+  }
+        boolean cancelled = false;
+  /**
+   * @return the tileId
+   */
+  public String getId() {
+    return tileId;
+  }
+        public TileDownloadingTask(String id) {
+                tileId = id;
+                cb = CubemapBuilder.getInstance();
+                addListener(CubemapBuilder.getInstance());
+        }
+  /**
+   * @param id the tileId to set
+   */
+  public void setId(String id) {
+    tileId = id;
+  }
+        /**
+           * Adds a new listener.
+           *
+           * @param lis Listener to be added.
+           */
+        public final void addListener(final ITileDownloadingTaskListener lis) {
+            listeners.add(lis);
+        }
+  /**
+   * @return the cache
+   */
+  public StreetsideCache getCache() {
+    return cache;
+  }
         /**
+         * @return the tileId
          */
         public String getId() {
                 return tileId;
+        }
+  /**
+   * @param cache the cache to set
+   */
+  public void setCache(StreetsideCache cache) {
+    this.cache = cache;
+  }
         /**
+         * @param id the tileId to set
          */
         public void setId(String id) {
                 tileId = id;
+        }
+  /**
+   * @return the cb
+   */
+  public CubemapBuilder getCb() {
+    return cb;
+  }
         /**
+         * @return the cache
          */
         public StreetsideCache getCache() {
                 return cache;
+        }
+  /**
+   * @param cb the cb to set
+   */
+  public void setCb(CubemapBuilder cb) {
+    this.cb = cb;
+  }
+        /**
+         * @param cache the cache to set
+         */
+        public void setCache(StreetsideCache cache) {
+                this.cache = cache;
+        }
+        /**
+         * @return the cb
+         */
+        public CubemapBuilder getCb() {
+                return cb;
+        }
+        /**
+         * @param cb the cb to set
+         */
+        public void setCb(CubemapBuilder cb) {
+                this.cb = cb;
+        }
+        /**
+         * @param cancelled the cancelled to set
+         */
+        public void setCancelled(boolean cancelled) {
+                this.cancelled = cancelled;
+        }
+  /**
+   * @param cancelled the cancelled to set
+   */
+  public void setCancelled(boolean cancelled) {
+    this.cancelled = cancelled;
+  }
   @Override
 …
     List<String> res = new ArrayList<>();
     if (StreetsideProperties.DOWNLOAD_CUBEFACE_TILES_TOGETHER.get()) {
+    if (Boolean.TRUE.equals(StreetsideProperties.DOWNLOAD_CUBEFACE_TILES_TOGETHER.get())) {
       // download all imagery for each cubeface at once
       if (!StreetsideProperties.SHOW_HIGH_RES_STREETSIDE_IMAGERY.get()) {
+      if (Boolean.FALSE.equals(StreetsideProperties.SHOW_HIGH_RES_STREETSIDE_IMAGERY.get())) {
         // download low-res imagery
         int tileNr = 0;
         for (int j = 0; j < CubemapUtils.getMaxCols(); j++) {
           for (int k = 0; k < CubemapUtils.getMaxRows(); k++) {
             String quadKey = String.valueOf(tileId + Integer.valueOf(tileNr++).toString());
+            String quadKey = tileId + tileNr++;
             res.add(downloadTile(quadKey));
+          }
 …
         for (int j = 0; j < CubemapUtils.getMaxCols(); j++) {
           for (int k = 0; k < CubemapUtils.getMaxRows(); k++) {
+            String quadKey = String
+              .valueOf(tileId + String.valueOf(Integer.valueOf(j).toString() + Integer.valueOf(k).toString()));
+            String quadKey = tileId + j + k;
             res.add(downloadTile(quadKey));
+          }
+        }
+      }
     // task downloads just one tile
+      // task downloads just one tile
     } else {
       res.add(downloadTile(tileId));
 …
     try {
+      img = ImageIO
+        .read(new Resty().bytes(StreetsideURL.VirtualEarth.streetsideTile(tileId, false).toExternalForm()).stream());
+      img = ImageIO.read(StreetsideURL.VirtualEarth.streetsideTile(tileId, false));
       if (img == null) {
         logger.error("Download of BufferedImage " + tileId + " is null!");
+        LOGGER.log(Logging.LEVEL_ERROR, "Download of BufferedImage " + tileId + " is null!");
+      }
 …
       fireTileAdded(tileId);
       if (StreetsideProperties.DEBUGING_ENABLED.get()) {
+      if (Boolean.TRUE.equals(StreetsideProperties.DEBUGING_ENABLED.get())) {
         long endTime = System.currentTimeMillis();
         long runTime = (endTime - startTime) / 1000;
+        logger.debug(MessageFormat.format("Loaded image for {0} in {1} seconds.", tileId, runTime));
+        LOGGER.log(Logging.LEVEL_DEBUG,
+            MessageFormat.format("Loaded image for {0} in {1} seconds.", tileId, runTime));
+      }
     } catch (IOException e) {
       logger.error(MessageFormat.format("Error downloading image for tileId {0}", tileId));
+      LOGGER.log(Logging.LEVEL_ERROR, MessageFormat.format("Error downloading image for tileId {0}", tileId), e);
       return null;
+    }
 …
+  }
         private void fireTileAdded(String id) {
             listeners.stream().filter(Objects::nonNull).forEach(lis -> lis.tileAdded(id));
+        }
+  private void fireTileAdded(String id) {
+    listeners.stream().filter(Objects::nonNull).forEach(lis -> lis.tileAdded(id));
+  }
+}

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/gui/StreetsideExportDialog.java

-              r34429
+              r36194
 import org.openstreetmap.josm.plugins.streetside.StreetsideLayer;
 /**
  * GUI for exporting images.
 …
   private static final long serialVersionUID = -2746815082016025516L;
+  /** Button to export all downloaded images. */
+  /**
+   * Button to export all downloaded images.
+   */
   public final JRadioButton all;
   /**
 …
    */
   public final JRadioButton selected;
+  /** Group of button containing all the options. */
+  /**
+   * Group of button containing all the options.
+   */
   public final ButtonGroup group;
   private final JButton choose;
   private final JLabel path;
+  /** File chooser. */
+  private final JButton ok;
+  /**
+   * File chooser.
+   */
   public JFileChooser chooser;
-  private final JButton ok;
   /**
    * Main constructor.
+   *
+   * @param ok
+   *          The button for to OK option.
+   * @param ok The button for to OK option.
    */
   public StreetsideExportDialog(JButton ok) {
 …
     sequence.setEnabled(StreetsideLayer.getInstance().getData().getSelectedImage() instanceof StreetsideImage);
     if (StreetsideLayer.getInstance().getData().getMultiSelectedImages().isEmpty()) {
      selected.setEnabled(false);
+      selected.setEnabled(false);
+    }
 …
   public void actionPerformed(ActionEvent e) {
     chooser = new JFileChooser();
+    chooser.setCurrentDirectory(new java.io.File(System
+        .getProperty("user.home")));
+    chooser.setCurrentDirectory(new java.io.File(System.getProperty("user.home")));
     chooser.setDialogTitle(tr("Select a directory"));
     chooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
 …
+   *
    * @author nokutu
+   *
    */
   public class RewriteButtonAction extends AbstractAction {
     private static final long serialVersionUID = 1035332841101190301L;
-        private String lastPath;
     private final StreetsideExportDialog dlg;
+    private String lastPath;
     /**
      * Main constructor.
+     *
+     * @param dlg
+     *          Parent dialog.
+     * @param dlg Parent dialog.
      */
     public RewriteButtonAction(StreetsideExportDialog dlg) {
 …
     @Override
     public void actionPerformed(ActionEvent arg0) {
+      choose
+          .setEnabled(true);
+      choose.setEnabled(true);
       if (lastPath != null) {
         dlg.path.setText(lastPath);

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/gui/StreetsideImageDisplay.java

-              r34349
+              r36194
 import org.openstreetmap.josm.plugins.streetside.utils.StreetsideProperties;
 /**
  * This object is a responsible JComponent which lets you zoom and drag. It is
 …
   private final Collection<ImageDetection> detections = new ArrayList<>();
+  /** The image currently displayed */
+  /**
+   * The image currently displayed
+   */
   private volatile BufferedImage image;
 …
    */
   private Rectangle selectedRect;
+  /**
+   * Main constructor.
+   */
+  public StreetsideImageDisplay() {
+    ImgDisplayMouseListener mouseListener = new ImgDisplayMouseListener();
+    addMouseListener(mouseListener);
+    addMouseWheelListener(mouseListener);
+    addMouseMotionListener(mouseListener);
+    StreetsideProperties.SHOW_DETECTED_SIGNS.addListener(valChanged -> repaint());
+  }
+  private static Point getCenterImgCoord(Rectangle visibleRect) {
+    return new Point(visibleRect.x + visibleRect.width / 2, visibleRect.y + visibleRect.height / 2);
+  }
+  /**
+   * calculateDrawImageRectangle
+   *
+   * @param imgRect  the part of the image that should be drawn (in image coordinates)
+   * @param compRect the part of the component where the image should be drawn (in
+   *         component coordinates)
+   * @return the part of compRect with the same width/height ratio as the image
+   */
+  private static Rectangle calculateDrawImageRectangle(Rectangle imgRect, Rectangle compRect) {
+    int x = 0;
+    int y = 0;
+    int w = compRect.width;
+    int h = compRect.height;
+    int wFact = w * imgRect.height;
+    int hFact = h * imgRect.width;
+    if (wFact != hFact) {
+      if (wFact > hFact) {
+        w = hFact / imgRect.height;
+        x = (compRect.width - w) / 2;
+      } else {
+        h = wFact / imgRect.width;
+        y = (compRect.height - h) / 2;
+      }
+    }
+    return new Rectangle(x + compRect.x, y + compRect.y, w, h);
+  }
+  private static void checkVisibleRectPos(Image image, Rectangle visibleRect) {
+    if (visibleRect.x < 0) {
+      visibleRect.x = 0;
+    }
+    if (visibleRect.y < 0) {
+      visibleRect.y = 0;
+    }
+    if (visibleRect.x + visibleRect.width > image.getWidth(null)) {
+      visibleRect.x = image.getWidth(null) - visibleRect.width;
+    }
+    if (visibleRect.y + visibleRect.height > image.getHeight(null)) {
+      visibleRect.y = image.getHeight(null) - visibleRect.height;
+    }
+  }
+  private static void checkVisibleRectSize(Image image, Rectangle visibleRect) {
+    if (visibleRect.width > image.getWidth(null)) {
+      visibleRect.width = image.getWidth(null);
+    }
+    if (visibleRect.height > image.getHeight(null)) {
+      visibleRect.height = image.getHeight(null);
+    }
+  }
+  /**
+   * Sets a new picture to be displayed.
+   *
+   * @param image    The picture to be displayed.
+   * @param detections image detections
+   */
+  public void setImage(BufferedImage image, Collection<ImageDetection> detections) {
+    synchronized (this) {
+      this.image = image;
+      this.detections.clear();
+      if (detections != null) {
+        this.detections.addAll(detections);
+      }
+      selectedRect = null;
+      if (image != null)
+        visibleRect = new Rectangle(0, 0, image.getWidth(null), image.getHeight(null));
+    }
+    repaint();
+  }
+  /**
+   * Returns the picture that is being displayed
+   *
+   * @return The picture that is being displayed.
+   */
+  public BufferedImage getImage() {
+    return image;
+  }
+  /**
+   * Paints the visible part of the picture.
+   */
+  @Override
+  public void paintComponent(Graphics g) {
+    Image image;
+    Rectangle visibleRect;
+    synchronized (this) {
+      image = this.image;
+      visibleRect = this.visibleRect;
+    }
+    if (image == null) {
+      g.setColor(Color.black);
+      String noImageStr = StreetsideLayer.hasInstance() ? tr("No image selected")
+          : tr("Press \"{0}\" to download images", StreetsideDownloadAction.SHORTCUT.getKeyText());
+      Rectangle2D noImageSize = g.getFontMetrics(g.getFont()).getStringBounds(noImageStr, g);
+      Dimension size = getSize();
+      g.drawString(noImageStr, (int) ((size.width - noImageSize.getWidth()) / 2),
+          (int) ((size.height - noImageSize.getHeight()) / 2));
+    } else {
+      Rectangle target = calculateDrawImageRectangle(visibleRect);
+      g.drawImage(image, target.x, target.y, target.x + target.width, target.y + target.height, visibleRect.x,
+          visibleRect.y, visibleRect.x + visibleRect.width, visibleRect.y + visibleRect.height, null);
+      if (selectedRect != null) {
+        Point topLeft = img2compCoord(visibleRect, selectedRect.x, selectedRect.y);
+        Point bottomRight = img2compCoord(visibleRect, selectedRect.x + selectedRect.width,
+            selectedRect.y + selectedRect.height);
+        g.setColor(new Color(128, 128, 128, 180));
+        g.fillRect(target.x, target.y, target.width, topLeft.y - target.y);
+        g.fillRect(target.x, target.y, topLeft.x - target.x, target.height);
+        g.fillRect(bottomRight.x, target.y, target.x + target.width - bottomRight.x, target.height);
+        g.fillRect(target.x, bottomRight.y, target.width, target.y + target.height - bottomRight.y);
+        g.setColor(Color.black);
+        g.drawRect(topLeft.x, topLeft.y, bottomRight.x - topLeft.x, bottomRight.y - topLeft.y);
+      }
+      if (Boolean.TRUE.equals(StreetsideProperties.SHOW_DETECTED_SIGNS.get())) {
+        Point upperLeft = img2compCoord(visibleRect, 0, 0);
+        Point lowerRight = img2compCoord(visibleRect, getImage().getWidth(), getImage().getHeight());
+        // Transformation, which can convert you a Shape relative to the unit square to a Shape relative to the Component
+        AffineTransform unit2compTransform = AffineTransform.getTranslateInstance(upperLeft.getX(),
+            upperLeft.getY());
+        unit2compTransform.concatenate(AffineTransform.getScaleInstance(lowerRight.getX() - upperLeft.getX(),
+            lowerRight.getY() - upperLeft.getY()));
+        final Graphics2D g2d = (Graphics2D) g;
+        g2d.setStroke(new BasicStroke(2));
+        for (ImageDetection d : detections) {
+          final Shape shape = d.getShape().createTransformedShape(unit2compTransform);
+          g2d.setColor(d.isTrafficSign() ? StreetsideColorScheme.IMAGEDETECTION_TRAFFICSIGN
+              : StreetsideColorScheme.IMAGEDETECTION_UNKNOWN);
+          g2d.draw(shape);
+          if (d.isTrafficSign()) {
+            g2d.drawImage(MapObject.getIcon(d.getValue()).getImage(), shape.getBounds().x,
+                shape.getBounds().y, shape.getBounds().width, shape.getBounds().height, null);
+          }
+        }
+      }
+    }
+  }
+  private Point img2compCoord(Rectangle visibleRect, int xImg, int yImg) {
+    Rectangle drawRect = calculateDrawImageRectangle(visibleRect);
+    return new Point(drawRect.x + ((xImg - visibleRect.x) * drawRect.width) / visibleRect.width,
+        drawRect.y + ((yImg - visibleRect.y) * drawRect.height) / visibleRect.height);
+  }
+  private Point comp2imgCoord(Rectangle visibleRect, int xComp, int yComp) {
+    Rectangle drawRect = calculateDrawImageRectangle(visibleRect);
+    return new Point(visibleRect.x + ((xComp - drawRect.x) * visibleRect.width) / drawRect.width,
+        visibleRect.y + ((yComp - drawRect.y) * visibleRect.height) / drawRect.height);
+  }
+  private Rectangle calculateDrawImageRectangle(Rectangle visibleRect) {
+    return calculateDrawImageRectangle(visibleRect, new Rectangle(0, 0, getSize().width, getSize().height));
+  }
+  /**
+   * Zooms to 1:1 and, if it is already in 1:1, to best fit.
+   */
+  public void zoomBestFitOrOne() {
+    Image image;
+    Rectangle visibleRect;
+    synchronized (this) {
+      image = this.image;
+      visibleRect = this.visibleRect;
+    }
+    if (image == null)
+      return;
+    if (visibleRect.width != image.getWidth(null) || visibleRect.height != image.getHeight(null)) {
+      // The display is not at best fit. => Zoom to best fit
+      visibleRect = new Rectangle(0, 0, image.getWidth(null), image.getHeight(null));
+    } else {
+      // The display is at best fit => zoom to 1:1
+      Point center = getCenterImgCoord(visibleRect);
+      visibleRect = new Rectangle(center.x - getWidth() / 2, center.y - getHeight() / 2, getWidth(), getHeight());
+      checkVisibleRectPos(image, visibleRect);
+    }
+    synchronized (this) {
+      this.visibleRect = visibleRect;
+    }
+    repaint();
+  }
   private class ImgDisplayMouseListener implements MouseListener, MouseWheelListener, MouseMotionListener {
 …
         // cursor doesn't move on the image.
         Rectangle drawRect = calculateDrawImageRectangle(visibleRect);
+        visibleRect.x = mousePointInImg.x
+            + ((drawRect.x - e.getX()) * visibleRect.width) / drawRect.width;
+        visibleRect.y = mousePointInImg.y
+            + ((drawRect.y - e.getY()) * visibleRect.height) / drawRect.height;
+        visibleRect.x = mousePointInImg.x + ((drawRect.x - e.getX()) * visibleRect.width) / drawRect.width;
+        visibleRect.y = mousePointInImg.y + ((drawRect.y - e.getY()) * visibleRect.height) / drawRect.height;
         // The position is also limited by the image size
         checkVisibleRectPos(image, visibleRect);
 …
+    }
+    /** Center the display on the point that has been clicked */
+    /**
+     * Center the display on the point that has been clicked
+     */
     @Override
     public void mouseClicked(MouseEvent e) {
 …
       if (image != null && Math.min(getSize().getWidth(), getSize().getHeight()) > 0) {
         if (e.getButton() == StreetsideProperties.PICTURE_OPTION_BUTTON.get()) {
+          if (!StreetsideImageDisplay.this.visibleRect.equals(new Rectangle(0, 0, image.getWidth(null), image.getHeight(null)))) {
+          if (!StreetsideImageDisplay.this.visibleRect
+              .equals(new Rectangle(0, 0, image.getWidth(null), image.getHeight(null)))) {
             // Zooms to 1:1
             StreetsideImageDisplay.this.visibleRect = new Rectangle(0, 0,
                 image.getWidth(null), image.getHeight(null));
+            StreetsideImageDisplay.this.visibleRect = new Rectangle(0, 0, image.getWidth(null),
+                image.getHeight(null));
           } else {
             // Zooms to best fit.
+            StreetsideImageDisplay.this.visibleRect = new Rectangle(
+,
+            StreetsideImageDisplay.this.visibleRect = new Rectangle(0,
                 (image.getHeight(null) - (image.getWidth(null) * getHeight()) / getWidth()) / 2,
+                image.getWidth(null),
+                (image.getWidth(null) * getHeight()) / getWidth()
+            );
+                image.getWidth(null), (image.getWidth(null) * getHeight()) / getWidth());
+          }
           StreetsideImageDisplay.this.repaint();
 …
         Point p = comp2imgCoord(visibleRect, e.getX(), e.getY());
         checkPointInVisibleRect(p, visibleRect);
+        Rectangle rect = new Rectangle(p.x < mousePointInImg.x ? p.x
+            : mousePointInImg.x, p.y < mousePointInImg.y ? p.y
+            : mousePointInImg.y, p.x < mousePointInImg.x ? mousePointInImg.x
+            - p.x : p.x - mousePointInImg.x,
+            p.y < mousePointInImg.y ? mousePointInImg.y - p.y : p.y
+                - mousePointInImg.y);
+        Rectangle rect = new Rectangle(p.x < mousePointInImg.x ? p.x : mousePointInImg.x,
+            p.y < mousePointInImg.y ? p.y : mousePointInImg.y,
+            p.x < mousePointInImg.x ? mousePointInImg.x - p.x : p.x - mousePointInImg.x,
+            p.y < mousePointInImg.y ? mousePointInImg.y - p.y : p.y - mousePointInImg.y);
         checkVisibleRectSize(image, rect);
         checkVisibleRectPos(image, rect);
 …
         // Check that the zoom doesn't exceed 2:1
         if (selectedRect.width < getSize().width / 2) {
                 selectedRect.width = getSize().width / 2;
+          selectedRect.width = getSize().width / 2;
+        }
         if (selectedRect.height < getSize().height / 2) {
                 selectedRect.height = getSize().height / 2;
+          selectedRect.height = getSize().height / 2;
+        }
         // Set the same ratio for the visible rectangle and the display
 …
         // Keep the center of the selection
         if (selectedRect.width != oldWidth) {
                 selectedRect.x -= (selectedRect.width - oldWidth) / 2;
+          selectedRect.x -= (selectedRect.width - oldWidth) / 2;
+        }
         if (selectedRect.height != oldHeight) {
                 selectedRect.y -= (selectedRect.height - oldHeight) / 2;
+          selectedRect.y -= (selectedRect.height - oldHeight) / 2;
+        }
         checkVisibleRectSize(image, selectedRect);
 …
+    }
+  }
-  /**
-   * Main constructor.
-   */
-  public StreetsideImageDisplay() {
-    ImgDisplayMouseListener mouseListener = new ImgDisplayMouseListener();
-    addMouseListener(mouseListener);
-    addMouseWheelListener(mouseListener);
-    addMouseMotionListener(mouseListener);
-    StreetsideProperties.SHOW_DETECTED_SIGNS.addListener(valChanged -> repaint());
+  }
-  /**
-   * Sets a new picture to be displayed.
+   *
-   * @param image The picture to be displayed.
-   * @param detections image detections
-   */
-  public void setImage(BufferedImage image, Collection<ImageDetection> detections) {
-    synchronized (this) {
-      this.image = image;
-      this.detections.clear();
-      if (detections != null) {
-        this.detections.addAll(detections);
+      }
-      selectedRect = null;
-      if (image != null)
-        visibleRect = new Rectangle(0, 0, image.getWidth(null),
-            image.getHeight(null));
+    }
-    repaint();
+  }
-  /**
-   * Returns the picture that is being displayed
+   *
-   * @return The picture that is being displayed.
-   */
-  public BufferedImage getImage() {
-    return image;
+  }
-  /**
-   * Paints the visible part of the picture.
-   */
-  @Override
-  public void paintComponent(Graphics g) {
-    Image image;
-    Rectangle visibleRect;
-    synchronized (this) {
-      image = this.image;
-      visibleRect = this.visibleRect;
+    }
-    if (image == null) {
-      g.setColor(Color.black);
-      String noImageStr = StreetsideLayer.hasInstance() ? tr("No image selected") : tr("Press \"{0}\" to download images", StreetsideDownloadAction.SHORTCUT.getKeyText());
-      Rectangle2D noImageSize = g.getFontMetrics(g.getFont()).getStringBounds(
-          noImageStr, g);
-      Dimension size = getSize();
-      g.drawString(noImageStr,
-          (int) ((size.width - noImageSize.getWidth()) / 2),
-          (int) ((size.height - noImageSize.getHeight()) / 2));
-    } else {
-      Rectangle target = calculateDrawImageRectangle(visibleRect);
-      g.drawImage(image, target.x, target.y, target.x + target.width, target.y
-          + target.height, visibleRect.x, visibleRect.y, visibleRect.x
-          + visibleRect.width, visibleRect.y + visibleRect.height, null);
-      if (selectedRect != null) {
-        Point topLeft = img2compCoord(visibleRect, selectedRect.x,
-            selectedRect.y);
-        Point bottomRight = img2compCoord(visibleRect, selectedRect.x
-            + selectedRect.width, selectedRect.y + selectedRect.height);
-        g.setColor(new Color(128, 128, 128, 180));
-        g.fillRect(target.x, target.y, target.width, topLeft.y - target.y);
-        g.fillRect(target.x, target.y, topLeft.x - target.x, target.height);
-        g.fillRect(bottomRight.x, target.y, target.x + target.width
-            - bottomRight.x, target.height);
-        g.fillRect(target.x, bottomRight.y, target.width, target.y
-            + target.height - bottomRight.y);
-        g.setColor(Color.black);
-        g.drawRect(topLeft.x, topLeft.y, bottomRight.x - topLeft.x,
-            bottomRight.y - topLeft.y);
+      }
-      if (StreetsideProperties.SHOW_DETECTED_SIGNS.get()) {
-        Point upperLeft = img2compCoord(visibleRect, 0, 0);
-        Point lowerRight = img2compCoord(visibleRect, getImage().getWidth(), getImage().getHeight());
-        // Transformation, which can convert you a Shape relative to the unit square to a Shape relative to the Component
-        AffineTransform unit2compTransform = AffineTransform.getTranslateInstance(upperLeft.getX(), upperLeft.getY());
-        unit2compTransform.concatenate(AffineTransform.getScaleInstance(lowerRight.getX() - upperLeft.getX(), lowerRight.getY() - upperLeft.getY()));
-        final Graphics2D g2d = (Graphics2D) g;
-        g2d.setStroke(new BasicStroke(2));
-        for (ImageDetection d : detections) {
-          final Shape shape = d.getShape().createTransformedShape(unit2compTransform);
-          g2d.setColor(d.isTrafficSign() ? StreetsideColorScheme.IMAGEDETECTION_TRAFFICSIGN : StreetsideColorScheme.IMAGEDETECTION_UNKNOWN);
-          g2d.draw(shape);
-          if (d.isTrafficSign()) {
-            g2d.drawImage(
-              MapObject.getIcon(d.getValue()).getImage(),
-              shape.getBounds().x, shape.getBounds().y,
-              shape.getBounds().width, shape.getBounds().height,
-              null
-            );
+          }
+        }
+      }
+    }
+  }
-  private Point img2compCoord(Rectangle visibleRect, int xImg, int yImg) {
-    Rectangle drawRect = calculateDrawImageRectangle(visibleRect);
-    return new Point(drawRect.x + ((xImg - visibleRect.x) * drawRect.width)
-        / visibleRect.width, drawRect.y
-        + ((yImg - visibleRect.y) * drawRect.height) / visibleRect.height);
+  }
-  private Point comp2imgCoord(Rectangle visibleRect, int xComp, int yComp) {
-    Rectangle drawRect = calculateDrawImageRectangle(visibleRect);
-    return new Point(
-        visibleRect.x + ((xComp - drawRect.x) * visibleRect.width) / drawRect.width,
-        visibleRect.y + ((yComp - drawRect.y) * visibleRect.height) / drawRect.height
-    );
+  }
-  private static Point getCenterImgCoord(Rectangle visibleRect) {
-    return new Point(visibleRect.x + visibleRect.width / 2, visibleRect.y + visibleRect.height / 2);
+  }
-  private Rectangle calculateDrawImageRectangle(Rectangle visibleRect) {
-    return calculateDrawImageRectangle(visibleRect, new Rectangle(0, 0, getSize().width, getSize().height));
+  }
-  /**
-   * calculateDrawImageRectangle
+   *
-   * @param imgRect
-   *          the part of the image that should be drawn (in image coordinates)
-   * @param compRect
-   *          the part of the component where the image should be drawn (in
-   *          component coordinates)
-   * @return the part of compRect with the same width/height ratio as the image
-   */
-  private static Rectangle calculateDrawImageRectangle(Rectangle imgRect, Rectangle compRect) {
-    int x = 0;
-    int y = 0;
-    int w = compRect.width;
-    int h = compRect.height;
-    int wFact = w * imgRect.height;
-    int hFact = h * imgRect.width;
-    if (wFact != hFact) {
-      if (wFact > hFact) {
-        w = hFact / imgRect.height;
-        x = (compRect.width - w) / 2;
-      } else {
-        h = wFact / imgRect.width;
-        y = (compRect.height - h) / 2;
+      }
+    }
-    return new Rectangle(x + compRect.x, y + compRect.y, w, h);
+  }
-  /**
-   * Zooms to 1:1 and, if it is already in 1:1, to best fit.
-   */
-  public void zoomBestFitOrOne() {
-    Image image;
-    Rectangle visibleRect;
-    synchronized (this) {
-      image = this.image;
-      visibleRect = this.visibleRect;
+    }
-    if (image == null)
-      return;
-    if (visibleRect.width != image.getWidth(null)
-        || visibleRect.height != image.getHeight(null)) {
-      // The display is not at best fit. => Zoom to best fit
-      visibleRect = new Rectangle(0, 0, image.getWidth(null),
-          image.getHeight(null));
-    } else {
-      // The display is at best fit => zoom to 1:1
-      Point center = getCenterImgCoord(visibleRect);
-      visibleRect = new Rectangle(center.x - getWidth() / 2, center.y
-          - getHeight() / 2, getWidth(), getHeight());
-      checkVisibleRectPos(image, visibleRect);
+    }
-    synchronized (this) {
-      this.visibleRect = visibleRect;
+    }
-    repaint();
+  }
-  private static void checkVisibleRectPos(Image image, Rectangle visibleRect) {
-    if (visibleRect.x < 0) {
-      visibleRect.x = 0;
+    }
-    if (visibleRect.y < 0) {
-      visibleRect.y = 0;
+    }
-    if (visibleRect.x + visibleRect.width > image.getWidth(null)) {
-      visibleRect.x = image.getWidth(null) - visibleRect.width;
+    }
-    if (visibleRect.y + visibleRect.height > image.getHeight(null)) {
-      visibleRect.y = image.getHeight(null) - visibleRect.height;
+    }
+  }
-  private static void checkVisibleRectSize(Image image, Rectangle visibleRect) {
-    if (visibleRect.width > image.getWidth(null)) {
-      visibleRect.width = image.getWidth(null);
+    }
-    if (visibleRect.height > image.getHeight(null)) {
-      visibleRect.height = image.getHeight(null);
+    }
+  }
+}

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/gui/StreetsideImageTreeCellRenderer.java

-              r34317
+              r36194
   @Override
+  public Component getTreeCellRendererComponent(
+    JTree tree, Object value, boolean sel, boolean expanded, boolean leaf, int row, boolean hasFocus
+  ) {
+  public Component getTreeCellRendererComponent(JTree tree, Object value, boolean sel, boolean expanded, boolean leaf,
+      int row, boolean hasFocus) {
     super.getTreeCellRendererComponent(tree, value.toString(), sel, expanded, leaf, row, hasFocus);
     setIcon(ICON);

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/gui/StreetsideMainDialog.java

-              r35202
+              r36194
 import java.util.Arrays;
 import java.util.List;
+import java.util.logging.Logger;
 import javax.imageio.ImageIO;
 …
 import javax.swing.SwingUtilities;
-import org.apache.log4j.Logger;
 import org.openstreetmap.josm.data.cache.CacheEntry;
 import org.openstreetmap.josm.data.cache.CacheEntryAttributes;
 …
 import org.openstreetmap.josm.tools.I18n;
 import org.openstreetmap.josm.tools.ImageProvider;
+import org.openstreetmap.josm.tools.Logging;
 /**
 …
  * @author renerr18
  */
+public final class StreetsideMainDialog extends ToggleDialog implements
+                ICachedLoaderListener, StreetsideDataListener {
+        private static final long serialVersionUID = 2645654786827812861L;
+  final static Logger logger = Logger.getLogger(StreetsideMainDialog.class);
+public final class StreetsideMainDialog extends ToggleDialog implements ICachedLoaderListener, StreetsideDataListener {
   public static final String BASE_TITLE = I18n.marktr("Microsoft Streetside image");
+        private static final String MESSAGE_SEPARATOR = " — ";
+        private static StreetsideMainDialog instance;
+        private volatile StreetsideAbstractImage image;
+        private final SideButton nextButton = new SideButton(new NextPictureAction());
+  private static final long serialVersionUID = 2645654786827812861L;
+  private static final Logger LOGGER = Logger.getLogger(StreetsideMainDialog.class.getCanonicalName());
+  private static final String MESSAGE_SEPARATOR = " — ";
+  private static StreetsideMainDialog instance;
+  /**
+   * Button used to jump to the image following the red line
+   */
+  public final SideButton redButton = new SideButton(new RedAction());
+  /**
+   * Button used to jump to the image following the blue line
+   */
+  public final SideButton blueButton = new SideButton(new BlueAction());
+  private final SideButton nextButton = new SideButton(new NextPictureAction());
   private final SideButton previousButton = new SideButton(new PreviousPictureAction());
-  /**
-   * Button used to jump to the image following the red line
-   */
-  public final SideButton redButton = new SideButton(new RedAction());
-  /**
-   * Button used to jump to the image following the blue line
-   */
-  public final SideButton blueButton = new SideButton(new BlueAction());
   private final SideButton playButton = new SideButton(new PlayAction());
   private final SideButton pauseButton = new SideButton(new PauseAction());
   private final SideButton stopButton = new SideButton(new StopAction());
+  /**
+   * Object containing the shown image and that handles zoom and drag
+   */
+  public StreetsideImageDisplay streetsideImageDisplay;
+  public StreetsideCache thumbnailCache;
+  private volatile StreetsideAbstractImage image;
   private ImageInfoHelpPopup imageInfoHelp;
+        /**
+         * Buttons mode.
+         *
+         * @author nokutu
+         */
+        public enum MODE {
+                /**
+                 * Standard mode to view pictures.
+                 */
+                NORMAL,
+                /**
+                 * Mode when in walk.
+                 */
+                WALK
+        }
+        /**
+         * Object containing the shown image and that handles zoom and drag
+         */
+        public StreetsideImageDisplay streetsideImageDisplay;
+        private StreetsideCache imageCache;
+        public StreetsideCache thumbnailCache;
+        private StreetsideMainDialog() {
+                super(I18n.tr(StreetsideMainDialog.BASE_TITLE), "streetside-main", I18n.tr("Open Streetside window"), null, 200,
+                                true, StreetsidePreferenceSetting.class);
+                addShortcuts();
+                streetsideImageDisplay = new StreetsideImageDisplay();
+                blueButton.setForeground(Color.BLUE);
+  private StreetsideCache imageCache;
+  private StreetsideMainDialog() {
+    super(I18n.tr(StreetsideMainDialog.BASE_TITLE), "streetside-main", I18n.tr("Open Streetside window"), null, 200,
+        true, StreetsidePreferenceSetting.class);
+    addShortcuts();
+    streetsideImageDisplay = new StreetsideImageDisplay();
+    blueButton.setForeground(Color.BLUE);
     redButton.setForeground(Color.RED);
+                setMode(MODE.NORMAL);
+        }
+        /**
+         * Adds the shortcuts to the buttons.
+         */
+    setMode(MODE.NORMAL);
+  }
+  /**
+   * Returns the unique instance of the class.
+   *
+   * @return The unique instance of the class.
+   */
+  public static synchronized StreetsideMainDialog getInstance() {
+    if (StreetsideMainDialog.instance == null) {
+      StreetsideMainDialog.instance = new StreetsideMainDialog();
+    }
+    return StreetsideMainDialog.instance;
+  }
+  /**
+   * @return true, iff the singleton instance is present
+   */
+  public static boolean hasInstance() {
+    return StreetsideMainDialog.instance != null;
+  }
+  /**
+   * Destroys the unique instance of the class.
+   */
+  public static synchronized void destroyInstance() {
+    StreetsideMainDialog.instance = null;
+  }
+  /**
+   * Adds the shortcuts to the buttons.
+   */
   private void addShortcuts() {
     nextButton.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(KeyStroke.getKeyStroke("PAGE_DOWN"), "next");
     nextButton.getActionMap().put("next", new NextPictureAction());
+    previousButton.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(KeyStroke.getKeyStroke("PAGE_UP"), "previous");
+    previousButton.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(KeyStroke.getKeyStroke("PAGE_UP"),
+        "previous");
     previousButton.getActionMap().put("previous", new PreviousPictureAction());
+    blueButton.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(KeyStroke.getKeyStroke("control PAGE_UP"), "blue");
+    blueButton.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(KeyStroke.getKeyStroke("control PAGE_UP"),
+        "blue");
     blueButton.getActionMap().put("blue", new BlueAction());
+    redButton.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(KeyStroke.getKeyStroke("control PAGE_DOWN"), "red");
+    redButton.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(KeyStroke.getKeyStroke("control PAGE_DOWN"),
+        "red");
     redButton.getActionMap().put("red", new RedAction());
+  }
+        /**
+         * Returns the unique instance of the class.
+         *
+         * @return The unique instance of the class.
+         */
+        public static synchronized StreetsideMainDialog getInstance() {
+                if (StreetsideMainDialog.instance == null) {
+                        StreetsideMainDialog.instance = new StreetsideMainDialog();
+                }
+                return StreetsideMainDialog.instance;
+        }
+        /**
+         * @return true, iff the singleton instance is present
+         */
+        public static boolean hasInstance() {
+                return StreetsideMainDialog.instance != null;
+        }
+        public synchronized void setImageInfoHelp(ImageInfoHelpPopup popup) {
+                imageInfoHelp = popup;
+        }
+        /**
+         * Sets a new mode for the dialog.
+         *
+         * @param mode The mode to be set. Must not be {@code null}.
+         */
+        public void setMode(MODE mode) {
+                switch (mode) {
+                case WALK:
+      createLayout(
+        streetsideImageDisplay,
+        Arrays.asList(playButton, pauseButton, stopButton)
+      );
+  public synchronized void setImageInfoHelp(ImageInfoHelpPopup popup) {
+    imageInfoHelp = popup;
+  }
+  /**
+   * Sets a new mode for the dialog.
+   *
+   * @param mode The mode to be set. Must not be {@code null}.
+   */
+  public void setMode(MODE mode) {
+    switch (mode) {
+    case WALK:
+      createLayout(streetsideImageDisplay, Arrays.asList(playButton, pauseButton, stopButton));
       break;
     case NORMAL:
     default:
+      createLayout(
+        streetsideImageDisplay,
+        Arrays.asList(blueButton, previousButton, nextButton, redButton)
+      );
+      createLayout(streetsideImageDisplay, Arrays.asList(blueButton, previousButton, nextButton, redButton));
       break;
+                }
                 disableAllButtons();
     if (MODE.NORMAL.equals(mode)) {
+    }
+    disableAllButtons();
+    if (MODE.NORMAL == mode) {
       updateImage();
+    }
     revalidate();
     repaint();
+        }
+        /**
+         * Destroys the unique instance of the class.
+         */
+        public static synchronized void destroyInstance() {
+                StreetsideMainDialog.instance = null;
+        }
+        /**
+         * Downloads the full quality picture of the selected StreetsideImage and sets
+         * in the StreetsideImageDisplay object.
+         */
+        public synchronized void updateImage() {
+                updateImage(true);
+        }
+        /**
+         * Downloads the picture of the selected StreetsideImage and sets in the
+         * StreetsideImageDisplay object.
+         *
+         * @param fullQuality If the full quality picture must be downloaded or just the
+         *                    thumbnail.
+         */
+        public synchronized void updateImage(boolean fullQuality) {
+                if (!SwingUtilities.isEventDispatchThread()) {
+                        SwingUtilities.invokeLater(this::updateImage);
+                } else {
+                        if (!StreetsideLayer.hasInstance()) {
+                                return;
+                        }
+                        if (image == null) {
+                                streetsideImageDisplay.setImage(null, null);
+                                setTitle(I18n.tr(StreetsideMainDialog.BASE_TITLE));
+                                return;
+                        }
+                        if (imageInfoHelp != null && StreetsideProperties.IMAGEINFO_HELP_COUNTDOWN.get() > 0 && imageInfoHelp.showPopup()) {
+                                // Count down the number of times the popup will be displayed
+                                StreetsideProperties.IMAGEINFO_HELP_COUNTDOWN.put(StreetsideProperties.IMAGEINFO_HELP_COUNTDOWN.get() - 1);
+                        }
+                        if (image instanceof StreetsideImage) {
+                                final StreetsideImage streetsideImage = (StreetsideImage) image;
+                                // Downloads the thumbnail.
+                                streetsideImageDisplay.setImage(null, null);
+                                if (thumbnailCache != null) {
+                                        thumbnailCache.cancelOutstandingTasks();
+                                }
+                                thumbnailCache = new StreetsideCache(streetsideImage.getId(),
+                                                StreetsideCache.Type.THUMBNAIL);
+                                try {
+                                        thumbnailCache.submit(this, false);
+                                } catch (final IOException e) {
+                                        logger.error(e);
+                                }
+                                // Downloads the full resolution image.
+                                if (fullQuality || new StreetsideCache(streetsideImage.getId(),
+                                                StreetsideCache.Type.FULL_IMAGE).get() != null) {
+                                        if (imageCache != null) {
+                                                imageCache.cancelOutstandingTasks();
+                                        }
+                                        imageCache = new StreetsideCache(streetsideImage.getId(),
+                                                        StreetsideCache.Type.FULL_IMAGE);
+                                        try {
+                                                imageCache.submit(this, false);
+                                        } catch (final IOException e) {
+                                                logger.error(e);
+                                        }
+                                }
+                        }
+                        updateTitle();
+                }
+        }
+        /**
+  }
+  /**
+   * Downloads the full quality picture of the selected StreetsideImage and sets
+   * in the StreetsideImageDisplay object.
+   */
+  public synchronized void updateImage() {
+    updateImage(true);
+  }
+  /**
+   * Downloads the picture of the selected StreetsideImage and sets in the
+   * StreetsideImageDisplay object.
+   *
+   * @param fullQuality If the full quality picture must be downloaded or just the
+   *          thumbnail.
+   */
+  public synchronized void updateImage(boolean fullQuality) {
+    if (!SwingUtilities.isEventDispatchThread()) {
+      SwingUtilities.invokeLater(this::updateImage);
+    } else {
+      if (!StreetsideLayer.hasInstance()) {
+        return;
+      }
+      if (image == null) {
+        streetsideImageDisplay.setImage(null, null);
+        setTitle(I18n.tr(StreetsideMainDialog.BASE_TITLE));
+        return;
+      }
+      if (imageInfoHelp != null && StreetsideProperties.IMAGEINFO_HELP_COUNTDOWN.get() > 0
+          && imageInfoHelp.showPopup()) {
+        // Count down the number of times the popup will be displayed
+        StreetsideProperties.IMAGEINFO_HELP_COUNTDOWN
+            .put(StreetsideProperties.IMAGEINFO_HELP_COUNTDOWN.get() - 1);
+      }
+      if (image instanceof StreetsideImage) {
+        final StreetsideImage streetsideImage = (StreetsideImage) image;
+        // Downloads the thumbnail.
+        streetsideImageDisplay.setImage(null, null);
+        if (thumbnailCache != null) {
+          thumbnailCache.cancelOutstandingTasks();
+        }
+        thumbnailCache = new StreetsideCache(streetsideImage.getId(), StreetsideCache.Type.THUMBNAIL);
+        try {
+          thumbnailCache.submit(this, false);
+        } catch (final IOException e) {
+          LOGGER.log(Logging.LEVEL_ERROR, e.getMessage(), e);
+        }
+        // Downloads the full resolution image.
+        if (fullQuality || new StreetsideCache(streetsideImage.getId(), StreetsideCache.Type.FULL_IMAGE)
+            .get() != null) {
+          if (imageCache != null) {
+            imageCache.cancelOutstandingTasks();
+          }
+          imageCache = new StreetsideCache(streetsideImage.getId(), StreetsideCache.Type.FULL_IMAGE);
+          try {
+            imageCache.submit(this, false);
+          } catch (final IOException e) {
+            LOGGER.log(Logging.LEVEL_ERROR, e.getMessage(), e);
+          }
+        }
+      }
+      updateTitle();
+    }
+  }
+  /**
    * Disables all the buttons in the dialog
    */
 …
+  }
+        /**
+         * Sets a new StreetsideImage to be shown.
+         *
+         * @param image The image to be shown.
+         */
+        public synchronized void setImage(StreetsideAbstractImage image) {
+                this.image = image;
+        }
+        /**
+         * Updates the title of the dialog.
+         */
+        public synchronized void updateTitle() {
+                if (!SwingUtilities.isEventDispatchThread()) {
+                        SwingUtilities.invokeLater(this::updateTitle);
+                } else if (image != null) {
+                        final StringBuilder title = new StringBuilder(I18n.tr(StreetsideMainDialog.BASE_TITLE));
+                        if (image instanceof StreetsideImage) {
+                                title.append(StreetsideMainDialog.MESSAGE_SEPARATOR).append(MessageFormat.format("(heading {0}°)",Double.toString(image.getHe())));
+  /**
+   * Updates the title of the dialog.
+   */
+  public synchronized void updateTitle() {
+    if (!SwingUtilities.isEventDispatchThread()) {
+      SwingUtilities.invokeLater(this::updateTitle);
+    } else if (image != null) {
+      final StringBuilder title = new StringBuilder(I18n.tr(StreetsideMainDialog.BASE_TITLE));
+      if (image instanceof StreetsideImage) {
+        title.append(StreetsideMainDialog.MESSAGE_SEPARATOR)
+            .append(MessageFormat.format("(heading {0}°)", Double.toString(image.getHe())));
         setTitle(title.toString());
+                        }
+                }
+        }
+        /**
+         * Returns the {@link StreetsideAbstractImage} object which is being shown.
+         *
+         * @return The {@link StreetsideAbstractImage} object which is being shown.
+         */
+        public synchronized StreetsideAbstractImage getImage() {
+                return image;
+        }
+        /**
+         * Action class form the next image button.
+         *
+         * @author nokutu
+         */
+        private static class NextPictureAction extends AbstractAction {
+                private static final long serialVersionUID = 6333692154558730392L;
+                /**
+                 * Constructs a normal NextPictureAction
+                 */
+                NextPictureAction() {
+                        super(I18n.tr("Next picture"));
+                        putValue(Action.SHORT_DESCRIPTION, I18n.tr("Shows the next picture in the sequence"));
+                        new ImageProvider("help", "next").getResource().attachImageIcon(this, true);
+                }
+                @Override
+                public void actionPerformed(ActionEvent e) {
+                        StreetsideLayer.getInstance().getData().selectNext();
+                }
+        }
+        /**
+         * Action class for the previous image button.
+         *
+         * @author nokutu
+         */
+        private static class PreviousPictureAction extends AbstractAction {
+                private static final long serialVersionUID = 4390593660514657107L;
+                /**
+                 * Constructs a normal PreviousPictureAction
+                 */
+                PreviousPictureAction() {
+                        super(I18n.tr("Previous picture"));
+                        putValue(Action.SHORT_DESCRIPTION, I18n.tr("Shows the previous picture in the sequence"));
+                        new ImageProvider("help", "previous").getResource().attachImageIcon(this, true);
+                }
+                @Override
+                public void actionPerformed(ActionEvent e) {
+                        StreetsideLayer.getInstance().getData().selectPrevious();
+                }
+        }
+        /**
+         * Action class to jump to the image following the red line.
+         *
+         * @author nokutu
+         */
+        private static class RedAction extends AbstractAction {
+                private static final long serialVersionUID = -1244456062285831231L;
+                /**
+                 * Constructs a normal RedAction
+                 */
+                RedAction() {
+                        putValue(Action.NAME, I18n.tr("Jump to red"));
+                        putValue(Action.SHORT_DESCRIPTION,
+                                        I18n.tr("Jumps to the picture at the other side of the red line"));
+                        new ImageProvider("dialogs", "red").getResource().attachImageIcon(this, true);
+                }
+                @Override
+                public void actionPerformed(ActionEvent e) {
+                        if (StreetsideMainDialog.getInstance().getImage() != null) {
+                                StreetsideLayer.getInstance().getData()
+                                .setSelectedImage(StreetsideLayer.getInstance().getNNearestImage(1), true);
+                        }
+                }
+        }
+        /**
+         * Action class to jump to the image following the blue line.
+         *
+         * @author nokutu
+         */
+        private static class BlueAction extends AbstractAction {
+                private static final long serialVersionUID = 5951233534212838780L;
+                /**
+                 * Constructs a normal BlueAction
+                 */
+                BlueAction() {
+                        putValue(Action.NAME, I18n.tr("Jump to blue"));
+                        putValue(Action.SHORT_DESCRIPTION,
+                                        I18n.tr("Jumps to the picture at the other side of the blue line"));
+                        new ImageProvider("dialogs", "blue").getResource().attachImageIcon(this, true);
+                }
+                @Override
+                public void actionPerformed(ActionEvent e) {
+                        if (StreetsideMainDialog.getInstance().getImage() != null) {
+                                StreetsideLayer.getInstance().getData()
+                                .setSelectedImage(StreetsideLayer.getInstance().getNNearestImage(2), true);
+                        }
+                }
+        }
+        private static class StopAction extends AbstractAction implements WalkListener {
+                private static final long serialVersionUID = 8789972456611625341L;
+                private WalkThread thread;
+                /**
+                 * Constructs a normal StopAction
+                 */
+                StopAction() {
+                        putValue(Action.NAME, I18n.tr("Stop"));
+                        putValue(Action.SHORT_DESCRIPTION, I18n.tr("Stops the walk."));
+                        new ImageProvider("dialogs/streetsideStop.png").getResource().attachImageIcon(this, true);
+                        StreetsidePlugin.getStreetsideWalkAction().addListener(this);
+                }
+                @Override
+                public void actionPerformed(ActionEvent e) {
+                        if (thread != null) {
+                                thread.stopWalk();
+                        }
+                }
+                @Override
+                public void walkStarted(WalkThread thread) {
+                        this.thread = thread;
+                }
+        }
+        private static class PlayAction extends AbstractAction implements WalkListener {
+                private static final long serialVersionUID = -1572747020946842769L;
+                private transient WalkThread thread;
+                /**
+                 * Constructs a normal PlayAction
+                 */
+                PlayAction() {
+                        putValue(Action.NAME, I18n.tr("Play"));
+                        putValue(Action.SHORT_DESCRIPTION, I18n.tr("Continues with the paused walk."));
+                        new ImageProvider("dialogs/streetsidePlay.png").getResource().attachImageIcon(this, true);
+                        StreetsidePlugin.getStreetsideWalkAction().addListener(this);
+                }
+                @Override
+                public void actionPerformed(ActionEvent e) {
+                        if (thread != null) {
+                                thread.play();
+                        }
+                }
+                @Override
+                public void walkStarted(WalkThread thread) {
+                        if (thread != null) {
+                                this.thread = thread;
+                        }
+                }
+        }
+        private static class PauseAction extends AbstractAction implements WalkListener {
+                /**
+                 *
+                 */
+                private static final long serialVersionUID = -8758326399460817222L;
+                private WalkThread thread;
+                /**
+                 * Constructs a normal PauseAction
+                 */
+                PauseAction() {
+                        putValue(Action.NAME, I18n.tr("Pause"));
+                        putValue(Action.SHORT_DESCRIPTION, I18n.tr("Pauses the walk."));
+                        new ImageProvider("dialogs/streetsidePause.png").getResource().attachImageIcon(this, true);
+                        StreetsidePlugin.getStreetsideWalkAction().addListener(this);
+                }
+                @Override
+                public void actionPerformed(ActionEvent e) {
+                        thread.pause();
+                }
+                @Override
+                public void walkStarted(WalkThread thread) {
+                        this.thread = thread;
+                }
+        }
+        /**
+         * When the pictures are returned from the cache, they are set in the
+         * {@link StreetsideImageDisplay} object.
+         */
+        @Override
+        public void loadingFinished(final CacheEntry data, final CacheEntryAttributes attributes, final LoadResult result) {
+                if (!SwingUtilities.isEventDispatchThread()) {
+                        SwingUtilities.invokeLater(() -> loadingFinished(data, attributes, result));
+                } else if (data != null && result == LoadResult.SUCCESS) {
+                        try {
+                                final BufferedImage img = ImageIO.read(new ByteArrayInputStream(data.getContent()));
+                                if (img == null) {
+                                        return;
+                                }
+                                if (
+                                                streetsideImageDisplay.getImage() == null
+                                                || img.getHeight() > streetsideImageDisplay.getImage().getHeight()
+                                                ) {
+                                        streetsideImageDisplay.setImage(
+                                                        img,
+                                                        null);
+                                }
+                        } catch (final IOException e) {
+                                logger.error(e);
+                        }
+                }
+        }
+        /**
+         * Creates the layout of the dialog.
+         *
+         * @param data    The content of the dialog
+         * @param buttons The buttons where you can click
+         */
+        public void createLayout(Component data, List<SideButton> buttons) {
+                removeAll();
+                createLayout(data, true, buttons);
+                add(titleBar, BorderLayout.NORTH);
+        }
+        @Override
+        public void selectedImageChanged(StreetsideAbstractImage oldImage, StreetsideAbstractImage newImage) {
+                setImage(newImage);
+                if (newImage != null && newImage.getSequence() != null) {
+                if (newImage.next() != null) {
+                    nextButton.setEnabled(true);
+                }
+                if (newImage.previous() != null) {
+                    previousButton.setEnabled(true);
+                }
+      }
+    }
+  }
+  /**
+   * Returns the {@link StreetsideAbstractImage} object which is being shown.
+   *
+   * @return The {@link StreetsideAbstractImage} object which is being shown.
+   */
+  public synchronized StreetsideAbstractImage getImage() {
+    return image;
+  }
+  /**
+   * Sets a new StreetsideImage to be shown.
+   *
+   * @param image The image to be shown.
+   */
+  public synchronized void setImage(StreetsideAbstractImage image) {
+    this.image = image;
+  }
+  /**
+   * When the pictures are returned from the cache, they are set in the
+   * {@link StreetsideImageDisplay} object.
+   */
+  @Override
+  public void loadingFinished(final CacheEntry data, final CacheEntryAttributes attributes, final LoadResult result) {
+    if (!SwingUtilities.isEventDispatchThread()) {
+      SwingUtilities.invokeLater(() -> loadingFinished(data, attributes, result));
+    } else if (data != null && result == LoadResult.SUCCESS) {
+      try {
+        final BufferedImage img = ImageIO.read(new ByteArrayInputStream(data.getContent()));
+        if (img == null) {
+          return;
+        }
+                updateImage();
+        }
+        @Override
+        public void imagesAdded() {
+                // This method is enforced by StreetsideDataListener, but only selectedImageChanged() is needed
+        }
+        /**
+         * @return the streetsideImageDisplay
+         */
+        public StreetsideImageDisplay getStreetsideImageDisplay() {
+                return streetsideImageDisplay;
+        }
+        /**
+         * @param streetsideImageDisplay the streetsideImageDisplay to set
+         */
+        public void setStreetsideImageDisplay(StreetsideImageDisplay streetsideImageDisplay) {
+                this.streetsideImageDisplay = streetsideImageDisplay;
+        }
+        if (streetsideImageDisplay.getImage() == null
+            || img.getHeight() > streetsideImageDisplay.getImage().getHeight()) {
+          streetsideImageDisplay.setImage(img, null);
+        }
+      } catch (final IOException e) {
+        LOGGER.log(Logging.LEVEL_ERROR, e.getMessage(), e);
+      }
+    }
+  }
+  /**
+   * Creates the layout of the dialog.
+   *
+   * @param data  The content of the dialog
+   * @param buttons The buttons where you can click
+   */
+  public void createLayout(Component data, List<SideButton> buttons) {
+    removeAll();
+    createLayout(data, true, buttons);
+    add(titleBar, BorderLayout.NORTH);
+  }
+  @Override
+  public void selectedImageChanged(StreetsideAbstractImage oldImage, StreetsideAbstractImage newImage) {
+    setImage(newImage);
+    if (newImage != null && newImage.getSequence() != null) {
+      if (newImage.next() != null) {
+        nextButton.setEnabled(true);
+      }
+      if (newImage.previous() != null) {
+        previousButton.setEnabled(true);
+      }
+    }
+    updateImage();
+  }
+  @Override
+  public void imagesAdded() {
+    // This method is enforced by StreetsideDataListener, but only selectedImageChanged() is needed
+  }
+  /**
+   * @return the streetsideImageDisplay
+   */
+  public StreetsideImageDisplay getStreetsideImageDisplay() {
+    return streetsideImageDisplay;
+  }
+  /**
+   * @param streetsideImageDisplay the streetsideImageDisplay to set
+   */
+  public void setStreetsideImageDisplay(StreetsideImageDisplay streetsideImageDisplay) {
+    this.streetsideImageDisplay = streetsideImageDisplay;
+  }
+  /**
+   * Buttons mode.
+   *
+   * @author nokutu
+   */
+  public enum MODE {
+    /**
+     * Standard mode to view pictures.
+     */
+    NORMAL,
+    /**
+     * Mode when in walk.
+     */
+    WALK
+  }
+  /**
+   * Action class form the next image button.
+   *
+   * @author nokutu
+   */
+  private static class NextPictureAction extends AbstractAction {
+    private static final long serialVersionUID = 6333692154558730392L;
+    /**
+     * Constructs a normal NextPictureAction
+     */
+    NextPictureAction() {
+      super(I18n.tr("Next picture"));
+      putValue(Action.SHORT_DESCRIPTION, I18n.tr("Shows the next picture in the sequence"));
+      new ImageProvider("help", "next").getResource().attachImageIcon(this, true);
+    }
+    @Override
+    public void actionPerformed(ActionEvent e) {
+      StreetsideLayer.getInstance().getData().selectNext();
+    }
+  }
+  /**
+   * Action class for the previous image button.
+   *
+   * @author nokutu
+   */
+  private static class PreviousPictureAction extends AbstractAction {
+    private static final long serialVersionUID = 4390593660514657107L;
+    /**
+     * Constructs a normal PreviousPictureAction
+     */
+    PreviousPictureAction() {
+      super(I18n.tr("Previous picture"));
+      putValue(Action.SHORT_DESCRIPTION, I18n.tr("Shows the previous picture in the sequence"));
+      new ImageProvider("help", "previous").getResource().attachImageIcon(this, true);
+    }
+    @Override
+    public void actionPerformed(ActionEvent e) {
+      StreetsideLayer.getInstance().getData().selectPrevious();
+    }
+  }
+  /**
+   * Action class to jump to the image following the red line.
+   *
+   * @author nokutu
+   */
+  private static class RedAction extends AbstractAction {
+    private static final long serialVersionUID = -1244456062285831231L;
+    /**
+     * Constructs a normal RedAction
+     */
+    RedAction() {
+      putValue(Action.NAME, I18n.tr("Jump to red"));
+      putValue(Action.SHORT_DESCRIPTION, I18n.tr("Jumps to the picture at the other side of the red line"));
+      new ImageProvider("dialogs", "red").getResource().attachImageIcon(this, true);
+    }
+    @Override
+    public void actionPerformed(ActionEvent e) {
+      if (StreetsideMainDialog.getInstance().getImage() != null) {
+        StreetsideLayer.getInstance().getData()
+            .setSelectedImage(StreetsideLayer.getInstance().getNNearestImage(1), true);
+      }
+    }
+  }
+  /**
+   * Action class to jump to the image following the blue line.
+   *
+   * @author nokutu
+   */
+  private static class BlueAction extends AbstractAction {
+    private static final long serialVersionUID = 5951233534212838780L;
+    /**
+     * Constructs a normal BlueAction
+     */
+    BlueAction() {
+      putValue(Action.NAME, I18n.tr("Jump to blue"));
+      putValue(Action.SHORT_DESCRIPTION, I18n.tr("Jumps to the picture at the other side of the blue line"));
+      new ImageProvider("dialogs", "blue").getResource().attachImageIcon(this, true);
+    }
+    @Override
+    public void actionPerformed(ActionEvent e) {
+      if (StreetsideMainDialog.getInstance().getImage() != null) {
+        StreetsideLayer.getInstance().getData()
+            .setSelectedImage(StreetsideLayer.getInstance().getNNearestImage(2), true);
+      }
+    }
+  }
+  private static class StopAction extends AbstractAction implements WalkListener {
+    private static final long serialVersionUID = 8789972456611625341L;
+    private WalkThread thread;
+    /**
+     * Constructs a normal StopAction
+     */
+    StopAction() {
+      putValue(Action.NAME, I18n.tr("Stop"));
+      putValue(Action.SHORT_DESCRIPTION, I18n.tr("Stops the walk."));
+      new ImageProvider("dialogs/streetsideStop.png").getResource().attachImageIcon(this, true);
+      StreetsidePlugin.getStreetsideWalkAction().addListener(this);
+    }
+    @Override
+    public void actionPerformed(ActionEvent e) {
+      if (thread != null) {
+        thread.stopWalk();
+      }
+    }
+    @Override
+    public void walkStarted(WalkThread thread) {
+      this.thread = thread;
+    }
+  }
+  private static class PlayAction extends AbstractAction implements WalkListener {
+    private static final long serialVersionUID = -1572747020946842769L;
+    private transient WalkThread thread;
+    /**
+     * Constructs a normal PlayAction
+     */
+    PlayAction() {
+      putValue(Action.NAME, I18n.tr("Play"));
+      putValue(Action.SHORT_DESCRIPTION, I18n.tr("Continues with the paused walk."));
+      new ImageProvider("dialogs/streetsidePlay.png").getResource().attachImageIcon(this, true);
+      StreetsidePlugin.getStreetsideWalkAction().addListener(this);
+    }
+    @Override
+    public void actionPerformed(ActionEvent e) {
+      if (thread != null) {
+        thread.play();
+      }
+    }
+    @Override
+    public void walkStarted(WalkThread thread) {
+      if (thread != null) {
+        this.thread = thread;
+      }
+    }
+  }
+  private static class PauseAction extends AbstractAction implements WalkListener {
+    /**
+     *
+     */
+    private static final long serialVersionUID = -8758326399460817222L;
+    private WalkThread thread;
+    /**
+     * Constructs a normal PauseAction
+     */
+    PauseAction() {
+      putValue(Action.NAME, I18n.tr("Pause"));
+      putValue(Action.SHORT_DESCRIPTION, I18n.tr("Pauses the walk."));
+      new ImageProvider("dialogs/streetsidePause.png").getResource().attachImageIcon(this, true);
+      StreetsidePlugin.getStreetsideWalkAction().addListener(this);
+    }
+    @Override
+    public void actionPerformed(ActionEvent e) {
+      thread.pause();
+    }
+    @Override
+    public void walkStarted(WalkThread thread) {
+      this.thread = thread;
+    }
+  }
+}

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/gui/StreetsidePreferenceSetting.java

-              r34433
+              r36194
 import java.io.IOException;
 import java.io.InputStream;
+import java.util.logging.Logger;
 import javax.imageio.ImageIO;
 …
 import javax.swing.SwingUtilities;
-import org.apache.log4j.Logger;
 import org.openstreetmap.josm.actions.ExpertToggleAction;
 import org.openstreetmap.josm.gui.preferences.PreferenceTabbedPane;
 …
 import org.openstreetmap.josm.tools.GBC;
 import org.openstreetmap.josm.tools.I18n;
+import org.openstreetmap.josm.tools.Logging;
 /**
 …
 public class StreetsidePreferenceSetting implements SubPreferenceSetting, StreetsideLoginListener {
+  final static Logger logger = Logger.getLogger(StreetsidePreferenceSetting.class);
+  private final JComboBox<String> downloadModeComboBox = new JComboBox<>(new String[]{
+      DOWNLOAD_MODE.VISIBLE_AREA.getLabel(),
+      DOWNLOAD_MODE.OSM_AREA.getLabel(),
+      DOWNLOAD_MODE.MANUAL_ONLY.getLabel()
+  });
+  private final JCheckBox displayHour =
+    new JCheckBox(I18n.tr("Display hour when the picture was taken"), StreetsideProperties.DISPLAY_HOUR.get());
+  private final JCheckBox format24 =
+    new JCheckBox(I18n.tr("Use 24 hour format"), StreetsideProperties.TIME_FORMAT_24.get());
+  private final JCheckBox moveTo =
+    new JCheckBox(I18n.tr("Move to picture''s location with next/previous buttons"), StreetsideProperties.MOVE_TO_IMG.get());
+  private final JCheckBox hoverEnabled =
+    new JCheckBox(I18n.tr("Preview images when hovering its icon"), StreetsideProperties.HOVER_ENABLED.get());
+  private final JCheckBox cutOffSeq =
+    new JCheckBox(I18n.tr("Cut off sequences at download bounds"), StreetsideProperties.CUT_OFF_SEQUENCES_AT_BOUNDS.get());
+  private final JCheckBox imageLinkToBlurEditor =
+    new JCheckBox(
+  private static final Logger logger = Logger.getLogger(StreetsidePreferenceSetting.class.getCanonicalName());
+  private final JComboBox<String> downloadModeComboBox = new JComboBox<>(
+      new String[] { DOWNLOAD_MODE.VISIBLE_AREA.getLabel(), DOWNLOAD_MODE.OSM_AREA.getLabel(),
+          DOWNLOAD_MODE.MANUAL_ONLY.getLabel() });
+  private final JCheckBox displayHour = new JCheckBox(I18n.tr("Display hour when the picture was taken"),
+      StreetsideProperties.DISPLAY_HOUR.get());
+  private final JCheckBox format24 = new JCheckBox(I18n.tr("Use 24 hour format"),
+      StreetsideProperties.TIME_FORMAT_24.get());
+  private final JCheckBox moveTo = new JCheckBox(I18n.tr("Move to picture''s location with next/previous buttons"),
+      StreetsideProperties.MOVE_TO_IMG.get());
+  private final JCheckBox hoverEnabled = new JCheckBox(I18n.tr("Preview images when hovering its icon"),
+      StreetsideProperties.HOVER_ENABLED.get());
+  private final JCheckBox cutOffSeq = new JCheckBox(I18n.tr("Cut off sequences at download bounds"),
+      StreetsideProperties.CUT_OFF_SEQUENCES_AT_BOUNDS.get());
+  private final JCheckBox imageLinkToBlurEditor = new JCheckBox(
       I18n.tr("When opening Streetside image in web browser, show the blur editor instead of the image viewer"),
+      StreetsideProperties.IMAGE_LINK_TO_BLUR_EDITOR.get()
+    );
+  private final JCheckBox developer =
+    new JCheckBox(I18n.tr("Enable experimental beta-features (might be unstable)"), StreetsideProperties.DEVELOPER.get());
+      StreetsideProperties.IMAGE_LINK_TO_BLUR_EDITOR.get());
+  private final JCheckBox developer = new JCheckBox(I18n.tr("Enable experimental beta-features (might be unstable)"),
+      StreetsideProperties.DEVELOPER.get());
   private final SpinnerNumberModel preFetchSize = new SpinnerNumberModel(
+    StreetsideProperties.PRE_FETCH_IMAGE_COUNT.get().intValue(),
+,
+    Integer.MAX_VALUE,
+  );
+      StreetsideProperties.PRE_FETCH_IMAGE_COUNT.get().intValue(), 0, Integer.MAX_VALUE, 1);
   private final JButton loginButton = new StreetsideButton(new LoginAction(this));
   private final JButton logoutButton = new StreetsideButton(new LogoutAction());
 …
     loginPanel.setBackground(StreetsideColorScheme.TOOLBAR_DARK_GREY);
     JLabel brandImage = new JLabel();
+    try (InputStream is = StreetsidePreferenceSetting.class.getResourceAsStream("/images/streetside-logo-white.png")) {
+    try (InputStream is = StreetsidePreferenceSetting.class
+        .getResourceAsStream("/images/streetside-logo-white.png")) {
       if (is != null) {
         brandImage.setIcon(new ImageIcon(ImageIO.read(is)));
       } else {
         logger.warn("Could not load Streetside brand image!");
+        logger.log(Logging.LEVEL_WARN, "Could not load Streetside brand image!");
+      }
     } catch (IOException e) {
       logger.warn("While reading Streetside brand image, an IO-exception occured!");
+      logger.log(Logging.LEVEL_WARN, "While reading Streetside brand image, an IO-exception occured!", e);
+    }
     loginPanel.add(brandImage, 0);
 …
     mainPanel.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));
+    downloadModeComboBox.setSelectedItem(DOWNLOAD_MODE.fromPrefId(StreetsideProperties.DOWNLOAD_MODE.get()).getLabel());
+    downloadModeComboBox
+        .setSelectedItem(DOWNLOAD_MODE.fromPrefId(StreetsideProperties.DOWNLOAD_MODE.get()).getLabel());
     JPanel downloadModePanel = new JPanel();
 …
       mainPanel.add(developer, GBC.eol());
+    }
+    StreetsideColorScheme.styleAsDefaultPanel(
+      mainPanel, downloadModePanel, displayHour, format24, moveTo, hoverEnabled, cutOffSeq, imageLinkToBlurEditor, developer, preFetchPanel
+    );
+    StreetsideColorScheme.styleAsDefaultPanel(mainPanel, downloadModePanel, displayHour, format24, moveTo,
+        hoverEnabled, cutOffSeq, imageLinkToBlurEditor, developer, preFetchPanel);
     mainPanel.add(Box.createVerticalGlue(), GBC.eol().fill(GridBagConstraints.BOTH));
 …
     synchronized (gui.getDisplayPreference().getTabPane()) {
       gui.getDisplayPreference().addSubTab(this, "Streetside", new JScrollPane(container));
+      gui.getDisplayPreference().getTabPane().setIconAt(gui.getDisplayPreference().getTabPane().getTabCount()-1, StreetsidePlugin.LOGO.setSize(12, 12).get());
+      gui.getDisplayPreference().getTabPane().setIconAt(gui.getDisplayPreference().getTabPane().getTabCount() - 1,
+          StreetsidePlugin.LOGO.setSize(12, 12).get());
+    }
 …
   @Override
   public boolean ok() {
+    StreetsideProperties.DOWNLOAD_MODE.put(DOWNLOAD_MODE.fromLabel(downloadModeComboBox.getSelectedItem().toString()).getPrefId());
+    StreetsideProperties.DOWNLOAD_MODE
+        .put(DOWNLOAD_MODE.fromLabel(downloadModeComboBox.getSelectedItem().toString()).getPrefId());
     StreetsideProperties.DISPLAY_HOUR.put(displayHour.isSelected());
     StreetsideProperties.TIME_FORMAT_24.put(format24.isSelected());
 …
+   *
    * @author nokutu
+   *
    */
   private static class LoginAction extends AbstractAction {
 …
     private static final long serialVersionUID = 8743119160917296506L;
         private final transient StreetsideLoginListener callback;
+    private final transient StreetsideLoginListener callback;
     LoginAction(StreetsideLoginListener loginCallback) {
 …
     private static final long serialVersionUID = -4146587895393766981L;
         private LogoutAction() {
+    private LogoutAction() {
       super(I18n.tr("Logout"));
+    }

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/gui/StreetsideViewerDialog.java

-              r34433
+              r36194
  */
+public final class StreetsideViewerDialog extends ToggleDialog
+                 {
+public final class StreetsideViewerDialog extends ToggleDialog {
         private static final long serialVersionUID = -8983900297628236197L;
+  private static final long serialVersionUID = -8983900297628236197L;
         private static final String BASE_TITLE = "360° Streetside Viewer";
+  private static final String BASE_TITLE = "360° Streetside Viewer";
         private static StreetsideViewerDialog instance;
+  private static StreetsideViewerDialog instance;
         /**
          * Object containing the shown image and that handles zoom and drag
          */
         private StreetsideViewerPanel streetsideViewerPanel;
+  /**
+   * Object containing the shown image and that handles zoom and drag
+   */
+  private final StreetsideViewerPanel streetsideViewerPanel;
         private StreetsideViewerDialog() {
           super(StreetsideViewerDialog.BASE_TITLE, "streetside-viewer", "Open Streetside Viewer window",
                                 null, 200, true, StreetsidePreferenceSetting.class);
                 streetsideViewerPanel = new StreetsideViewerPanel();
                 createLayout(streetsideViewerPanel, true, null);
+        }
+  private StreetsideViewerDialog() {
+    super(StreetsideViewerDialog.BASE_TITLE, "streetside-viewer", "Open Streetside Viewer window", null, 200, true,
+        StreetsidePreferenceSetting.class);
+    streetsideViewerPanel = new StreetsideViewerPanel();
+    createLayout(streetsideViewerPanel, true, null);
+  }
         /**
          * Returns the unique instance of the class.
+         *
          * @return The unique instance of the class.
          */
         public static synchronized StreetsideViewerDialog getInstance() {
                 if (StreetsideViewerDialog.instance == null) {
                         StreetsideViewerDialog.instance = new StreetsideViewerDialog();
+                }
                 return StreetsideViewerDialog.instance;
+        }
+  /**
+   * Returns the unique instance of the class.
+   *
+   * @return The unique instance of the class.
+   */
+  public static synchronized StreetsideViewerDialog getInstance() {
+    if (StreetsideViewerDialog.instance == null) {
+      StreetsideViewerDialog.instance = new StreetsideViewerDialog();
+    }
+    return StreetsideViewerDialog.instance;
+  }
         /**
          * @return true, iff the singleton instance is present
          */
         public static boolean hasInstance() {
                 return StreetsideViewerDialog.instance != null;
+        }
+  /**
+   * @return true, iff the singleton instance is present
+   */
+  public static boolean hasInstance() {
+    return StreetsideViewerDialog.instance != null;
+  }
         /**
          * Destroys the unique instance of the class.
          */
         public static synchronized void destroyInstance() {
                 StreetsideViewerDialog.instance = null;
+        }
+  /**
+   * Destroys the unique instance of the class.
+   */
+  public static synchronized void destroyInstance() {
+    StreetsideViewerDialog.instance = null;
+  }
+        /**
+         * Creates the layout of the dialog.
+         *
+         * @param data
+         *            The content of the dialog
+         * @param buttons
+         *            The buttons where you can click
+         */
+        public void createLayout(Component data, List<SideButton> buttons) {
+                removeAll();
+                createLayout(data, true, buttons);
+                add(titleBar, BorderLayout.NORTH);
+        }
+  /**
+   * Creates the layout of the dialog.
+   *
+   * @param data  The content of the dialog
+   * @param buttons The buttons where you can click
+   */
+  public void createLayout(Component data, List<SideButton> buttons) {
+    removeAll();
+    createLayout(data, true, buttons);
+    add(titleBar, BorderLayout.NORTH);
+  }
         public StreetsideViewerPanel getStreetsideViewerPanel() {
                 return streetsideViewerPanel;
+        }
+  public StreetsideViewerPanel getStreetsideViewerPanel() {
+    return streetsideViewerPanel;
+  }
+}

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/gui/StreetsideWalkDialog.java

-              r34317
+              r36194
   private static final long serialVersionUID = 7974881240732957573L;
+  /** Spin containing the interval value. */
+  /**
+   * Spin containing the interval value.
+   */
   public SpinnerModel spin;
+  /** Whether it must wait for the picture to be downloaded */
+  /**
+   * Whether it must wait for the picture to be downloaded
+   */
   public JCheckBox waitForPicture;
+  /** Whether the view must follow the selected image. */
+  /**
+   * Whether the view must follow the selected image.
+   */
   public JCheckBox followSelection;
+  /** Go forward or backwards */
+  /**
+   * Go forward or backwards
+   */
   public JCheckBox goForward;

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/gui/boilerplate/SelectableLabel.java

-              r34317
+              r36194
 public class SelectableLabel extends JTextPane {
-  private static final long serialVersionUID = 5432480892000739831L;
   public static final Font DEFAULT_FONT = UIManager.getFont("Label.font").deriveFont(Font.PLAIN);
   public static final Color DEFAULT_BACKGROUND = UIManager.getColor("Panel.background");
+  private static final long serialVersionUID = 5432480892000739831L;
   public SelectableLabel() {

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/gui/boilerplate/StreetsideButton.java

r34317	r36194
12	12
13	13	import org.openstreetmap.josm.plugins.streetside.utils.StreetsideColorScheme;
14
15	14
16	15	public class StreetsideButton extends JButton {

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/gui/dialog/ChooseGeoImageLayersDialog.java

-              r34399
+              r36194
 public class ChooseGeoImageLayersDialog extends JDialog {
   private static final long serialVersionUID = -1793622345412435234L;
+  private static final String QUESTION = I18n.marktr("Which image layers do you want to import into the Streetside layer?");
+  private static final String QUESTION = I18n
+      .marktr("Which image layers do you want to import into the Streetside layer?");
   public ChooseGeoImageLayersDialog(final Component parent, final List<GeoImageLayer> layers) {
       super(GuiHelper.getFrameForComponent(parent), I18n.tr(QUESTION));
+    super(GuiHelper.getFrameForComponent(parent), I18n.tr(QUESTION));
     final Container c = getContentPane();
     c.setLayout(new BorderLayout(10, 10));
 …
   protected static class GeoImageLayerListCellRenderer implements ListCellRenderer<GeoImageLayer> {
     @Override
+    public Component getListCellRendererComponent(
+      JList<? extends GeoImageLayer> list, GeoImageLayer value, int index, boolean isSelected, boolean cellHasFocus
+    ) {
+      final JLabel result = value == null
+          ? null
+    public Component getListCellRendererComponent(JList<? extends GeoImageLayer> list, GeoImageLayer value,
+        int index, boolean isSelected, boolean cellHasFocus) {
+      final JLabel result = value == null ? null
           /* i18n: {0} is the layer name, {1} the number of images in it */
+          : new JLabel(I18n.tr("{0} ({1} images)", value.getName(), value.getImages().size()), value.getIcon(), SwingConstants.LEADING);
+          : new JLabel(I18n.tr("{0} ({1} images)", value.getName(), value.getImages().size()),
+              value.getIcon(), SwingConstants.LEADING);
       if (result != null) {
         result.setOpaque(true);
+        result.setBackground(isSelected ? UIManager.getColor("List.selectionBackground") : UIManager.getColor("List.background"));
+        result.setBackground(isSelected ? UIManager.getColor("List.selectionBackground")
+            : UIManager.getColor("List.background"));
+      }
       return result;

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/gui/imageinfo/AddTagToPrimitiveAction.java

-              r34577
+              r36194
       int conflictResolution = JOptionPane.YES_OPTION;
       if (target.hasKey(tag.getKey()) && !target.hasTag(tag.getKey(), tag.getValue())) {
+        conflictResolution = JOptionPane.showConfirmDialog(
+          MainApplication.getMainFrame(),
+          "<html>" +
+            I18n.tr("A tag with key <i>{0}</i> is already present on the selected OSM object.", tag.getKey()) + "<br>" +
+            I18n.tr(
+              "Do you really want to replace the current value <i>{0}</i> with the new value <i>{1}</i>?",
+              target.get(tag.getKey()),
+              tag.getValue()
+            ) + "</html>",
+          I18n.tr("Tag conflict"),
+          JOptionPane.YES_NO_OPTION,
+          JOptionPane.WARNING_MESSAGE
+        );
+        conflictResolution = JOptionPane.showConfirmDialog(MainApplication.getMainFrame(), "<html>" + I18n
+            .tr("A tag with key <i>{0}</i> is already present on the selected OSM object.", tag.getKey())
+            + "<br>"
+            + I18n.tr(
+                "Do you really want to replace the current value <i>{0}</i> with the new value <i>{1}</i>?",
+                target.get(tag.getKey()), tag.getValue())
+            + "</html>", I18n.tr("Tag conflict"), JOptionPane.YES_NO_OPTION, JOptionPane.WARNING_MESSAGE);
+      }
       if (JOptionPane.YES_OPTION == conflictResolution) {

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/gui/imageinfo/ClipboardAction.java

r34433	r36194
67	67	/**
68	68	* Sets the component, under which the popup will be shown, which indicates that the key was copied to the clipboard.
	69	*
69	70	* @param popupParent the component to set as parent of the popup
70	71	*/

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/gui/imageinfo/ImageInfoHelpPopup.java

-              r34412
+              r36194
 import java.awt.IllegalComponentStateException;
 import java.awt.event.ActionEvent;
+import java.util.logging.Logger;
 import javax.swing.AbstractAction;
 …
 import javax.swing.JTextPane;
-import org.apache.log4j.Logger;
 import org.openstreetmap.josm.plugins.streetside.gui.boilerplate.SelectableLabel;
 import org.openstreetmap.josm.plugins.streetside.gui.boilerplate.StreetsideButton;
 …
 import org.openstreetmap.josm.tools.I18n;
 import org.openstreetmap.josm.tools.ImageProvider;
+import org.openstreetmap.josm.tools.Logging;
 public class ImageInfoHelpPopup extends JPopupMenu {
 …
   private static final long serialVersionUID = -1721594904273820586L;
   final static Logger logger = Logger.getLogger(ImageInfoHelpPopup.class);
+  private static final Logger LOGGER = Logger.getLogger(ImageInfoHelpPopup.class.getCanonicalName());
   private final Component invokerComp;
 …
     mainText.setContentType("text/html");
     mainText.setFont(SelectableLabel.DEFAULT_FONT);
     mainText.setText("<html><div style='width:250px'>" +
       "Welcome to the Microsoft Streetside JOSM Plugin. To view the vector bubbles for the 360 degree imagery, select Imagery->Streetside from the JOSM menu."
       + "<br><br>"
       + "Once the blue bubbles appear on the map, click on a vector bubble and undock/maximize the 360 viewer to view the imagery."
       + "</div></html>");
+    mainText.setText("<html><div style='width:250px'>"
+        + "Welcome to the Microsoft Streetside JOSM Plugin. To view the vector bubbles for the 360 degree imagery, select Imagery->Streetside from the JOSM menu."
+        + "<br><br>"
+        + "Once the blue bubbles appear on the map, click on a vector bubble and undock/maximize the 360 viewer to view the imagery."
+        + "</div></html>");
     add(mainText, BorderLayout.CENTER);
 …
     infoButton.addActionListener(e -> setVisible(false));
     bottomBar.add(infoButton);
                 StreetsideButton closeBtn = new StreetsideButton(new AbstractAction() {
+    StreetsideButton closeBtn = new StreetsideButton(new AbstractAction() {
                         private static final long serialVersionUID = 2853315308169651854L;
+      private static final long serialVersionUID = 2853315308169651854L;
                         @Override
                         public void actionPerformed(ActionEvent e) {
                                 setVisible(false);
                                 StreetsideProperties.IMAGEINFO_HELP_COUNTDOWN.put(0);
+                        }
                 });
+      @Override
+      public void actionPerformed(ActionEvent e) {
+        setVisible(false);
+        StreetsideProperties.IMAGEINFO_HELP_COUNTDOWN.put(0);
+      }
+    });
                 closeBtn.setText(I18n.tr("I got it, close this."));
                 bottomBar.add(closeBtn);
                 add(bottomBar, BorderLayout.SOUTH);
+    closeBtn.setText(I18n.tr("I got it, close this."));
+    bottomBar.add(closeBtn);
+    add(bottomBar, BorderLayout.SOUTH);
                 setBackground(Color.WHITE);
+        }
+    setBackground(Color.WHITE);
+  }
   /**
 …
         return true;
       } catch (IllegalComponentStateException e) {
+        logger.warn(I18n.tr("Could not show ImageInfoHelpPopup, because probably the invoker component has disappeared from screen.", e));
+        LOGGER.log(Logging.LEVEL_WARN, I18n.tr(
+            "Could not show ImageInfoHelpPopup, because probably the invoker component has disappeared from screen.",
+            e));
+      }
+    }

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/gui/imageinfo/ImageInfoPanel.java

-              r34416
+              r36194
 import java.awt.datatransfer.StringSelection;
 import java.util.Collection;
+import java.util.logging.Logger;
 import javax.swing.JLabel;
 …
 import javax.swing.JTextPane;
-import org.apache.log4j.Logger;
 import org.openstreetmap.josm.data.osm.DataSelectionListener;
 import org.openstreetmap.josm.data.osm.OsmPrimitive;
 …
 import org.openstreetmap.josm.plugins.streetside.utils.StreetsideURL;
 import org.openstreetmap.josm.tools.I18n;
+import org.openstreetmap.josm.tools.Logging;
 public final class ImageInfoPanel extends ToggleDialog implements StreetsideDataListener, DataSelectionListener {
   private static final long serialVersionUID = 4141847503072417190L;
   final static Logger logger = Logger.getLogger(ImageInfoPanel.class);
+  private static final Logger LOGGER = Logger.getLogger(ImageInfoPanel.class.getCanonicalName());
   private static ImageInfoPanel instance;
 …
   private ImageInfoPanel() {
+    super(
+      I18n.tr("Streetside 360° image info"),
+      "streetside-info",
+      I18n.tr("Displays detail information on the currently selected Streetside image"),
+      null,
+    );
+    super(I18n.tr("Streetside 360° image info"), "streetside-info",
+        I18n.tr("Displays detail information on the currently selected Streetside image"), null, 150);
     SelectionEventManager.getInstance().addSelectionListener(this);
 …
    */
   @Override
+  public synchronized void selectedImageChanged(final StreetsideAbstractImage oldImage, final StreetsideAbstractImage newImage) {
+    logger.info(String.format(
+      "Selected Streetside image changed from %s to %s.",
+      oldImage instanceof StreetsideImage ? ((StreetsideImage) oldImage).getId() : "‹none›",
+      newImage instanceof StreetsideImage ? ((StreetsideImage) newImage).getId() : "‹none›"
+    ));
+  public synchronized void selectedImageChanged(final StreetsideAbstractImage oldImage,
+      final StreetsideAbstractImage newImage) {
+    LOGGER.info(String.format("Selected Streetside image changed from %s to %s.",
+        oldImage instanceof StreetsideImage ? oldImage.getId() : "‹none›",
+        newImage instanceof StreetsideImage ? newImage.getId() : "‹none›"));
     imgKeyValue.setEnabled(newImage instanceof StreetsideImage);
     final String newImageKey = newImage instanceof StreetsideImage ? ((StreetsideImage) newImage).getId(): null;
+    final String newImageKey = newImage instanceof StreetsideImage ? newImage.getId() : null;
     if (newImageKey != null) {
+      imageLinkChangeListener = b -> imgLinkAction.setURL(
+        StreetsideURL.MainWebsite.browseImage(newImageKey)
+      );
+      imageLinkChangeListener = b -> imgLinkAction.setURL(StreetsideURL.MainWebsite.browseImage(newImageKey));
       imageLinkChangeListener.valueChanged(null);
       StreetsideProperties.IMAGE_LINK_TO_BLUR_EDITOR.addListener(imageLinkChangeListener);
 …
+    }
+    final boolean partOfSequence = newImage != null && newImage.getSequence() != null && newImage.getSequence().getId() != null;
+    final boolean partOfSequence = newImage != null && newImage.getSequence() != null
+        && newImage.getSequence().getId() != null;
     seqKeyValue.setEnabled(partOfSequence);
     if (partOfSequence) {
 …
   public synchronized void selectionChanged(final SelectionChangeEvent event) {
     final Collection<? extends OsmPrimitive> sel = event.getSelection();
+    if (StreetsideProperties.DEBUGING_ENABLED.get()) {
+      logger.debug(String.format("Selection changed. %d primitives are selected.", sel == null ? 0 : sel.size()));
+    if (Boolean.TRUE.equals(StreetsideProperties.DEBUGING_ENABLED.get())) {
+      LOGGER.log(Logging.LEVEL_DEBUG,
+          String.format("Selection changed. %d primitives are selected.", sel == null ? 0 : sel.size()));
+    }
     addStreetsideTagAction.setTarget(sel != null && sel.size() == 1 ? sel.iterator().next() : null);

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/gui/imageinfo/StreetsideViewerHelpPopup.java

-              r34412
+              r36194
 import java.awt.event.ActionEvent;
 import java.text.MessageFormat;
+import java.util.logging.Logger;
 import javax.swing.AbstractAction;
 …
 import javax.swing.JTextPane;
-import org.apache.log4j.Logger;
 import org.openstreetmap.josm.plugins.streetside.gui.boilerplate.SelectableLabel;
 import org.openstreetmap.josm.plugins.streetside.gui.boilerplate.StreetsideButton;
 …
 import org.openstreetmap.josm.tools.I18n;
 import org.openstreetmap.josm.tools.ImageProvider;
+import org.openstreetmap.josm.tools.Logging;
 public class StreetsideViewerHelpPopup extends JPopupMenu {
         private static final long serialVersionUID = -7840242522398163839L;
+  private static final long serialVersionUID = -7840242522398163839L;
         final static Logger logger = Logger.getLogger(StreetsideViewerHelpPopup.class);
+  private static final Logger LOGGER = Logger.getLogger(StreetsideViewerHelpPopup.class.getCanonicalName());
         private final Component invokerComp;
         private boolean alreadyDisplayed;
+  private final Component invokerComp;
+  private boolean alreadyDisplayed;
         public StreetsideViewerHelpPopup(Component invoker) {
+  public StreetsideViewerHelpPopup(Component invoker) {
                 invokerComp = invoker;
                 removeAll();
                 setLayout(new BorderLayout());
+    invokerComp = invoker;
+    removeAll();
+    setLayout(new BorderLayout());
                 JPanel topBar = new JPanel();
                 topBar.add(new JLabel(ImageProvider.get("streetside-logo-white")));
                 topBar.setBackground(StreetsideColorScheme.TOOLBAR_DARK_GREY);
                 add(topBar, BorderLayout.NORTH);
+    JPanel topBar = new JPanel();
+    topBar.add(new JLabel(ImageProvider.get("streetside-logo-white")));
+    topBar.setBackground(StreetsideColorScheme.TOOLBAR_DARK_GREY);
+    add(topBar, BorderLayout.NORTH);
+                JTextPane mainText = new JTextPane();
+                mainText.setContentType("text/html");
+                mainText.setFont(SelectableLabel.DEFAULT_FONT);
+                mainText.setText("<html><div style='width:250px'>" +
+                                "Welcome to the Microsoft Streetside JOSM Plugin. To view the vector bubbles for the 360 degree imagery, select Imagery->Streetside from the JOSM menu."
+                                + "<br><br>"
+                                +
+                                                "Once the blue bubbles appear on the map, click on a vector bubble and undock/maximize the 360 viewer to view the imagery."
+                                + "</div></html>");
+                add(mainText, BorderLayout.CENTER);
+    JTextPane mainText = new JTextPane();
+    mainText.setContentType("text/html");
+    mainText.setFont(SelectableLabel.DEFAULT_FONT);
+    mainText.setText("<html><div style='width:250px'>"
+        + "Welcome to the Microsoft Streetside JOSM Plugin. To view the vector bubbles for the 360 degree imagery, select Imagery->Streetside from the JOSM menu."
+        + "<br><br>"
+        + "Once the blue bubbles appear on the map, click on a vector bubble and undock/maximize the 360 viewer to view the imagery."
+        + "</div></html>");
+    add(mainText, BorderLayout.CENTER);
                 JPanel bottomBar = new JPanel();
                 bottomBar.setBackground(new Color(0x00FFFFFF, true));
                 StreetsideButton infoButton = new StreetsideButton(ImageInfoPanel.getInstance().getToggleAction());
                 infoButton.addActionListener(e -> setVisible(false));
                 bottomBar.add(infoButton);
                 StreetsideButton closeBtn = new StreetsideButton(new AbstractAction() {
                         private static final long serialVersionUID = -6193886964751195196L;
+    JPanel bottomBar = new JPanel();
+    bottomBar.setBackground(new Color(0x00FFFFFF, true));
+    StreetsideButton infoButton = new StreetsideButton(ImageInfoPanel.getInstance().getToggleAction());
+    infoButton.addActionListener(e -> setVisible(false));
+    bottomBar.add(infoButton);
+    StreetsideButton closeBtn = new StreetsideButton(new AbstractAction() {
+      private static final long serialVersionUID = -6193886964751195196L;
                         @Override
                         public void actionPerformed(ActionEvent e) {
                                 setVisible(false);
                                 StreetsideProperties.IMAGEINFO_HELP_COUNTDOWN.put(0);
+                        }
                 });
+      @Override
+      public void actionPerformed(ActionEvent e) {
+        setVisible(false);
+        StreetsideProperties.IMAGEINFO_HELP_COUNTDOWN.put(0);
+      }
+    });
                 closeBtn.setText(I18n.tr("I got it, close this."));
  bottomBar.add(closeBtn);
  add(bottomBar, BorderLayout.SOUTH);
+    closeBtn.setText(I18n.tr("I got it, close this."));
+    bottomBar.add(closeBtn);
+    add(bottomBar, BorderLayout.SOUTH);
+ setBackground(Color.WHITE);
+    setBackground(Color.WHITE);
+  }
+  /**
+   * @return <code>true</code> if the popup is displayed
+   */
+  public boolean showPopup() {
+    if (!alreadyDisplayed && invokerComp.isShowing()) {
+      try {
+        show(invokerComp, invokerComp.getWidth(), 0);
+        alreadyDisplayed = true;
+        return true;
+      } catch (IllegalComponentStateException e) {
+        LOGGER.log(Logging.LEVEL_ERROR, MessageFormat.format(
+            "Could not show ImageInfoHelpPopup, because probably the invoker component has disappeared from screen. {0}",
+            e.getMessage()), e);
+      }
+    }
+    return false;
+  }
+}
-/**
-* @return <code>true</code> if the popup is displayed
-*/
-public boolean showPopup() {
- if (!alreadyDisplayed && invokerComp.isShowing()) {
-   try {
-     show(invokerComp, invokerComp.getWidth(), 0);
-     alreadyDisplayed = true;
-     return true;
-   } catch (IllegalComponentStateException e) {
-     logger.error(MessageFormat.format("Could not show ImageInfoHelpPopup, because probably the invoker component has disappeared from screen. {0}", e.getMessage()));
+   }
+ }
- return false;
+}
+}

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/gui/imageinfo/StreetsideViewerPanel.java

-              r36065
+              r36194
 //License: GPL. For details, see LICENSE file.
+// License: GPL. For details, see LICENSE file.
 package org.openstreetmap.josm.plugins.streetside.gui.imageinfo;
 …
 import java.awt.GraphicsEnvironment;
 import java.text.MessageFormat;
+import java.util.logging.Logger;
 import javax.swing.JCheckBox;
 …
 import javax.swing.SwingUtilities;
-import org.apache.log4j.Logger;
 import org.openstreetmap.josm.data.preferences.AbstractProperty.ValueChangeListener;
 import org.openstreetmap.josm.plugins.streetside.StreetsideAbstractImage;
 …
 import org.openstreetmap.josm.plugins.streetside.utils.StreetsideURL;
 import org.openstreetmap.josm.tools.I18n;
+import org.openstreetmap.josm.tools.Logging;
+public final class StreetsideViewerPanel extends JPanel
+                implements StreetsideDataListener {
+public final class StreetsideViewerPanel extends JPanel implements StreetsideDataListener {
         private static final long serialVersionUID = 4141847503072417190L;
+  private static final long serialVersionUID = 4141847503072417190L;
+        final static Logger logger = Logger.getLogger(StreetsideViewerPanel.class);
+        private JCheckBox highResImageryCheck;
+        private WebLinkAction imgLinkAction;
+        private ImageReloadAction imgReloadAction;
+        private ValueChangeListener<Boolean> imageLinkChangeListener;
+        private static ThreeSixtyDegreeViewerPanel threeSixtyDegreeViewerPanel;
+  private static final Logger LOGGER = Logger.getLogger(StreetsideViewerPanel.class.getCanonicalName());
+  private static ThreeSixtyDegreeViewerPanel threeSixtyDegreeViewerPanel;
+  private JCheckBox highResImageryCheck;
+  private WebLinkAction imgLinkAction;
+  private ImageReloadAction imgReloadAction;
+  private ValueChangeListener<Boolean> imageLinkChangeListener;
   private StreetsideViewerHelpPopup streetsideViewerHelp;
         public StreetsideViewerPanel() {
+  public StreetsideViewerPanel() {
                 super(new BorderLayout());
+    super(new BorderLayout());
                 SwingUtilities.invokeLater(() -> initializeAndStartGUI());
+    SwingUtilities.invokeLater(this::initializeAndStartGUI);
                 selectedImageChanged(null, null);
+    selectedImageChanged(null, null);
+                setToolTipText(I18n.tr("Select Microsoft Streetside from the Imagery menu, then click on a blue vector bubble.."));
+        }
+    setToolTipText(
+        I18n.tr("Select Microsoft Streetside from the Imagery menu, then click on a blue vector bubble.."));
+  }
+        private void initializeAndStartGUI() {
+  public static CubemapBox getCubemapBox() {
+    return threeSixtyDegreeViewerPanel.getCubemapBox();
+  }
+                threeSixtyDegreeViewerPanel = new ThreeSixtyDegreeViewerPanel();
+  /**
+   * @return the threeSixtyDegreeViewerPanel
+   */
+  public static ThreeSixtyDegreeViewerPanel getThreeSixtyDegreeViewerPanel() {
+    return threeSixtyDegreeViewerPanel;
+  }
+  private void initializeAndStartGUI() {
+    threeSixtyDegreeViewerPanel = new ThreeSixtyDegreeViewerPanel();
     if (!GraphicsEnvironment.isHeadless()) {
 …
+    }
                 add(threeSixtyDegreeViewerPanel, BorderLayout.CENTER);
                 revalidate();
                 repaint();
             JPanel checkPanel = new JPanel();
+    add(threeSixtyDegreeViewerPanel, BorderLayout.CENTER);
+    revalidate();
+    repaint();
+    JPanel checkPanel = new JPanel();
             imgReloadAction = new ImageReloadAction("Reload");
+    imgReloadAction = new ImageReloadAction("Reload");
             StreetsideButton imgReloadButton = new StreetsideButton(imgReloadAction);
+    StreetsideButton imgReloadButton = new StreetsideButton(imgReloadAction);
+            highResImageryCheck = new JCheckBox("High resolution");
+            highResImageryCheck.setSelected(StreetsideProperties.SHOW_HIGH_RES_STREETSIDE_IMAGERY.get());
+            highResImageryCheck.addActionListener(
+              action -> StreetsideProperties.SHOW_HIGH_RES_STREETSIDE_IMAGERY.put(highResImageryCheck.isSelected())
+            );
+            StreetsideProperties.SHOW_HIGH_RES_STREETSIDE_IMAGERY.addListener(
+              valueChange -> highResImageryCheck.setSelected(StreetsideProperties.SHOW_HIGH_RES_STREETSIDE_IMAGERY.get())
+            );
+            checkPanel.add(highResImageryCheck, BorderLayout.WEST);
+            checkPanel.add(imgReloadButton, BorderLayout.EAST);
+    highResImageryCheck = new JCheckBox("High resolution");
+    highResImageryCheck.setSelected(StreetsideProperties.SHOW_HIGH_RES_STREETSIDE_IMAGERY.get());
+    highResImageryCheck.addActionListener(
+        action -> StreetsideProperties.SHOW_HIGH_RES_STREETSIDE_IMAGERY.put(highResImageryCheck.isSelected()));
+    StreetsideProperties.SHOW_HIGH_RES_STREETSIDE_IMAGERY.addListener(valueChange -> highResImageryCheck
+        .setSelected(StreetsideProperties.SHOW_HIGH_RES_STREETSIDE_IMAGERY.get()));
+    checkPanel.add(highResImageryCheck, BorderLayout.WEST);
+    checkPanel.add(imgReloadButton, BorderLayout.EAST);
             JPanel privacyLink = new JPanel();
+    JPanel privacyLink = new JPanel();
             imgLinkAction = new WebLinkAction("Report a privacy concern with this image", null);
             privacyLink.add(new StreetsideButton(imgLinkAction, true));
             checkPanel.add(privacyLink, BorderLayout.PAGE_END);
+    imgLinkAction = new WebLinkAction("Report a privacy concern with this image", null);
+    privacyLink.add(new StreetsideButton(imgLinkAction, true));
+    checkPanel.add(privacyLink, BorderLayout.PAGE_END);
             add(threeSixtyDegreeViewerPanel, BorderLayout.CENTER);
+    add(threeSixtyDegreeViewerPanel, BorderLayout.CENTER);
             JPanel bottomPanel = new JPanel();
             bottomPanel.add(checkPanel, BorderLayout.NORTH);
             bottomPanel.add(privacyLink, BorderLayout.SOUTH);
+    JPanel bottomPanel = new JPanel();
+    bottomPanel.add(checkPanel, BorderLayout.NORTH);
+    bottomPanel.add(privacyLink, BorderLayout.SOUTH);
             add(bottomPanel, BorderLayout.PAGE_END);
+        }
+    add(bottomPanel, BorderLayout.PAGE_END);
+  }
         /*
          * (non-Javadoc)
+         *
          * @see
          * org.openstreetmap.josm.plugins.streetside.StreetsideDataListener#imagesAdded(
          * )
          */
         @Override
         public void imagesAdded() {
                 // Method is not needed, but enforcesd by the interface StreetsideDataListener
+        }
+  /*
+   * (non-Javadoc)
+   *
+   * @see
+   * org.openstreetmap.josm.plugins.streetside.StreetsideDataListener#imagesAdded(
+   * )
+   */
+  @Override
+  public void imagesAdded() {
+    // Method is not needed, but enforcesd by the interface StreetsideDataListener
+  }
         /*
          * (non-Javadoc)
+         *
          * @see org.openstreetmap.josm.plugins.streetside.StreetsideDataListener#
          * selectedImageChanged(org.openstreetmap.josm.plugins.streetside.
          * StreetsideAbstractImage,
          * org.openstreetmap.josm.plugins.streetside.StreetsideAbstractImage)
          */
         @Override
         public synchronized void selectedImageChanged(final StreetsideAbstractImage oldImage,
                         final StreetsideAbstractImage newImage) {
+  /*
+   * (non-Javadoc)
+   *
+   * @see org.openstreetmap.josm.plugins.streetside.StreetsideDataListener#
+   * selectedImageChanged(org.openstreetmap.josm.plugins.streetside.
+   * StreetsideAbstractImage,
+   * org.openstreetmap.josm.plugins.streetside.StreetsideAbstractImage)
+   */
+  @Override
+  public synchronized void selectedImageChanged(final StreetsideAbstractImage oldImage,
+      final StreetsideAbstractImage newImage) {
                 // method is invoked with null initially by framework
                 if(newImage!=null) {
+    // method is invoked with null initially by framework
+    if (newImage != null) {
+                    logger.info(String.format(
+                      "Selected Streetside image changed from %s to %s.",
+                      oldImage instanceof StreetsideImage ? ((StreetsideImage) oldImage).getId() : "‹none›",
+                      newImage instanceof StreetsideImage ? ((StreetsideImage) newImage).getId() : "‹none›"
+                    ));
+      LOGGER.info(String.format("Selected Streetside image changed from %s to %s.",
+          oldImage instanceof StreetsideImage ? oldImage.getId() : "‹none›",
+          newImage instanceof StreetsideImage ? newImage.getId() : "‹none›"));
+                    final String newImageId = CubemapBuilder.getInstance().getCubemap() !=null ? CubemapBuilder.getInstance().getCubemap().getId() : newImage instanceof StreetsideImage ? ((StreetsideImage) newImage).getId(): null;
+                    if (newImageId != null) {
+                      final String bubbleId = CubemapUtils.convertQuaternary2Decimal(newImageId);
+                      imageLinkChangeListener = b -> imgLinkAction.setURL(
+                        StreetsideURL.MainWebsite.streetsidePrivacyLink(bubbleId)
+                      );
+      final String newImageId = CubemapBuilder.getInstance().getCubemap() != null
+          ? CubemapBuilder.getInstance().getCubemap().getId()
+          : newImage instanceof StreetsideImage ? ((StreetsideImage) newImage).getId() : null;
+      if (newImageId != null) {
+        final String bubbleId = CubemapUtils.convertQuaternary2Decimal(newImageId);
+        imageLinkChangeListener = b -> imgLinkAction
+            .setURL(StreetsideURL.MainWebsite.streetsidePrivacyLink(bubbleId));
+                      if(StreetsideProperties.DEBUGING_ENABLED.get()) {
+                        logger.debug(MessageFormat.format("Privacy link set for Streetside image {0} quadKey {1}", bubbleId, newImageId));
+                      }
+        if (Boolean.TRUE.equals(StreetsideProperties.DEBUGING_ENABLED.get())) {
+          LOGGER.log(Logging.LEVEL_DEBUG, MessageFormat
+              .format("Privacy link set for Streetside image {0} quadKey {1}", bubbleId, newImageId));
+        }
+                      imageLinkChangeListener.valueChanged(null);
+                      StreetsideProperties.CUBEMAP_LINK_TO_BLUR_EDITOR.addListener(imageLinkChangeListener);
+                    } else {
+                      if (imageLinkChangeListener != null) {
+                        StreetsideProperties.CUBEMAP_LINK_TO_BLUR_EDITOR.removeListener(imageLinkChangeListener);
+                        imageLinkChangeListener = null;
+                      }
+                      imgLinkAction.setURL(null);
+                    }
+                  }
+        }
+        public static CubemapBox getCubemapBox() {
+                return threeSixtyDegreeViewerPanel.getCubemapBox();
+        }
+        /**
+         * @return the threeSixtyDegreeViewerPanel
+         */
+        public static ThreeSixtyDegreeViewerPanel getThreeSixtyDegreeViewerPanel() {
+                return threeSixtyDegreeViewerPanel;
+        }
+        imageLinkChangeListener.valueChanged(null);
+        StreetsideProperties.CUBEMAP_LINK_TO_BLUR_EDITOR.addListener(imageLinkChangeListener);
+      } else {
+        if (imageLinkChangeListener != null) {
+          StreetsideProperties.CUBEMAP_LINK_TO_BLUR_EDITOR.removeListener(imageLinkChangeListener);
+          imageLinkChangeListener = null;
+        }
+        imgLinkAction.setURL(null);
+      }
+    }
+  }
+}

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/gui/imageinfo/ThreeSixtyDegreeViewerPanel.java

-              r34774
+              r36194
 //License: GPL. For details, see LICENSE file.
+// License: GPL. For details, see LICENSE file.
 package org.openstreetmap.josm.plugins.streetside.gui.imageinfo;
 …
 import javafx.scene.PointLight;
 import javafx.scene.Scene;
+import javafx.scene.SceneAntialiasing;
 import javafx.scene.control.Label;
-import javafx.scene.SceneAntialiasing;
 import javafx.scene.control.TextArea;
 import javafx.scene.image.Image;
 …
   private static final long serialVersionUID = -4940350009018422000L;
+  private static final CameraTransformer cameraTransform = new CameraTransformer();
+  private static final double cameraDistance = 5000;
   private static Scene cubemapScene;
   private static Scene defaultScene;
   private static Scene loadingScene;
   private static Group root;
   private static Group subGroup;
   private static CubemapBox cubemapBox;
   private static PerspectiveCamera camera;
-  private static CameraTransformer cameraTransform = new CameraTransformer();
   private static double mousePosX;
   private static double mousePosY;
 …
   private static double mouseDeltaX;
   private static double mouseDeltaY;
-  private static double cameraDistance = 5000;
   private static Image front;
   private static Image right;
 …
   public ThreeSixtyDegreeViewerPanel() {
+  }
-  public void initialize() {
-    root = new Group();
-    camera = new PerspectiveCamera(true);
-    cameraTransform.setTranslate(0, 0, 0);
-    cameraTransform.getChildren().addAll(camera);
-    camera.setNearClip(0.1);
-    camera.setFarClip(1000000.0);
-    camera.setFieldOfView(42);
-    camera.setTranslateZ(-cameraDistance);
-    final PointLight light = new PointLight(Color.WHITE);
-    cameraTransform.getChildren().add(light);
-    light.setTranslateX(camera.getTranslateX());
-    light.setTranslateY(camera.getTranslateY());
-    light.setTranslateZ(camera.getTranslateZ());
-    root.getChildren().add(cameraTransform);
-    final double size = 100000D;
-    cubemapBox = new CubemapBox(front, right, back, left, up, down, size, camera);
-    subGroup = new Group();
-    subGroup.getChildren().add(cameraTransform);
-    createLoadingScene();
-    Platform.runLater(new Runnable() {
-      @Override
-      public void run() {
-        setScene(createDefaultScene());
+      }
-    });
+  }
 …
       if (me.isPrimaryButtonDown()) {
         cameraTransform.ry.setAngle(
           ((cameraTransform.ry.getAngle() + mouseDeltaX * modifierFactor * modifier * 2.0) % 360 + 540) % 360 - 180
         ); // +
+            ((cameraTransform.ry.getAngle() + mouseDeltaX * modifierFactor * modifier * 2.0) % 360 + 540)
+                % 360 - 180); // +
         cameraTransform.rx.setAngle(
           ((cameraTransform.rx.getAngle() - mouseDeltaY * modifierFactor * modifier * 2.0) % 360 + 540) % 360 - 180
         ); // -
+            ((cameraTransform.rx.getAngle() - mouseDeltaY * modifierFactor * modifier * 2.0) % 360 + 540)
+                % 360 - 180); // -
       } else if (me.isSecondaryButtonDown()) {
 …
+  }
+  public void initialize() {
+    root = new Group();
+    camera = new PerspectiveCamera(true);
+    cameraTransform.setTranslate(0, 0, 0);
+    cameraTransform.getChildren().addAll(camera);
+    camera.setNearClip(0.1);
+    camera.setFarClip(1000000.0);
+    camera.setFieldOfView(42);
+    camera.setTranslateZ(-cameraDistance);
+    final PointLight light = new PointLight(Color.WHITE);
+    cameraTransform.getChildren().add(light);
+    light.setTranslateX(camera.getTranslateX());
+    light.setTranslateY(camera.getTranslateY());
+    light.setTranslateZ(camera.getTranslateZ());
+    root.getChildren().add(cameraTransform);
+    final double size = 100000D;
+    cubemapBox = new CubemapBox(front, right, back, left, up, down, size, camera);
+    subGroup = new Group();
+    subGroup.getChildren().add(cameraTransform);
+    createLoadingScene();
+    Platform.runLater(() -> setScene(createDefaultScene()));
+  }
   public CubemapBox getCubemapBox() {
     if (cubemapBox == null) {

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/gui/imageinfo/WebLinkAction.java

-              r34416
+              r36194
 import java.io.IOException;
 import java.net.URL;
+import java.util.logging.Logger;
 import javax.swing.AbstractAction;
 import javax.swing.JOptionPane;
-import org.apache.log4j.Logger;
 import org.openstreetmap.josm.gui.Notification;
 import org.openstreetmap.josm.plugins.streetside.utils.StreetsideUtils;
 import org.openstreetmap.josm.tools.ImageProvider;
 import org.openstreetmap.josm.tools.ImageProvider.ImageSizes;
+import org.openstreetmap.josm.tools.Logging;
 public class WebLinkAction extends AbstractAction {
 …
   private static final long serialVersionUID = -8168227661356480455L;
   final static Logger logger = Logger.getLogger(WebLinkAction.class);
+  private static final Logger LOGGER = Logger.getLogger(WebLinkAction.class.getCanonicalName());
   private URL url;
 …
     } catch (IOException e1) {
       String msg = "Could not open the URL " + url == null ? "‹null›" : url + " in a browser";
       logger.warn(msg, e1);
+      LOGGER.log(Logging.LEVEL_WARN, msg, e1);
       new Notification(msg).setIcon(JOptionPane.WARNING_MESSAGE).show();
+    }

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/history/StreetsideRecord.java

-              r34400
+              r36194
 */
 public class StreetsideRecord {
+/** The unique instance of the class. */
+private static StreetsideRecord instance;
+  /**
+   * The unique instance of the class.
+   */
+  private static StreetsideRecord instance;
 private final List<StreetsideRecordListener> listeners = new ArrayList<>();
+  private final List<StreetsideRecordListener> listeners = new ArrayList<>();
+/** The set of commands that have taken place or that have been undone. */
+public List<StreetsideCommand> commandList;
+/** Last written command. */
+public int position;
+  /**
+   * The set of commands that have taken place or that have been undone.
+   */
+  public List<StreetsideCommand> commandList;
+  /**
+   * Last written command.
+   */
+  public int position;
+/**
+* Main constructor.
+*/
+public StreetsideRecord() {
+ this.commandList = new ArrayList<>();
+ this.position = -1;
+  /**
+   * Main constructor.
+   */
+  public StreetsideRecord() {
+    this.commandList = new ArrayList<>();
+    this.position = -1;
+  }
+  /**
+   * Returns the unique instance of the class.
+   *
+   * @return The unique instance of the class.
+   */
+  public static synchronized StreetsideRecord getInstance() {
+    if (StreetsideRecord.instance == null)
+      StreetsideRecord.instance = new StreetsideRecord();
+    return StreetsideRecord.instance;
+  }
+  /**
+   * Adds a listener.
+   *
+   * @param lis The listener to be added.
+   */
+  public void addListener(StreetsideRecordListener lis) {
+    this.listeners.add(lis);
+  }
+  /**
+   * Removes the given listener.
+   *
+   * @param lis The listener to be removed.
+   */
+  public void removeListener(StreetsideRecordListener lis) {
+    this.listeners.remove(lis);
+  }
+  /**
+   * Adds a new command to the list.
+   *
+   * @param command The command to be added.
+   */
+  public void addCommand(final StreetsideCommand command) {
+    if (command instanceof StreetsideExecutableCommand)
+      ((StreetsideExecutableCommand) command).execute();
+    // Checks if it is a continuation of last command
+    if (this.position != -1) {
+      boolean equalSets = true;
+      for (StreetsideAbstractImage img : this.commandList.get(this.position).images) {
+        equalSets = command.images.contains(img) && equalSets;
+      }
+      for (StreetsideAbstractImage img : command.images) {
+        equalSets = this.commandList.get(this.position).images.contains(img) && equalSets;
+      }
+      if (equalSets && this.commandList.get(this.position).getClass() == command.getClass()) {
+        this.commandList.get(this.position).sum(command);
+        fireRecordChanged();
+        return;
+      }
+    }
+    // Adds the command to the last position of the list.
+    this.commandList.add(this.position + 1, command);
+    this.position++;
+    while (this.commandList.size() > this.position + 1) {
+      this.commandList.remove(this.position + 1);
+    }
+    fireRecordChanged();
+  }
+  /**
+   * Undo latest command.
+   */
+  public void undo() {
+    if (this.position <= -1) {
+      return;
+    }
+    this.commandList.get(this.position).undo();
+    this.position--;
+    fireRecordChanged();
+  }
+  /**
+   * Redoes latest undone action.
+   */
+  public void redo() {
+    if (position + 1 >= commandList.size()) {
+      return;
+    }
+    this.position++;
+    this.commandList.get(this.position).redo();
+    fireRecordChanged();
+  }
+  private void fireRecordChanged() {
+    this.listeners.stream().filter(Objects::nonNull).forEach(StreetsideRecordListener::recordChanged);
+  }
+  /**
+   * Resets the object to its start state.
+   */
+  public void reset() {
+    this.commandList.clear();
+    this.position = -1;
+  }
+}
-/**
-* Returns the unique instance of the class.
+*
-* @return The unique instance of the class.
-*/
-public static synchronized StreetsideRecord getInstance() {
- if (StreetsideRecord.instance == null)
-   StreetsideRecord.instance = new StreetsideRecord();
- return StreetsideRecord.instance;
+}
-/**
-* Adds a listener.
+*
-* @param lis
-*          The listener to be added.
-*/
-public void addListener(StreetsideRecordListener lis) {
- this.listeners.add(lis);
+}
-/**
-* Removes the given listener.
+*
-* @param lis
-*          The listener to be removed.
-*/
-public void removeListener(StreetsideRecordListener lis) {
- this.listeners.remove(lis);
+}
-/**
-* Adds a new command to the list.
+*
-* @param command
-*          The command to be added.
-*/
-public void addCommand(final StreetsideCommand command) {
- if (command instanceof StreetsideExecutableCommand)
-   ((StreetsideExecutableCommand) command).execute();
- // Checks if it is a continuation of last command
- if (this.position != -1) {
-   boolean equalSets = true;
-   for (StreetsideAbstractImage img : this.commandList.get(this.position).images) {
-     equalSets = command.images.contains(img) && equalSets;
+   }
-   for (StreetsideAbstractImage img : command.images) {
-     equalSets = this.commandList.get(this.position).images.contains(img) && equalSets;
+   }
-   if (equalSets && this.commandList.get(this.position).getClass() == command.getClass()) {
-     this.commandList.get(this.position).sum(command);
-     fireRecordChanged();
-     return;
+   }
+ }
- // Adds the command to the last position of the list.
- this.commandList.add(this.position + 1, command);
- this.position++;
- while (this.commandList.size() > this.position + 1) {
-   this.commandList.remove(this.position + 1);
+ }
- fireRecordChanged();
+}
-/**
-* Undo latest command.
-*/
-public void undo() {
- if (this.position <= -1) {
-   return;
+ }
- this.commandList.get(this.position).undo();
- this.position--;
- fireRecordChanged();
+}
-/**
-* Redoes latest undone action.
-*/
-public void redo() {
- if (position + 1 >= commandList.size()) {
-   return;
+ }
- this.position++;
- this.commandList.get(this.position).redo();
- fireRecordChanged();
+}
-private void fireRecordChanged() {
- this.listeners.stream().filter(Objects::nonNull).forEach(StreetsideRecordListener::recordChanged);
+}
-/**
-* Resets the object to its start state.
-*/
-public void reset() {
- this.commandList.clear();
- this.position = -1;
+}
+}

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/history/StreetsideRecordListener.java

-              r34317
+              r36194
 public interface StreetsideRecordListener {
 /**
 * Fired when any command is undone or redone.
 */
 void recordChanged();
+  /**
+   * Fired when any command is undone or redone.
+   */
+  void recordChanged();
+}

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/history/commands/CommandJoin.java

r34317	r36194
27	27	* @param b the second image, that is joined with the first one
28	28	* @throws IllegalArgumentException if the images are already in the same sequence
29		* @throws NullPointerException if {@code a} or {@code b} is null
	29	* @throws NullPointerException if {@code a} or {@code b} is null
30	30	*/
31	31	public CommandJoin(final StreetsideAbstractImage a, final StreetsideAbstractImage b) {

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/history/commands/CommandMove.java

-              r34416
+              r36194
    * Main constructor.
+   *
+   * @param images
+   *          Set of images that are going to be moved.
+   * @param x
+   *          How much the x coordinate increases.
+   * @param y
+   *          How much the y coordinate increases.
+   * @param images Set of images that are going to be moved.
+   * @param x    How much the x coordinate increases.
+   * @param y    How much the y coordinate increases.
    */
+  public CommandMove(Set<StreetsideAbstractImage> images, double x,
+                     double y) {
+  public CommandMove(Set<StreetsideAbstractImage> images, double x, double y) {
     super(images);
     this.x = x;
 …
   @Override
   public String toString() {
+    return trn("Moved {0} image", "Moved {0} images", images.size(),
+        images.size());
+    return trn("Moved {0} image", "Moved {0} images", images.size(), images.size());
+  }

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/history/commands/CommandTurn.java

-              r34432
+              r36194
    * Main constructor.
+   *
+   * @param images
+   *          Set of images that is turned.
+   * @param ca
+   *          How much the images turn.
+   * @param images Set of images that is turned.
+   * @param ca   How much the images turn.
    */
   public CommandTurn(Set<StreetsideAbstractImage> images, double ca) {
 …
   @Override
   public String toString() {
+    return trn("Turned {0} image", "Turned {0} images", images.size(),
+        images.size());
+    return trn("Turned {0} image", "Turned {0} images", images.size(), images.size());
+  }

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/history/commands/CommandUnjoin.java

-              r34416
+              r36194
    * Main constructor.
+   *
+   * @param images
+   *          The two images that are going to be unjoined. Must be of exactly
+   *          size 2.
+   * @throws IllegalArgumentException
+   *           if the List size is different from 2.
+   * @param images The two images that are going to be unjoined. Must be of exactly
+   *         size 2.
+   * @throws IllegalArgumentException if the List size is different from 2.
    */
   public CommandUnjoin(List<StreetsideAbstractImage> images) {

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/history/commands/StreetsideCommand.java

-              r34317
+              r36194
 */
 public abstract class StreetsideCommand {
+/** Set of {@link StreetsideAbstractImage} objects affected by the command */
+public Set<StreetsideAbstractImage> images;
+  /**
+   * Set of {@link StreetsideAbstractImage} objects affected by the command
+   */
+  public Set<StreetsideAbstractImage> images;
+/**
+* Main constructor.
+*
+* @param images
+*          The images that are affected by the command.
+*/
+public StreetsideCommand(Set<StreetsideAbstractImage> images) {
+ this.images = new ConcurrentSkipListSet<>(images);
+  /**
+   * Main constructor.
+   *
+   * @param images The images that are affected by the command.
+   */
+  protected StreetsideCommand(Set<StreetsideAbstractImage> images) {
+    this.images = new ConcurrentSkipListSet<>(images);
+  }
+  /**
+   * Undoes the action.
+   */
+  public abstract void undo();
+  /**
+   * Redoes the action.
+   */
+  public abstract void redo();
+  /**
+   * If two equal commands are applied consecutively to the same set of images,
+   * they are summed in order to reduce them to just one command.
+   *
+   * @param command The command to be summed to last command.
+   */
+  public abstract void sum(StreetsideCommand command);
+  @Override
+  public abstract String toString();
+}
-/**
-* Undoes the action.
-*/
-public abstract void undo();
-/**
-* Redoes the action.
-*/
-public abstract void redo();
-/**
-* If two equal commands are applied consecutively to the same set of images,
-* they are summed in order to reduce them to just one command.
+*
-* @param command
-*          The command to be summed to last command.
-*/
-public abstract void sum(StreetsideCommand command);
-@Override
-public abstract String toString();
+}

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/history/commands/StreetsideExecutableCommand.java

-              r34317
+              r36194
 public abstract class StreetsideExecutableCommand extends StreetsideCommand {
+/**
+* Main constructor.
+*
+* @param images
+*          The set of images affected by the command.
+*/
+public StreetsideExecutableCommand(Set<StreetsideAbstractImage> images) {
+ super(images);
+  /**
+   * Main constructor.
+   *
+   * @param images The set of images affected by the command.
+   */
+  protected StreetsideExecutableCommand(Set<StreetsideAbstractImage> images) {
+    super(images);
+  }
+  /**
+   * Executes the command. It is run when the command is added to the history
+   * record.
+   */
+  public abstract void execute();
+}
-/**
-* Executes the command. It is run when the command is added to the history
-* record.
-*/
-public abstract void execute();
+}

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/io/download/BoundsDownloadRunnable.java

-              r34432
+              r36194
 import java.net.URL;
 import java.net.URLConnection;
-import java.text.MessageFormat;
 import java.util.function.Function;
+import java.util.logging.Logger;
-import org.apache.log4j.Logger;
 import org.openstreetmap.josm.data.Bounds;
 import org.openstreetmap.josm.gui.Notification;
 …
 import org.openstreetmap.josm.plugins.streetside.utils.StreetsideURL.APIv3;
 import org.openstreetmap.josm.tools.ImageProvider.ImageSizes;
+import org.openstreetmap.josm.tools.Logging;
 public abstract class BoundsDownloadRunnable implements Runnable {
   final static Logger logger = Logger.getLogger(BoundsDownloadRunnable.class);
+  private static final Logger LOGGER = Logger.getLogger(BoundsDownloadRunnable.class.getCanonicalName());
   protected Bounds bounds;
-  protected abstract Function<Bounds, URL> getUrlGenerator();
   public BoundsDownloadRunnable(final Bounds bounds) {
+  protected BoundsDownloadRunnable(final Bounds bounds) {
     this.bounds = bounds;
+  }
+  /**
+   * Logs information about the given connection via {@link Logger}.
+   * If it's a {@link HttpURLConnection}, the request method, the response code and the URL itself are logged.
+   * Otherwise only the URL is logged.
+   *
+   * @param con  the {@link URLConnection} for which information is logged
+   * @param info an additional info text, which is appended to the output in braces
+   * @throws IOException if {@link HttpURLConnection#getResponseCode()} throws an {@link IOException}
+   */
+  public static void logConnectionInfo(final URLConnection con, final String info) throws IOException {
+    final StringBuilder message;
+    if (con instanceof HttpURLConnection) {
+      message = new StringBuilder(((HttpURLConnection) con).getRequestMethod()).append(' ').append(con.getURL())
+          .append(" → ").append(((HttpURLConnection) con).getResponseCode());
+    } else {
+      message = new StringBuilder("Download from ").append(con.getURL());
+    }
+    if (info != null && info.length() >= 1) {
+      message.append(" (").append(info).append(')');
+    }
+    LOGGER.info(message::toString);
+  }
+  protected abstract Function<Bounds, URL> getUrlGenerator();
   @Override
   public void run() {
     URL nextURL = getUrlGenerator().apply(bounds);
     if(StreetsideProperties.DEBUGING_ENABLED.get()) {
       logger.debug(MessageFormat.format("Downloading bounds: URL: {0}", nextURL.toString()));
+    if (Boolean.TRUE.equals(StreetsideProperties.DEBUGING_ENABLED.get())) {
+      LOGGER.log(Logging.LEVEL_DEBUG, "Downloading bounds: URL: {0}", nextURL);
+    }
     try {
       while (nextURL != null) {
         if (Thread.interrupted()) {
+          logger.error(getClass().getSimpleName() + " for " +  bounds.toString() + " interrupted!");
+          LOGGER.log(Logging.LEVEL_ERROR, "{0} for {1} interrupted!",
+              new Object[] { getClass().getSimpleName(), bounds });
           return;
+        }
 …
+      }
     } catch (IOException e) {
       String message = "Could not read from URL " +  nextURL.toString() + "!";
       logger.warn(message, e);
+      String message = "Could not read from URL " + nextURL + "!";
+      LOGGER.log(Logging.LEVEL_WARN, message, e);
       if (!GraphicsEnvironment.isHeadless()) {
+        new Notification(message)
+          .setIcon(StreetsidePlugin.LOGO.setSize(ImageSizes.LARGEICON).get())
+          .setDuration(Notification.TIME_LONG)
+          .show();
+        new Notification(message).setIcon(StreetsidePlugin.LOGO.setSize(ImageSizes.LARGEICON).get())
+            .setDuration(Notification.TIME_LONG).show();
+      }
-      e.printStackTrace();
+    }
+  }
-  /**
-   * Logs information about the given connection via {@link Logger}.
-   * If it's a {@link HttpURLConnection}, the request method, the response code and the URL itself are logged.
-   * Otherwise only the URL is logged.
-   * @param con the {@link URLConnection} for which information is logged
-   * @param info an additional info text, which is appended to the output in braces
-   * @throws IOException if {@link HttpURLConnection#getResponseCode()} throws an {@link IOException}
-   */
-  public static void logConnectionInfo(final URLConnection con, final String info) throws IOException {
-    final StringBuilder message;
-    if (con instanceof HttpURLConnection) {
-      message = new StringBuilder(((HttpURLConnection) con).getRequestMethod())
-        .append(' ').append(con.getURL())
-        .append(" → ").append(((HttpURLConnection) con).getResponseCode());
-    } else {
-      message = new StringBuilder("Download from ").append(con.getURL());
+    }
-    if (info != null && info.length() >= 1) {
-      message.append(" (").append(info).append(')');
+    }
-    logger.info(message.toString());
+  }

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/io/download/SequenceDownloadRunnable.java

-              r34433
+              r36194
 package org.openstreetmap.josm.plugins.streetside.io.download;
-import java.io.BufferedInputStream;
 import java.io.IOException;
 import java.net.URL;
 …
 import java.util.List;
 import java.util.function.Function;
+import java.util.logging.Logger;
 import org.openstreetmap.josm.data.Bounds;
 …
 import org.openstreetmap.josm.plugins.streetside.utils.StreetsideSequenceIdGenerator;
 import org.openstreetmap.josm.plugins.streetside.utils.StreetsideURL.APIv3;
+import org.openstreetmap.josm.tools.Logging;
+import com.fasterxml.jackson.core.JsonParseException;
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.core.JsonToken;
+import com.fasterxml.jackson.databind.DeserializationFeature;
+import com.fasterxml.jackson.databind.JsonMappingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import jakarta.json.Json;
+import jakarta.json.JsonException;
+import jakarta.json.JsonObject;
+import jakarta.json.JsonValue;
+import jakarta.json.stream.JsonParser;
 public final class SequenceDownloadRunnable extends BoundsDownloadRunnable {
+        private final StreetsideData data;
+  private static final Logger LOG = Logger.getLogger(BoundsDownloadRunnable.class.getCanonicalName());
   private static final Function<Bounds, URL> URL_GEN = APIv3::searchStreetsideImages;
+  private final StreetsideData data;
   public SequenceDownloadRunnable(final StreetsideData data, final Bounds bounds) {
 …
     final long startTime = System.currentTimeMillis();
     ObjectMapper mapper = new ObjectMapper();
     // Creation of Jackson Object Mapper necessary for Silverlight 2.0 JSON Syntax parsing:
     // (no double quotes in JSON on attribute names)
     mapper.configure(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES, true);
+    try (JsonParser parser = Json.createParser(con.getInputStream())) {
+      if (!parser.hasNext() || parser.next() != JsonParser.Event.START_ARRAY) {
+        throw new IllegalStateException("Expected an array");
+      }
+    // Allow unrecognized properties - won't break with addition of new attributes
+    mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, true);
+      StreetsideImage previous = null;
+    try {
+      JsonParser parser = mapper.getFactory().createParser(new BufferedInputStream(con.getInputStream()));
+    if(parser.nextToken() != JsonToken.START_ARRAY) {
+      parser.close();
+      throw new IllegalStateException("Expected an array");
+    }
+    StreetsideImage previous = null;
+    while (parser.nextToken() == JsonToken.START_OBJECT) {
+      while (parser.hasNext() && parser.next() == JsonParser.Event.START_OBJECT) {
         // read everything from this START_OBJECT to the matching END_OBJECT
         // and return it as a tree model ObjectNode
         ObjectNode node = mapper.readTree(parser);
+        JsonObject node = parser.getObject();
         // Discard the first sequence ('enabled') - it does not contain bubble data
         if (node.get("id") != null && node.get("la") != null && node.get("lo") != null) {
+          StreetsideImage image = new StreetsideImage(CubemapUtils.convertDecimal2Quaternary(node.path("id").asLong()), new LatLon(node.path("la").asDouble(), node.get("lo").asDouble()), node.get("he").asDouble());
+          if(previous!=null) {
+          StreetsideImage image = new StreetsideImage(
+              CubemapUtils.convertDecimal2Quaternary(node.getJsonNumber("id").longValue()),
+              new LatLon(node.getJsonNumber("la").doubleValue(), node.getJsonNumber("lo").doubleValue()),
+              node.getJsonNumber("he").doubleValue());
+          if (previous != null) {
             image.setPr(Long.parseLong(previous.getId()));
             previous.setNe(Long.parseLong(image.getId()));
 …
+          }
           previous = image;
+          image.setAd(node.path("ad").asInt());
+          image.setAl(node.path("al").asDouble());
+          image.setBl(node.path("bl").asText());
+          image.setMl(node.path("ml").asInt());
+          image.setNbn(node.findValuesAsText("nbn"));
+          image.setNe(node.path("ne").asLong());
+          image.setPbn(node.findValuesAsText("pbn"));
+          image.setPi(node.path("pi").asDouble());
+          image.setPr(node.path("pr").asLong());
+          image.setRo(node.path("ro").asDouble());
+          if (node.containsKey("ad"))
+            image.setAd(node.getJsonNumber("ad").intValue());
+          if (node.containsKey("al"))
+            image.setAl(node.getJsonNumber("al").doubleValue());
+          if (node.containsKey("bl"))
+            image.setBl(node.getString("bl"));
+          if (node.containsKey("ml"))
+            image.setMl(node.getJsonNumber("ml").intValue());
+          if (node.containsKey("ne"))
+            image.setNe(node.getJsonNumber("ne").longValue());
+          if (node.containsKey("pi"))
+            image.setPi(node.getJsonNumber("pi").doubleValue());
+          if (node.containsKey("pr"))
+            image.setPr(node.getJsonNumber("pr").longValue());
+          if (node.containsKey("ro"))
+            image.setRo(node.getJsonNumber("ro").doubleValue());
+          if (node.containsKey("nbn"))
+              image.setNbn(node.getJsonArray("nbn").getValuesAs(JsonValue::toString));
+          if (node.containsKey("pbn"))
+              image.setPbn(node.getJsonArray("pbn").getValuesAs(JsonValue::toString));
           // Add list of cubemap tile images to images
 …
               // Initialize four-tiled cubemap faces (four images per cube side with 18-length
               // Quadkey)
               if (!StreetsideProperties.SHOW_HIGH_RES_STREETSIDE_IMAGERY.get()) {
                 StreetsideImage tile = new StreetsideImage(String.valueOf(image.getId() + Integer.valueOf(i)));
+              if (Boolean.FALSE.equals(StreetsideProperties.SHOW_HIGH_RES_STREETSIDE_IMAGERY.get())) {
+                StreetsideImage tile = new StreetsideImage(image.getId() + i);
                 tiles.add(tile);
+              }
               // Initialize four-tiled cubemap faces (four images per cub eside with 20-length
               // Quadkey)
               if (StreetsideProperties.SHOW_HIGH_RES_STREETSIDE_IMAGERY.get()) {
+              if (Boolean.TRUE.equals(StreetsideProperties.SHOW_HIGH_RES_STREETSIDE_IMAGERY.get())) {
                 for (int j = 0; j < 4; j++) {
+                  StreetsideImage tile = new StreetsideImage(
+                    String.valueOf(
+                      image.getId() + face.getValue() + CubemapUtils.rowCol2StreetsideCellAddressMap
+                        .get(String.valueOf(Integer.valueOf(i).toString() + Integer.valueOf(j).toString()))
+                      ));
+                  StreetsideImage tile = new StreetsideImage(image.getId() + face.getValue()
+                      + CubemapUtils.rowCol2StreetsideCellAddressMap
+                          .get(i + Integer.toString(j)));
                   tiles.add(tile);
+                }
 …
           });
           bubbleImages.add(image);
           logger.info("Added image with id <" + image.getId() + ">");
           if (StreetsideProperties.PREDOWNLOAD_CUBEMAPS.get()) {
+          bubbleImages.add(image);
+          LOG.info("Added image with id <" + image.getId() + ">");
+          if (Boolean.TRUE.equals(StreetsideProperties.PREDOWNLOAD_CUBEMAPS.get())) {
             StreetsideData.downloadSurroundingCubemaps(image);
+          }
         } else {
           logger.info(MessageFormat.format("Unparsable JSON node object: {0}",node.toString()));
+          LOG.info(MessageFormat.format("Unparsable JSON node object: {0}", node));
+        }
+      }
+    parser.close();
+    } catch (JsonParseException e) {
+      logger.error(MessageFormat.format("JSON parsing error occured during Streetside sequence download {0}",e.getMessage()));
+    } catch (JsonMappingException e) {
+      logger.error(MessageFormat.format("JSON mapping error occured during Streetside sequence download {0}",e.getMessage()));
+    } catch (ClassCastException | JsonException e) {
+      LOG.log(Logging.LEVEL_ERROR, e, () -> MessageFormat
+          .format("JSON parsing error occurred during Streetside sequence download {0}", e.getMessage()));
     } catch (IOException e) {
+      logger.error(MessageFormat.format("Input/output error occured during Streetside sequence download {0}",e.getMessage()));
+      LOG.log(Logging.LEVEL_ERROR, e, () -> MessageFormat
+          .format("Input/output error occurred during Streetside sequence download {0}", e.getMessage()));
+    }
+    /** Top Level Bubble Metadata in Streetside are bubble (aka images) not Sequences
+    /*
+     * Top Level Bubble Metadata in Streetside are bubble (aka images) not Sequences
      *  so a sequence needs to be created and have images added to it. If the distribution
      *  of Streetside images is non-sequential, the Mapillary "Walking Action" may behave
      *  unpredictably.
      **/
+     */
     seq.add(bubbleImages);
     if (StreetsideProperties.CUT_OFF_SEQUENCES_AT_BOUNDS.get()) {
+    if (Boolean.TRUE.equals(StreetsideProperties.CUT_OFF_SEQUENCES_AT_BOUNDS.get())) {
       for (StreetsideAbstractImage img : seq.getImages()) {
         if (bounds.contains(img.getLatLon())) {
 …
     final long endTime = System.currentTimeMillis();
+    logger.info(MessageFormat.format("Sucessfully loaded {0} Microsoft Streetside images in {1} seconds.", seq.getImages().size(),(endTime-startTime)/1000));
+    LOG.info(MessageFormat.format("Successfully loaded {0} Microsoft Streetside images in {1} seconds.",
+        seq.getImages().size(), (endTime - startTime) / 1000));
+  }

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/io/download/StreetsideDownloader.java

-              r34399
+              r36194
 import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
+import org.apache.log4j.Logger;
+import java.util.logging.Logger;
 import org.openstreetmap.josm.data.Bounds;
 import org.openstreetmap.josm.data.coor.LatLon;
 …
 import org.openstreetmap.josm.plugins.streetside.utils.StreetsideProperties;
 import org.openstreetmap.josm.tools.I18n;
+import org.openstreetmap.josm.tools.Logging;
 /**
 …
 public final class StreetsideDownloader {
+  final static Logger logger = Logger.getLogger(StreetsideDownloader.class);
+  /** Possible download modes. */
+  private static final Logger LOGGER = Logger.getLogger(StreetsideDownloader.class.getCanonicalName());
+  /**
+   * Max area to be downloaded
+   */
+  private static final double MAX_AREA = StreetsideProperties.MAX_DOWNLOAD_AREA.get();
+  /**
+   * Executor that will run the petitions.
+   */
+  private static ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 5, 100, TimeUnit.SECONDS,
+      new ArrayBlockingQueue<>(100), new ThreadPoolExecutor.DiscardPolicy());
+  /**
+   * Indicates whether the last download request has been rejected because it requested an area that was too big.
+   * Iff true, the last download has been rejected, if false, it was executed.
+   */
+  private static boolean stoppedDownload;
+  private StreetsideDownloader() {
+    // Private constructor to avoid instantiation
+  }
+  /**
+   * Downloads all images of the area covered by the OSM data.
+   */
+  public static void downloadOSMArea() {
+    if (MainApplication.getLayerManager().getEditLayer() == null) {
+      return;
+    }
+    if (isAreaTooBig(MainApplication.getLayerManager().getEditLayer().data.getDataSourceBounds().stream()
+        .map(Bounds::getArea).reduce(0.0, Double::sum))) {
+      return;
+    }
+    MainApplication.getLayerManager().getEditLayer().data.getDataSourceBounds().stream()
+        .filter(bounds -> !StreetsideLayer.getInstance().getData().getBounds().contains(bounds))
+        .forEach(bounds -> {
+          StreetsideLayer.getInstance().getData().getBounds().add(bounds);
+          StreetsideDownloader.getImages(bounds.getMin(), bounds.getMax());
+        });
+  }
+  /**
+   * Gets all the images in a square. It downloads all the images of all the
+   * sequences that pass through the given rectangle.
+   *
+   * @param minLatLon The minimum latitude and longitude of the rectangle.
+   * @param maxLatLon The maximum latitude and longitude of the rectangle
+   */
+  public static void getImages(LatLon minLatLon, LatLon maxLatLon) {
+    if (minLatLon == null || maxLatLon == null) {
+      throw new IllegalArgumentException();
+    }
+    getImages(new Bounds(minLatLon, maxLatLon));
+  }
+  /**
+   * Gets the images within the given bounds.
+   *
+   * @param bounds A {@link Bounds} object containing the area to be downloaded.
+   */
+  public static void getImages(Bounds bounds) {
+    run(new StreetsideSquareDownloadRunnable(bounds));
+  }
+  /**
+   * Returns the current download mode.
+   *
+   * @return the currently enabled {@link DOWNLOAD_MODE}
+   */
+  public static DOWNLOAD_MODE getMode() {
+    return DOWNLOAD_MODE.fromPrefId(StreetsideProperties.DOWNLOAD_MODE.get());
+  }
+  private static void run(Runnable t) {
+    executor.execute(t);
+  }
+  /**
+   * If some part of the current view has not been downloaded, it is downloaded.
+   */
+  public static void downloadVisibleArea() {
+    Bounds view = MainApplication.getMap().mapView.getRealBounds();
+    if (isAreaTooBig(view.getArea())) {
+      return;
+    }
+    if (isViewDownloaded(view)) {
+      return;
+    }
+    StreetsideLayer.getInstance().getData().getBounds().add(view);
+    getImages(view);
+  }
+  private static boolean isViewDownloaded(Bounds view) {
+    int n = 15;
+    boolean[][] inside = new boolean[n][n];
+    for (int i = 0; i < n; i++) {
+      for (int j = 0; j < n; j++) {
+        if (isInBounds(new LatLon(view.getMinLat() + (view.getMaxLat() - view.getMinLat()) * ((double) i / n),
+            view.getMinLon() + (view.getMaxLon() - view.getMinLon()) * ((double) j / n)))) {
+          inside[i][j] = true;
+        }
+      }
+    }
+    for (int i = 0; i < n; i++) {
+      for (int j = 0; j < n; j++) {
+        if (!inside[i][j])
+          return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Checks if the given {@link LatLon} object lies inside the bounds of the
+   * image.
+   *
+   * @param latlon The coordinates to check.
+   * @return true if it lies inside the bounds; false otherwise;
+   */
+  private static boolean isInBounds(LatLon latlon) {
+    return StreetsideLayer.getInstance().getData().getBounds().parallelStream().anyMatch(b -> b.contains(latlon));
+  }
+  /**
+   * Checks if the area for which Streetside images should be downloaded is too big. This means that probably
+   * lots of Streetside images are going to be downloaded, slowing down the
+   * program too much. A notification is shown when the download has stopped or continued.
+   *
+   * @param area area to check
+   * @return {@code true} if the area is too big
+   */
+  private static boolean isAreaTooBig(final double area) {
+    final boolean tooBig = area > MAX_AREA;
+    if (!stoppedDownload && tooBig) {
+      new Notification(I18n
+          .tr("The Streetside layer has stopped downloading images, because the requested area is too big!")
+          + (getMode() == DOWNLOAD_MODE.VISIBLE_AREA
+              ? "\n" + I18n
+                  .tr("To solve this problem, you could zoom in and load a smaller area of the map.")
+              : (getMode() == DOWNLOAD_MODE.OSM_AREA ? "\n" + I18n.tr(
+                  "To solve this problem, you could switch to download mode ''{0}'' and load Streetside images for a smaller portion of the map.",
+                  DOWNLOAD_MODE.MANUAL_ONLY) : ""))).setIcon(StreetsidePlugin.LOGO.get())
+                      .setDuration(Notification.TIME_LONG).show();
+    }
+    if (stoppedDownload && !tooBig) {
+      new Notification("The Streetside layer now continues to download images…")
+          .setIcon(StreetsidePlugin.LOGO.get()).show();
+    }
+    stoppedDownload = tooBig;
+    return tooBig;
+  }
+  /**
+   * Stops all running threads.
+   */
+  public static void stopAll() {
+    executor.shutdownNow();
+    try {
+      executor.awaitTermination(30, TimeUnit.SECONDS);
+    } catch (InterruptedException e) {
+      LOGGER.log(Logging.LEVEL_ERROR, e.getMessage(), e);
+    }
+    executor = new ThreadPoolExecutor(3, 5, 100, TimeUnit.SECONDS, new ArrayBlockingQueue<>(100),
+        new ThreadPoolExecutor.DiscardPolicy());
+  }
+  /**
+   * Possible download modes.
+   */
   public enum DOWNLOAD_MODE {
     VISIBLE_AREA("visibleArea", I18n.tr("everything in the visible area")),
 …
     MANUAL_ONLY("manualOnly", I18n.tr("only when manually requested"));
     public final static DOWNLOAD_MODE DEFAULT = OSM_AREA;
+    public static final DOWNLOAD_MODE DEFAULT = OSM_AREA;
     private final String prefId;
 …
       this.prefId = prefId;
       this.label = label;
+    }
+    public static DOWNLOAD_MODE fromPrefId(String prefId) {
+      for (DOWNLOAD_MODE mode : DOWNLOAD_MODE.values()) {
+        if (mode.getPrefId().equals(prefId)) {
+          return mode;
+        }
+      }
+      return DEFAULT;
+    }
+    public static DOWNLOAD_MODE fromLabel(String label) {
+      for (DOWNLOAD_MODE mode : DOWNLOAD_MODE.values()) {
+        if (mode.getLabel().equals(label)) {
+          return mode;
+        }
+      }
+      return DEFAULT;
+    }
 …
       return label;
+    }
-    public static DOWNLOAD_MODE fromPrefId(String prefId) {
-      for (DOWNLOAD_MODE mode : DOWNLOAD_MODE.values()) {
-        if (mode.getPrefId().equals(prefId)) {
-          return mode;
+        }
+      }
-      return DEFAULT;
+    }
-    public static DOWNLOAD_MODE fromLabel(String label) {
-      for (DOWNLOAD_MODE mode : DOWNLOAD_MODE.values()) {
-        if (mode.getLabel().equals(label)) {
-          return mode;
+        }
+      }
-      return DEFAULT;
+    }
+  }
-  /** Max area to be downloaded */
-  private static final double MAX_AREA = StreetsideProperties.MAX_DOWNLOAD_AREA.get();
-  /** Executor that will run the petitions. */
-  private static ThreadPoolExecutor executor = new ThreadPoolExecutor(
-, 5, 100, TimeUnit.SECONDS, new ArrayBlockingQueue<>(100), new ThreadPoolExecutor.DiscardPolicy());
-  /**
-   * Indicates whether the last download request has been rejected because it requested an area that was too big.
-   * Iff true, the last download has been rejected, if false, it was executed.
-   */
-  private static boolean stoppedDownload;
-  private StreetsideDownloader() {
-    // Private constructor to avoid instantiation
+  }
-  /**
-   * Gets all the images in a square. It downloads all the images of all the
-   * sequences that pass through the given rectangle.
+   *
-   * @param minLatLon The minimum latitude and longitude of the rectangle.
-   * @param maxLatLon The maximum latitude and longitude of the rectangle
-   */
-  public static void getImages(LatLon minLatLon, LatLon maxLatLon) {
-    if (minLatLon == null || maxLatLon == null) {
-      throw new IllegalArgumentException();
+    }
-    getImages(new Bounds(minLatLon, maxLatLon));
+  }
-  /**
-   * Gets the images within the given bounds.
+   *
-   * @param bounds A {@link Bounds} object containing the area to be downloaded.
-   */
-  public static void getImages(Bounds bounds) {
-    run(new StreetsideSquareDownloadRunnable(bounds));
+  }
-  /**
-   * Returns the current download mode.
+   *
-   * @return the currently enabled {@link DOWNLOAD_MODE}
-   */
-  public static DOWNLOAD_MODE getMode() {
-    return DOWNLOAD_MODE.fromPrefId(StreetsideProperties.DOWNLOAD_MODE.get());
+  }
-  private static void run(Runnable t) {
-    executor.execute(t);
+  }
-  /**
-   * If some part of the current view has not been downloaded, it is downloaded.
-   */
-  public static void downloadVisibleArea() {
-    Bounds view = MainApplication.getMap().mapView.getRealBounds();
-    if (isAreaTooBig(view.getArea())) {
-      return;
+    }
-    if (isViewDownloaded(view)) {
-      return;
+    }
-    StreetsideLayer.getInstance().getData().getBounds().add(view);
-    getImages(view);
+  }
-  private static boolean isViewDownloaded(Bounds view) {
-    int n = 15;
-    boolean[][] inside = new boolean[n][n];
-    for (int i = 0; i < n; i++) {
-      for (int j = 0; j < n; j++) {
-        if (isInBounds(new LatLon(view.getMinLat()
-          + (view.getMaxLat() - view.getMinLat()) * ((double) i / n),
-          view.getMinLon() + (view.getMaxLon() - view.getMinLon())
-            * ((double) j / n)))) {
-          inside[i][j] = true;
+        }
+      }
+    }
-    for (int i = 0; i < n; i++) {
-      for (int j = 0; j < n; j++) {
-        if (!inside[i][j])
-          return false;
+      }
+    }
-    return true;
+  }
-  /**
-   * Checks if the given {@link LatLon} object lies inside the bounds of the
-   * image.
+   *
-   * @param latlon The coordinates to check.
+   *
-   * @return true if it lies inside the bounds; false otherwise;
-   */
-  private static boolean isInBounds(LatLon latlon) {
-    return StreetsideLayer.getInstance().getData().getBounds().parallelStream().anyMatch(b -> b.contains(latlon));
+  }
-  /**
-   * Downloads all images of the area covered by the OSM data.
-   */
-  public static void downloadOSMArea() {
-    if (MainApplication.getLayerManager().getEditLayer() == null) {
-      return;
+    }
-    if (isAreaTooBig(MainApplication.getLayerManager().getEditLayer().data.getDataSourceBounds().parallelStream().map(Bounds::getArea).reduce(0.0, Double::sum))) {
-      return;
+    }
-    MainApplication.getLayerManager().getEditLayer().data.getDataSourceBounds().stream().filter(bounds -> !StreetsideLayer.getInstance().getData().getBounds().contains(bounds)).forEach(bounds -> {
-      StreetsideLayer.getInstance().getData().getBounds().add(bounds);
-      StreetsideDownloader.getImages(bounds.getMin(), bounds.getMax());
-    });
+  }
-  /**
-   * Checks if the area for which Streetside images should be downloaded is too big. This means that probably
-   * lots of Streetside images are going to be downloaded, slowing down the
-   * program too much. A notification is shown when the download has stopped or continued.
-   * @param area area to check
-   * @return {@code true} if the area is too big
-   */
-  private static boolean isAreaTooBig(final double area) {
-    final boolean tooBig = area > MAX_AREA;
-    if (!stoppedDownload && tooBig) {
-      new Notification(
-        I18n.tr("The Streetside layer has stopped downloading images, because the requested area is too big!") + (
-          getMode() == DOWNLOAD_MODE.VISIBLE_AREA
-          ? "\n"+I18n.tr("To solve this problem, you could zoom in and load a smaller area of the map.")
-          : (getMode() == DOWNLOAD_MODE.OSM_AREA ? "\n"+I18n.tr("To solve this problem, you could switch to download mode ''{0}'' and load Streetside images for a smaller portion of the map.", DOWNLOAD_MODE.MANUAL_ONLY): "")
+        )
-      ).setIcon(StreetsidePlugin.LOGO.get()).setDuration(Notification.TIME_LONG).show();
+    }
-    if (stoppedDownload && !tooBig) {
-      new Notification("The Streetside layer now continues to download images…").setIcon(StreetsidePlugin.LOGO.get()).show();
+    }
-    stoppedDownload = tooBig;
-    return tooBig;
+  }
-  /**
-   * Stops all running threads.
-   */
-  public static void stopAll() {
-    executor.shutdownNow();
-    try {
-      executor.awaitTermination(30, TimeUnit.SECONDS);
-    } catch (InterruptedException e) {
-      logger.error(e);
+    }
-    executor = new ThreadPoolExecutor(3, 5, 100, TimeUnit.SECONDS,
-      new ArrayBlockingQueue<>(100), new ThreadPoolExecutor.DiscardPolicy());
+  }
+}

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/io/download/StreetsideSquareDownloadRunnable.java

-              r34412
+              r36194
 package org.openstreetmap.josm.plugins.streetside.io.download;
-import org.apache.log4j.Logger;
 import org.openstreetmap.josm.data.Bounds;
 import org.openstreetmap.josm.plugins.streetside.StreetsideLayer;
 …
 public class StreetsideSquareDownloadRunnable implements Runnable {
-  final static Logger logger = Logger.getLogger(StreetsideSquareDownloadRunnable.class);
   private final Bounds bounds;
 …
+   *
    * @param bounds the bounds of the area that should be downloaded
+   *
    */
   public StreetsideSquareDownloadRunnable(Bounds bounds) {

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/io/export/StreetsideExportDownloadThread.java

-              r34416
+              r36194
 import java.io.IOException;
 import java.util.concurrent.ArrayBlockingQueue;
+import java.util.logging.Logger;
 import javax.imageio.ImageIO;
-import org.apache.log4j.Logger;
 import org.openstreetmap.josm.data.cache.CacheEntry;
 import org.openstreetmap.josm.data.cache.CacheEntryAttributes;
 …
 import org.openstreetmap.josm.plugins.streetside.cache.CacheUtils;
 import org.openstreetmap.josm.plugins.streetside.cache.StreetsideCache;
+import org.openstreetmap.josm.tools.Logging;
 /**
 …
  * @see StreetsideExportWriterThread
  */
+public class StreetsideExportDownloadThread extends Thread implements
+    ICachedLoaderListener {
+public class StreetsideExportDownloadThread extends Thread implements ICachedLoaderListener {
   final static Logger logger = Logger.getLogger(StreetsideExportDownloadThread.class);
+  private static final Logger LOGGER = Logger.getLogger(StreetsideExportDownloadThread.class.getCanonicalName());
   private final ArrayBlockingQueue<BufferedImage> queue;
 …
    * Main constructor.
+   *
+   * @param image
+   *          Image to be downloaded.
+   * @param queue
+   *          Queue of {@link BufferedImage} objects for the
+   * @param image     Image to be downloaded.
+   * @param queue     Queue of {@link BufferedImage} objects for the
    *          {@link StreetsideExportWriterThread}.
+   * @param queueImages
+   *          Queue of {@link StreetsideAbstractImage} objects for the
+   * @param queueImages Queue of {@link StreetsideAbstractImage} objects for the
    *          {@link StreetsideExportWriterThread}.
    */
+  public StreetsideExportDownloadThread(StreetsideImage image,
+      ArrayBlockingQueue<BufferedImage> queue,
+  public StreetsideExportDownloadThread(StreetsideImage image, ArrayBlockingQueue<BufferedImage> queue,
       ArrayBlockingQueue<StreetsideAbstractImage> queueImages) {
     this.queue = queue;
 …
   @Override
+  public synchronized void loadingFinished(CacheEntry data,
+      CacheEntryAttributes attributes, LoadResult result) {
+  public synchronized void loadingFinished(CacheEntry data, CacheEntryAttributes attributes, LoadResult result) {
     try {
       synchronized (StreetsideExportDownloadThread.class) {
+        queue
+            .put(ImageIO.read(new ByteArrayInputStream(data.getContent())));
+        queue.put(ImageIO.read(new ByteArrayInputStream(data.getContent())));
         queueImages.put(image);
+      }
     } catch (InterruptedException | IOException e) {
       logger.error(e);
+      LOGGER.log(Logging.LEVEL_ERROR, e.getMessage(), e);
+    }
+  }

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/io/export/StreetsideExportManager.java

-              r34429
+              r36194
 import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
+import java.util.logging.Logger;
-import org.apache.log4j.Logger;
 import org.openstreetmap.josm.gui.PleaseWaitRunnable;
 import org.openstreetmap.josm.gui.progress.swing.PleaseWaitProgressMonitor;
 import org.openstreetmap.josm.plugins.streetside.StreetsideAbstractImage;
 import org.openstreetmap.josm.plugins.streetside.StreetsideImage;
+import org.openstreetmap.josm.tools.Logging;
 /**
 …
 public class StreetsideExportManager extends PleaseWaitRunnable {
   final static Logger logger = Logger.getLogger(StreetsideExportManager.class);
+  private static final Logger LOGGER = Logger.getLogger(StreetsideExportManager.class.getCanonicalName());
   private final ArrayBlockingQueue<BufferedImage> queue = new ArrayBlockingQueue<>(10);
   private final ArrayBlockingQueue<StreetsideAbstractImage> queueImages = new ArrayBlockingQueue<>(10);
   private int amount;
   private Set<StreetsideAbstractImage> images;
   private String path;
+  private final int amount;
+  private final Set<StreetsideAbstractImage> images;
+  private final String path;
   private Thread writer;
 …
+   *
    * @param images Set of {@link StreetsideAbstractImage} objects to be exported.
    * @param path Export path.
+   * @param path   Export path.
    */
   public StreetsideExportManager(Set<StreetsideAbstractImage> images, String path) {
+    super(
+      tr("Downloading") + "…",
+      new PleaseWaitProgressMonitor(tr("Exporting Streetside Images")),
+      true
+    );
+    super(tr("Downloading") + "…", new PleaseWaitProgressMonitor(tr("Exporting Streetside Images")), true);
     this.images = images == null ? new HashSet<>() : images;
     this.path = path;
 …
   protected void realRun() throws IOException {
     // Starts a writer thread in order to write the pictures on the disk.
+    writer = new StreetsideExportWriterThread(path, queue,
+        queueImages, amount, getProgressMonitor());
+    writer = new StreetsideExportWriterThread(path, queue, queueImages, amount, getProgressMonitor());
     writer.start();
     if (path == null) {
 …
         writer.join();
       } catch (InterruptedException e) {
         logger.error(e);
+        LOGGER.log(Logging.LEVEL_ERROR, e.getMessage(), e);
+      }
       return;
+    }
+    ex = new ThreadPoolExecutor(20, 35, 25, TimeUnit.SECONDS,
+      new ArrayBlockingQueue<>(10));
+    ex = new ThreadPoolExecutor(20, 35, 25, TimeUnit.SECONDS, new ArrayBlockingQueue<>(10));
     for (StreetsideAbstractImage image : images) {
       if (image instanceof StreetsideImage) {
         try {
+          ex.execute(new StreetsideExportDownloadThread(
+              (StreetsideImage) image, queue, queueImages));
+          ex.execute(new StreetsideExportDownloadThread((StreetsideImage) image, queue, queueImages));
         } catch (Exception e) {
           logger.error(e);
+          LOGGER.log(Logging.LEVEL_ERROR, e.getMessage(), e);
+        }
+      }
 …
+        }
       } catch (Exception e) {
         logger.error(e);
+        LOGGER.log(Logging.LEVEL_ERROR, e.getMessage(), e);
+      }
+    }
 …
       writer.join();
     } catch (InterruptedException e) {
       logger.error(e);
+      LOGGER.log(Logging.LEVEL_ERROR, e.getMessage(), e);
+    }
+  }

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/io/export/StreetsideExportWriterThread.java

-              r34429
+              r36194
 import java.io.OutputStream;
 import java.util.concurrent.ArrayBlockingQueue;
+import java.util.logging.Logger;
 import javax.imageio.ImageIO;
 …
 import org.apache.commons.imaging.formats.tiff.write.TiffOutputDirectory;
 import org.apache.commons.imaging.formats.tiff.write.TiffOutputSet;
-import org.apache.log4j.Logger;
 import org.openstreetmap.josm.gui.progress.ProgressMonitor;
 import org.openstreetmap.josm.gui.progress.swing.PleaseWaitProgressMonitor;
 import org.openstreetmap.josm.plugins.streetside.StreetsideAbstractImage;
+import org.openstreetmap.josm.tools.Logging;
 /**
 …
 public class StreetsideExportWriterThread extends Thread {
   final static Logger logger = Logger.getLogger(StreetsideExportWriterThread.class);
+  private static final Logger LOGGER = Logger.getLogger(StreetsideExportWriterThread.class.getCanonicalName());
   private final String path;
 …
    * Main constructor.
+   *
+   * @param path
+   *          Path to write the pictures.
+   * @param queue
+   *          Queue of {@link StreetsideAbstractImage} objects.
+   * @param queueImages
+   *          Queue of {@link BufferedImage} objects.
+   * @param amount
+   *          Amount of images that are going to be exported.
+   * @param monitor
+   *          Progress monitor.
+   * @param path    Path to write the pictures.
+   * @param queue     Queue of {@link StreetsideAbstractImage} objects.
+   * @param queueImages Queue of {@link BufferedImage} objects.
+   * @param amount    Amount of images that are going to be exported.
+   * @param monitor   Progress monitor.
    */
+  public StreetsideExportWriterThread(String path,
+      ArrayBlockingQueue<BufferedImage> queue,
+      ArrayBlockingQueue<StreetsideAbstractImage> queueImages, int amount,
+      ProgressMonitor monitor) {
+  public StreetsideExportWriterThread(String path, ArrayBlockingQueue<BufferedImage> queue,
+      ArrayBlockingQueue<StreetsideAbstractImage> queueImages, int amount, ProgressMonitor monitor) {
     this.path = path;
     this.queue = queue;
 …
         img = queue.take();
         mimg = queueImages.take();
         // Transforms the image into a byte array.
 …
         gpsDirectory.removeField(GpsTagConstants.GPS_TAG_GPS_IMG_DIRECTION);
+        gpsDirectory.add(GpsTagConstants.GPS_TAG_GPS_IMG_DIRECTION,
+            RationalNumber.valueOf(mimg.getMovingHe()));
+        gpsDirectory.add(GpsTagConstants.GPS_TAG_GPS_IMG_DIRECTION, RationalNumber.valueOf(mimg.getMovingHe()));
         exifDirectory.removeField(ExifTagConstants.EXIF_TAG_DATE_TIME_ORIGINAL);
 …
         os.close();
       } catch (InterruptedException e) {
         logger.info("Streetside export cancelled");
+        LOGGER.info("Streetside export cancelled");
         return;
       } catch (IOException | ImageReadException | ImageWriteException e) {
         logger.error(e);
+        LOGGER.log(Logging.LEVEL_ERROR, e.getMessage(), e);
+      }

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/mode/AbstractMode.java

-              r34400
+              r36194
  * @see StreetsideLayer
  */
+public abstract class AbstractMode extends MouseAdapter implements
+  ZoomChangeListener {
+public abstract class AbstractMode extends MouseAdapter implements ZoomChangeListener {
   private static final int DOWNLOAD_COOLDOWN = 2000;
 …
   public int cursor = Cursor.DEFAULT_CURSOR;
+  /**
+   * Resets the semiautomatic mode thread.
+   */
+  public static void resetThread() {
+    semiautomaticThread.interrupt();
+    semiautomaticThread = new SemiautomaticThread();
+  }
   protected StreetsideAbstractImage getClosest(Point clickPoint) {
     double snapDistance = 10;
 …
       imagePoint.setLocation(imagePoint.getX(), imagePoint.getY());
       double dist = clickPoint.distanceSq(imagePoint);
+      if (minDistance > dist && clickPoint.distance(imagePoint) < snapDistance
+        && image.isVisible()) {
+      if (minDistance > dist && clickPoint.distance(imagePoint) < snapDistance && image.isVisible()) {
         minDistance = dist;
         closest = image;
 …
    * Paint the dataset using the engine set.
+   *
    * @param g {@link Graphics2D} used for painting
    * @param mv The object that can translate GeoPoints to screen coordinates.
+   * @param g   {@link Graphics2D} used for painting
+   * @param mv  The object that can translate GeoPoints to screen coordinates.
    * @param box Area where painting is going to be performed
    */
 …
+  }
-  /**
-   * Resets the semiautomatic mode thread.
-   */
-  public static void resetThread() {
-    semiautomaticThread.interrupt();
-    semiautomaticThread = new SemiautomaticThread();
+  }
   private static class SemiautomaticThread extends Thread {
+    /** If in semiautomatic mode, the last Epoch time when there was a download */
+    /**
+     * If in semiautomatic mode, the last Epoch time when there was a download
+     */
     private long lastDownload;

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/mode/SelectMode.java

-              r34627
+              r36194
  */
 public class SelectMode extends AbstractMode {
+  private final StreetsideRecord record;
   private StreetsideAbstractImage closest;
   private StreetsideAbstractImage lastClicked;
-  private final StreetsideRecord record;
   private boolean nothingHighlighted;
   private boolean imageHighlighted;
 …
+    }
     StreetsideAbstractImage closest = getClosest(e.getPoint());
     if (!(MainApplication.getLayerManager().getActiveLayer() instanceof StreetsideLayer)
             && closest != null && MainApplication.getMap().mapMode == MainApplication.getMap().mapModeSelect) {
+    if (!(MainApplication.getLayerManager().getActiveLayer() instanceof StreetsideLayer) && closest != null
+        && MainApplication.getMap().mapMode == MainApplication.getMap().mapModeSelect) {
       lastClicked = this.closest;
       StreetsideLayer.getInstance().getData().setSelectedImage(closest);
 …
+    }
     // Double click
+    if (e.getClickCount() == 2 && StreetsideLayer.getInstance().getData().getSelectedImage() != null && closest != null) {
+    if (e.getClickCount() == 2 && StreetsideLayer.getInstance().getData().getSelectedImage() != null
+        && closest != null) {
       closest.getSequence().getImages().forEach(StreetsideLayer.getInstance().getData()::addMultiSelectedImage);
+    }
 …
       StreetsideLayer.getInstance().getData().addMultiSelectedImage(closest);
       // shift + click
+    } else if (
+            e.getModifiers() == (InputEvent.BUTTON1_MASK | InputEvent.SHIFT_MASK)
+                    && lastClicked instanceof StreetsideImage
+            ) {
+      if (this.closest != null
+              && this.closest.getSequence() == lastClicked.getSequence()) {
+    } else if (e.getModifiers() == (InputEvent.BUTTON1_MASK | InputEvent.SHIFT_MASK)
+        && lastClicked instanceof StreetsideImage) {
+      if (this.closest != null && this.closest.getSequence() == lastClicked.getSequence()) {
         int i = this.closest.getSequence().getImages().indexOf(this.closest);
         int j = lastClicked.getSequence().getImages().indexOf(lastClicked);
+        StreetsideLayer.getInstance().getData().addMultiSelectedImage(
+                i < j
+                        ? new ConcurrentSkipListSet<>(this.closest.getSequence().getImages().subList(i, j + 1))
+                        : new ConcurrentSkipListSet<>(this.closest.getSequence().getImages().subList(j, i + 1))
+        );
+        StreetsideLayer.getInstance().getData().addMultiSelectedImage(i < j
+            ? new ConcurrentSkipListSet<>(this.closest.getSequence().getImages().subList(i, j + 1))
+            : new ConcurrentSkipListSet<>(this.closest.getSequence().getImages().subList(j, i + 1)));
+      }
       // click
 …
   public void mouseDragged(MouseEvent e) {
     StreetsideAbstractImage highlightImg = StreetsideLayer.getInstance().getData().getHighlightedImage();
+    if (
+            MainApplication.getLayerManager().getActiveLayer() == StreetsideLayer.getInstance()
+                && SwingUtilities.isLeftMouseButton(e)
+                && highlightImg != null && highlightImg.getLatLon() != null
+            ) {
+    if (MainApplication.getLayerManager().getActiveLayer() == StreetsideLayer.getInstance()
+        && SwingUtilities.isLeftMouseButton(e) && highlightImg != null && highlightImg.getLatLon() != null) {
       Point highlightImgPoint = MainApplication.getMap().mapView.getPoint(highlightImg.getTempLatLon());
       if (e.isShiftDown()) { // turn
+        StreetsideLayer.getInstance().getData().getMultiSelectedImages().parallelStream().filter(img -> !(img instanceof StreetsideImage) || StreetsideProperties.DEVELOPER.get())
+                .forEach(img -> img.turn(Math.toDegrees(Math.atan2(e.getX() - highlightImgPoint.getX(), -e.getY() + highlightImgPoint.getY())) - highlightImg.getTempHe()));
+        StreetsideLayer.getInstance().getData().getMultiSelectedImages().parallelStream()
+            .filter(img -> !(img instanceof StreetsideImage) || StreetsideProperties.DEVELOPER.get())
+            .forEach(img -> img.turn(Math.toDegrees(
+                Math.atan2(e.getX() - highlightImgPoint.getX(), -e.getY() + highlightImgPoint.getY()))
+                - highlightImg.getTempHe()));
       } else { // move
         LatLon eventLatLon = MainApplication.getMap().mapView.getLatLon(e.getX(), e.getY());
+        LatLon imgLatLon = MainApplication.getMap().mapView.getLatLon(highlightImgPoint.getX(), highlightImgPoint.getY());
+        StreetsideLayer.getInstance().getData().getMultiSelectedImages().parallelStream().filter(img -> !(img instanceof StreetsideImage) || StreetsideProperties.DEVELOPER.get())
+                .forEach(img -> img.move(eventLatLon.getX() - imgLatLon.getX(), eventLatLon.getY() - imgLatLon.getY()));
+        LatLon imgLatLon = MainApplication.getMap().mapView.getLatLon(highlightImgPoint.getX(),
+            highlightImgPoint.getY());
+        StreetsideLayer.getInstance().getData().getMultiSelectedImages().parallelStream()
+            .filter(img -> !(img instanceof StreetsideImage) || StreetsideProperties.DEVELOPER.get())
+            .forEach(img -> img.move(eventLatLon.getX() - imgLatLon.getX(),
+                eventLatLon.getY() - imgLatLon.getY()));
+      }
       StreetsideLayer.invalidateInstance();
 …
       double to = data.getSelectedImage().getMovingHe();
       record.addCommand(new CommandTurn(data.getMultiSelectedImages(), to - from));
+    } else if (!Objects.equals(data.getSelectedImage().getTempLatLon(), data.getSelectedImage().getMovingLatLon())) {
+    } else if (!Objects.equals(data.getSelectedImage().getTempLatLon(),
+        data.getSelectedImage().getMovingLatLon())) {
       LatLon from = data.getSelectedImage().getTempLatLon();
       LatLon to = data.getSelectedImage().getMovingLatLon();
+      record.addCommand(new CommandMove(data.getMultiSelectedImages(), to.getX() - from.getX(), to.getY() - from.getY()));
+      record.addCommand(
+          new CommandMove(data.getMultiSelectedImages(), to.getX() - from.getX(), to.getY() - from.getY()));
+    }
+    data.getMultiSelectedImages().parallelStream().filter(Objects::nonNull).forEach(StreetsideAbstractImage::stopMoving);
+    data.getMultiSelectedImages().parallelStream().filter(Objects::nonNull)
+        .forEach(StreetsideAbstractImage::stopMoving);
     StreetsideLayer.invalidateInstance();
+  }
 …
   public void mouseMoved(MouseEvent e) {
     if (MainApplication.getLayerManager().getActiveLayer() instanceof OsmDataLayer
             && MainApplication.getMap().mapMode != MainApplication.getMap().mapModeSelect) {
+        && MainApplication.getMap().mapMode != MainApplication.getMap().mapModeSelect) {
       return;
+    }
     if (!StreetsideProperties.HOVER_ENABLED.get()) {
+    if (Boolean.FALSE.equals(StreetsideProperties.HOVER_ENABLED.get())) {
       return;
+    }
 …
       StreetsideMainDialog.getInstance().updateImage(false);
+    } else if (StreetsideLayer.getInstance().getData().getHighlightedImage() != closestTemp && closestTemp == null) {
+    } else if (StreetsideLayer.getInstance().getData().getHighlightedImage() != closestTemp
+        && closestTemp == null) {
       StreetsideLayer.getInstance().getData().setHighlightedImage(null);
       StreetsideMainDialog.getInstance().setImage(StreetsideLayer.getInstance().getData().getSelectedImage());

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/model/ImageDetection.java

-              r34317
+              r36194
   private final String value;
+  public ImageDetection(final Path2D shape, final String imageKey, final String key, final double score, final String packag, final String value) {
+  public ImageDetection(final Path2D shape, final String imageKey, final String key, final double score,
+      final String packag, final String value) {
     super(shape, imageKey, key);
     this.packag = packag;

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/model/KeyIndexedObject.java

r34317	r36194
46	46	}
47	47	KeyIndexedObject other = (KeyIndexedObject) obj;
48		if (!key.equals(other.key)) {
49		return false;
50		}
51		return true;
	48	return key.equals(other.key);
52	49	}
53	50

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/model/MapObject.java

-              r34416
+              r36194
   private final long updatedTime;
+  public MapObject(
+    final LatLon coordinate, final String key, final String objPackage, final String value,
+    long firstSeenTime, long lastSeenTime, long updatedTime
+  ) {
+  public MapObject(final LatLon coordinate, final String key, final String objPackage, final String value,
+      long firstSeenTime, long lastSeenTime, long updatedTime) {
     super(key);
     if (objPackage == null || value == null || coordinate == null) {
 …
+  }
-  public LatLon getCoordinate() {
-    return coordinate;
+  }
   /**
    * @param objectTypeID the {@link String} representing the type of map object. This ID can be retrieved via
    *   {@link #getValue()} for any given {@link MapObject}.
+   *           {@link #getValue()} for any given {@link MapObject}.
    * @return the icon, which represents the given objectTypeID
    */
 …
+    }
     return cachedIcon;
+  }
+  public LatLon getCoordinate() {
+    return coordinate;
+  }

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/oauth/OAuthPortListener.java

-              r34577
+              r36194
 // License: GPL. For details, see LICENSE file.
 package org.openstreetmap.josm.plugins.streetside.oauth;
 import java.io.IOException;
 …
 import java.net.ServerSocket;
 import java.net.Socket;
+import java.nio.charset.StandardCharsets;
 import java.util.Scanner;
+import java.util.logging.Logger;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
-import org.apache.log4j.Logger;
 import org.openstreetmap.josm.plugins.streetside.utils.StreetsideProperties;
 import org.openstreetmap.josm.tools.I18n;
+import org.openstreetmap.josm.tools.Logging;
 /**
 …
 */
 public class OAuthPortListener extends Thread {
+public static final int PORT = 8763;
+  public static final int PORT = 8763;
+  protected static final String RESPONSE = String.format(
+      "<!DOCTYPE html><html><head><meta charset=\"utf8\"><title>%s</title></head><body>%s</body></html>",
+      I18n.tr("Streetside login"), I18n.tr("Login successful, return to JOSM."));
+  private static final Logger LOGGER = Logger.getLogger(OAuthPortListener.class.getCanonicalName());
+  private final StreetsideLoginListener callback;
+final static Logger logger = Logger.getLogger(OAuthPortListener.class);
+  public OAuthPortListener(StreetsideLoginListener loginCallback) {
+    callback = loginCallback;
+  }
+protected static final String RESPONSE = String.format(
    "<!DOCTYPE html><html><head><meta charset=\"utf8\"><title>%s</title></head><body>%s</body></html>",
    I18n.tr("Streetside login"),
    I18n.tr("Login successful, return to JOSM.")
 );
+private final StreetsideLoginListener callback;
+  private static void writeContent(PrintWriter out) {
+    out.println("HTTP/1.1 200 OK");
+    out.println("Content-Length: " + RESPONSE.length());
+    out.println("Content-Type: text/html" + "\r\n\r\n");
+    out.println(RESPONSE);
+  }
+public OAuthPortListener(StreetsideLoginListener loginCallback) {
+ callback = loginCallback;
+  @Override
+  public void run() {
+    try (ServerSocket serverSocket = new ServerSocket(PORT);
+        Socket clientSocket = serverSocket.accept();
+        PrintWriter out = new PrintWriter(
+            new OutputStreamWriter(clientSocket.getOutputStream(), StandardCharsets.UTF_8), true);
+        Scanner in = new Scanner(
+            new InputStreamReader(clientSocket.getInputStream(), StandardCharsets.UTF_8))) {
+      String s;
+      String accessToken = null;
+      while (in.hasNextLine()) {
+        s = in.nextLine();
+        Matcher tokenMatcher = Pattern.compile("^.*&access_token=([^&]+)&.*$").matcher('&' + s + '&');
+        if (tokenMatcher.matches()) {
+          accessToken = tokenMatcher.group(1);
+          break;
+        } else if (s.contains("keep-alive")) {
+          break;
+        }
+      }
+      writeContent(out);
+      out.flush();
+      StreetsideUser.reset();
+      LOGGER.info(I18n.tr("Successful login with Streetside, the access token is: {0}", accessToken));
+      // Saves the access token in preferences.
+      StreetsideUser.setTokenValid(true);
+      StreetsideProperties.ACCESS_TOKEN.put(accessToken);
+      String username = StreetsideUser.getUsername();
+      LOGGER.info(I18n.tr("The username is: {0}", username));
+      if (callback != null) {
+        callback.onLogin(username);
+      }
+    } catch (BindException e) {
+      LOGGER.log(Logging.LEVEL_WARN, e.getMessage(), e);
+    } catch (IOException e) {
+      LOGGER.log(Logging.LEVEL_ERROR, e.getMessage(), e);
+    }
+  }
+}
-@Override
-public void run() {
- try (
-     ServerSocket serverSocket = new ServerSocket(PORT);
-     Socket clientSocket = serverSocket.accept();
-     PrintWriter out = new PrintWriter(new OutputStreamWriter(clientSocket.getOutputStream(), "UTF-8"), true);
-     Scanner in = new Scanner(new InputStreamReader(clientSocket.getInputStream(), "UTF-8"))
- ) {
-   String s;
-   String accessToken = null;
-   while (in.hasNextLine()) {
-     s = in.nextLine();
-     Matcher tokenMatcher = Pattern.compile("^.*&access_token=([^&]+)&.*$").matcher('&'+s+'&');
-     if (tokenMatcher.matches()) {
-       accessToken = tokenMatcher.group(1);
-       break;
-     } else if (s.contains("keep-alive")) {
-       break;
+     }
+   }
-   writeContent(out);
-   out.flush();
-   StreetsideUser.reset();
-   logger.info(I18n.tr("Successful login with Streetside, the access token is: {0}", accessToken));
-   // Saves the access token in preferences.
-   StreetsideUser.setTokenValid(true);
-     StreetsideProperties.ACCESS_TOKEN.put(accessToken);
-     String username = StreetsideUser.getUsername();
-     logger.info(I18n.tr("The username is: {0}", username));
-     if (callback != null) {
-       callback.onLogin(username);
+     }
- } catch (BindException e) {
-   logger.warn(e);
- } catch (IOException e) {
-   logger.error(e);
+ }
+}
-private static void writeContent(PrintWriter out) {
- out.println("HTTP/1.1 200 OK");
- out.println("Content-Length: " + RESPONSE.length());
- out.println("Content-Type: text/html" + "\r\n\r\n");
- out.println(RESPONSE);
+}
+}

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/oauth/OAuthUtils.java

-              r36122
+              r36194
 import java.net.HttpURLConnection;
 import java.net.URL;
+import java.nio.charset.StandardCharsets;
+import org.openstreetmap.josm.plugins.streetside.utils.StreetsideProperties;
 import jakarta.json.Json;
 …
 import jakarta.json.JsonObject;
 import jakarta.json.JsonReader;
-import org.openstreetmap.josm.plugins.streetside.utils.StreetsideProperties;
 /**
 …
 public final class OAuthUtils {
+private OAuthUtils() {
+ // Private constructor to avoid instantiation
+  private OAuthUtils() {
+    // Private constructor to avoid instantiation
+  }
+  /**
+   * Returns a JsonObject containing the result of making a GET request with the
+   * authorization header.
+   *
+   * @param url The {@link URL} where the request must be made.
+   * @return A JsonObject containing the result of the GET request.
+   * @throws IOException Errors relating to the connection.
+   */
+  public static JsonObject getWithHeader(URL url) throws IOException {
+    HttpURLConnection con = (HttpURLConnection) url.openConnection();
+    con.setRequestMethod("GET");
+    con.setRequestProperty("Authorization", "Bearer " + StreetsideProperties.ACCESS_TOKEN.get());
+    try (JsonReader reader = Json.createReader(
+        new BufferedReader(new InputStreamReader(con.getInputStream(), StandardCharsets.UTF_8)))) {
+      return reader.readObject();
+    } catch (JsonException e) {
+      throw new IOException(e);
+    }
+  }
+}
-/**
-* Returns a JsonObject containing the result of making a GET request with the
-* authorization header.
+*
-* @param url
-*          The {@link URL} where the request must be made.
-* @return A JsonObject containing the result of the GET request.
-* @throws IOException
-*           Errors relating to the connection.
-*/
-public static JsonObject getWithHeader(URL url) throws IOException {
- HttpURLConnection con = (HttpURLConnection) url.openConnection();
- con.setRequestMethod("GET");
- con.setRequestProperty("Authorization", "Bearer " + StreetsideProperties.ACCESS_TOKEN.get());
- try (
-   JsonReader reader = Json.createReader(new BufferedReader(new InputStreamReader(con.getInputStream(), "UTF-8")))
- ) {
-   return reader.readObject();
- } catch (JsonException e) {
-   throw new IOException(e);
+ }
+}
+}

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/oauth/StreetsideLoginListener.java

-              r34317
+              r36194
    * Should be called whenever the user logs into a mapillary account.
    * E.g. for updating the GUI to reflect the login status.
+   *
    * @param username the username that the user is now logged in with
    */
   void onLogin(final String username);
   /**
    * Should be called whenever the user logs out of a mapillary account.

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/oauth/StreetsideUser.java

-              r34400
+              r36194
 // License: GPL. For details, see LICENSE file.
 package org.openstreetmap.josm.plugins.streetside.oauth;
 import java.util.Map;
 …
 public final class StreetsideUser {
+private static String username;
+private static String imagesPolicy;
+private static String imagesHash;
+/** If the stored token is valid or not. */
+private static boolean isTokenValid = true;
+  private static String username;
+  private static String imagesPolicy;
+  private static String imagesHash;
+  /**
+   * If the stored token is valid or not.
+   */
+  private static boolean isTokenValid = true;
+private StreetsideUser() {
+ // Private constructor to avoid instantiation
+  private StreetsideUser() {
+    // Private constructor to avoid instantiation
+  }
+  /**
+   * @return The username of the logged in user.
+   */
+  public static synchronized String getUsername() {
+    // users are not currently supported in Streetside
+    return null;
+  }
+  /**
+   * @return A HashMap object containing the images_policy and images_hash
+   * strings.
+   */
+  public static synchronized Map<String, String> getSecrets() {
+    // secrets are not currently supported in Streetside
+    return null;
+  }
+  /**
+   * Resets the MapillaryUser to null values.
+   */
+  public static synchronized void reset() {
+    username = null;
+    imagesPolicy = null;
+    imagesHash = null;
+    isTokenValid = false;
+    StreetsideProperties.ACCESS_TOKEN.put(StreetsideProperties.ACCESS_TOKEN.getDefaultValue());
+  }
+  public static synchronized void setTokenValid(boolean value) {
+    isTokenValid = value;
+  }
+}
-/**
-* @return The username of the logged in user.
-*/
-public static synchronized String getUsername() {
-   // users are not currently supported in Streetside
-   return null;
+}
-/**
-* @return A HashMap object containing the images_policy and images_hash
-*         strings.
-*/
-public static synchronized Map<String, String> getSecrets() {
-  // secrets are not currently supported in Streetside
-  return null;
+}
-/**
-* Resets the MapillaryUser to null values.
-*/
-public static synchronized void reset() {
- username = null;
- imagesPolicy = null;
- imagesHash = null;
- isTokenValid = false;
- StreetsideProperties.ACCESS_TOKEN.put(StreetsideProperties.ACCESS_TOKEN.getDefaultValue());
+}
-public static synchronized void setTokenValid(boolean value) {
- isTokenValid = value;
+}
+}

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/utils/GraphicsUtils.java

-              r34577
+              r36194
 import java.awt.image.BufferedImage;
 import java.text.MessageFormat;
+import java.util.logging.Logger;
 import org.apache.log4j.Logger;
+import org.openstreetmap.josm.tools.Logging;
 import javafx.application.Platform;
 import javafx.scene.image.PixelWriter;
-//import javafx.embed.swing.SwingFXUtils;
-//import javafx.scene.image.Image;
 import javafx.scene.image.WritableImage;
-@SuppressWarnings({ "restriction"})
 public class GraphicsUtils {
   final static Logger logger = Logger.getLogger(GraphicsUtils.class);
+  private static final Logger LOGGER = Logger.getLogger(GraphicsUtils.class.getCanonicalName());
   private GraphicsUtils() {
 …
+  }
         public static javafx.scene.image.Image convertBufferedImage2JavaFXImage(BufferedImage bf) {
                 WritableImage res = null;
                 if (bf != null) {
                         res = new WritableImage(bf.getWidth(), bf.getHeight());
                         PixelWriter pw = res.getPixelWriter();
                         for (int x = 0; x < bf.getWidth(); x++) {
                                 for (int y = 0; y < bf.getHeight(); y++) {
                                         pw.setArgb(x, y, bf.getRGB(x, y));
+                                }
+                        }
+                }
                 return res;
+        }
+  public static javafx.scene.image.Image convertBufferedImage2JavaFXImage(BufferedImage bf) {
+    WritableImage res = null;
+    if (bf != null) {
+      res = new WritableImage(bf.getWidth(), bf.getHeight());
+      PixelWriter pw = res.getPixelWriter();
+      for (int x = 0; x < bf.getWidth(); x++) {
+        for (int y = 0; y < bf.getHeight(); y++) {
+          pw.setArgb(x, y, bf.getRGB(x, y));
+        }
+      }
+    }
+    return res;
+  }
         public static class PlatformHelper {
+  public static BufferedImage buildMultiTiledCubemapFaceImage(final BufferedImage[] tiles) {
+          private PlatformHelper() {
+            // Private constructor to avoid instantiation
+          }
+    long start = System.currentTimeMillis();
+          public static void run(Runnable treatment) {
+            if(treatment == null) throw new IllegalArgumentException("The treatment to perform can not be null");
+    BufferedImage res = null;
+            if(Platform.isFxApplicationThread()) treatment.run();
+            else Platform.runLater(treatment);
+        }
+    }
+    int pixelBuffer = Boolean.TRUE.equals(StreetsideProperties.SHOW_HIGH_RES_STREETSIDE_IMAGERY.get()) ? 2 : 1;
+        public static BufferedImage buildMultiTiledCubemapFaceImage(final BufferedImage[] tiles) {
+    BufferedImage[] croppedTiles = cropMultiTiledImages(tiles, pixelBuffer);
+                long start = System.currentTimeMillis();
+    // we assume the no. of rows and cols are known and each chunk has equal width and height
+    int rows = Boolean.TRUE.equals(StreetsideProperties.SHOW_HIGH_RES_STREETSIDE_IMAGERY.get()) ? 4 : 2;
+    int cols = Boolean.TRUE.equals(StreetsideProperties.SHOW_HIGH_RES_STREETSIDE_IMAGERY.get()) ? 4 : 2;
+          BufferedImage res = null;
+    int chunkWidth;
+    int chunkHeight;
+                int pixelBuffer = StreetsideProperties.SHOW_HIGH_RES_STREETSIDE_IMAGERY.get()?2:1;
+    chunkWidth = croppedTiles[0].getWidth();
+    chunkHeight = croppedTiles[0].getHeight();
+                BufferedImage[] croppedTiles = cropMultiTiledImages(tiles, pixelBuffer);
+    //Initializing the final image
+    BufferedImage img = new BufferedImage(chunkWidth * cols, chunkHeight * rows, BufferedImage.TYPE_INT_ARGB);
+                int rows = StreetsideProperties.SHOW_HIGH_RES_STREETSIDE_IMAGERY.get()?4:2; //we assume the no. of rows and cols are known and each chunk has equal width and height
+        int cols = StreetsideProperties.SHOW_HIGH_RES_STREETSIDE_IMAGERY.get()?4:2;
+        int chunkWidth, chunkHeight;
+        chunkWidth = croppedTiles[0].getWidth();
+        chunkHeight = croppedTiles[0].getHeight();
+        //Initializing the final image
+        BufferedImage img = new BufferedImage(chunkWidth*cols, chunkHeight*rows, BufferedImage.TYPE_INT_ARGB);
+        int num = 0;
+        for (int i = 0; i < rows; i++) {
+            for (int j = 0; j < cols; j++) {
+    int num = 0;
+    for (int i = 0; i < rows; i++) {
+      for (int j = 0; j < cols; j++) {
         // TODO: unintended mirror image created with draw call - requires
         // extra reversal step - fix!
         img.createGraphics().drawImage(croppedTiles[num], chunkWidth * j, (chunkHeight * i), null);
+        int width = StreetsideProperties.SHOW_HIGH_RES_STREETSIDE_IMAGERY.get() ? 1014 : 510;
+        int width = Boolean.TRUE.equals(StreetsideProperties.SHOW_HIGH_RES_STREETSIDE_IMAGERY.get()) ? 1014
+            : 510;
         int height = width;
         // BufferedImage for mirror image
+        res = new BufferedImage(
+          width,
+          height, BufferedImage.TYPE_INT_ARGB);
+        res = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
         // Create mirror image pixel by pixel
 …
+    }
     if (StreetsideProperties.DEBUGING_ENABLED.get()) {
       logger
         .debug(MessageFormat.format("Image concatenated in {0} millisecs.", (System.currentTimeMillis() - start)));
+    if (Boolean.TRUE.equals(StreetsideProperties.DEBUGING_ENABLED.get())) {
+      LOGGER.log(Logging.LEVEL_DEBUG,
+          MessageFormat.format("Image concatenated in {0} millisecs.", (System.currentTimeMillis() - start)));
+    }
     return res;
+        }
+  }
+        public static BufferedImage rotateImage(BufferedImage bufImg) {
+                AffineTransform tx = AffineTransform.getScaleInstance(-1, -1);
+            tx.translate(-bufImg.getWidth(null), -bufImg.getHeight(null));
+            AffineTransformOp op = new AffineTransformOp(tx,
+                AffineTransformOp.TYPE_NEAREST_NEIGHBOR);
+            bufImg = op.filter(bufImg, null);
+            return bufImg;
+        }
+  public static BufferedImage rotateImage(BufferedImage bufImg) {
+    AffineTransform tx = AffineTransform.getScaleInstance(-1, -1);
+    tx.translate(-bufImg.getWidth(null), -bufImg.getHeight(null));
+    AffineTransformOp op = new AffineTransformOp(tx, AffineTransformOp.TYPE_NEAREST_NEIGHBOR);
+    bufImg = op.filter(bufImg, null);
+    return bufImg;
+  }
         private static BufferedImage[] cropMultiTiledImages(BufferedImage[] tiles, int pixelBuffer) {
+  private static BufferedImage[] cropMultiTiledImages(BufferedImage[] tiles, int pixelBuffer) {
                 long start = System.currentTimeMillis();
+    long start = System.currentTimeMillis();
           BufferedImage[] res = new BufferedImage[tiles.length];
+    BufferedImage[] res = new BufferedImage[tiles.length];
                         for(int i=0; i<tiles.length;i++) {
                                 if(StreetsideProperties.SHOW_HIGH_RES_STREETSIDE_IMAGERY.get()) {
                                         res[i] = tiles[i].getSubimage(pixelBuffer, pixelBuffer, 256-pixelBuffer, 256-pixelBuffer);
                                 } else {
                                         res[i] = tiles[i].getSubimage(pixelBuffer, pixelBuffer, 256-pixelBuffer, 256-pixelBuffer);
+                                }
+                        }
+    for (int i = 0; i < tiles.length; i++) {
+      if (Boolean.TRUE.equals(StreetsideProperties.SHOW_HIGH_RES_STREETSIDE_IMAGERY.get())) {
+        res[i] = tiles[i].getSubimage(pixelBuffer, pixelBuffer, 256 - pixelBuffer, 256 - pixelBuffer);
+      } else {
+        res[i] = tiles[i].getSubimage(pixelBuffer, pixelBuffer, 256 - pixelBuffer, 256 - pixelBuffer);
+      }
+    }
+                if(StreetsideProperties.DEBUGING_ENABLED.get()) {
+                        logger.debug(MessageFormat.format("Images cropped in {0} millisecs.", (System.currentTimeMillis()-start)));
+                }
+    if (Boolean.TRUE.equals(StreetsideProperties.DEBUGING_ENABLED.get())) {
+      LOGGER.log(Logging.LEVEL_DEBUG,
+          MessageFormat.format("Images cropped in {0} millisecs.", (System.currentTimeMillis() - start)));
+    }
+                return res;
+        }
+    return res;
+  }
+  public static class PlatformHelper {
+    private PlatformHelper() {
+      // Private constructor to avoid instantiation
+    }
+    public static void run(Runnable treatment) {
+      if (treatment == null)
+        throw new IllegalArgumentException("The treatment to perform can not be null");
+      if (Platform.isFxApplicationThread())
+        treatment.run();
+      else
+        Platform.runLater(treatment);
+    }
+  }
+}

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/utils/ImageUtil.java

-              r34365
+              r36194
 import java.awt.Image;
+import java.util.logging.Logger;
 import javax.swing.ImageIcon;
-import org.apache.log4j.Logger;
 import org.openstreetmap.josm.tools.I18n;
+import org.openstreetmap.josm.tools.Logging;
 public final class ImageUtil {
   final static Logger logger = Logger.getLogger(ImageUtil.class);
+  private static final Logger LOGGER = Logger.getLogger(ImageUtil.class.getCanonicalName());
   private ImageUtil() {
 …
   /**
    * Scales an {@link ImageIcon} to the desired size
+   *
    * @param icon the icon, which should be resized
    * @param size the desired length of the longest edge of the icon
    * @return the resized {@link ImageIcon}. It is the same object that you put in,
    *         only the contained {@link Image} is exchanged.
+   * only the contained {@link Image} is exchanged.
    */
   public static ImageIcon scaleImageIcon(final ImageIcon icon, int size) {
     if(StreetsideProperties.DEBUGING_ENABLED.get()) {
       logger.debug(I18n.tr("Scale icon {0} → {1}", icon.getIconWidth(), size));
+    if (Boolean.TRUE.equals(StreetsideProperties.DEBUGING_ENABLED.get())) {
+      LOGGER.log(Logging.LEVEL_DEBUG, I18n.tr("Scale icon {0} → {1}", icon.getIconWidth(), size));
+    }
+    return new ImageIcon(icon.getImage().getScaledInstance(
+      icon.getIconWidth() >= icon.getIconHeight() ? size : Math.max(1, Math.round(icon.getIconWidth() / (float) icon.getIconHeight() * size)),
+      icon.getIconHeight() >= icon.getIconWidth() ? size : Math.max(1, Math.round(icon.getIconHeight() / (float) icon.getIconWidth() * size)),
+      Image.SCALE_SMOOTH
+    ));
+    return new ImageIcon(
+        icon.getImage()
+            .getScaledInstance(
+                icon.getIconWidth() >= icon.getIconHeight() ? size
+                    : Math.max(1,
+                        Math.round(icon.getIconWidth() / (float) icon.getIconHeight() * size)),
+                icon.getIconHeight() >= icon.getIconWidth() ? size
+                    : Math.max(1,
+                        Math.round(icon.getIconHeight() / (float) icon.getIconWidth() * size)),
+                Image.SCALE_SMOOTH));
+  }
+}

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/utils/MapViewGeometryUtil.java

-              r34317
+              r36194
  * can then easily be drawn on a {@link MapView}s {@link Graphics2D}-context.
  */
 public final  class MapViewGeometryUtil {
+public final class MapViewGeometryUtil {
   private MapViewGeometryUtil() {
     // Private constructor to avoid instantiation
 …
   /**
    * Subtracts the download bounds from the rectangular bounds of the map view.
+   * @param mv the MapView that is used for the LatLon-to-Point-conversion and that determines
+   *     the Bounds from which the downloaded Bounds are subtracted
+   *
+   * @param mv       the MapView that is used for the LatLon-to-Point-conversion and that determines
+   *             the Bounds from which the downloaded Bounds are subtracted
    * @param downloadBounds multiple {@link Bounds} objects that represent the downloaded area
    * @return the difference between the {@link MapView}s bounds and the downloaded area
 …
       Point p1 = mv.getPoint(bounds.getMin());
       Point p2 = mv.getPoint(bounds.getMax());
       Rectangle r = new Rectangle(Math.min(p1.x, p2.x), Math.min(p1.y, p2.y),
           Math.abs(p2.x - p1.x), Math.abs(p2.y - p1.y));
+      Rectangle r = new Rectangle(Math.min(p1.x, p2.x), Math.min(p1.y, p2.y), Math.abs(p2.x - p1.x),
+          Math.abs(p2.y - p1.y));
       a.subtract(new Area(r));
+    }
 …
    * Converts a {@link StreetsideSequence} into a {@link Path2D} that can be drawn
    * on the specified {@link NavigatableComponent}'s {@link Graphics2D}-context.
+   * @param nc the {@link NavigatableComponent} for which this conversion should be performed, typically a {@link MapView}
+   *
+   * @param nc  the {@link NavigatableComponent} for which this conversion should be performed, typically a {@link MapView}
    * @param seq the sequence to convert
    * @return the {@link Path2D} object to which the {@link StreetsideSequence} has been converted

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/utils/PluginState.java

-              r34577
+              r36194
 import static org.openstreetmap.josm.tools.I18n.tr;
+import java.util.logging.Logger;
 import javax.swing.JOptionPane;
-import org.apache.log4j.Logger;
 import org.openstreetmap.josm.gui.MainApplication;
 import org.openstreetmap.josm.tools.I18n;
+import org.openstreetmap.josm.tools.Logging;
 /**
 …
 public final class PluginState {
   final static Logger logger = Logger.getLogger(PluginState.class);
+  private static final Logger LOGGER = Logger.getLogger(PluginState.class.getCanonicalName());
   private static boolean submittingChangeset;
   private static int runningDownloads;
+  /** Images that have to be uploaded. */
+  /**
+   * Images that have to be uploaded.
+   */
   private static int imagesToUpload;
+  /** Images that have been uploaded. */
+  /**
+   * Images that have been uploaded.
+   */
   private static int imagesUploaded;
 …
   public static void finishDownload() {
     if (runningDownloads == 0) {
       logger.warn(I18n.tr("The amount of running downloads is equal to 0"));
+      LOGGER.log(Logging.LEVEL_WARN, I18n.tr("The amount of running downloads is equal to 0"));
       return;
+    }
 …
     return submittingChangeset;
+  }
+   /**
+  public static void setSubmittingChangeset(boolean isSubmitting) {
+    submittingChangeset = isSubmitting;
+  }
+  /**
    * Checks if there is any running upload.
+   *
 …
    * Sets the amount of images that are going to be uploaded.
+   *
+   * @param amount
+   *          The amount of images that are going to be uploaded.
+   * @param amount The amount of images that are going to be uploaded.
    */
   public static void addImagesToUpload(int amount) {
 …
     imagesUploaded++;
     if (imagesToUpload == imagesUploaded) {
         finishedUploadDialog(imagesUploaded);
+      finishedUploadDialog(imagesUploaded);
+    }
+  }
   private static void finishedUploadDialog(int numImages) {
+    JOptionPane.showMessageDialog(
+      MainApplication.getMainFrame(),
+      tr("You have successfully uploaded {0} images to Bing.com", numImages),
+      tr("Finished upload"),
+      JOptionPane.INFORMATION_MESSAGE
+    );
+    JOptionPane.showMessageDialog(MainApplication.getMainFrame(),
+        tr("You have successfully uploaded {0} images to Bing.com", numImages), tr("Finished upload"),
+        JOptionPane.INFORMATION_MESSAGE);
+  }
   public static void notLoggedInToMapillaryDialog() {
+    JOptionPane.showMessageDialog(
+        MainApplication.getMainFrame(),
+    JOptionPane.showMessageDialog(MainApplication.getMainFrame(),
         tr("You are not logged in, please log in to Streetside in the preferences"),
+        tr("Not Logged in to Streetside"),
+        JOptionPane.WARNING_MESSAGE
+    );
+        tr("Not Logged in to Streetside"), JOptionPane.WARNING_MESSAGE);
+  }
 …
     return tr("Uploading: {0}", "(" + imagesUploaded + "/" + imagesToUpload + ")");
+  }
-  public static void setSubmittingChangeset(boolean isSubmitting) {
-      submittingChangeset = isSubmitting;
+  }
+}

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/utils/StreetsideColorScheme.java

-              r34317
+              r36194
   /**
    * Styles the given components as default panels (currently only the background is set to white)
+   *
    * @param components the components to style as default panels (e.g. checkboxes also, that's why
    *   not only JPanels are accepted)
+   *           not only JPanels are accepted)
    */
   public static void styleAsDefaultPanel(JComponent... components) {

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/utils/StreetsideProperties.java

-              r34433
+              r36194
 public final class StreetsideProperties {
+  public static final BooleanProperty DELETE_AFTER_UPLOAD = new BooleanProperty("streetside.delete-after-upload", true);
+  public static final BooleanProperty DELETE_AFTER_UPLOAD = new BooleanProperty("streetside.delete-after-upload",
+      true);
   public static final BooleanProperty DEVELOPER = new BooleanProperty("streetside.developer", false);
   public static final BooleanProperty DISPLAY_HOUR = new BooleanProperty("streetside.display-hour", true);
 …
   public static final BooleanProperty MOVE_TO_IMG = new BooleanProperty("streetside.move-to-picture", true);
   public static final BooleanProperty TIME_FORMAT_24 = new BooleanProperty("streetside.format-24", false);
+  public static final BooleanProperty IMAGE_LINK_TO_BLUR_EDITOR = new BooleanProperty("streetside.image-link-to-blur-editor", true);
+  public static final BooleanProperty CUBEMAP_LINK_TO_BLUR_EDITOR = new BooleanProperty("streetside.cubemap-link-to-blur-editor", true);
+  public static final IntegerProperty TILE_DOWNLOAD_THREAD_PAUSE_LEN_SEC = new IntegerProperty("streetside.tile-download-thread-pause-len-sec", 60);
+  public static final BooleanProperty PREDOWNLOAD_CUBEMAPS = new BooleanProperty("streetside.predownload-cubemaps", false);
+  public static final BooleanProperty IMAGE_LINK_TO_BLUR_EDITOR = new BooleanProperty(
+      "streetside.image-link-to-blur-editor", true);
+  public static final BooleanProperty CUBEMAP_LINK_TO_BLUR_EDITOR = new BooleanProperty(
+      "streetside.cubemap-link-to-blur-editor", true);
+  public static final IntegerProperty TILE_DOWNLOAD_THREAD_PAUSE_LEN_SEC = new IntegerProperty(
+      "streetside.tile-download-thread-pause-len-sec", 60);
+  public static final BooleanProperty PREDOWNLOAD_CUBEMAPS = new BooleanProperty("streetside.predownload-cubemaps",
+      false);
   public static final BooleanProperty DEBUGING_ENABLED = new BooleanProperty("streetside.debugging-enabled", false);
+  public static final BooleanProperty DOWNLOAD_CUBEFACE_TILES_TOGETHER = new BooleanProperty("streetside.download-cubeface-tiles-together", false);
+  public static final BooleanProperty DOWNLOAD_CUBEFACE_TILES_TOGETHER = new BooleanProperty(
+      "streetside.download-cubeface-tiles-together", false);
   /**
 …
    * Otherwise only all images (!) inside the download bounds are added, the others are discarded.
    */
   public static final BooleanProperty CUT_OFF_SEQUENCES_AT_BOUNDS =
     new BooleanProperty("streetside.cut-off-sequences-at-bounds", false);
+  public static final BooleanProperty CUT_OFF_SEQUENCES_AT_BOUNDS = new BooleanProperty(
+      "streetside.cut-off-sequences-at-bounds", false);
   public static final IntegerProperty MAPOBJECT_ICON_SIZE = new IntegerProperty("streetside.mapobjects.iconsize", 32);
+  public static final IntegerProperty MAX_MAPOBJECTS = new IntegerProperty("streetside.mapobjects.maximum-number", 200);
+  public static final BooleanProperty SHOW_DETECTED_SIGNS = new BooleanProperty("streetside.show-detected-signs", true);
+  public static final BooleanProperty SHOW_HIGH_RES_STREETSIDE_IMAGERY = new BooleanProperty("streetside.show-high-res-streetside-imagery", true);
+  public static final IntegerProperty MAX_MAPOBJECTS = new IntegerProperty("streetside.mapobjects.maximum-number",
+);
+  public static final BooleanProperty SHOW_DETECTED_SIGNS = new BooleanProperty("streetside.show-detected-signs",
+      true);
+  public static final BooleanProperty SHOW_HIGH_RES_STREETSIDE_IMAGERY = new BooleanProperty(
+      "streetside.show-high-res-streetside-imagery", true);
   /**
 …
    * See {@code OsmDataLayer#PROPERTY_OUTSIDE_COLOR}
    */
+  public static final NamedColorProperty OUTSIDE_DOWNLOADED_AREA = new NamedColorProperty("outside downloaded area", Color.YELLOW);
+  public static final NamedColorProperty OUTSIDE_DOWNLOADED_AREA = new NamedColorProperty("outside downloaded area",
+      Color.YELLOW);
   public static final DoubleProperty MAX_DOWNLOAD_AREA = new DoubleProperty("streetside.max-download-area", 0.015);
   public static final IntegerProperty PICTURE_DRAG_BUTTON = new IntegerProperty("streetside.picture-drag-button", 3);
+  public static final IntegerProperty PICTURE_OPTION_BUTTON = new IntegerProperty("streetside.picture-option-button", 2);
+  public static final IntegerProperty PICTURE_OPTION_BUTTON = new IntegerProperty("streetside.picture-option-button",
+);
   public static final IntegerProperty PICTURE_ZOOM_BUTTON = new IntegerProperty("streetside.picture-zoom-button", 1);
   public static final IntegerProperty SEQUENCE_MAX_JUMP_DISTANCE =
     new IntegerProperty("streetside.sequence-max-jump-distance", 100);
+  public static final IntegerProperty SEQUENCE_MAX_JUMP_DISTANCE = new IntegerProperty(
+      "streetside.sequence-max-jump-distance", 100);
   public static final StringProperty ACCESS_TOKEN = new StringProperty("streetside.access-token", null);
   public static final StringProperty DOWNLOAD_MODE =
     new StringProperty("streetside.download-mode", StreetsideDownloader.DOWNLOAD_MODE.DEFAULT.getPrefId());
   public static final StringProperty START_DIR =
     new StringProperty("streetside.start-directory", System.getProperty("user.home"));
   public static final StringProperty URL_CLIENT_ID =
     new StringProperty("streetside.url-clientid", System.getProperty("T1Fzd20xZjdtR0s1VDk5OFNIOXpYdzoxNDYyOGRkYzUyYTFiMzgz"));
   public static final StringProperty BING_MAPS_KEY =
     new StringProperty("streetside.bing-maps-key", System.getProperty("AuftgJsO0Xs8Ts4M1xZUQJQXJNsvmh3IV8DkNieCiy3tCwCUMq76-WpkrBtNAuEm"));
   public static final StringProperty TEST_BUBBLE_ID =
     new StringProperty("streetside.test-bubble-id", System.getProperty("80848005"));
+  public static final StringProperty DOWNLOAD_MODE = new StringProperty("streetside.download-mode",
+      StreetsideDownloader.DOWNLOAD_MODE.DEFAULT.getPrefId());
+  public static final StringProperty START_DIR = new StringProperty("streetside.start-directory",
+      System.getProperty("user.home"));
+  public static final StringProperty URL_CLIENT_ID = new StringProperty("streetside.url-clientid",
+      System.getProperty("streetside.url-clientid", "T1Fzd20xZjdtR0s1VDk5OFNIOXpYdzoxNDYyOGRkYzUyYTFiMzgz"));
+  public static final StringProperty BING_MAPS_KEY = new StringProperty("streetside.bing-maps-key",
+      System.getProperty("streetside.bing-maps-key", "AuftgJsO0Xs8Ts4M1xZUQJQXJNsvmh3IV8DkNieCiy3tCwCUMq76-WpkrBtNAuEm"));
+  public static final StringProperty TEST_BUBBLE_ID = new StringProperty("streetside.test-bubble-id",
+      System.getProperty("streetside.test-bubble-id", "80848005"));
   /**
 …
    * Or opening the {@link ImageInfoPanel} immediately brings this number down to zero.
    */
   public static final IntegerProperty IMAGEINFO_HELP_COUNTDOWN =
     new IntegerProperty("streetside.imageInfo.helpDisplayedCountdown", 4);
+  public static final IntegerProperty IMAGEINFO_HELP_COUNTDOWN = new IntegerProperty(
+      "streetside.imageInfo.helpDisplayedCountdown", 4);
   /**
 …
    * Or opening the {@link StreetsideViewerPanel} immediately brings this number down to zero.
    */
   public static final IntegerProperty STREETSIDE_VIEWER_HELP_COUNTDOWN =
     new IntegerProperty("streetside.streetsideViewer.helpDisplayedCountdown", 4);
+  public static final IntegerProperty STREETSIDE_VIEWER_HELP_COUNTDOWN = new IntegerProperty(
+      "streetside.streetsideViewer.helpDisplayedCountdown", 4);
   /**
    * The number of images to be prefetched when a streetside image is selected
    */
+  public static final IntegerProperty PRE_FETCH_IMAGE_COUNT = new IntegerProperty("streetside.prefetch-image-count", 2);
+  public static final IntegerProperty PRE_FETCH_IMAGE_COUNT = new IntegerProperty("streetside.prefetch-image-count",
+);
   /**
    * The number of images to be prefetched when a streetside image is selected
    */
   public static final IntegerProperty PRE_FETCH_CUBEMAP_COUNT = new IntegerProperty("streetside.prefetch-image-count", 2);
+  public static final IntegerProperty PRE_FETCH_CUBEMAP_COUNT = new IntegerProperty("streetside.prefetch-image-count",
+);
   private StreetsideProperties() {

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/utils/StreetsideSequenceIdGenerator.java

-              r34577
+              r36194
  * handle sequences of contiguous imagery, but Streetside only has implicit
  * sequences defined by the "pre" and "ne" attributes.
+ *
  * See {@link org.openstreetmap.josm.plugins.streetside.StreetsideSequence}
+ *
+ * @see org.openstreetmap.josm.plugins.streetside.StreetsideSequence
  */
 public class StreetsideSequenceIdGenerator {

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/utils/StreetsideURL.java

-              r34431
+              r36194
 import java.util.Map;
 import java.util.Map.Entry;
+import org.apache.log4j.Logger;
+import java.util.logging.Logger;
 import org.openstreetmap.josm.data.Bounds;
 import org.openstreetmap.josm.plugins.streetside.cubemap.CubemapUtils;
 …
 public final class StreetsideURL {
+  final static Logger logger = Logger.getLogger(StreetsideURL.class);
+        /** Base URL of the Bing Bubble API. */
+        private static final String STREETSIDE_BASE_URL = "https://dev.virtualearth.net/mapcontrol/HumanScaleServices/GetBubbles.ashx";
+        /** Base URL for Streetside privacy concerns. */
+  private static final Logger LOGGER = Logger.getLogger(StreetsideURL.class.getCanonicalName());
+  /**
+   * Base URL of the Bing Bubble API.
+   */
+  private static final String STREETSIDE_BASE_URL = "https://dev.virtualearth.net/mapcontrol/HumanScaleServices/GetBubbles.ashx";
+  /**
+   * Base URL for Streetside privacy concerns.
+   */
   private static final String STREETSIDE_PRIVACY_URL = "https://www.bing.com/maps/privacyreport/streetsideprivacyreport?bubbleid=";
+        private static final int OSM_BBOX_NORTH = 3;
+        private static final int OSM_BBOX_SOUTH = 1;
+        private static final int OSM_BBOXEAST = 2;
+        private static final int OSM_BBOX_WEST = 0;
+        public static final class APIv3 {
+                private APIv3() {
+                        // Private constructor to avoid instantiation
+                }
+                public static URL searchStreetsideImages(Bounds bounds) {
+                        return StreetsideURL.string2URL(StreetsideURL.STREETSIDE_BASE_URL, APIv3.queryStreetsideString(bounds));
+                }
+                /**
+                 * The APIv3 returns a Link header for each request. It contains a URL for requesting more results.
+                 * If you supply the value of the Link header, this method returns the next URL,
+                 * if such a URL is defined in the header.
+                 * @param value the value of the HTTP-header with key "Link"
+                 * @return the {@link URL} for the next result page, or <code>null</code> if no such URL could be found
+                 */
+                public static URL parseNextFromLinkHeaderValue(String value) {
+                        if (value != null) {
+                                // Iterate over the different entries of the Link header
+                                for (final String link : value.split(",", Integer.MAX_VALUE)) {
+                                        boolean isNext = false;
+                                        URL url = null;
+                                        // Iterate over the parts of each entry (typically it's one `rel="‹linkType›"` and one like `<https://URL>`)
+                                        for (String linkPart : link.split(";", Integer.MAX_VALUE)) {
+                                                linkPart = linkPart.trim();
+                                                isNext |= linkPart.matches("rel\\s*=\\s*\"next\"");
+                                                if (linkPart.length() >= 1 && linkPart.charAt(0) == '<' && linkPart.endsWith(">")) {
+                                                        try {
+                                                                url = new URL(linkPart.substring(1, linkPart.length() - 1));
+                                                        } catch (final MalformedURLException e) {
+                                                                Logging.log(Logging.LEVEL_WARN, "Mapillary API v3 returns a malformed URL in the Link header.", e);
+                                                        }
+                                                }
+                                        }
+                                        // If both a URL and the rel=next attribute are present, return the URL. Otherwise null is returned
+                                        if (url != null && isNext) {
+                                                return url;
+                                        }
+                                }
+                        }
+                        return null;
+                }
+                public static String queryString(final Bounds bounds) {
+                        if (bounds != null) {
+                                final Map<String, String> parts = new HashMap<>();
+                                parts.put("bbox", bounds.toBBox().toStringCSV(","));
+                                return StreetsideURL.queryString(parts);
+                        }
+                        return StreetsideURL.queryString(null);
+                }
+                public static String queryStreetsideString(final Bounds bounds) {
+                        if (bounds != null) {
+                                final Map<String, String> parts = new HashMap<>();
+                                parts.put("bbox", bounds.toBBox().toStringCSV(","));
+                                return StreetsideURL.queryStreetsideBoundsString(parts);
+                        }
+                        return StreetsideURL.queryStreetsideBoundsString(null);
+                }
+        }
+        public static final class VirtualEarth {
+                private static final String BASE_URL_PREFIX = "https://t.ssl.ak.tiles.virtualearth.net/tiles/hs";
+                private static final String BASE_URL_SUFFIX = ".jpg?g=6528&n=z";
+                private VirtualEarth() {
+                        // Private constructor to avoid instantiation
+                }
+                public static URL streetsideTile(final String id, boolean thumbnail) {
+                        StringBuilder modifiedId = new StringBuilder();
+                        if (thumbnail) {
+  private static final int OSM_BBOX_NORTH = 3;
+  private static final int OSM_BBOX_SOUTH = 1;
+  private static final int OSM_BBOXEAST = 2;
+  private static final int OSM_BBOX_WEST = 0;
+  private StreetsideURL() {
+    // Private constructor to avoid instantiation
+  }
+  public static URL[] string2URLs(String baseUrlPrefix, String cubemapImageId, String baseUrlSuffix) {
+    List<URL> res = new ArrayList<>();
+    switch (Boolean.TRUE.equals(StreetsideProperties.SHOW_HIGH_RES_STREETSIDE_IMAGERY.get()) ? 16 : 4) {
+    case 16:
+      EnumSet.allOf(CubemapUtils.CubemapFaces.class).forEach(face -> {
+        for (int i = 0; i < 4; i++) {
+          for (int j = 0; j < 4; j++) {
+            try {
+              final String urlStr = baseUrlPrefix + cubemapImageId
+                  + CubemapUtils.rowCol2StreetsideCellAddressMap.get(String.valueOf(i) + j)
+                  + baseUrlSuffix;
+              res.add(new URL(urlStr));
+            } catch (final MalformedURLException e) {
+              LOGGER.log(Logging.LEVEL_ERROR, "Error creating URL String for cubemap " + cubemapImageId);
+              e.printStackTrace();
+            }
+          }
+        }
+      });
+      break;
+    case 4:
+      EnumSet.allOf(CubemapUtils.CubemapFaces.class).forEach(face -> {
+        for (int i = 0; i < 4; i++) {
+          try {
+            final String urlStr = baseUrlPrefix + cubemapImageId
+                + CubemapUtils.rowCol2StreetsideCellAddressMap.get(String.valueOf(i)) + baseUrlSuffix;
+            res.add(new URL(urlStr));
+          } catch (final MalformedURLException e) {
+            LOGGER.log(Logging.LEVEL_WARN, "Error creating URL String for cubemap " + cubemapImageId);
+            e.printStackTrace();
+          }
+        }
+      });
+      break; // break is optional
+    default:
+      // Statements
+    }
+    return res.toArray(new URL[0]);
+  }
+  /**
+   * Builds a query string from it's parts that are supplied as a {@link Map}
+   *
+   * @param parts the parts of the query string
+   * @return the constructed query string (including a leading ?)
+   */
+  static String queryString(Map<String, String> parts) {
+    final StringBuilder ret = new StringBuilder("?client_id=").append(StreetsideProperties.URL_CLIENT_ID.get());
+    if (parts != null) {
+      for (final Entry<String, String> entry : parts.entrySet()) {
+        try {
+          ret.append('&').append(URLEncoder.encode(entry.getKey(), StandardCharsets.UTF_8.name())).append('=')
+              .append(URLEncoder.encode(entry.getValue(), StandardCharsets.UTF_8.name()));
+        } catch (final UnsupportedEncodingException e) {
+          LOGGER.log(Logging.LEVEL_WARN, e.getMessage(), e); // This should not happen, as the encoding is hard-coded
+        }
+      }
+    }
+    if (Boolean.TRUE.equals(StreetsideProperties.DEBUGING_ENABLED.get())) {
+      LOGGER.log(Logging.LEVEL_DEBUG, MessageFormat.format("queryString result: {0}", ret));
+    }
+    return ret.toString();
+  }
+  static String queryStreetsideBoundsString(Map<String, String> parts) {
+    final StringBuilder ret = new StringBuilder("?n=");
+    if (parts != null) {
+      final List<String> bbox = new ArrayList<>(Arrays.asList(parts.get("bbox").split(",")));
+      try {
+        ret.append(URLEncoder.encode(bbox.get(StreetsideURL.OSM_BBOX_NORTH), StandardCharsets.UTF_8.name()))
+            .append("&s=")
+            .append(URLEncoder.encode(bbox.get(StreetsideURL.OSM_BBOX_SOUTH),
+                StandardCharsets.UTF_8.name()))
+            .append("&e=")
+            .append(URLEncoder.encode(bbox.get(StreetsideURL.OSM_BBOXEAST), StandardCharsets.UTF_8.name()))
+            .append("&w=")
+            .append(URLEncoder.encode(bbox.get(StreetsideURL.OSM_BBOX_WEST), StandardCharsets.UTF_8.name()))
+            .append("&c=1000").append("&appkey=").append(StreetsideProperties.BING_MAPS_KEY.get());
+      } catch (final UnsupportedEncodingException e) {
+        LOGGER.log(Logging.LEVEL_ERROR, e.getMessage(), e); // This should not happen, as the encoding is hard-coded
+      }
+    }
+    return ret.toString();
+  }
+  static String queryByIdString(Map<String, String> parts) {
+    final StringBuilder ret = new StringBuilder("?id=");
+    try {
+      ret.append(URLEncoder.encode(StreetsideProperties.TEST_BUBBLE_ID.get(), StandardCharsets.UTF_8.name()));
+      ret.append('&').append(URLEncoder.encode("appkey=", StandardCharsets.UTF_8.name())).append('=')
+          .append(URLEncoder.encode(StreetsideProperties.BING_MAPS_KEY.get(), StandardCharsets.UTF_8.name()));
+    } catch (final UnsupportedEncodingException e) {
+      LOGGER.log(Logging.LEVEL_ERROR, e.getMessage(), e); // This should not happen, as the encoding is hard-coded
+    }
+    if (Boolean.TRUE.equals(StreetsideProperties.DEBUGING_ENABLED.get())) {
+      LOGGER.info("queryById result: " + ret);
+    }
+    return ret.toString();
+  }
+  /**
+   * Converts a {@link String} into a {@link URL} without throwing a {@link MalformedURLException}.
+   * Instead such an exception will lead to an {@link Logger}.
+   * So you should be very confident that your URL is well-formed when calling this method.
+   *
+   * @param strings the Strings describing the URL
+   * @return the URL that is constructed from the given string
+   */
+  static URL string2URL(String... strings) {
+    final StringBuilder builder = new StringBuilder();
+    for (int i = 0; strings != null && i < strings.length; i++) {
+      builder.append(strings[i]);
+    }
+    try {
+      return new URL(builder.toString());
+    } catch (final MalformedURLException e) {
+      LOGGER.log(Logging.LEVEL_ERROR, I18n.tr(String.format("The class '%s' produces malformed URLs like '%s'!",
+          StreetsideURL.class.getName(), builder), e));
+      return null;
+    }
+  }
+  public static final class APIv3 {
+    private APIv3() {
+      // Private constructor to avoid instantiation
+    }
+    public static URL searchStreetsideImages(Bounds bounds) {
+      return StreetsideURL.string2URL(StreetsideURL.STREETSIDE_BASE_URL, APIv3.queryStreetsideString(bounds));
+    }
+    /**
+     * The APIv3 returns a Link header for each request. It contains a URL for requesting more results.
+     * If you supply the value of the Link header, this method returns the next URL,
+     * if such a URL is defined in the header.
+     *
+     * @param value the value of the HTTP-header with key "Link"
+     * @return the {@link URL} for the next result page, or <code>null</code> if no such URL could be found
+     */
+    public static URL parseNextFromLinkHeaderValue(String value) {
+      if (value != null) {
+        // Iterate over the different entries of the Link header
+        for (final String link : value.split(",", Integer.MAX_VALUE)) {
+          boolean isNext = false;
+          URL url = null;
+          // Iterate over the parts of each entry (typically it's one `rel="‹linkType›"` and one like `<https://URL>`)
+          for (String linkPart : link.split(";", Integer.MAX_VALUE)) {
+            linkPart = linkPart.trim();
+            isNext |= linkPart.matches("rel\\s*=\\s*\"next\"");
+            if (linkPart.length() >= 1 && linkPart.charAt(0) == '<' && linkPart.endsWith(">")) {
+              try {
+                url = new URL(linkPart.substring(1, linkPart.length() - 1));
+              } catch (final MalformedURLException e) {
+                Logging.log(Logging.LEVEL_WARN,
+                    "Mapillary API v3 returns a malformed URL in the Link header.", e);
+              }
+            }
+          }
+          // If both a URL and the rel=next attribute are present, return the URL. Otherwise null is returned
+          if (url != null && isNext) {
+            return url;
+          }
+        }
+      }
+      return null;
+    }
+    public static String queryString(final Bounds bounds) {
+      if (bounds != null) {
+        final Map<String, String> parts = new HashMap<>();
+        parts.put("bbox", bounds.toBBox().toStringCSV(","));
+        return StreetsideURL.queryString(parts);
+      }
+      return StreetsideURL.queryString(null);
+    }
+    public static String queryStreetsideString(final Bounds bounds) {
+      if (bounds != null) {
+        final Map<String, String> parts = new HashMap<>();
+        parts.put("bbox", bounds.toBBox().toStringCSV(","));
+        return StreetsideURL.queryStreetsideBoundsString(parts);
+      }
+      return StreetsideURL.queryStreetsideBoundsString(null);
+    }
+  }
+  public static final class VirtualEarth {
+    private static final String BASE_URL_PREFIX = "https://t.ssl.ak.tiles.virtualearth.net/tiles/hs";
+    private static final String BASE_URL_SUFFIX = ".jpg?g=6528&n=z";
+    private VirtualEarth() {
+      // Private constructor to avoid instantiation
+    }
+    public static URL streetsideTile(final String id, boolean thumbnail) {
+      StringBuilder modifiedId = new StringBuilder();
+      if (thumbnail) {
         // pad thumbnail imagery with leading zeros
         if (id.length() < 16) {
 …
+        }
         modifiedId.append(id).append("01");
+      } else if(StreetsideProperties.SHOW_HIGH_RES_STREETSIDE_IMAGERY.get()){
+        // pad 16-tiled imagery with leading zeros
+        if (id.length() < 20) {
+          for (int i = 0; i < 20 - id.length(); i++) {
+            modifiedId.append("0");
+      } else {
+          if (Boolean.TRUE.equals(StreetsideProperties.SHOW_HIGH_RES_STREETSIDE_IMAGERY.get())) {
+              // pad 16-tiled imagery with leading zeros
+              if (id.length() < 20) {
+                  for (int i = 0; i < 20 - id.length(); i++) {
+                      modifiedId.append("0");
+                  }
+              }
+          } else {
+              // pad 4-tiled imagery with leading zeros
+              if (id.length() < 19) {
+                  for (int i = 0; i < 19 - id.length(); i++) {
+                      modifiedId.append("0");
+                  }
+              }
+          }
           modifiedId.append(id);
+        }
+      } else if(!StreetsideProperties.SHOW_HIGH_RES_STREETSIDE_IMAGERY.get()) {
+        // pad 4-tiled imagery with leading zeros
+        if (id.length() < 19) {
+          for (int i = 0; i < 19 - id.length(); i++) {
+            modifiedId.append("0");
+          }
+          modifiedId.append(id);
+        }
+      }
+                  URL url = StreetsideURL.string2URL(VirtualEarth.BASE_URL_PREFIX + modifiedId.toString() + VirtualEarth.BASE_URL_SUFFIX);
+            if(StreetsideProperties.DEBUGING_ENABLED.get()) {
+                    logger.debug(MessageFormat.format("Tile task URL {0} invoked.", url.toString()));
+            }
+                        return url;
+                }
+        }
+        public static final class MainWebsite {
+                private MainWebsite() {
+                        // Private constructor to avoid instantiation
+                }
+                /**
+                 * Gives you the URL for the online viewer of a specific Streetside image.
+                 * @param id the id of the image to which you want to link
+                 * @return the URL of the online viewer for the image with the given image key
+                 * @throws IllegalArgumentException if the image key is <code>null</code>
+                 */
+                public static URL browseImage(String id) {
+                        if (id == null) {
+                                throw new IllegalArgumentException("The image id may not be null!");
+                        }
+                        StringBuilder modifiedId = new StringBuilder();
+      }
+      URL url = StreetsideURL
+          .string2URL(VirtualEarth.BASE_URL_PREFIX + modifiedId + VirtualEarth.BASE_URL_SUFFIX);
+      if (Boolean.TRUE.equals(StreetsideProperties.DEBUGING_ENABLED.get())) {
+        LOGGER.log(Logging.LEVEL_DEBUG, MessageFormat.format("Tile task URL {0} invoked.", url));
+      }
+      return url;
+    }
+  }
+  public static final class MainWebsite {
+    private MainWebsite() {
+      // Private constructor to avoid instantiation
+    }
+    /**
+     * Gives you the URL for the online viewer of a specific Streetside image.
+     *
+     * @param id the id of the image to which you want to link
+     * @return the URL of the online viewer for the image with the given image key
+     * @throws IllegalArgumentException if the image key is <code>null</code>
+     */
+    public static URL browseImage(String id) {
+      if (id == null) {
+        throw new IllegalArgumentException("The image id may not be null!");
+      }
+      StringBuilder modifiedId = new StringBuilder();
       // pad thumbnail imagery with leading zeros
 …
       modifiedId.append(id).append("01");
+                        return StreetsideURL.string2URL(MessageFormat.format("{0}{1}{2}",VirtualEarth.BASE_URL_PREFIX, modifiedId.toString(), VirtualEarth.BASE_URL_SUFFIX));
+                }
+                /**
+                 * Gives you the URL for the blur editor of the image with the given key.
+                 * @param id the key of the image for which you want to open the blur editor
+                 * @return the URL of the blur editor
+                 * @throws IllegalArgumentException if the image key is <code>null</code>
+                 */
+                public static URL streetsidePrivacyLink(final String id) {
+                        if (id == null) {
+                                throw new IllegalArgumentException("The image id must not be null!");
+                        }
+                        String urlEncodedId;
+                        try {
+                                urlEncodedId = URLEncoder.encode(id, StandardCharsets.UTF_8.name());
+                        } catch (final UnsupportedEncodingException e) {
+                                logger.error(I18n.tr("Unsupported encoding when URL encoding", e));
+                                urlEncodedId = id;
+                        }
+                        return StreetsideURL.string2URL(StreetsideURL.STREETSIDE_PRIVACY_URL, urlEncodedId);
+                }
+        }
+        private StreetsideURL() {
+                // Private constructor to avoid instantiation
+        }
+        public static URL[] string2URLs(String baseUrlPrefix, String cubemapImageId, String baseUrlSuffix) {
+                List<URL> res = new ArrayList<>();
+                switch (StreetsideProperties.SHOW_HIGH_RES_STREETSIDE_IMAGERY.get() ? 16 : 4) {
+                case 16:
+                        EnumSet.allOf(CubemapUtils.CubemapFaces.class).forEach(face -> {
+                                for (int i = 0; i < 4; i++) {
+                                        for (int j = 0; j < 4; j++) {
+                                                try {
+                                                        final String urlStr = baseUrlPrefix + cubemapImageId
+                                                                        + CubemapUtils.rowCol2StreetsideCellAddressMap
+                                                                                        .get(String.valueOf(i) + String.valueOf(j))
+                                                                        + baseUrlSuffix;
+                                                        res.add(new URL(urlStr));
+                                                } catch (final MalformedURLException e) {
+                                                        logger.error("Error creating URL String for cubemap " + cubemapImageId);
+                                                        e.printStackTrace();
+                                                }
+                                        }
+                                }
+                        });
+                        break;
+                case 4:
+                        EnumSet.allOf(CubemapUtils.CubemapFaces.class).forEach(face -> {
+                                for (int i = 0; i < 4; i++) {
+                                        try {
+                                                final String urlStr = baseUrlPrefix + cubemapImageId
+                                                                + CubemapUtils.rowCol2StreetsideCellAddressMap.get(String.valueOf(i)) + baseUrlSuffix;
+                                                res.add(new URL(urlStr));
+                                        } catch (final MalformedURLException e) {
+                                                logger.error("Error creating URL String for cubemap " + cubemapImageId);
+                                                e.printStackTrace();
+                                        }
+                                }
+                        });
+                        break; // break is optional
+                default:
+                        // Statements
+                }
+                return res.stream().toArray(URL[]::new);
+        }
+        /**
+         * Builds a query string from it's parts that are supplied as a {@link Map}
+         * @param parts the parts of the query string
+         * @return the constructed query string (including a leading ?)
+         */
+        static String queryString(Map<String, String> parts) {
+                final StringBuilder ret = new StringBuilder("?client_id=").append(StreetsideProperties.URL_CLIENT_ID.get());
+                if (parts != null) {
+                        for (final Entry<String, String> entry : parts.entrySet()) {
+                                try {
+                                        ret.append('&')
+                                        .append(URLEncoder.encode(entry.getKey(), StandardCharsets.UTF_8.name()))
+                                        .append('=')
+                                        .append(URLEncoder.encode(entry.getValue(), StandardCharsets.UTF_8.name()));
+                                } catch (final UnsupportedEncodingException e) {
+                                        logger.error(e); // This should not happen, as the encoding is hard-coded
+                                }
+                        }
+                }
+                if(StreetsideProperties.DEBUGING_ENABLED.get()) {
+                  logger.debug(MessageFormat.format("queryString result: {0}", ret.toString()));
+                }
+                return ret.toString();
+        }
+        static String queryStreetsideBoundsString(Map<String, String> parts) {
+                final StringBuilder ret = new StringBuilder("?n=");
+                if (parts != null) {
+                        final List<String> bbox = new ArrayList<>(Arrays.asList(parts.get("bbox").split(",")));
+                        try {
+                                ret.append(URLEncoder.encode(bbox.get(StreetsideURL.OSM_BBOX_NORTH), StandardCharsets.UTF_8.name()))
+                                .append("&s=")
+                                .append(URLEncoder.encode(bbox.get(StreetsideURL.OSM_BBOX_SOUTH), StandardCharsets.UTF_8.name()))
+                                .append("&e=")
+                                .append(URLEncoder.encode(bbox.get(StreetsideURL.OSM_BBOXEAST), StandardCharsets.UTF_8.name()))
+                                .append("&w=")
+                                .append(URLEncoder.encode(bbox.get(StreetsideURL.OSM_BBOX_WEST), StandardCharsets.UTF_8.name()))
+                                .append("&c=1000")
+                                .append("&appkey=")
+                                .append(StreetsideProperties.BING_MAPS_KEY.get());
+                        } catch (final UnsupportedEncodingException e) {
+                                logger.error(e); // This should not happen, as the encoding is hard-coded
+                        }
+                }
+                return ret.toString();
+        }
+        static String queryByIdString(Map<String, String> parts) {
+                final StringBuilder ret = new StringBuilder("?id=");
+                try {
+                        ret.append(URLEncoder.encode(StreetsideProperties.TEST_BUBBLE_ID.get(), StandardCharsets.UTF_8.name()));
+                        ret.append('&').append(URLEncoder.encode("appkey=", StandardCharsets.UTF_8.name())).append('=')
+                        .append(URLEncoder.encode(StreetsideProperties.BING_MAPS_KEY.get(), StandardCharsets.UTF_8.name()));
+                } catch (final UnsupportedEncodingException e) {
+                        logger.error(e); // This should not happen, as the encoding is hard-coded
+                }
+                if(StreetsideProperties.DEBUGING_ENABLED.get()) {
+                  logger.info("queryById result: " + ret.toString());
+                }
+                return ret.toString();
+        }
+        /**
+         * Converts a {@link String} into a {@link URL} without throwing a {@link MalformedURLException}.
+         * Instead such an exception will lead to an {@link Logger}.
+         * So you should be very confident that your URL is well-formed when calling this method.
+         * @param strings the Strings describing the URL
+         * @return the URL that is constructed from the given string
+         */
+        static URL string2URL(String... strings) {
+                final StringBuilder builder = new StringBuilder();
+                for (int i = 0; strings != null && i < strings.length; i++) {
+                        builder.append(strings[i]);
+                }
+                try {
+                        return new URL(builder.toString());
+                } catch (final MalformedURLException e) {
+                        logger.error(I18n.tr(String.format(
+                                        "The class '%s' produces malformed URLs like '%s'!",
+                                        StreetsideURL.class.getName(),
+                                        builder
+                                        ), e));
+                        return null;
+                }
+        }
+      return StreetsideURL.string2URL(MessageFormat.format("{0}{1}{2}", VirtualEarth.BASE_URL_PREFIX, modifiedId,
+          VirtualEarth.BASE_URL_SUFFIX));
+    }
+    /**
+     * Gives you the URL for the blur editor of the image with the given key.
+     *
+     * @param id the key of the image for which you want to open the blur editor
+     * @return the URL of the blur editor
+     * @throws IllegalArgumentException if the image key is <code>null</code>
+     */
+    public static URL streetsidePrivacyLink(final String id) {
+      if (id == null) {
+        throw new IllegalArgumentException("The image id must not be null!");
+      }
+      String urlEncodedId;
+      try {
+        urlEncodedId = URLEncoder.encode(id, StandardCharsets.UTF_8.name());
+      } catch (final UnsupportedEncodingException e) {
+        LOGGER.log(Logging.LEVEL_ERROR, I18n.tr("Unsupported encoding when URL encoding", e), e);
+        urlEncodedId = id;
+      }
+      return StreetsideURL.string2URL(StreetsideURL.STREETSIDE_PRIVACY_URL, urlEncodedId);
+    }
+  }
+}

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/utils/StreetsideUtils.java

-              r34431
+              r36194
 import org.apache.commons.imaging.common.RationalNumber;
 import org.apache.commons.imaging.formats.tiff.constants.GpsTagConstants;
-import org.apache.log4j.Logger;
 import org.openstreetmap.josm.data.Bounds;
 import org.openstreetmap.josm.data.coor.LatLon;
 …
 public final class StreetsideUtils {
-  final static Logger logger = Logger.getLogger(StreetsideUtils.class);
   private static final double MIN_ZOOM_SQUARE_SIDE = 0.002;
 …
+   *
    * @param degMinSec an array of length 3, the values in there are (in this order)
    *                  degrees, minutes and seconds
    * @param ref       the latitude or longitude reference determining if the given value
    *                  is:
    *                  <ul>
    *                  <li>north (
    *                  {@link GpsTagConstants#GPS_TAG_GPS_LATITUDE_REF_VALUE_NORTH}) or
    *                  south (
    *                  {@link GpsTagConstants#GPS_TAG_GPS_LATITUDE_REF_VALUE_SOUTH}) of
    *                  the equator</li>
    *                  <li>east (
    *                  {@link GpsTagConstants#GPS_TAG_GPS_LONGITUDE_REF_VALUE_EAST}) or
    *                  west ({@link GpsTagConstants#GPS_TAG_GPS_LONGITUDE_REF_VALUE_WEST}
    *                  ) of the equator</li>
    *                  </ul>
+   *          degrees, minutes and seconds
+   * @param ref     the latitude or longitude reference determining if the given value
+   *          is:
+   *          <ul>
+   *          <li>north (
+   *          {@link GpsTagConstants#GPS_TAG_GPS_LATITUDE_REF_VALUE_NORTH}) or
+   *          south (
+   *          {@link GpsTagConstants#GPS_TAG_GPS_LATITUDE_REF_VALUE_SOUTH}) of
+   *          the equator</li>
+   *          <li>east (
+   *          {@link GpsTagConstants#GPS_TAG_GPS_LONGITUDE_REF_VALUE_EAST}) or
+   *          west ({@link GpsTagConstants#GPS_TAG_GPS_LONGITUDE_REF_VALUE_WEST}
+   *          ) of the equator</li>
+   *          </ul>
    * @return the decimal degree-value for the given input, negative when west of
    * 0-meridian or south of equator, positive otherwise
    * @throws IllegalArgumentException if {@code degMinSec} doesn't have length 3 or if {@code ref} is
    *                                  not one of the values mentioned above
+   *                  not one of the values mentioned above
    */
   public static double degMinSecToDouble(RationalNumber[] degMinSec, String ref) {
 …
     switch (ref) {
       case GpsTagConstants.GPS_TAG_GPS_LATITUDE_REF_VALUE_NORTH:
       case GpsTagConstants.GPS_TAG_GPS_LATITUDE_REF_VALUE_SOUTH:
       case GpsTagConstants.GPS_TAG_GPS_LONGITUDE_REF_VALUE_EAST:
       case GpsTagConstants.GPS_TAG_GPS_LONGITUDE_REF_VALUE_WEST:
         break;
       default:
         throw new IllegalArgumentException("Invalid ref.");
+    case GpsTagConstants.GPS_TAG_GPS_LATITUDE_REF_VALUE_NORTH:
+    case GpsTagConstants.GPS_TAG_GPS_LATITUDE_REF_VALUE_SOUTH:
+    case GpsTagConstants.GPS_TAG_GPS_LONGITUDE_REF_VALUE_EAST:
+    case GpsTagConstants.GPS_TAG_GPS_LONGITUDE_REF_VALUE_WEST:
+      break;
+    default:
+      throw new IllegalArgumentException("Invalid ref.");
+    }
 …
     if (GpsTagConstants.GPS_TAG_GPS_LATITUDE_REF_VALUE_SOUTH.equals(ref)
             || GpsTagConstants.GPS_TAG_GPS_LONGITUDE_REF_VALUE_WEST.equals(ref)) {
+        || GpsTagConstants.GPS_TAG_GPS_LONGITUDE_REF_VALUE_WEST.equals(ref)) {
       result *= -1;
+    }
 …
+    }
     if ((imgA.next() != null || imgB.previous() != null) && (imgB.next() != null || imgA.previous() != null)) {
+      throw new IllegalArgumentException("You can only join an image at the end of a sequence with one at the beginning of another sequence.");
+      throw new IllegalArgumentException(
+          "You can only join an image at the end of a sequence with one at the beginning of another sequence.");
+    }
     if (imgA.next() != null || imgB.previous() != null) {
 …
   /**
    * Separates two images belonging to the same sequence. The two images have to be consecutive in the same sequence.
+   * Two new sequences are created and all images up to (and including) either {@code imgA} or {@code imgB} (whichever appears first in the sequence) are put into the first of the two sequences.
+   * Two new sequences are created and all images up to (and including) either {@code imgA} or {@code imgB}
+   * (whichever appears first in the sequence) are put into the first of the two sequences.
    * All others are put into the second new sequence.
+   *
 …
+    }
     if (imgB.equals(imgA.next()) && imgA.equals(imgB.next())) {
+      throw new IllegalArgumentException("When unjoining with two images these must be consecutive in one sequence.");
+      throw new IllegalArgumentException(
+          "When unjoining with two images these must be consecutive in one sequence.");
+    }
 …
       ret.append(I18n.tr("Total Streetside images: {0}", StreetsideLayer.getInstance().getToolTipText()));
     } else if (PluginState.isSubmittingChangeset()) {
         ret.append(I18n.tr("Submitting Streetside Changeset"));
+      ret.append(I18n.tr("Submitting Streetside Changeset"));
     } else {
       ret.append(I18n.tr("No images found"));

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/utils/api/JsonDecoder.java

-              r36122
+              r36194
 import java.util.function.Function;
+import org.openstreetmap.josm.data.coor.LatLon;
+import org.openstreetmap.josm.tools.I18n;
+import org.openstreetmap.josm.tools.Logging;
 import jakarta.json.JsonArray;
 import jakarta.json.JsonNumber;
 import jakarta.json.JsonObject;
 import jakarta.json.JsonValue;
-import org.openstreetmap.josm.data.coor.LatLon;
-import org.openstreetmap.josm.tools.I18n;
-import org.openstreetmap.josm.tools.Logging;
 public final class JsonDecoder {
 …
    * of the desired Java objects. The method, which converts the GeoJSON features into Java objects
    * is given as a parameter to this method.
+   * @param <T> feature type
+   * @param json the {@link JsonObject} to be parsed
+   *
+   * @param <T>      feature type
+   * @param json       the {@link JsonObject} to be parsed
    * @param featureDecoder feature decoder which transforms JSON objects to Java objects
    * @return a {@link Collection} which is parsed from the given {@link JsonObject}, which contains GeoJSON.
    *         Currently a {@link HashSet} is used, but please don't rely on it, this could change at any time without
    *         prior notice. The return value will not be <code>null</code>.
+   * Currently a {@link HashSet} is used, but please don't rely on it, this could change at any time without
+   * prior notice. The return value will not be <code>null</code>.
    */
+  public static <T> Collection<T> decodeFeatureCollection(final JsonObject json, Function<JsonObject, T> featureDecoder) {
+  public static <T> Collection<T> decodeFeatureCollection(final JsonObject json,
+      Function<JsonObject, T> featureDecoder) {
     final Collection<T> result = new HashSet<>();
+    if (
+      json != null && "FeatureCollection".equals(json.getString("type", null)) && json.containsKey("features")
+    ) {
+    if (json != null && "FeatureCollection".equals(json.getString("type", null)) && json.containsKey("features")) {
       final JsonValue features = json.get("features");
       for (int i = 0; features instanceof JsonArray && i < ((JsonArray) features).size(); i++) {
 …
    * Decodes a {@link JsonArray} of exactly size 2 to a {@link LatLon} instance.
    * The first value in the {@link JsonArray} is treated as longitude, the second one as latitude.
+   *
    * @param json the {@link JsonArray} containing the two numbers
    * @return the decoded {@link LatLon} instance, or <code>null</code> if the parameter is
    *         not a {@link JsonArray} of exactly size 2 containing two {@link JsonNumber}s.
+   * not a {@link JsonArray} of exactly size 2 containing two {@link JsonNumber}s.
    */
   static LatLon decodeLatLon(final JsonArray json) {
 …
   /**
    * Decodes a pair of double values, which are stored in a {@link JsonArray} of exactly size 2.
+   *
    * @param json the {@link JsonArray} containing the two values
    * @return a double array which contains the two values in the same order, or <code>null</code>
    *         if the parameter was not a {@link JsonArray} of exactly size 2 containing two {@link JsonNumber}s
+   * if the parameter was not a {@link JsonArray} of exactly size 2 containing two {@link JsonNumber}s
    */
   static double[] decodeDoublePair(final JsonArray json) {
+    if (
+      json != null &&
+      json.size() == 2 &&
+      json.get(0) instanceof JsonNumber &&
+      json.get(1) instanceof JsonNumber
+    ) {
+      return new double[]{json.getJsonNumber(0).doubleValue(), json.getJsonNumber(1).doubleValue()};
+    if (json != null && json.size() == 2 && json.get(0) instanceof JsonNumber
+        && json.get(1) instanceof JsonNumber) {
+      return new double[] { json.getJsonNumber(0).doubleValue(), json.getJsonNumber(1).doubleValue() };
+    }
     return EMPTY_DOUBLE;
 …
    * Decodes a timestamp formatted as a {@link String} to the equivalent UNIX epoch timestamp
    * (number of milliseconds since 1970-01-01T00:00:00.000+0000).
+   *
    * @param timestamp the timestamp formatted according to the format <code>yyyy-MM-dd'T'HH:mm:ss.SSSX</code>
    * @return the point in time as a {@link Long} value representing the UNIX epoch time, or <code>null</code> if the
    *   parameter does not match the required format (this also triggers a warning via
    *   {@link Logging}, or the parameter is <code>null</code>).
+   * parameter does not match the required format (this also triggers a warning via
+   * {@link Logging}, or the parameter is <code>null</code>).
    */
   static Long decodeTimestamp(final String timestamp) {
 …
       } catch (ParseException e) {
         StackTraceElement calledBy = e.getStackTrace()[Math.min(e.getStackTrace().length - 1, 2)];
+        Logging.warn(I18n.tr(String.format(
+          "Could not decode time from the timestamp `%s` (called by %s.%s:%d)",
+          timestamp, calledBy.getClassName(), calledBy.getMethodName(), calledBy.getLineNumber()
+        ), e));
+        Logging.warn(I18n.tr(String.format("Could not decode time from the timestamp `%s` (called by %s.%s:%d)",
+            timestamp, calledBy.getClassName(), calledBy.getMethodName(), calledBy.getLineNumber()), e));
+      }
+    }

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/utils/api/JsonImageDetectionDecoder.java

-              r36122
+              r36194
 import java.awt.geom.Path2D;
+import org.openstreetmap.josm.plugins.streetside.model.ImageDetection;
+import org.openstreetmap.josm.plugins.streetside.utils.StreetsideURL.APIv3;
+import org.openstreetmap.josm.tools.Logging;
 import jakarta.json.JsonArray;
 import jakarta.json.JsonNumber;
 import jakarta.json.JsonObject;
 import jakarta.json.JsonValue;
-import org.openstreetmap.josm.plugins.streetside.model.ImageDetection;
-import org.openstreetmap.josm.plugins.streetside.utils.StreetsideURL.APIv3;
-import org.openstreetmap.josm.tools.Logging;
 /**
 …
       final Double score = scoreVal instanceof JsonNumber ? ((JsonNumber) scoreVal).doubleValue() : null;
       final Shape shape = decodeShape(((JsonObject) properties).get("shape"));
+      if (shape instanceof Path2D && imageKey != null && key != null && score != null && packag != null && value != null) {
+      if (shape instanceof Path2D && imageKey != null && key != null && score != null && packag != null
+          && value != null) {
         return new ImageDetection((Path2D) shape, imageKey, key, score, packag, value);
+      }
 …
     if (json instanceof JsonObject) {
       if (!"Polygon".equals(((JsonObject) json).getString("type", null))) {
+        Logging.warn(
+          String.format("Image detections using shapes with type=%s are currently not supported!",
+          ((JsonObject) json).getString("type", "‹no type set›"))
+        );
+        Logging.warn(String.format("Image detections using shapes with type=%s are currently not supported!",
+            ((JsonObject) json).getString("type", "‹no type set›")));
       } else {
         final JsonValue coordinates = ((JsonObject) json).get("coordinates");
 …
   /**
    * Decodes a polygon (may be a multipolygon) from JSON
+   *
    * @param json the json array to decode, must not be <code>null</code>
    * @return the decoded polygon as {@link Path2D.Double}
 …
   /**
    * Decodes a simple polygon (consisting of only one continuous path) from JSON
+   *
    * @param json the json array to decode, must not be <code>null</code>
    * @return the decoded polygon as {@link Path2D.Double}

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/utils/api/JsonSequencesDecoder.java

-              r36122
+              r36194
 import java.util.function.Function;
+import org.openstreetmap.josm.data.coor.LatLon;
+import org.openstreetmap.josm.plugins.streetside.StreetsideImage;
+import org.openstreetmap.josm.plugins.streetside.StreetsideSequence;
+import org.openstreetmap.josm.plugins.streetside.utils.StreetsideURL.APIv3;
 import jakarta.json.JsonArray;
 import jakarta.json.JsonNumber;
 …
 import jakarta.json.JsonString;
 import jakarta.json.JsonValue;
-import org.openstreetmap.josm.data.coor.LatLon;
-import org.openstreetmap.josm.plugins.streetside.StreetsideImage;
-import org.openstreetmap.josm.plugins.streetside.StreetsideSequence;
-import org.openstreetmap.josm.plugins.streetside.utils.StreetsideURL.APIv3;
 /**
 …
   /**
    * Parses a given {@link JsonObject} as a GeoJSON Feature into a {@link StreetsideSequence}.
+   *
    * @param json the {@link JsonObject} to be parsed
    * @return a {@link StreetsideSequence} that is parsed from the given {@link JsonObject}. If mandatory information is
    *         missing from the JSON or it's not meeting the expecting format in another way, <code>null</code> will be
    *         returned.
+   * missing from the JSON or it's not meeting the expecting format in another way, <code>null</code> will be
+   * returned.
    */
   public static StreetsideSequence decodeSequence(final JsonObject json) {
 …
     final JsonObject properties = json.getJsonObject("properties");
     final Long ca = properties == null ? null : JsonDecoder.decodeTimestamp(properties.getString("cd", null));
+    if (properties != null && properties.getString("id", null) != null && properties.getString("user_key", null) != null && ca != null) {
+    if (properties != null && properties.getString("id", null) != null
+        && properties.getString("user_key", null) != null && ca != null) {
       result = new StreetsideSequence(properties.getString("id", null), ca);
+      final Double[] hes = decodeCoordinateProperty(
+        properties,
+        "hes",
+        val ->  val instanceof JsonNumber ? ((JsonNumber) val).doubleValue() : null,
+        Double.class
+      );
+      final String[] imageIds = decodeCoordinateProperty(
+        properties,
+        "image_ids",
+        val -> val instanceof JsonString ? ((JsonString) val).getString() : null,
+        String.class
+      );
+      final Double[] hes = decodeCoordinateProperty(properties, "hes",
+          val -> val instanceof JsonNumber ? ((JsonNumber) val).doubleValue() : null, Double.class);
+      final String[] imageIds = decodeCoordinateProperty(properties, "image_ids",
+          val -> val instanceof JsonString ? ((JsonString) val).getString() : null, String.class);
       final LatLon[] geometry = decodeLatLons(json.getJsonObject("geometry"));
       final int sequenceLength = Math.min(Math.min(hes.length, imageIds.length), geometry.length);
 …
    * @param clazz the desired type that the elements of the resulting array should have
    * @return the supplied array converted from {@link JsonArray} to a java array of the supplied type, converted using
    *         the supplied function. Never <code>null</code>, in case of array==null, an array of length 0 is returned.
+   *     the supplied function. Never <code>null</code>, in case of array==null, an array of length 0 is returned.
    */
   @SuppressWarnings("unchecked")
+  private static <T> T[] decodeJsonArray(final JsonArray array, final Function<JsonValue, T> decodeValueFunction, final Class<T> clazz) {
+  private static <T> T[] decodeJsonArray(final JsonArray array, final Function<JsonValue, T> decodeValueFunction,
+      final Class<T> clazz) {
     final T[] result;
     if (array == null) {
       result =  (T[]) Array.newInstance(clazz, 0);
+      result = (T[]) Array.newInstance(clazz, 0);
     } else {
       result = (T[]) Array.newInstance(clazz, array.size());
 …
    * @param key the key, which identifies the desired array inside the `coordinateProperties` object to be converted
    * @param decodeValueFunction a function that converts the {@link JsonValue}s in the JSON array to java objects of the
    *        desired type
+   *    desired type
    * @param clazz the {@link Class} object of the desired type, that the entries of the resulting array should have
    * @return the resulting array, when converting the desired entry of the `coordinateProperties`.
    *         Never <code>null</code>. If no `coordinateProperties` are set, or if the desired key is not set or is not
    *         an array, then an empty array of the desired type is returned.
+   *     Never <code>null</code>. If no `coordinateProperties` are set, or if the desired key is not set or is not
+   *     an array, then an empty array of the desired type is returned.
    */
   @SuppressWarnings("unchecked")
+  private static <T> T[] decodeCoordinateProperty(
+    final JsonObject json, final String key, final Function<JsonValue, T> decodeValueFunction, final Class<T> clazz
+  ) {
+  private static <T> T[] decodeCoordinateProperty(final JsonObject json, final String key,
+      final Function<JsonValue, T> decodeValueFunction, final Class<T> clazz) {
     final JsonValue coordinateProperties = json == null ? null : json.get("coordinateProperties");
     if (coordinateProperties instanceof JsonObject) {

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/utils/api/JsonStreetsideDecoder.java

-              r36122
+              r36194
    * of the desired Java objects. The method, which converts the GeoJSON features into Java objects
    * is given as a parameter to this method.
+   * @param <T> feature type
+   * @param json the {@link JsonObject} to be parsed
+   *
+   * @param <T>      feature type
+   * @param json       the {@link JsonObject} to be parsed
    * @param featureDecoder feature decoder which transforms JSON objects to Java objects
    * @return a {@link Collection} which is parsed from the given {@link JsonObject}, which contains GeoJSON.
    *         Currently a {@link HashSet} is used, but please don't rely on it, this could change at any time without
    *         prior notice. The return value will not be <code>null</code>.
+   * Currently a {@link HashSet} is used, but please don't rely on it, this could change at any time without
+   * prior notice. The return value will not be <code>null</code>.
    */
+  public static <T> Collection<T> decodeFeatureCollection(final JsonObject json, Function<JsonObject, T> featureDecoder) {
+  public static <T> Collection<T> decodeFeatureCollection(final JsonObject json,
+      Function<JsonObject, T> featureDecoder) {
     return JsonDecoder.decodeFeatureCollection(json, featureDecoder);
+  }
 …
    * Decodes a {@link JsonArray} of exactly size 2 to a {@link LatLon} instance.
    * The first value in the {@link JsonArray} is treated as longitude, the second one as latitude.
+   *
    * @param json the {@link JsonArray} containing the two numbers
    * @return the decoded {@link LatLon} instance, or <code>null</code> if the parameter is
    *         not a {@link JsonArray} of exactly size 2 containing two {@link JsonNumber}s.
+   * not a {@link JsonArray} of exactly size 2 containing two {@link JsonNumber}s.
    */
   static LatLon decodeLatLon(final JsonArray json) {
 …
    * Decodes a timestamp formatted as a {@link String} to the equivalent UNIX epoch timestamp
    * (number of milliseconds since 1970-01-01T00:00:00.000+0000).
+   *
    * @param timestamp the timestamp formatted according to the format <code>yyyy-MM-dd'T'HH:mm:ss.SSSX</code>
    * @return the point in time as a {@link Long} value representing the UNIX epoch time, or <code>null</code> if the
    *   parameter does not match the required format (this also triggers a warning via
    *   {@link Logging}, or the parameter is <code>null</code>).
+   * parameter does not match the required format (this also triggers a warning via
+   * {@link Logging}, or the parameter is <code>null</code>).
    */
   static Long decodeTimestamp(final String timestamp) {

applications/editors/josm/plugins/MicrosoftStreetside/src/org/openstreetmap/josm/plugins/streetside/utils/api/JsonStreetsideSequencesDecoder.java

-              r36122
+              r36194
 import java.util.function.Function;
+import org.openstreetmap.josm.data.coor.LatLon;
+import org.openstreetmap.josm.plugins.streetside.StreetsideImage;
+import org.openstreetmap.josm.plugins.streetside.StreetsideSequence;
+import org.openstreetmap.josm.plugins.streetside.utils.StreetsideURL.APIv3;
 import jakarta.json.JsonArray;
 import jakarta.json.JsonNumber;
 …
 import jakarta.json.JsonString;
 import jakarta.json.JsonValue;
-import org.openstreetmap.josm.data.coor.LatLon;
-import org.openstreetmap.josm.plugins.streetside.StreetsideImage;
-import org.openstreetmap.josm.plugins.streetside.StreetsideSequence;
-import org.openstreetmap.josm.plugins.streetside.utils.StreetsideURL.APIv3;
 /**
 …
   /**
    * Parses a given {@link JsonObject} as a GeoJSON Feature into a {@link StreetsideSequence}.
+   *
    * @param json the {@link JsonObject} to be parsed
    * @return a {@link StreetsideSequence} that is parsed from the given {@link JsonObject}. If mandatory information is
    *         missing from the JSON or it's not meeting the expecting format in another way, <code>null</code> will be
    *         returned.
+   * missing from the JSON or it's not meeting the expecting format in another way, <code>null</code> will be
+   * returned.
    */
   public static StreetsideSequence decodeSequence(final JsonObject json) {
 …
       result = new StreetsideSequence(properties.getString("id", null), ca);
+      final Double[] cas = decodeCoordinateProperty(
+        properties,
+        "hes",
+        val ->  val instanceof JsonNumber ? ((JsonNumber) val).doubleValue() : null,
+        Double.class
+      );
+      final String[] imageIds = decodeCoordinateProperty(
+        properties,
+        "image_ids",
+        val -> val instanceof JsonString ? ((JsonString) val).getString() : null,
+        String.class
+      );
+      final Double[] cas = decodeCoordinateProperty(properties, "hes",
+          val -> val instanceof JsonNumber ? ((JsonNumber) val).doubleValue() : null, Double.class);
+      final String[] imageIds = decodeCoordinateProperty(properties, "image_ids",
+          val -> val instanceof JsonString ? ((JsonString) val).getString() : null, String.class);
       final LatLon[] geometry = decodeLatLons(json.getJsonObject("geometry"));
       final int sequenceLength = Math.min(Math.min(cas.length, imageIds.length), geometry.length);
 …
    * @param image the {@link StreetsideImage} to be parsed
    * @return a {@link StreetsideSequence} that is parsed from the given {@link JsonObject}. If mandatory information is
    *         missing from the JSON or it's not meeting the expecting format in another way, <code>null</code> will be
    *         returned.
+   *     missing from the JSON or it's not meeting the expecting format in another way, <code>null</code> will be
+   *     returned.
    */
   public static StreetsideImage decodeBubbleData(final StreetsideImage image) {
 …
     // Declare and instantiate new Streetside object to ensure proper setting of superclass attributes
     StreetsideImage result = null;
     if(image.getId() != null ) {
+    if (image.getId() != null) {
       result = new StreetsideImage(image.getId(), new LatLon(image.getLa(), image.getLo()), 0.0);
       result.setAl(image.getAl());
 …
    * @param json the {@link JsonObject} to be parsed
    * @return a {@link StreetsideSequence} that is parsed from the given {@link JsonObject}. If mandatory information is
    *         missing from the JSON or it's not meeting the expecting format in another way, <code>null</code> will be
    *         returned.
+   *     missing from the JSON or it's not meeting the expecting format in another way, <code>null</code> will be
+   *     returned.
    */
   public static StreetsideSequence decodeStreetsideSequence(final JsonObject json) {
 …
     StreetsideSequence result = null;
+    if (json.getString("id", null) != null && json.getString("la", null) != null && json.getString("lo", null) != null) {
+        result = new StreetsideSequence(json.getString("id", null),
+                json.getJsonNumber("la").doubleValue(), json.getJsonNumber("lo").doubleValue(), json.getJsonNumber("cd").longValue());
+    if (json.getString("id", null) != null && json.getString("la", null) != null
+        && json.getString("lo", null) != null) {
+      result = new StreetsideSequence(json.getString("id", null), json.getJsonNumber("la").doubleValue(),
+          json.getJsonNumber("lo").doubleValue(), json.getJsonNumber("cd").longValue());
+    }
 …
    * @param clazz the desired type that the elements of the resulting array should have
    * @return the supplied array converted from {@link JsonArray} to a java array of the supplied type, converted using
    *         the supplied function. Never <code>null</code>, in case of array==null, an array of length 0 is returned.
+   *     the supplied function. Never <code>null</code>, in case of array==null, an array of length 0 is returned.
    */
   @SuppressWarnings("unchecked")
+  private static <T> T[] decodeJsonArray(final JsonArray array, final Function<JsonValue, T> decodeValueFunction, final Class<T> clazz) {
+  private static <T> T[] decodeJsonArray(final JsonArray array, final Function<JsonValue, T> decodeValueFunction,
+      final Class<T> clazz) {
     final T[] result;
     if (array == null) {
       result =  (T[]) Array.newInstance(clazz, 0);
+      result = (T[]) Array.newInstance(clazz, 0);
     } else {
       result = (T[]) Array.newInstance(clazz, array.size());
 …
    * @param key the key, which identifies the desired array inside the `coordinateProperties` object to be converted
    * @param decodeValueFunction a function that converts the {@link JsonValue}s in the JSON array to java objects of the
    *        desired type
+   *    desired type
    * @param clazz the {@link Class} object of the desired type, that the entries of the resulting array should have
    * @return the resulting array, when converting the desired entry of the `coordinateProperties`.
    *         Never <code>null</code>. If no `coordinateProperties` are set, or if the desired key is not set or is not
    *         an array, then an empty array of the desired type is returned.
+   *     Never <code>null</code>. If no `coordinateProperties` are set, or if the desired key is not set or is not
+   *     an array, then an empty array of the desired type is returned.
    */
   @SuppressWarnings("unchecked")
+  private static <T> T[] decodeCoordinateProperty(
+    final JsonObject json, final String key, final Function<JsonValue, T> decodeValueFunction, final Class<T> clazz
+  ) {
+  private static <T> T[] decodeCoordinateProperty(final JsonObject json, final String key,
+      final Function<JsonValue, T> decodeValueFunction, final Class<T> clazz) {
     final JsonValue coordinateProperties = json == null ? null : json.get("coordinateProperties");
     if (coordinateProperties instanceof JsonObject) {

Context Navigation

Changeset 36194 in osm for applications/editors/josm/plugins/MicrosoftStreetside/src/org

Legend:

Download in other formats: