import org.jdesktop.swingx.mapviewer.Waypoint; //导入依赖的package包/类
@Subscribe
public void setActiveWaypoint(MouseOverWaypoint mouseOverWaypoint) {
	if (this.track != null
			&& this.track.getId().equals(
					mouseOverWaypoint.getTrack().getId())) {
		GeoPosition geoPos = GeoUtil.toGeoPoint(mouseOverWaypoint
				.getSelectedWayPoint());
		Set<Waypoint> wps = this.waypointPainter.getWaypoints();
		Set<SelectedWaypoint> selected = Sets.newHashSet(filter(wps,
				SelectedWaypoint.class));
		// TODO use binary search!?
		SelectedWaypoint first = getFirst(selected, null);
		if (first == null) {
			wps.add(first = new SelectedWaypoint());
		}
		first.setPosition(geoPos);
		first.setSelectedWayPoint(this.track,
				mouseOverWaypoint.getSelectedWayPoint());

		this.mapKit.getMainMap().repaint();
	}
}
 

import org.jdesktop.swingx.mapviewer.Waypoint; //导入依赖的package包/类
private Set<Waypoint> getSegmentBorders(Track track) {
	List<Waypoint> waypoints = Lists.newArrayList();
	int cnt = 0;
	for (Segment segment : track.getSegments()) {
		if (cnt == 0) {
			waypoints.add(new TrackStartWaypoint(toGeoPoint(getFirst(
					segment.getTrackpoints(), null))));
		}
		LinkedTrackPoint last = getLast(segment.getTrackpoints());
		if (last != null && last.getLink() != null) {
			waypoints.add(new SegmentBorderWaypoint(toGeoPoint(last
					.getLink().getNext()), ++cnt, this.segmentationUnit));
		} else {
			waypoints.add(new TrackEndWaypoint(toGeoPoint(last)));
		}
	}
	return Sets.newLinkedHashSet(Orderings.classTypeOrdering(
			ImmutableList.<Class<? extends Waypoint>> of(
					SegmentBorderWaypoint.class, TrackStartWaypoint.class,
					TrackEndWaypoint.class, SelectedWaypoint.class))
			.sortedCopy(waypoints));
}
 

import org.jdesktop.swingx.mapviewer.Waypoint; //导入依赖的package包/类
private Map<Class<? extends Waypoint>, WaypointRenderer> proxyAll(
		final int xOffset, final int yOffset,
		Map<Class<? extends Waypoint>, WaypointRenderer> map) {
	Function<WaypointRenderer, WaypointRenderer> f = new Function<WaypointRenderer, WaypointRenderer>() {
		@Override
		public WaypointRenderer apply(WaypointRenderer renderer) {
			return new OffsetWaypointRendererDelegate(xOffset, yOffset,
					renderer);
		}
	};
	return ImmutableMap.copyOf(Maps.transformValues(map, f));
}
 

import org.jdesktop.swingx.mapviewer.Waypoint; //导入依赖的package包/类
private Map<Class<? extends Waypoint>, WaypointRenderer> createWaypointRenderers(
		Theme theme) {
	Font font = new Font(Font.SANS_SERIF, 0, 12);
	return ImmutableMap.<Class<? extends Waypoint>, WaypointRenderer> of(
			TrackStartWaypoint.class,
			new SegmentBorderWaypointRendererStart(theme, font),
			SegmentBorderWaypoint.class,
			new SegmentBorderWaypointRendererPoint(theme, font),
			TrackEndWaypoint.class, new SegmentBorderWaypointRendererEnd(
					theme, font), SelectedWaypoint.class,
			new SelectedWaypointRenderer(theme, font));
}
 

import org.jdesktop.swingx.mapviewer.Waypoint; //导入依赖的package包/类
@Override
public boolean paintWaypoint(Graphics2D g, JXMapViewer jxMapViewer,
		Waypoint waypoint) {
	Class<? extends Waypoint> wpClass = waypoint.getClass();
	return checkNotNull(this.delegates.get(wpClass),
			"No painter registered for %s", wpClass).paintWaypoint(g, //$NON-NLS-1$
			jxMapViewer, waypoint);
}
 

import org.jdesktop.swingx.mapviewer.Waypoint; //导入依赖的package包/类
@Override
public boolean paintWaypoint(Graphics2D g, JXMapViewer mapViewer,
		Waypoint wp) {

	SegmentBorderWaypoint waypoint = (SegmentBorderWaypoint) wp;

	drawCircleBackground(g, waypoint, 5);
	drawCircleBorder(g, waypoint, 3);

	g.setColor(this.theme.getBgColor());
	g.setStroke(new BasicStroke(this.stroke + 2));
	g.drawLine(0, 0, locX, locY);

	g.setColor(this.theme.getFgColor());
	g.setStroke(new BasicStroke(this.stroke));
	g.drawLine(0, 0, locX, locY);

	String text = getText(waypoint);

	FontRenderContext frc = g.getFontRenderContext();
	TextLayout layout = new TextLayout(text, this.font, frc);
	Rectangle2D bounds = layout.getBounds();

	g.setColor(this.theme.getFgColor());
	drawRect(g, bounds, add + 1);

	// g.setComposite(AlphaComposite
	// .getInstance(AlphaComposite.SRC_OVER, 0.5F));

	g.setColor(this.theme.getBgColor());
	drawRect(g, bounds, add);

	g.setColor(this.theme.getFgColor());
	layout.draw(g, locX, locY);

	return false;
}
 

