CustomWaypointPainter.java

/*
 * Copyright (c) 2016 Fraunhofer IGD
 * 
 * All rights reserved. This program and the accompanying materials are made
 * available under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation, either version 3 of the License,
 * or (at your option) any later version.
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with this distribution. If not, see <http://www.gnu.org/licenses/>.
 * 
 * Contributors:
 *     Fraunhofer IGD <http://www.igd.fraunhofer.de/>
 */
package de.fhg.igd.mapviewer.waypoints;

import java.awt.Dimension;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.Polygon;
import java.awt.Rectangle;
import java.awt.geom.Point2D;
import java.awt.image.BufferedImage;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.jdesktop.swingx.mapviewer.GeoPosition;
import org.jdesktop.swingx.mapviewer.GeotoolsConverter;
import org.jdesktop.swingx.mapviewer.IllegalGeoPositionException;
import org.jdesktop.swingx.mapviewer.PixelConverter;
import org.jdesktop.swingx.mapviewer.TileOverlayPainter;
import org.jdesktop.swingx.mapviewer.TileProviderUtils;

import de.fhg.igd.geom.BoundingBox;
import de.fhg.igd.geom.Verifier;
import de.fhg.igd.geom.indices.RTree;
import de.fhg.igd.mapviewer.AbstractTileOverlayPainter;
import de.fhg.igd.mapviewer.MapKitTileOverlayPainter;
import de.fhg.igd.mapviewer.Refresher;
import de.fhg.igd.mapviewer.marker.area.Area;

/**
 * CustomWaypointPainter
 * 
 * Based on the implementation of the WaypointPainter class
 *
 * @param <W> the way-point type
 * @author <a href="mailto:simon.templer@igd.fhg.de">Simon Templer</a>
 * @version $Id$
 */
