source: josm/trunk/src/org/openstreetmap/josm/gui/layer/geoimage/ImageDisplay.java@ 18947

Last change on this file since 18947 was 18947, checked in by GerdP, 4 months ago

fix memory leak, ImgDisplay.destroy() was only called when at least one image was viewed
  • Property svn:eol-style set to native
File size: 40.7 KB
Line 
1// License: GPL. For details, see LICENSE file.
2package org.openstreetmap.josm.gui.layer.geoimage;
3
4import static org.openstreetmap.josm.tools.I18n.tr;
5
6import java.awt.Color;
7import java.awt.Dimension;
8import java.awt.FontMetrics;
9import java.awt.Graphics;
10import java.awt.Graphics2D;
11import java.awt.Image;
12import java.awt.Point;
13import java.awt.Rectangle;
14import java.awt.RenderingHints;
15import java.awt.event.ComponentEvent;
16import java.awt.event.MouseAdapter;
17import java.awt.event.MouseEvent;
18import java.awt.event.MouseWheelEvent;
19import java.awt.geom.Rectangle2D;
20import java.awt.image.BufferedImage;
21import java.io.IOException;
22import java.util.Objects;
23import java.util.concurrent.Future;
24
25import javax.swing.JComponent;
26import javax.swing.SwingUtilities;
27
28import org.openstreetmap.josm.data.imagery.street_level.IImageEntry;
29import org.openstreetmap.josm.data.imagery.street_level.Projections;
30import org.openstreetmap.josm.data.preferences.BooleanProperty;
31import org.openstreetmap.josm.data.preferences.DoubleProperty;
32import org.openstreetmap.josm.data.preferences.IntegerProperty;
33import org.openstreetmap.josm.gui.MainApplication;
34import org.openstreetmap.josm.gui.layer.AbstractMapViewPaintable;
35import org.openstreetmap.josm.gui.layer.geoimage.viewers.projections.IImageViewer;
36import org.openstreetmap.josm.gui.layer.geoimage.viewers.projections.ImageProjectionRegistry;
37import org.openstreetmap.josm.gui.layer.imagery.ImageryFilterSettings;
38import org.openstreetmap.josm.gui.layer.imagery.ImageryFilterSettings.FilterChangeListener;
39import org.openstreetmap.josm.gui.util.GuiHelper;
40import org.openstreetmap.josm.gui.util.imagery.Vector3D;
41import org.openstreetmap.josm.spi.preferences.Config;
42import org.openstreetmap.josm.spi.preferences.PreferenceChangeEvent;
43import org.openstreetmap.josm.spi.preferences.PreferenceChangedListener;
44import org.openstreetmap.josm.tools.Destroyable;
45import org.openstreetmap.josm.tools.ImageProcessor;
46import org.openstreetmap.josm.tools.JosmRuntimeException;
47import org.openstreetmap.josm.tools.Logging;
48import org.openstreetmap.josm.tools.Utils;
49
50/**
51 * GUI component to display an image (photograph).
52 *
53 * Offers basic mouse interaction (zoom, drag) and on-screen text.
54 * @since 2566
55 */
56public class ImageDisplay extends JComponent implements Destroyable, PreferenceChangedListener, FilterChangeListener {
57
58 /** The current image viewer */
59 private IImageViewer iImageViewer;
60
61 /** The file that is currently displayed */
62 private IImageEntry<?> entry;
63
64 /** The previous file that is currently displayed. Cleared on paint. Only used to help improve UI error information. */
65 private IImageEntry<?> oldEntry;
66
67 /** The image currently displayed */
68 private transient BufferedImage image;
69
70 /** The image currently displayed after applying {@link #imageProcessor} */
71 private transient BufferedImage processedImage;
72
73 /**
74 * Process the image before it is being displayed
75 */
76 private final ImageProcessor imageProcessor;
77
78 /** The image currently displayed */
79 private boolean errorLoading;
80
81 /** The rectangle (in image coordinates) of the image that is visible. This rectangle is calculated
82 * each time the zoom is modified */
83 private VisRect visibleRect;
84
85 /** When a selection is done, the rectangle of the selection (in image coordinates) */
86 private VisRect selectedRect;
87
88 private final ImgDisplayMouseListener imgMouseListener = new ImgDisplayMouseListener();
89
90 private String emptyText;
91 private String osdText;
92
93 private static final BooleanProperty AGPIFO_STYLE =
94 new BooleanProperty("geoimage.agpifo-style-drag-and-zoom", false);
95 private static int dragButton;
96 private static int zoomButton;
97
98 /** Alternative to mouse wheel zoom; esp. handy if no mouse wheel is present **/
99 private static final BooleanProperty ZOOM_ON_CLICK =
100 new BooleanProperty("geoimage.use-mouse-clicks-to-zoom", true);
101
102 /** Zoom factor when click or wheel zooming **/
103 private static final DoubleProperty ZOOM_STEP =
104 new DoubleProperty("geoimage.zoom-step-factor", 3 / 2.0);
105
106 /** Maximum zoom allowed **/
107 private static final DoubleProperty MAX_ZOOM =
108 new DoubleProperty("geoimage.maximum-zoom-scale", 2.0);
109
110 /** Maximum width (in pixels) for loading images **/
111 private static final IntegerProperty MAX_WIDTH =
112 new IntegerProperty("geoimage.maximum-width", 6000);
113
114 /** Show a background for the error text (may be hard on eyes) */
115 private static final BooleanProperty ERROR_MESSAGE_BACKGROUND = new BooleanProperty("geoimage.message.error.background", false);
116
117 private UpdateImageThread updateImageThreadInstance;
118
119 private boolean destroyed;
120
121 private class UpdateImageThread extends Thread {
122 private boolean restart;
123
124 @SuppressWarnings("DoNotCall") // we are calling `run` from the thread we want it to be running on (aka recursive)
125 @Override
126 public void run() {
127 updateProcessedImage();
128 if (restart) {
129 restart = false;
130 run();
131 }
132 }
133
134 public void restart() {
135 restart = true;
136 if (!isAlive()) {
137 restart = false;
138 updateImageThreadInstance = new UpdateImageThread();
139 updateImageThreadInstance.start();
140 }
141 }
142 }
143
144 @Override
145 public void preferenceChanged(PreferenceChangeEvent e) {
146 if (e == null ||
147 e.getKey().equals(AGPIFO_STYLE.getKey())) {
148 dragButton = AGPIFO_STYLE.get() ? 1 : 3;
149 zoomButton = dragButton == 1 ? 3 : 1;
150 }
151 }
152
153 /**
154 * Manage the visible rectangle of an image with full bounds stored in init.
155 * @since 13127
156 */
157 public static class VisRect extends Rectangle {
158 private final Rectangle init;
159
160 /** set when this {@code VisRect} is updated by a mouse drag operation and
161 * unset on mouse release **/
162 public boolean isDragUpdate;
163
164 /**
165 * Constructs a new {@code VisRect}.
166 * @param x the specified X coordinate
167 * @param y the specified Y coordinate
168 * @param width the width of the rectangle
169 * @param height the height of the rectangle
170 */
171 public VisRect(int x, int y, int width, int height) {
172 super(x, y, width, height);
173 init = new Rectangle(this);
174 }
175
176 /**
177 * Constructs a new {@code VisRect}.
178 * @param x the specified X coordinate
179 * @param y the specified Y coordinate
180 * @param width the width of the rectangle
181 * @param height the height of the rectangle
182 * @param peer share full bounds with this peer {@code VisRect}
183 */
184 public VisRect(int x, int y, int width, int height, VisRect peer) {
185 super(x, y, width, height);
186 init = peer.init;
187 }
188
189 /**
190 * Constructs a new {@code VisRect} from another one.
191 * @param v rectangle to copy
192 */
193 public VisRect(VisRect v) {
194 super(v);
195 init = v.init;
196 }
197
198 /**
199 * Constructs a new empty {@code VisRect}.
200 */
201 public VisRect() {
202 this(0, 0, 0, 0);
203 }
204
205 public boolean isFullView() {
206 return init.equals(this);
207 }
208
209 public boolean isFullView1D() {
210 return (init.x == x && init.width == width)
211 || (init.y == y && init.height == height);
212 }
213
214 public void reset() {
215 setBounds(init);
216 }
217
218 public void checkRectPos() {
219 if (x < 0) {
220 x = 0;
221 }
222 if (y < 0) {
223 y = 0;
224 }
225 if (x + width > init.width) {
226 x = init.width - width;
227 }
228 if (y + height > init.height) {
229 y = init.height - height;
230 }
231 }
232
233 public void checkRectSize() {
234 if (width > init.width) {
235 width = init.width;
236 }
237 if (height > init.height) {
238 height = init.height;
239 }
240 }
241
242 public void checkPointInside(Point p) {
243 if (p.x < x) {
244 p.x = x;
245 }
246 if (p.x > x + width) {
247 p.x = x + width;
248 }
249 if (p.y < y) {
250 p.y = y;
251 }
252 if (p.y > y + height) {
253 p.y = y + height;
254 }
255 }
256
257 @Override
258 public int hashCode() {
259 return 31 * super.hashCode() + Objects.hash(init);
260 }
261
262 @Override
263 public boolean equals(Object obj) {
264 if (this == obj)
265 return true;
266 if (!super.equals(obj) || getClass() != obj.getClass())
267 return false;
268 VisRect other = (VisRect) obj;
269 return Objects.equals(init, other.init);
270 }
271 }
272
273 /** The thread that reads the images. */
274 protected class LoadImageRunnable implements Runnable {
275
276 private final IImageEntry<?> entry;
277
278 LoadImageRunnable(IImageEntry<?> entry) {
279 this.entry = entry;
280 }
281
282 @Override
283 public void run() {
284 try {
285 Dimension target = new Dimension(MAX_WIDTH.get(), MAX_WIDTH.get());
286 BufferedImage img = entry.read(target);
287 if (img == null) {
288 synchronized (ImageDisplay.this) {
289 errorLoading = true;
290 ImageDisplay.this.repaint();
291 return;
292 }
293 }
294
295 int width = img.getWidth();
296 int height = img.getHeight();
297 entry.setWidth(width);
298 entry.setHeight(height);
299
300 synchronized (ImageDisplay.this) {
301 if (this.entry != ImageDisplay.this.entry) {
302 // The file has changed
303 return;
304 }
305
306 ImageDisplay.this.image = img;
307 updateProcessedImage();
308 // This will clear the loading info box
309 ImageDisplay.this.oldEntry = ImageDisplay.this.entry;
310 visibleRect = getIImageViewer(entry).getDefaultVisibleRectangle(ImageDisplay.this, image);
311
312 selectedRect = null;
313 errorLoading = false;
314 }
315 ImageDisplay.this.repaint();
316 } catch (IOException ex) {
317 Logging.error(ex);
318 }
319 }
320 }
321
322 private class ImgDisplayMouseListener extends MouseAdapter {
323
324 private MouseEvent lastMouseEvent;
325 private Point mousePointInImg;
326
327 private boolean mouseIsDragging(MouseEvent e) {
328 return (dragButton == 1 && SwingUtilities.isLeftMouseButton(e)) ||
329 (dragButton == 2 && SwingUtilities.isMiddleMouseButton(e)) ||
330 (dragButton == 3 && SwingUtilities.isRightMouseButton(e));
331 }
332
333 private boolean mouseIsZoomSelecting(MouseEvent e) {
334 return (zoomButton == 1 && SwingUtilities.isLeftMouseButton(e)) ||
335 (zoomButton == 2 && SwingUtilities.isMiddleMouseButton(e)) ||
336 (zoomButton == 3 && SwingUtilities.isRightMouseButton(e));
337 }
338
339 private boolean isAtMaxZoom(Rectangle visibleRect) {
340 return (visibleRect.width == (int) (getSize().width / MAX_ZOOM.get()) ||
341 visibleRect.height == (int) (getSize().height / MAX_ZOOM.get()));
342 }
343
344 private void mouseWheelMovedImpl(int x, int y, int rotation, boolean refreshMousePointInImg) {
345 IImageEntry<?> currentEntry;
346 IImageViewer imageViewer;
347 Image currentImage;
348 VisRect currentVisibleRect;
349
350 synchronized (ImageDisplay.this) {
351 currentEntry = ImageDisplay.this.entry;
352 currentImage = ImageDisplay.this.image;
353 currentVisibleRect = ImageDisplay.this.visibleRect;
354 imageViewer = ImageDisplay.this.iImageViewer;
355 }
356
357 selectedRect = null;
358
359 if (currentImage == null)
360 return;
361
362 // Calculate the mouse cursor position in image coordinates to center the zoom.
363 if (refreshMousePointInImg)
364 mousePointInImg = comp2imgCoord(currentVisibleRect, x, y, getSize());
365
366 // Apply the zoom to the visible rectangle in image coordinates
367 if (rotation > 0) {
368 currentVisibleRect.width = (int) (currentVisibleRect.width * ZOOM_STEP.get());
369 currentVisibleRect.height = (int) (currentVisibleRect.height * ZOOM_STEP.get());
370 } else if (rotation < 0) {
371 currentVisibleRect.width = (int) (currentVisibleRect.width / ZOOM_STEP.get());
372 currentVisibleRect.height = (int) (currentVisibleRect.height / ZOOM_STEP.get());
373 } // else rotation == 0, which can happen with some modern trackpads (see #22770)
374
375 // Check that the zoom doesn't exceed MAX_ZOOM:1
376 ensureMaxZoom(currentVisibleRect);
377
378 // The size of the visible rectangle is limited by the image size or the viewer implementation.
379 if (imageViewer != null) {
380 imageViewer.checkAndModifyVisibleRectSize(currentImage, currentVisibleRect);
381 } else {
382 currentVisibleRect.checkRectSize();
383 }
384
385 // Set the position of the visible rectangle, so that the mouse cursor doesn't move on the image.
386 Rectangle drawRect = calculateDrawImageRectangle(currentVisibleRect, getSize());
387 currentVisibleRect.x = mousePointInImg.x + ((drawRect.x - x) * currentVisibleRect.width) / drawRect.width;
388 currentVisibleRect.y = mousePointInImg.y + ((drawRect.y - y) * currentVisibleRect.height) / drawRect.height;
389
390 // The position is also limited by the image size
391 currentVisibleRect.checkRectPos();
392
393 synchronized (ImageDisplay.this) {
394 if (ImageDisplay.this.entry == currentEntry) {
395 ImageDisplay.this.visibleRect = currentVisibleRect;
396 }
397 }
398 ImageDisplay.this.repaint();
399 }
400
401 /** Zoom in and out, trying to preserve the point of the image that was under the mouse cursor
402 * at the same place */
403 @Override
404 public void mouseWheelMoved(MouseWheelEvent e) {
405 boolean refreshMousePointInImg = false;
406
407 // To avoid issues when the user tries to zoom in on the image borders, this
408 // point is not recalculated as long as e occurs at roughly the same position.
409 if (lastMouseEvent == null || mousePointInImg == null ||
410 ((lastMouseEvent.getX()-e.getX())*(lastMouseEvent.getX()-e.getX())
411 +(lastMouseEvent.getY()-e.getY())*(lastMouseEvent.getY()-e.getY()) > 4*4)) {
412 lastMouseEvent = e;
413 refreshMousePointInImg = true;
414 }
415
416 mouseWheelMovedImpl(e.getX(), e.getY(), e.getWheelRotation(), refreshMousePointInImg);
417 }
418
419 /** Center the display on the point that has been clicked */
420 @Override
421 public void mouseClicked(MouseEvent e) {
422 // Move the center to the clicked point.
423 IImageEntry<?> currentEntry;
424 Image currentImage;
425 VisRect currentVisibleRect;
426
427 synchronized (ImageDisplay.this) {
428 currentEntry = ImageDisplay.this.entry;
429 currentImage = ImageDisplay.this.image;
430 currentVisibleRect = ImageDisplay.this.visibleRect;
431 }
432
433 if (currentImage == null)
434 return;
435
436 if (ZOOM_ON_CLICK.get()) {
437 // click notions are less coherent than wheel, refresh mousePointInImg on each click
438 lastMouseEvent = null;
439
440 if (mouseIsZoomSelecting(e) && !isAtMaxZoom(currentVisibleRect)) {
441 // zoom in if clicked with the zoom button
442 mouseWheelMovedImpl(e.getX(), e.getY(), -1, true);
443 return;
444 }
445 if (mouseIsDragging(e)) {
446 // zoom out if clicked with the drag button
447 mouseWheelMovedImpl(e.getX(), e.getY(), 1, true);
448 return;
449 }
450 }
451
452 // Calculate the translation to set the clicked point the center of the view.
453 Point click = comp2imgCoord(currentVisibleRect, e.getX(), e.getY(), getSize());
454 Point center = getCenterImgCoord(currentVisibleRect);
455
456 currentVisibleRect.x += click.x - center.x;
457 currentVisibleRect.y += click.y - center.y;
458
459 currentVisibleRect.checkRectPos();
460
461 synchronized (ImageDisplay.this) {
462 if (ImageDisplay.this.entry == currentEntry) {
463 ImageDisplay.this.visibleRect = currentVisibleRect;
464 }
465 }
466 ImageDisplay.this.repaint();
467 }
468
469 /** Initialize the dragging, either with button 1 (simple dragging) or button 3 (selection of
470 * a picture part) */
471 @Override
472 public void mousePressed(MouseEvent e) {
473 Image currentImage;
474 VisRect currentVisibleRect;
475
476 synchronized (ImageDisplay.this) {
477 currentImage = ImageDisplay.this.image;
478 currentVisibleRect = ImageDisplay.this.visibleRect;
479 }
480
481 if (currentImage == null)
482 return;
483
484 selectedRect = null;
485
486 if (mouseIsDragging(e) || mouseIsZoomSelecting(e))
487 mousePointInImg = comp2imgCoord(currentVisibleRect, e.getX(), e.getY(), getSize());
488 }
489
490 @Override
491 public void mouseDragged(MouseEvent e) {
492 if (!mouseIsDragging(e) && !mouseIsZoomSelecting(e))
493 return;
494
495 IImageEntry<?> imageEntry;
496 Image currentImage;
497 VisRect currentVisibleRect;
498
499 synchronized (ImageDisplay.this) {
500 imageEntry = ImageDisplay.this.entry;
501 currentImage = ImageDisplay.this.image;
502 currentVisibleRect = ImageDisplay.this.visibleRect;
503 }
504
505 if (currentImage == null)
506 return;
507
508 if (mouseIsDragging(e) && mousePointInImg != null) {
509 Point p = comp2imgCoord(currentVisibleRect, e.getX(), e.getY(), getSize());
510 getIImageViewer(entry).mouseDragged(this.mousePointInImg, p, currentVisibleRect);
511 currentVisibleRect.checkRectPos();
512 synchronized (ImageDisplay.this) {
513 if (ImageDisplay.this.entry == imageEntry) {
514 ImageDisplay.this.visibleRect = currentVisibleRect;
515 }
516 }
517 // We have to update the mousePointInImg for 360 image panning, as otherwise the panning never stops.
518 // This does not work well with the perspective viewer at this time (2021-08-26).
519 boolean is360panning = entry != null && Projections.EQUIRECTANGULAR == entry.getProjectionType();
520 if (is360panning) {
521 this.mousePointInImg = p;
522 }
523 ImageDisplay.this.repaint();
524 if (is360panning) {
525 // repaint direction arrow
526 MainApplication.getLayerManager().getLayersOfType(GeoImageLayer.class).forEach(AbstractMapViewPaintable::invalidate);
527 }
528 }
529
530 if (mouseIsZoomSelecting(e) && mousePointInImg != null) {
531 Point p = comp2imgCoord(currentVisibleRect, e.getX(), e.getY(), getSize());
532 currentVisibleRect.checkPointInside(p);
533 VisRect selectedRectTemp = new VisRect(
534 Math.min(p.x, mousePointInImg.x),
535 Math.min(p.y, mousePointInImg.y),
536 p.x < mousePointInImg.x ? mousePointInImg.x - p.x : p.x - mousePointInImg.x,
537 p.y < mousePointInImg.y ? mousePointInImg.y - p.y : p.y - mousePointInImg.y,
538 currentVisibleRect);
539 selectedRectTemp.checkRectSize();
540 selectedRectTemp.checkRectPos();
541 ImageDisplay.this.selectedRect = selectedRectTemp;
542 ImageDisplay.this.repaint();
543 }
544 }
545
546 @Override
547 public void mouseReleased(MouseEvent e) {
548 IImageEntry<?> currentEntry;
549 Image currentImage;
550 VisRect currentVisibleRect;
551
552 synchronized (ImageDisplay.this) {
553 currentEntry = ImageDisplay.this.entry;
554 currentImage = ImageDisplay.this.image;
555 currentVisibleRect = ImageDisplay.this.visibleRect;
556 }
557
558 if (currentImage == null)
559 return;
560
561 if (mouseIsDragging(e)) {
562 currentVisibleRect.isDragUpdate = false;
563 }
564
565 if (mouseIsZoomSelecting(e) && selectedRect != null) {
566 int oldWidth = selectedRect.width;
567 int oldHeight = selectedRect.height;
568
569 // Check that the zoom doesn't exceed MAX_ZOOM:1
570 ensureMaxZoom(selectedRect);
571
572 // Keep the center of the selection
573 if (selectedRect.width != oldWidth) {
574 selectedRect.x -= (selectedRect.width - oldWidth) / 2;
575 }
576 if (selectedRect.height != oldHeight) {
577 selectedRect.y -= (selectedRect.height - oldHeight) / 2;
578 }
579
580 selectedRect.checkRectSize();
581 selectedRect.checkRectPos();
582 }
583
584 synchronized (ImageDisplay.this) {
585 if (currentEntry == ImageDisplay.this.entry) {
586 if (selectedRect == null) {
587 ImageDisplay.this.visibleRect = currentVisibleRect;
588 } else {
589 ImageDisplay.this.visibleRect.setBounds(selectedRect);
590 selectedRect = null;
591 }
592 }
593 }
594 ImageDisplay.this.repaint();
595 }
596 }
597
598 /**
599 * Constructs a new {@code ImageDisplay} with no image processor.
600 */
601 public ImageDisplay() {
602 this(imageObject -> imageObject);
603 }
604
605 /**
606 * Constructs a new {@code ImageDisplay} with a given image processor.
607 * @param imageProcessor image processor
608 * @since 17740
609 */
610 public ImageDisplay(ImageProcessor imageProcessor) {
611 addMouseListener(imgMouseListener);
612 addMouseWheelListener(imgMouseListener);
613 addMouseMotionListener(imgMouseListener);
614 Config.getPref().addPreferenceChangeListener(this);
615 preferenceChanged(null);
616 this.imageProcessor = imageProcessor;
617 if (imageProcessor instanceof ImageryFilterSettings) {
618 ((ImageryFilterSettings) imageProcessor).addFilterChangeListener(this);
619 }
620 }
621
622 @Override
623 public void destroy() {
624 if (!destroyed) {
625 removeMouseListener(imgMouseListener);
626 removeMouseWheelListener(imgMouseListener);
627 removeMouseMotionListener(imgMouseListener);
628 Config.getPref().removePreferenceChangeListener(this);
629 if (imageProcessor instanceof ImageryFilterSettings) {
630 ((ImageryFilterSettings) imageProcessor).removeFilterChangeListener(this);
631 }
632 }
633 destroyed = true;
634 }
635
636 /**
637 * Sets a new source image to be displayed by this {@code ImageDisplay}.
638 * @param entry new source image
639 * @return a {@link Future} representing pending completion of the image loading task
640 * @since 18246 (signature)
641 */
642 public Future<?> setImage(IImageEntry<?> entry) {
643 LoadImageRunnable runnable = setImage0(entry);
644 return runnable != null && !MainApplication.worker.isShutdown() ? MainApplication.worker.submit(runnable) : null;
645 }
646
647 protected LoadImageRunnable setImage0(IImageEntry<?> entry) {
648 synchronized (this) {
649 this.oldEntry = this.entry;
650 this.entry = entry;
651 if (entry == null) {
652 image = null;
653 updateProcessedImage();
654 this.oldEntry = null;
655 }
656 errorLoading = false;
657 }
658 repaint();
659 return entry != null ? new LoadImageRunnable(entry) : null;
660 }
661
662 /**
663 * Set the message displayed when there is no image to display.
664 * By default it display a simple No image
665 * @param emptyText the string to display
666 * @since 15333
667 */
668 public void setEmptyText(String emptyText) {
669 this.emptyText = emptyText;
670 }
671
672 /**
673 * Sets the On-Screen-Display text.
674 * @param text text to display on top of the image
675 */
676 public void setOsdText(String text) {
677 if (!text.equals(this.osdText)) {
678 this.osdText = text;
679 repaint();
680 }
681 }
682
683 @Override
684 public void filterChanged() {
685 if (updateImageThreadInstance != null) {
686 updateImageThreadInstance.restart();
687 } else {
688 updateImageThreadInstance = new UpdateImageThread();
689 updateImageThreadInstance.start();
690 }
691 }
692
693 private void updateProcessedImage() {
694 processedImage = image == null ? null : imageProcessor.process(image);
695 GuiHelper.runInEDT(this::repaint);
696 }
697
698 @Override
699 public void paintComponent(Graphics g) {
700 super.paintComponent(g);
701
702 IImageEntry<?> currentEntry;
703 IImageEntry<?> currentOldEntry;
704 IImageViewer currentImageViewer;
705 BufferedImage currentImage;
706 boolean currentErrorLoading;
707
708 synchronized (this) {
709 currentImage = this.processedImage;
710 currentEntry = this.entry;
711 currentOldEntry = this.oldEntry;
712 currentErrorLoading = this.errorLoading;
713 }
714
715 if (g instanceof Graphics2D) {
716 ((Graphics2D) g).setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
717 }
718
719 Dimension size = getSize();
720 // Draw the image first, then draw error information
721 if (currentImage != null && (currentEntry != null || currentOldEntry != null)) {
722 currentImageViewer = this.getIImageViewer(currentEntry);
723 // This must be after the getIImageViewer call, since we may be switching image viewers. This is important,
724 // since an image viewer on switch may change the visible rectangle.
725 VisRect currentVisibleRect;
726 synchronized (this) {
727 currentVisibleRect = this.visibleRect;
728 }
729 Rectangle r = new Rectangle(currentVisibleRect);
730 Rectangle target = calculateDrawImageRectangle(currentVisibleRect, size);
731
732 currentImageViewer.paintImage(g, currentImage, target, r);
733 paintSelectedRect(g, target, currentVisibleRect, size);
734 if (currentErrorLoading && currentEntry != null) {
735 String loadingStr = tr("Error on file {0}", currentEntry.getDisplayName());
736 Rectangle2D noImageSize = g.getFontMetrics(g.getFont()).getStringBounds(loadingStr, g);
737 g.drawString(loadingStr, (int) ((size.width - noImageSize.getWidth()) / 2),
738 (int) ((size.height - noImageSize.getHeight()) / 2));
739 }
740 paintOsdText(g);
741 }
742 paintErrorMessage(g, currentEntry, currentOldEntry, currentImage, currentErrorLoading, size);
743 }
744
745 /**
746 * Paint an error message
747 * @param g The graphics to paint on
748 * @param imageEntry The current image entry
749 * @param oldImageEntry The old image entry
750 * @param bufferedImage The image being painted
751 * @param currentErrorLoading If there was an error loading the image
752 * @param size The size of the component
753 */
754 private void paintErrorMessage(Graphics g, IImageEntry<?> imageEntry, IImageEntry<?> oldImageEntry,
755 BufferedImage bufferedImage, boolean currentErrorLoading, Dimension size) {
756 final String errorMessage;
757 // If the new entry is null, then there is no image.
758 if (imageEntry == null) {
759 if (emptyText == null) {
760 emptyText = tr("No image");
761 }
762 errorMessage = emptyText;
763 } else if (bufferedImage == null || !Objects.equals(imageEntry, oldImageEntry)) {
764 // The image is not necessarily null when loading anymore. If the oldEntry is not the same as the new entry,
765 // we are probably still loading the image. (oldEntry gets set to entry when the image finishes loading).
766 if (!currentErrorLoading) {
767 errorMessage = tr("Loading {0}", imageEntry.getDisplayName());
768 } else {
769 errorMessage = tr("Error on file {0}", imageEntry.getDisplayName());
770 }
771 } else {
772 errorMessage = null;
773 }
774 if (!Utils.isBlank(errorMessage)) {
775 Rectangle2D errorStringSize = g.getFontMetrics(g.getFont()).getStringBounds(errorMessage, g);
776 if (Boolean.TRUE.equals(ERROR_MESSAGE_BACKGROUND.get())) {
777 int height = g.getFontMetrics().getHeight();
778 int descender = g.getFontMetrics().getDescent();
779 g.setColor(getBackground());
780 int width = (int) (errorStringSize.getWidth() * 1);
781 // top-left of text
782 int tlx = (int) ((size.getWidth() - errorStringSize.getWidth()) / 2);
783 int tly = (int) ((size.getHeight() - 3 * errorStringSize.getHeight()) / 2 + descender);
784 g.fillRect(tlx, tly, width, height);
785 }
786
787 // lower-left of text
788 int llx = (int) ((size.width - errorStringSize.getWidth()) / 2);
789 int lly = (int) ((size.height - errorStringSize.getHeight()) / 2);
790 g.setColor(getForeground());
791 g.drawString(errorMessage, llx, lly);
792 }
793 }
794
795 /**
796 * Paint OSD text
797 * @param g The graphics to paint on
798 */
799 private void paintOsdText(Graphics g) {
800 if (osdText != null) {
801 FontMetrics metrics = g.getFontMetrics(g.getFont());
802 int ascent = metrics.getAscent();
803 Color bkground = new Color(255, 255, 255, 128);
804 int lastPos = 0;
805 int pos = osdText.indexOf('\n');
806 int x = 3;
807 int y = 3;
808 String line;
809 while (pos > 0) {
810 line = osdText.substring(lastPos, pos);
811 Rectangle2D lineSize = metrics.getStringBounds(line, g);
812 g.setColor(bkground);
813 g.fillRect(x, y, (int) lineSize.getWidth(), (int) lineSize.getHeight());
814 g.setColor(Color.black);
815 g.drawString(line, x, y + ascent);
816 y += (int) lineSize.getHeight();
817 lastPos = pos + 1;
818 pos = osdText.indexOf('\n', lastPos);
819 }
820
821 line = osdText.substring(lastPos);
822 Rectangle2D lineSize = g.getFontMetrics(g.getFont()).getStringBounds(line, g);
823 g.setColor(bkground);
824 g.fillRect(x, y, (int) lineSize.getWidth(), (int) lineSize.getHeight());
825 g.setColor(Color.black);
826 g.drawString(line, x, y + ascent);
827 }
828 }
829
830 /**
831 * Paint the selected rectangle
832 * @param g The graphics to paint on
833 * @param target The target area (i.e., the selection)
834 * @param visibleRectTemp The current visible rect
835 * @param size The size of the component
836 */
837 private void paintSelectedRect(Graphics g, Rectangle target, VisRect visibleRectTemp, Dimension size) {
838 if (selectedRect != null) {
839 Point topLeft = img2compCoord(visibleRectTemp, selectedRect.x, selectedRect.y, size);
840 Point bottomRight = img2compCoord(visibleRectTemp,
841 selectedRect.x + selectedRect.width,
842 selectedRect.y + selectedRect.height, size);
843 g.setColor(new Color(128, 128, 128, 180));
844 g.fillRect(target.x, target.y, target.width, topLeft.y - target.y);
845 g.fillRect(target.x, target.y, topLeft.x - target.x, target.height);
846 g.fillRect(bottomRight.x, target.y, target.x + target.width - bottomRight.x, target.height);
847 g.fillRect(target.x, bottomRight.y, target.width, target.y + target.height - bottomRight.y);
848 g.setColor(Color.black);
849 g.drawRect(topLeft.x, topLeft.y, bottomRight.x - topLeft.x, bottomRight.y - topLeft.y);
850 }
851 }
852
853 static Point img2compCoord(VisRect visibleRect, int xImg, int yImg, Dimension compSize) {
854 Rectangle drawRect = calculateDrawImageRectangle(visibleRect, compSize);
855 return new Point(drawRect.x + ((xImg - visibleRect.x) * drawRect.width) / visibleRect.width,
856 drawRect.y + ((yImg - visibleRect.y) * drawRect.height) / visibleRect.height);
857 }
858
859 static Point comp2imgCoord(VisRect visibleRect, int xComp, int yComp, Dimension compSize) {
860 Rectangle drawRect = calculateDrawImageRectangle(visibleRect, compSize);
861 Point p = new Point(
862 ((xComp - drawRect.x) * visibleRect.width),
863 ((yComp - drawRect.y) * visibleRect.height));
864 p.x += (((p.x % drawRect.width) << 1) >= drawRect.width) ? drawRect.width : 0;
865 p.y += (((p.y % drawRect.height) << 1) >= drawRect.height) ? drawRect.height : 0;
866 p.x = visibleRect.x + p.x / drawRect.width;
867 p.y = visibleRect.y + p.y / drawRect.height;
868 return p;
869 }
870
871 static Point getCenterImgCoord(Rectangle visibleRect) {
872 return new Point(visibleRect.x + visibleRect.width / 2,
873 visibleRect.y + visibleRect.height / 2);
874 }
875
876 /**
877 * calculateDrawImageRectangle
878 *
879 * @param visibleRect the part of the image that should be drawn (in image coordinates)
880 * @param compSize the part of the component where the image should be drawn (in component coordinates)
881 * @return the part of compRect with the same width/height ratio as the image
882 */
883 static VisRect calculateDrawImageRectangle(VisRect visibleRect, Dimension compSize) {
884 return calculateDrawImageRectangle(visibleRect, new Rectangle(0, 0, compSize.width, compSize.height));
885 }
886
887 /**
888 * calculateDrawImageRectangle
889 *
890 * @param imgRect the part of the image that should be drawn (in image coordinates)
891 * @param compRect the part of the component where the image should be drawn (in component coordinates)
892 * @return the part of compRect with the same width/height ratio as the image
893 */
894 static VisRect calculateDrawImageRectangle(VisRect imgRect, Rectangle compRect) {
895 int x = 0;
896 int y = 0;
897 int w = compRect.width;
898 int h = compRect.height;
899
900 int wFact = w * imgRect.height;
901 int hFact = h * imgRect.width;
902 if (wFact != hFact) {
903 if (wFact > hFact) {
904 w = hFact / imgRect.height;
905 x = (compRect.width - w) / 2;
906 } else {
907 h = wFact / imgRect.width;
908 y = (compRect.height - h) / 2;
909 }
910 }
911
912 // overscan to prevent empty edges when zooming in to zoom scales > 2:1
913 if (w > imgRect.width && h > imgRect.height && !imgRect.isFullView1D() && wFact != hFact) {
914 if (wFact > hFact) {
915 w = compRect.width;
916 x = 0;
917 h = wFact / imgRect.width;
918 y = (compRect.height - h) / 2;
919 } else {
920 h = compRect.height;
921 y = 0;
922 w = hFact / imgRect.height;
923 x = (compRect.width - w) / 2;
924 }
925 }
926
927 return new VisRect(x + compRect.x, y + compRect.y, w, h, imgRect);
928 }
929
930 /**
931 * Make the current image either scale to fit inside this component,
932 * or show a portion of image (1:1), if the image size is larger than
933 * the component size.
934 */
935 public void zoomBestFitOrOne() {
936 IImageEntry<?> currentEntry;
937 Image currentImage;
938 VisRect currentVisibleRect;
939
940 synchronized (this) {
941 currentEntry = this.entry;
942 currentImage = this.image;
943 currentVisibleRect = this.visibleRect;
944 }
945
946 if (currentImage == null)
947 return;
948
949 if (currentVisibleRect.width != currentImage.getWidth(null) || currentVisibleRect.height != currentImage.getHeight(null)) {
950 // The display is not at best fit. => Zoom to best fit
951 currentVisibleRect.reset();
952 } else {
953 // The display is at best fit => zoom to 1:1
954 Point center = getCenterImgCoord(currentVisibleRect);
955 currentVisibleRect.setBounds(center.x - getWidth() / 2, center.y - getHeight() / 2,
956 getWidth(), getHeight());
957 currentVisibleRect.checkRectSize();
958 currentVisibleRect.checkRectPos();
959 }
960
961 synchronized (this) {
962 if (this.entry == currentEntry) {
963 this.visibleRect = currentVisibleRect;
964 }
965 }
966 repaint();
967 }
968
969 /**
970 * Get the image viewer for an entry
971 * @param entry The entry to get the viewer for. May be {@code null}.
972 * @return The new image viewer, may be {@code null}
973 */
974 private IImageViewer getIImageViewer(IImageEntry<?> entry) {
975 IImageViewer imageViewer;
976 IImageEntry<?> imageEntry;
977 synchronized (this) {
978 imageViewer = this.iImageViewer;
979 imageEntry = entry == null ? this.entry : entry;
980 }
981 if (imageEntry == null || (imageViewer != null && imageViewer.getSupportedProjections().contains(imageEntry.getProjectionType()))) {
982 return imageViewer;
983 }
984 try {
985 imageViewer = ImageProjectionRegistry.getViewer(imageEntry.getProjectionType()).getConstructor().newInstance();
986 } catch (ReflectiveOperationException e) {
987 throw new JosmRuntimeException(e);
988 }
989 synchronized (this) {
990 if (imageEntry.equals(this.entry)) {
991 this.removeComponentListener(this.iImageViewer);
992 this.iImageViewer = imageViewer;
993 imageViewer.componentResized(new ComponentEvent(this, ComponentEvent.COMPONENT_RESIZED));
994 this.addComponentListener(this.iImageViewer);
995 }
996 }
997 return imageViewer;
998 }
999
1000 /**
1001 * Get the rotation in the image viewer for an entry
1002 * @param entry The entry to get the rotation for. May be {@code null}.
1003 * @return the current rotation in the image viewer, or {@code null}
1004 * @since 18263
1005 */
1006 public Vector3D getRotation(IImageEntry<?> entry) {
1007 return entry != null ? getIImageViewer(entry).getRotation() : null;
1008 }
1009
1010 /**
1011 * Ensure that a rectangle isn't zoomed in too much
1012 * @param rectangle The rectangle to get (typically the visible area)
1013 */
1014 private void ensureMaxZoom(final Rectangle rectangle) {
1015 if (rectangle.width < getSize().width / MAX_ZOOM.get()) {
1016 rectangle.width = (int) (getSize().width / MAX_ZOOM.get());
1017 }
1018 if (rectangle.height < getSize().height / MAX_ZOOM.get()) {
1019 rectangle.height = (int) (getSize().height / MAX_ZOOM.get());
1020 }
1021
1022 // Set the same ratio for the visible rectangle and the display area
1023 int hFact = rectangle.height * getSize().width;
1024 int wFact = rectangle.width * getSize().height;
1025 if (hFact > wFact) {
1026 rectangle.width = hFact / getSize().height;
1027 } else {
1028 rectangle.height = wFact / getSize().width;
1029 }
1030 }
1031
1032 /**
1033 * Update the visible rectangle (ensure zoom does not exceed specified values).
1034 * Specifically only visible for {@link IImageViewer} implementations.
1035 * @since 18246
1036 */
1037 public void updateVisibleRectangle() {
1038 final VisRect currentVisibleRect;
1039 final Image mouseImage;
1040 final IImageViewer iImageViewer;
1041 synchronized (this) {
1042 currentVisibleRect = this.visibleRect;
1043 mouseImage = this.image;
1044 iImageViewer = this.getIImageViewer(this.entry);
1045 }
1046 if (mouseImage != null && currentVisibleRect != null && iImageViewer != null) {
1047 final Image maxImageSize = iImageViewer.getMaxImageSize(this, mouseImage);
1048 final VisRect maxVisibleRect = new VisRect(0, 0, maxImageSize.getWidth(null), maxImageSize.getHeight(null));
1049 maxVisibleRect.setRect(currentVisibleRect);
1050 ensureMaxZoom(maxVisibleRect);
1051
1052 maxVisibleRect.checkRectSize();
1053 synchronized (this) {
1054 this.visibleRect = maxVisibleRect;
1055 }
1056 }
1057 }
1058}
Note: See TracBrowser for help on using the repository browser.