import org.jdesktop.swingx.mapviewer.Waypoint; //导入依赖的package包/类
@Override
public boolean paintWaypoint(Graphics2D g, JXMapViewer jxMapViewer,
		Waypoint waypoint) {
	int r = this.font.getSize() - 2;
	@SuppressWarnings("unchecked")
	T casted = (T) waypoint;
	drawCircleBackground(g, casted, r);
	drawCircleBorder(g, casted, r - 2);

	return false;
}
 

import org.jdesktop.swingx.mapviewer.Waypoint; //导入依赖的package包/类
private Set<Waypoint> convert(Collection<? extends WayPoint> commonWaypoints) {
	Set<Waypoint> waypoints = Sets.newHashSet();
	for (WayPoint wp : commonWaypoints) {
		waypoints.add(convert(wp));
	}
	return waypoints;
}
 

import org.jdesktop.swingx.mapviewer.Waypoint; //导入依赖的package包/类
@Override
public boolean paintWaypoint(Graphics2D g, JXMapViewer mapViewer,
		Waypoint waypoint) {
	g.translate(this.xoffset, this.yoffset);
	boolean result = this.delegate.paintWaypoint(g, mapViewer, waypoint);
	g.translate(-this.xoffset, -this.yoffset);
	return result;
}
 

import org.jdesktop.swingx.mapviewer.Waypoint; //导入依赖的package包/类
public boolean paintWaypoint(Graphics2D g, JXMapViewer map, Waypoint waypoint) {
	if (waypoint instanceof DefaultWaypoint) {
		DefaultWaypoint tmp = (DefaultWaypoint)waypoint;
		BufferedImage img = null;
		int x = -9;

		switch (tmp.getType()) {
		case PRECISE:
			img = precise;
			x = -9;
			break;
		case APPROXIMATE:
			img = approximate;
			x = -9;
			break;
		case REVERSE:
			img = reverse;
			x = -11;
			break;
		}

		int y = -img.getHeight();		
		g.drawImage(img, x, y, null);
	}

	return false;
}
 

import org.jdesktop.swingx.mapviewer.Waypoint; //导入依赖的package包/类
protected void createGUI() {
    kit = new JXMapKit();
    GeoPosition origin = new GeoPosition(0,0);
    GeoPosition sanjose = new GeoPosition(37,20,0, -121,-53,0);
    GeoPosition statlib = new GeoPosition(40,41,20, -74,-2,-42.4);
    Set set  = new HashSet();
    set.add(new Waypoint(statlib));
    set.add(new Waypoint(sanjose));
    WaypointPainter wp = new WaypointPainter();
    wp.setWaypoints(set);
    kit.getMainMap().setOverlayPainter(wp);
    kit.getMainMap().setCenterPosition(new GeoPosition(38.5,-100));
    kit.setZoom(2);
    this.add(kit);
}
 

import org.jdesktop.swingx.mapviewer.Waypoint; //导入依赖的package包/类
/**
 * Draws the Waypoints on the map that are sized and colored according to
 * the provided hubness information. Larger circles correspond to larger
 * hubs in the data and the color corresponds to whether their influence is
 * beneficial or detrimental on the analysis. Red coloring corresponds to
 * high bad hubness.
 *
 * @param evt ActionEvent object.
 */
private void hDrawButtonActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_hDrawButtonActionPerformed
    // Initialize the waypoints.
    Set<Waypoint> waypoints = new HashSet<>(latitudeLongitudeData.size());
    for (int i = 0; i < latitudeLongitudeData.size(); i++) {
        waypoints.add(new SensorWayPoint(
                latitudeLongitudeData.data.get(i).fAttr[0],
                -latitudeLongitudeData.data.get(i).fAttr[1],
                hubnessArray[i],
                badHubnessArray[i]));
    }
    // Create a WaypointPainter to draw the points.
    WaypointPainter painter = new WaypointPainter();
    painter.setWaypoints(waypoints);
    painter.setRenderer(new WaypointRenderer() {
        @Override
        public boolean paintWaypoint(Graphics2D g, JXMapViewer map,
                Waypoint wp) {
            SensorWayPoint waypoint = (SensorWayPoint) wp;
            float darkRange = 0.25f;
            float redRange = 0.5f;
            float greenRange = 0.5f;
            // Calculate the badness coefficient that will be used to
            // determine the Waypoint color in the visualization.
            float badnessCoefficient;
            if (maxBadHubness != minBadHubness) {
                badnessCoefficient =
                        (waypoint.getBadHubness() - minBadHubness)
                        / (maxBadHubness - minBadHubness);
            } else {
                badnessCoefficient = 0;
            }
            float r = badnessCoefficient * darkRange
                    + badnessCoefficient * redRange;
            float gr = badnessCoefficient * darkRange
                    + (1 - badnessCoefficient) * greenRange;
            float b = badnessCoefficient * darkRange;
            Color currColor = new Color(r, gr, b);
            // Get the zoom level.
            int zLevel = jXMapKit1.getMainMap().getZoom();
            // Determine the radius according the the relative hubness
            // score.
            int radius = (int) ((((waypoint.getHubness() - minHubness)
                    / (maxHubness - minHubness)) * (radiusMax - radiusMin))
                    + radiusMin);
            if (zLevel < 14 && zLevel >= 12) {
                radius += 4;
            } else if (zLevel < 12 && zLevel >= 10) {
                radius += 8;
            } else if (zLevel < 10) {
                radius += 12;
            }
            g.setColor(currColor);
            g.fillOval(-radius, -radius, 2 * radius, 2 * radius);
            return true;
        }
    });
    jXMapKit1.getMainMap().setOverlayPainter(painter);
}
 