public abstract class CustomWaypointPainter<W extends SelectableWaypoint<W>>
		extends MapKitTileOverlayPainter {

	private static final Log log = LogFactory.getLog(CustomWaypointPainter.class);

	private WaypointRenderer<W> renderer;

	private static final int PAGE_SIZE = 32;

	private final RTree<W> waypoints = new RTree<W>(PAGE_SIZE);

	private final Verifier<? super W, BoundingBox> matchTileVerifier = new Verifier<SelectableWaypoint<W>, BoundingBox>() {

		@Override
		public boolean verify(SelectableWaypoint<W> first, BoundingBox second) {
			return second.intersectsOrCovers(first.getBoundingBox());
		}
	};

	/**
	 * Way-points with a big area (bounding box) are painted first, selected
	 * way-points are painted last
	 */
	private final Comparator<? super W> paintFirstComparator = new Comparator<W>() {

		@Override
		public int compare(W o1, W o2) {
			// selected come last
			if (o1.isSelected() && !o2.isSelected()) {
				return 1;
			}
			else if (o2.isSelected() && !o1.isSelected()) {
				return -1;
			}
			else {
				double a1 = (o1.isPoint()) ? (0)
						: (o1.getBoundingBox().getWidth() * o1.getBoundingBox().getHeight());
				double a2 = (o2.isPoint()) ? (0)
						: (o2.getBoundingBox().getWidth() * o2.getBoundingBox().getHeight());

				int areaHint = 0;
				// compare size
				if (a1 > a2) {
					areaHint = -1;
				}
				else if (a2 > a1) {
					areaHint = 1;
				}

				return areaHint;
			}
		}

	};

	/**
	 * Creates a custom way-point painter that uses markers for painting
	 */
	public CustomWaypointPainter() {
		this(new MarkerWaypointRenderer<W>());
	}

	/**
	 * Creates a new instance of CustomWaypointPainter with one worker thread
	 * for painting tiles.
	 * 
	 * @param renderer the way-point renderer
	 */
	public CustomWaypointPainter(WaypointRenderer<W> renderer) {
		this(renderer, 1);
	}

	/**
	 * Creates a new instance of CustomWaypointPainter.
	 * 
	 * @param renderer the way-point renderer
	 * @param numberOfThreads the number of worker threads to use for painting
	 *            tiles
	 */
	public CustomWaypointPainter(WaypointRenderer<W> renderer, int numberOfThreads) {
		super(numberOfThreads);

		setRenderer(renderer);
	}

	/**
	 * Sets the way-point renderer to use when painting way-points
	 * 
	 * @param renderer the new CustomWaypointRenderer to use
	 */
	public void setRenderer(WaypointRenderer<W> renderer) {
		this.renderer = renderer;
	}

	/**
	 * Add a way-point
	 * 
	 * @param wp the way-point
	 * @param refresh the refresher
	 */
	public void addWaypoint(W wp, Refresher refresh) {
		BoundingBox bb = wp.getBoundingBox();

		if (bb != null) {
			synchronized (waypoints) {
				waypoints.insert(wp);
			}

			if (refresh != null) {
				wp.addToRefresher(refresh);
			}
		}
	}

	/**
	 * Remove a way-point
	 * 
	 * @param wp the way-point
	 * @param refresh the refresher
	 */
	public void removeWaypoint(W wp, Refresher refresh) {
		synchronized (waypoints) {
			waypoints.delete(wp);
		}

		if (refresh != null) {
			wp.addToRefresher(refresh);
		}
	}

	/**
	 * @see AbstractTileOverlayPainter#repaintTile(int, int, int, int,
	 *      PixelConverter, int)
	 */
	@Override
	public BufferedImage repaintTile(int posX, int posY, int width, int height,
			PixelConverter converter, int zoom) {
		if (renderer == null) {
			return null;
		}

		int overlap = getMaxOverlap();

		// overlap pixel coordinates
		Point topLeftPixel = new Point(Math.max(posX - overlap, 0), Math.max(posY - overlap, 0));
		Point bottomRightPixel = new Point(posX + width + overlap, posY + height + overlap); // TODO
																								// check
																								// against
																								// map
																								// size

		// overlap geo positions
		GeoPosition topLeft = converter.pixelToGeo(topLeftPixel, zoom);
		GeoPosition bottomRight = converter.pixelToGeo(bottomRightPixel, zoom);

		// overlap geo positions in RTree CRS
		try {
			BoundingBox tileBounds = createSearchBB(topLeft, bottomRight);

			synchronized (waypoints) {
				Set<W> candidates = waypoints.query(tileBounds, matchTileVerifier);

				if (candidates != null) {
					// sort way-points
					List<W> sorted = new ArrayList<W>(candidates);
					Collections.sort(sorted, paintFirstComparator);

					BufferedImage image = createImage(width, height);
					Graphics2D gfx = image.createGraphics();
					configureGraphics(gfx);

					try {
						// for each way-point within these bounds
						for (W w : sorted) {
							processWaypoint(w, posX, posY, width, height, converter, zoom, gfx);
						}

						/*
						 * DEBUG String test = getClass().getSimpleName() +
						 * " - x=" + posX + ", y=" + posY + ": " +
						 * candidates.size() + " WPs"; gfx.setColor(Color.BLUE);
						 * gfx.drawString(test, 4, height - 4);
						 * 
						 * gfx.drawString("minX: " + tileBounds.getMinX(), 4,
						 * height - 84); gfx.drawString("maxX: " +
						 * tileBounds.getMaxX(), 4, height - 64);
						 * gfx.drawString("minY: " + tileBounds.getMinY(), 4,
						 * height - 44); gfx.drawString("maxY: " +
						 * tileBounds.getMaxY(), 4, height - 24);
						 * 
						 * gfx.drawRect(0, 0, width - 1, height - 1);
						 */
					} finally {
						gfx.dispose();
					}

					return image;
				}
				else {
					return null;
				}
			}
		} catch (IllegalGeoPositionException e) {
			log.warn("Error painting waypoint tile: " + e.getMessage()); //$NON-NLS-1$
			return null;
		}
	}

	/**
	 * Create a search bounding box
	 * 
	 * @param topLeft the first geo-position
	 * @param bottomRight the second geo-position
	 * @return the bounding box
	 * 
	 * @throws IllegalGeoPositionException if a conversion fails
	 */
	private BoundingBox createSearchBB(GeoPosition topLeft, GeoPosition bottomRight)
			throws IllegalGeoPositionException {
		topLeft = GeotoolsConverter.getInstance().convert(topLeft, SelectableWaypoint.COMMON_EPSG);
		bottomRight = GeotoolsConverter.getInstance().convert(bottomRight,
				SelectableWaypoint.COMMON_EPSG);

		return new BoundingBox(Math.min(bottomRight.getX(), topLeft.getX()),
				Math.min(bottomRight.getY(), topLeft.getY()), -2.0,
				Math.max(bottomRight.getX(), topLeft.getX()),
				Math.max(bottomRight.getY(), topLeft.getY()), 2.0);
	}

	private void processWaypoint(W w, int minX, int minY, int width, int height,
			PixelConverter converter, int zoom, Graphics2D g) {
		try {
			Point2D point = converter.geoToPixel(w.getPosition(), zoom);
			int x = (int) (point.getX() - minX);
			int y = (int) (point.getY() - minY);
			PixelConverter converterWrapper = new TranslationPixelConverterDecorator(converter,
					(int) point.getX(), (int) point.getY());
			g.translate(x, y);
			Rectangle gBounds = new Rectangle(minX - (int) point.getX(), minY - (int) point.getY(),
					width, height);
			renderer.paintWaypoint(g, converterWrapper, zoom, w, gBounds);
			g.translate(-x, -y);
		} catch (IllegalGeoPositionException e) {
			// waypoint not in map bounds or position invalid
			// log.warn("Error painting waypoint", e);
		}
	}

	/**
	 * Find a way-point at a given position
	 * 
	 * @param point the position
	 * @return the way-point
	 */
	public W findWaypoint(Point point) {
		Rectangle viewPort = getMapKit().getMainMap().getViewportBounds();

		final int overlap = getMaxOverlap(); // the overlap is the reason why
												// the point is used instead of
												// a GeoPosition

		final int x = viewPort.x + point.x;
		final int y = viewPort.y + point.y;
		final int zoom = getMapKit().getMainMap().getZoom();
		final PixelConverter converter = getMapKit().getMainMap().getTileFactory().getTileProvider()
				.getConverter();

		final Dimension mapSize = TileProviderUtils
				.getMapSize(getMapKit().getMainMap().getTileFactory().getTileProvider(), zoom);
		final int width = mapSize.width
				* getMapKit().getMainMap().getTileFactory().getTileProvider().getTileWidth(zoom);
		final int height = mapSize.height
				* getMapKit().getMainMap().getTileFactory().getTileProvider().getTileHeight(zoom);

		final GeoPosition topLeft = converter
				.pixelToGeo(new Point(Math.max(x - overlap, 0), Math.max(y - overlap, 0)), zoom);
		final GeoPosition bottomRight = converter.pixelToGeo(
				new Point(Math.min(x + overlap, width), Math.min(y + overlap, height)), zoom);

		BoundingBox searchBox;
		try {
			searchBox = createSearchBB(topLeft, bottomRight);

			Set<W> wps = waypoints.query(searchBox, new Verifier<W, BoundingBox>() {

				@Override
				public boolean verify(W wp, BoundingBox box) {
					try {
						Point2D wpPixel = converter.geoToPixel(wp.getPosition(), zoom);

						int relX = x - (int) wpPixel.getX();
						int relY = y - (int) wpPixel.getY();

						Area area = wp.getMarker().getArea(zoom);
						if (area != null && area.contains(relX, relY)) {
							// match
							return true;
						}
					} catch (IllegalGeoPositionException e) {
						log.debug("Error converting waypoint position", e); //$NON-NLS-1$
					}

					return false;
				}
			});

			if (wps == null || wps.isEmpty()) {
				return null;
			}
			else {
				if (wps.size() == 1) {
					return wps.iterator().next();
				}
				else {
					List<W> sorted = new ArrayList<W>(wps);
					Collections.sort(sorted, new Comparator<W>() {

						@Override
						public int compare(W o1, W o2) {
							double a1 = o1.getMarker().getArea(zoom).getArea();
							double a2 = o2.getMarker().getArea(zoom).getArea();

							// compare size
							if (a1 < a2) {
								return -1;
							}
							else if (a2 < a1) {
								return 1;
							}
							else {
								return 0;
							}
						}

					});
					return sorted.get(0);
				}
			}
		} catch (IllegalGeoPositionException e) {
			return null;
		}
	}

	/**
	 * Find the way-points in a given rectangular area
	 * 
	 * @param rect the area
	 * @return the way-points in the area
	 */
	public Set<W> findWaypoints(Rectangle rect) {
		Rectangle viewPort = getMapKit().getMainMap().getViewportBounds();

		final Rectangle worldRect = new Rectangle(viewPort.x + rect.x, viewPort.y + rect.y,
				rect.width, rect.height);

		final int zoom = getMapKit().getMainMap().getZoom();
		final PixelConverter converter = getMapKit().getMainMap().getTileFactory().getTileProvider()
				.getConverter();

		final GeoPosition topLeft = converter.pixelToGeo(new Point(worldRect.x, worldRect.y), zoom);
		final GeoPosition bottomRight = converter.pixelToGeo(
				(new Point(worldRect.x + worldRect.width, worldRect.y + worldRect.height)), zoom);

		return findWaypoints(topLeft, bottomRight, worldRect, converter, zoom);
	}

	/**
	 * Find way-points in a rectangular area defined by the given
	 * {@link GeoPosition}s
	 * 
	 * @param topLeft the top left position
	 * @param bottomRight the bottom right position
	 * @param worldRect the bounding box in world pixel coordinates
	 * @param converter the pixel converter
	 * @param zoom the zoom level
	 * 
	 * @return the way-points in the area
	 */
	public Set<W> findWaypoints(GeoPosition topLeft, GeoPosition bottomRight,
			final Rectangle worldRect, final PixelConverter converter, final int zoom) {
		BoundingBox searchBox;
		try {
			searchBox = createSearchBB(topLeft, bottomRight);
			final BoundingBox verifyBox = searchBox;

			Set<W> wps = waypoints.query(searchBox, new Verifier<W, BoundingBox>() {

				@Override
				public boolean verify(W wp, BoundingBox second) {
					try {
						Point2D wpPixel = converter.geoToPixel(wp.getPosition(), zoom);
						int dx = (int) wpPixel.getX();
						int dy = (int) wpPixel.getY();

						worldRect.translate(-dx, -dy);
						try {
							Area area = wp.getMarker().getArea(zoom);
							if (area != null) {
								return area.containedIn(worldRect);
							}
							else {
								// something that has not been painted yet may
								// not be selected
								return false;
							}
						} finally {
							worldRect.translate(dx, dy);
						}
					} catch (IllegalGeoPositionException e) {
						log.warn("Could not convert waypoint position to pixel", e);
						// fall back to simple method
						return verifyBox.covers(wp.getBoundingBox());
					}
				}

			});

			if (wps == null) {
				return new HashSet<W>();
			}
			else {
				return wps;
			}
		} catch (IllegalGeoPositionException e) {
			return new HashSet<W>();
		}
	}

	/**
	 * Find the way-points in a given polygon
	 * 
	 * @param poly the polygon
	 * @return the way-points in the polygon area
	 */
	public Set<W> findWaypoints(final Polygon poly) {
		Rectangle viewPort = getMapKit().getMainMap().getViewportBounds();

		final int zoom = getMapKit().getMainMap().getZoom();
		final PixelConverter converter = getMapKit().getMainMap().getTileFactory().getTileProvider()
				.getConverter();

		de.fhg.igd.geom.Point2D[] points = new de.fhg.igd.geom.Point2D[poly.npoints];

		// create a metamodel polygon
		for (int i = 0; i < poly.npoints; i++) {
			int worldX = viewPort.x + poly.xpoints[i];
			int worldY = viewPort.y + poly.ypoints[i];

			// convert to geo position
			GeoPosition pos = converter.pixelToGeo(new Point(worldX, worldY), zoom);

			// convert to common CRS
			try {
				pos = GeotoolsConverter.getInstance().convert(pos, SelectableWaypoint.COMMON_EPSG);
			} catch (IllegalGeoPositionException e) {
				log.warn("Error converting polygon point for query"); //$NON-NLS-1$
				return new HashSet<W>();
			}

			points[i] = new de.fhg.igd.geom.Point2D(pos.getX(), pos.getY());
		}

		final de.fhg.igd.geom.shape.Polygon verifyPolygon = new de.fhg.igd.geom.shape.Polygon(
				points);

		// we need a 3D search bounding box for the R-Tree
		BoundingBox searchBox = verifyPolygon.getBoundingBox();
		searchBox.setMinZ(-2.0);
		searchBox.setMaxZ(2.0);

		poly.translate(viewPort.x, viewPort.y);
		try {
			Set<W> wps = waypoints.query(searchBox, new Verifier<W, BoundingBox>() {

				@Override
				public boolean verify(W wp, BoundingBox second) {
					try {
						Point2D wpPixel = converter.geoToPixel(wp.getPosition(), zoom);
						int dx = (int) wpPixel.getX();
						int dy = (int) wpPixel.getY();

						poly.translate(-dx, -dy);
						try {
							Area area = wp.getMarker().getArea(zoom);
							if (area != null) {
								return area.containedIn(poly);
							}
							else {
								// something that has not been painted yet may
								// not be selected
								return false;
							}
						} finally {
							poly.translate(dx, dy);
						}
					} catch (IllegalGeoPositionException e) {
						log.warn("Could not convert waypoint position to pixel", e);
						// fall back to simple method
						return verifyPolygon.contains(wp.getBoundingBox().toExtent());
					}
				}

			});

			if (wps == null) {
				return new HashSet<W>();
			}
			else {
				return wps;
			}
		} finally {
			poly.translate(-viewPort.x, -viewPort.y);
		}
	}

	/**
	 * Clear the way-points
	 */
	public void clearWaypoints() {
		synchronized (waypoints) {
			waypoints.flush();
		}

		refreshAll();
	}

	/**
	 * @see TileOverlayPainter#dispose()
	 */
	@Override
	public void dispose() {
		clearWaypoints();

		super.dispose();
	}

	/**
	 * Get the way-points bounding box.
	 * 
	 * @return the bounding box
	 */
	public BoundingBox getBoundingBox() {
		return waypoints.getRoot().getBoundingBox();
	}

}