import org.jdesktop.swingx.mapviewer.Waypoint; //导入依赖的package包/类
public WaypointRendererDelegate(
		Map<Class<? extends Waypoint>, ? extends WaypointRenderer> delegates) {
	this.delegates = ImmutableMap.copyOf(delegates);
}
 

import org.jdesktop.swingx.mapviewer.Waypoint; //导入依赖的package包/类
@Override
public boolean paintWaypoint(Graphics2D g, JXMapViewer map, Waypoint wp) {
	boolean b = this.delegate.paintWaypoint(g, map, wp);
	g.drawString(((MarkedWaypoint) wp).getName(), 15, -15);
	return b;
}
 

import org.jdesktop.swingx.mapviewer.Waypoint; //导入依赖的package包/类
public MarkedWaypointPainter(DatasourceFascade dsf, Track track) {
	setWaypoints(ImmutableSet.<Waypoint> builder()
			.addAll(convert(track.getWaypoints()))
			.addAll(convert(dsf.getCommonWaypoints())).build());
	setRenderer(new MarkedWaypointRenderer());
}
 

import org.jdesktop.swingx.mapviewer.Waypoint; //导入依赖的package包/类
public DefaultWaypointPainter() {
	painter = new WaypointPainter<JXMapViewer>();
	painter.setRenderer(new SingleWaypointRenderer());
	waypoints = new ArrayList<Waypoint>();
}
 

import org.jdesktop.swingx.mapviewer.Waypoint; //导入依赖的package包/类
/**
 * @param args the program args (ignored)
 */
public static <T> void main(String[] args)
{
	JXMapViewer mapViewer = new JXMapViewer();

	// Create a TileFactoryInfo for OpenStreetMap
	TileFactoryInfo info = new OSMTileFactoryInfo();
	DefaultTileFactory tileFactory = new DefaultTileFactory(info);
	tileFactory.setThreadPoolSize(8);
	mapViewer.setTileFactory(tileFactory);

	GeoPosition frankfurt = new GeoPosition(50,  7, 0, 8, 41, 0);
	GeoPosition wiesbaden = new GeoPosition(50,  5, 0, 8, 14, 0);
	GeoPosition mainz     = new GeoPosition(50,  0, 0, 8, 16, 0);
	GeoPosition darmstadt = new GeoPosition(49, 52, 0, 8, 39, 0);
	GeoPosition offenbach = new GeoPosition(50,  6, 0, 8, 46, 0);

	// Set the focus
	mapViewer.setZoom(10);
	mapViewer.setAddressLocation(frankfurt);

	// Create a track from the geo-positions
	List<GeoPosition> track = Arrays.asList(frankfurt, wiesbaden, mainz, darmstadt, offenbach);
	RoutePainter routePainter = new RoutePainter(track);

	// Create waypoints from the geo-positions
	Set<Waypoint> waypoints = new HashSet<Waypoint>(Arrays.asList(
			new DefaultWaypoint(frankfurt),
			new DefaultWaypoint(wiesbaden),
			new DefaultWaypoint(mainz),
			new DefaultWaypoint(darmstadt),
			new DefaultWaypoint(offenbach)));

	// Create a waypoint painter that takes all the waypoints
	WaypointPainter<Waypoint> waypointPainter = new WaypointPainter<Waypoint>();
	waypointPainter.setWaypoints(waypoints);

	// Create a compound painter that uses both the route-painter and the waypoint-painter
	List<Painter<JXMapViewer>> painters = new ArrayList<Painter<JXMapViewer>>();
	painters.add(routePainter);
	painters.add(waypointPainter);

	CompoundPainter<JXMapViewer> painter = new CompoundPainter<JXMapViewer>(painters);
	mapViewer.setOverlayPainter(painter);

	// Display the viewer in a JFrame
	JFrame frame = new JFrame("JXMapviewer2 Example 2");
	frame.getContentPane().add(mapViewer);
	frame.setSize(800, 600);
	frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	frame.setVisible(true);
}