import org.openstreetmap.josm.gui.MapView; //导入依赖的package包/类
@Override
public void paint(final Graphics2D g2D, final MapView mv, final Bounds bounds) {
    mv.setDoubleBuffered(true);
    if (tripView) {
        // draw selected road sign's trip
        paintHandler.drawTripData(g2D, mv, selRoadSigns.get(0));
    } else if (dataSet != null) {

        if (!dataSet.getRoadSigns().isEmpty()) {
            // draw road signs
            paintHandler.drawRoadSigns(g2D, mv, dataSet.getRoadSigns(), selRoadSigns);
        } else if (!dataSet.getRoadSignClusters().isEmpty()) {
            // draw road sign clusters
            paintHandler.drawRoadSignClusters(g2D, mv, dataSet.getRoadSignClusters());
        }
    }
}
 

import org.openstreetmap.josm.gui.MapView; //导入依赖的package包/类
static Pair<Pair<Point, Point>, Pair<Point, Point>> arrowGeometry(final MapView mapView, final List<LatLon> points,
        final boolean isFromSegment, final double length) {
    LatLon arrowPoint;
    double bearing;
    if (isFromSegment) {
        arrowPoint = points.size() > 2 ? points.get(points.size() / 2) : new LatLon(
                (points.get(1).lat() + points.get(0).lat()) / 2, (points.get(1).lon() + points.get(0).lon()) / 2);
        bearing = Math.toDegrees(points.get(points.size() - 1).bearing(arrowPoint));
    } else {
        arrowPoint = points.get(points.size() - 1);
        bearing = Math.toDegrees(points.get(points.size() - 1).bearing(points.get(points.size() - 2)));
    }


    final Pair<Coordinate, Coordinate> arrowEndCoordinates =
            GeometryUtil.arrowEndPoints(new Coordinate(arrowPoint.lat(), arrowPoint.lon()), bearing, length);
    final Pair<Point, Point> arrowLine1 = new Pair<>(mapView.getPoint(arrowPoint), mapView.getPoint(
            new LatLon(arrowEndCoordinates.getFirst().getLat(), arrowEndCoordinates.getFirst().getLon())));
    final Pair<Point, Point> arrowLine2 = new Pair<>(mapView.getPoint(arrowPoint), mapView.getPoint(
            new LatLon(arrowEndCoordinates.getSecond().getLat(), arrowEndCoordinates.getSecond().getLon())));
    return new Pair<>(arrowLine1, arrowLine2);
}
 

import org.openstreetmap.josm.gui.MapView; //导入依赖的package包/类
@Override
void drawItem(final Graphics2D graphics, final MapView mapView, final TurnRestriction turnRestriction,
        final boolean selected) {
    final Point point = mapView.getPoint(turnRestriction.getPoint());
    if (turnRestriction.getTurnRestrictions() != null) {
        // draw complex turn restriction

        final int radius = selected ? COMPLEX_TURN_SEL_RADIUS : COMPLEX_TURN_RADIUS;
        PaintManager.drawCircle(graphics, point, COMPLEX_TURN_COLOR, radius);
        PaintManager.drawText(graphics, Integer.toString(turnRestriction.getTurnRestrictions().size()), point,
                mapView.getFont().deriveFont(Font.BOLD, COMPLEX_TURN_FONT_SIZE), Color.white);
    } else {
        // draw simple turn restriction
        if (selected) {
            // draw turn segments
            drawTurnSegments(graphics, mapView, turnRestriction);
        }

        // draw turn restriction
        if (mapView.contains(point)) {
            final ImageIcon icon = selected ? IconConfig.getInstance().getSelectedTurnRestrictionIcon()
                    : IconConfig.getInstance().getTurnRestrictionIcon();
            PaintManager.drawIcon(graphics, icon, point);
        }
    }
}
 

import org.openstreetmap.josm.gui.MapView; //导入依赖的package包/类
@Override
void drawItem(final Graphics2D graphics, final MapView mapView, final Tile tile, final boolean selected) {
    final Color borderColor = tile.getStatus() == Status.OPEN ? TILE_OPEN_COLOR
            : (tile.getStatus() == Status.SOLVED ? TILE_SOLVED_COLOR : TILE_INVALID_COLOR);
    final Color tileColor = tileColor(tile);
    final Composite composite = selected ? TILE_SEL_COMPOSITE : TILE_COMPOSITE;
    final BoundingBox bbox = Util.tileToBoundingBox(tile.getX(), tile.getY());
    final Point northEast = mapView.getPoint(new LatLon(bbox.getNorth(), bbox.getEast()));
    final Point northWest = mapView.getPoint(new LatLon(bbox.getSouth(), bbox.getWest()));
    PaintManager.drawRectangle(graphics, northEast, northWest, NORMAL_COMPOSITE, composite, TILE_LINE_STROKE,
            borderColor, tileColor);

    final int radius = selected ? SEL_POINT_POS_RADIUS : POINT_POS_RADIUS;
    // draw points belonging to the tile
    if (tile.getPoints() != null && tile.getPoints().size() > 1) {
        for (final LatLon latLon : tile.getPoints()) {
            PaintManager.drawCircle(graphics, mapView.getPoint(latLon), POINT_COLOR, radius);
        }
    }
}
 

import org.openstreetmap.josm.gui.MapView; //导入依赖的package包/类
@Override
void drawItem(final Graphics2D graphics, final MapView mapView, final RoadSegment segment,
        final boolean isSelected) {
    Stroke stroke;
    Color color;
    // draw segment
    if (isSelected) {
        stroke = ROAD_SEGMENT_SEL_STROKE;
        color = ROAD_SEGMENT_SEL_COLOR;
    } else {
        stroke = ROAD_SEGMENT_STROKE;
        color = ROAD_SEGMENT_COLOR;
    }
    double arrowLength = isSelected ? SEL_ARROW_LENGTH : ARROW_LENGTH;
    arrowLength = PaintUtil.arrowLength(mapView, arrowLength);
    final Pair<Pair<Point, Point>, Pair<Point, Point>> arrowGeometry =
            PaintUtil.arrowGeometry(mapView, segment.getPoints(), false, arrowLength);
    final List<Point> geometry = PaintUtil.toPoints(mapView, segment.getPoints());
    PaintManager.drawDirectedSegment(graphics, geometry, arrowGeometry, color, stroke);
}
 

import org.openstreetmap.josm.gui.MapView; //导入依赖的package包/类
/**
 * Draws the given data set and selected items to the map.
 *
 * @param graphics a {@code Graphics2D} used to drawing to the map
 * @param mapView the current {@code MapView}
 * @param bounds the current map {@code Bounds}
 * @param dataSet the {@code DataSet} to draw to the map
 * @param items a list of selected items
 */
void drawDataSet(final Graphics2D graphics, final MapView mapView, final Bounds bounds, final DataSet<T> dataSet,
        final List<T> selectedItems) {
    final int zoom = Util.zoom(bounds);
    final Composite originalComposite = graphics.getComposite();
    final Stroke originalStroke = graphics.getStroke();
    if (zoom <= Config.getInstance().getMaxClusterZoom()) {
        if (dataSet.getClusters() != null && !dataSet.getClusters().isEmpty()) {
            drawClusters(graphics, mapView, dataSet.getClusters(), zoom, getClusterColor());
        }
    } else {
        if (dataSet.getItems() != null && !dataSet.getItems().isEmpty()) {
            drawItems(graphics, mapView, dataSet.getItems(), selectedItems);
        }
    }
    graphics.setComposite(originalComposite);
    graphics.setStroke(originalStroke);
}
 

import org.openstreetmap.josm.gui.MapView; //导入依赖的package包/类
@Override
public void mapFrameInitialized(MapFrame oldFrame, MapFrame newFrame) {
    if (newFrame != null) {
        dialog = new NotesDialog(this);
        newFrame.addToggleDialog(dialog);
        if (newFrame.mapView != null) {
            newFrame.mapView.addComponentListener(viewChangeAdapter);
        }

        MapView.addLayerChangeListener(this);

        uploadHook = new NotesUploadHook();
        UploadAction.registerUploadHook(uploadHook);
    } else {
        MapView.removeLayerChangeListener(this);
        UploadAction.unregisterUploadHook(uploadHook);
        if (oldFrame.mapView != null) {
            oldFrame.mapView.removeComponentListener(viewChangeAdapter);
        }
        uploadHook = null;
        dialog = null;
    }
}
 

import org.openstreetmap.josm.gui.MapView; //导入依赖的package包/类
private void grabNotes() {
    if (Main.map == null)
        return;
    MapView mv = Main.map.mapView;
    Bounds bbox = mv.getLatLonBounds(mv.getBounds());

    // Have the user changed view since last time
    boolean active = isActive();
    if (active && (lastBbox == null || !lastBbox.equals(bbox))) {
        if (task != null) {
            task.cancel();
        }

        // wait 500ms before downloading in case the user is in the middle
        // of a pan/zoom
        task = new DownloadNotesTask();
        timer.schedule(task, 500);
        lastBbox = bbox;
    }
}
 

import org.openstreetmap.josm.gui.MapView; //导入依赖的package包/类
/**
 * Computes the bounding box of the currently visible {@code MapView}.
 *
 * @param mapView the currently visible map view
 * @return a {@code BoundingBox} object
 */
public static BoundingBox buildBBox(final MapView mapView) {
    final Bounds bounds =
            new Bounds(mapView.getLatLon(0, mapView.getHeight()), mapView.getLatLon(mapView.getWidth(), 0));
    return new BoundingBox(bounds.getMax().lat(), bounds.getMin().lat(), bounds.getMax().lon(),
            bounds.getMin().lon());
}
 

import org.openstreetmap.josm.gui.MapView; //导入依赖的package包/类
/**
 * Draws the given road signs clusters to the map. A road sign cluster is represented by an icon and the road sign
 * count drawn in the middle of the icon.
 *
 * @param g2D the {@code Graphics2D} used to draw
 * @param mv the current {@code MapView}
 * @param clusterList the list of {@code RoadSignCluster}s to be drawn
 */
void drawRoadSignClusters(final Graphics2D g2D, final MapView mv, final List<RoadSignCluster> clusterList) {
    for (final RoadSignCluster cluster : clusterList) {
        final Point point = mv.getPoint(cluster.getPosition());
        final Pair<ImageIcon, Float> pair = ClusterIconConfig.getInstance().getIcon(cluster.getCount());
        g2D.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, pair.getSecond()));
        PaintManager.drawIcon(g2D, pair.getFirst(), point);
    }
    g2D.setComposite(COMP);
}
 

import org.openstreetmap.josm.gui.MapView; //导入依赖的package包/类
private void drawRoadSign(final Graphics2D g2D, final MapView mv, final RoadSign roadSign, final boolean selected) {
    final Point point = mv.getPoint(roadSign.getSignPos().getPosition());
    if (mv.contains(point)) {
        if (selected) {
            PaintManager.drawIcon(g2D, IconConfig.getInstance().getSelRoadSignBgIcon(), point);
        }
        PaintManager.drawIcon(g2D, iconFactory.getIcon(roadSign.getType()), point);
    }
}
 

import org.openstreetmap.josm.gui.MapView; //导入依赖的package包/类
private Pair<Pair<Point, Point>, Pair<Point, Point>> getArrowGeometry(final MapView mapView, final LatLon start,
        final LatLon end, final double length) {
    final LatLon midPoint = new LatLon((start.lat() + end.lat()) / 2, (start.lon() + end.lon()) / 2);
    final double bearing = Math.toDegrees(start.bearing(midPoint));
    final Pair<Coordinate, Coordinate> arrowEndCoordinates =
            GeometryUtil.arrowEndPoints(new Coordinate(midPoint.lat(), midPoint.lon()), bearing, -length);
    final Pair<Point, Point> arrowLine1 = new Pair<>(mapView.getPoint(midPoint), mapView.getPoint(
            new LatLon(arrowEndCoordinates.getFirst().getLat(), arrowEndCoordinates.getFirst().getLon())));
    final Pair<Point, Point> arrowLine2 = new Pair<>(mapView.getPoint(midPoint), mapView.getPoint(
            new LatLon(arrowEndCoordinates.getSecond().getLat(), arrowEndCoordinates.getSecond().getLon())));
    return new Pair<>(arrowLine1, arrowLine2);
}
 

import org.openstreetmap.josm.gui.MapView; //导入依赖的package包/类
/**
 * Transforms geographic coordinates into screen points.
 *
 * @param mapView a {@code MapView} used for coordinate transformation
 * @param geometry a list of {@code LatLon} representing the geographic coordinates
 * @return a list of {@code Point}s
 */
static List<Point> toPoints(final MapView mapView, final List<LatLon> geometry) {
    final List<Point> points = new ArrayList<>();
    for (final LatLon latLon : geometry) {
        points.add(mapView.getPoint(latLon));
    }
    return points;
}
 

import org.openstreetmap.josm.gui.MapView; //导入依赖的package包/类
private static void drawTurnSegments(final Graphics2D graphics, final MapView mapView,
        final TurnRestriction turnRestriction) {
    graphics.setFont(mapView.getFont().deriveFont(Font.BOLD));
    if (turnRestriction.getSegments() != null) {
        // draw segments
        for (int i = 0; i < turnRestriction.getSegments().size(); i++) {
            final Color color = i == 0 ? TURN_SEGMENT_FROM_COLOR : TURN_SEGMENT_TO_COLOR;
            final double arrowLength = PaintUtil.arrowLength(mapView, TURN_ARROW_LENGTH);
            final List<Point> geometry =
                    PaintUtil.toPoints(mapView, turnRestriction.getSegments().get(i).getPoints());
            final boolean isFromSegment = i == 0;
            final Pair<Pair<Point, Point>, Pair<Point, Point>> arrowGeometry = PaintUtil.arrowGeometry(mapView,
                    turnRestriction.getSegments().get(i).getPoints(), isFromSegment, arrowLength);
            PaintManager.drawDirectedSegment(graphics, geometry, arrowGeometry, color, TURN_SEGMENT_STROKE);
        }

        // draw labels
        final TurnSegment firstSegment = turnRestriction.getSegments().get(0);
        Point labelPoint = labelPoint(mapView, firstSegment.getPoints(), true);
        final Font font = mapView.getFont().deriveFont(Font.BOLD, TURN_SEGMENT_FONT_SIZE);
        PaintManager.drawText(graphics, Integer.toString(firstSegment.getNumberOfTrips()), labelPoint, font,
                LABEL_BACKGROUND_COLOR, Color.black, LABEL_COMPOSITE);

        final TurnSegment lastSegment = turnRestriction.getSegments().get(turnRestriction.getSegments().size() - 1);
        labelPoint = labelPoint(mapView, lastSegment.getPoints(), true);
        PaintManager.drawText(graphics, Integer.toString(turnRestriction.getNumberOfPasses()), labelPoint, font,
                LABEL_BACKGROUND_COLOR, Color.black, LABEL_COMPOSITE);
    }
}
 

import org.openstreetmap.josm.gui.MapView; //导入依赖的package包/类
@Override
public void paint(final Graphics2D graphics, final MapView mapView, final Bounds bounds) {
    mapView.setDoubleBuffered(true);
    graphics.setRenderingHints(RENDERING_MAP);
    if (dataSet != null) {
        paintHandler.drawDataSet(graphics, mapView, bounds, dataSet, selectedItems);
    }
}
 

import org.openstreetmap.josm.gui.MapView; //导入依赖的package包/类
private void drawClusters(final Graphics2D graphics, final MapView mapView, final List<Cluster> clusters,
        final int zoom, final Color color) {
    final SortedMap<Integer, Double> clusterRadiusMap = generateClusterRadiusMap(zoom, clusters);
    graphics.setComposite(CLUSTER_COMPOSITE);
    for (final Cluster cluster : clusters) {
        final Integer radius = clusterRadius(clusterRadiusMap, cluster.getSize()).intValue();
        PaintManager.drawCircle(graphics, mapView.getPoint(cluster.getPoint()), color,
                radius);
    }
    graphics.setComposite(NORMAL_COMPOSITE);
}
 

import org.openstreetmap.josm.gui.MapView; //导入依赖的package包/类
/**
 * Removes all temporary layers added to the current mapView
 */
public static void cleanup() {
    MapView mapView = MainApplication.getMap().mapView;
    mapView.removeTemporaryLayer(roadSegm);
    mapView.removeTemporaryLayer(buildingSegm);
    roadSegm = null;
    buildingSegm = null;
    MainApplication.getMap().repaint();
}
 

import org.openstreetmap.josm.gui.MapView; //导入依赖的package包/类
@Override
public void paint(Graphics2D g, MapView mv, Bounds bbox) {
    if (segment != null) {
        g.setColor(color);
        g.setStroke(stroke);

        Point p1 = mv.getPoint(segment.getFirstNode());
        Point p2 = mv.getPoint(segment.getSecondNode());
        Line2D overlappingLine = new Line2D.Double(p1.getX(), p1.getY(),
                                                   p2.getX(), p2.getY());
        g.draw(overlappingLine);
    }
}
 

import org.openstreetmap.josm.gui.MapView; //导入依赖的package包/类
/**
 * Determines the bounds of the current selected layer
 * @return
 */
protected Bounds bounds(){
    MapView mv = Main.map.mapView;
    return new Bounds(
        mv.getLatLon(0, mv.getHeight()),
        mv.getLatLon(mv.getWidth(), 0));
}
 

import org.openstreetmap.josm.gui.MapView; //导入依赖的package包/类
/**
 * Returns the nearest node to cursor. All nodes that are “behind” segments
 * are neglected. This is to avoid way self-intersection after moving the
 * candidateNode to a new place.
 *
 * @param mv the current map view
 * @param w the way to check
 * @param p the cursor position
 * @return nearest node to cursor
 */
public static Node findCandidateNode(MapView mv, Way w, Point p) {
    if (mv == null || w == null || p == null) {
        return null;
    }

    EastNorth pEN = mv.getEastNorth(p.x, p.y);

    Double bestDistance = Double.MAX_VALUE;
    Double currentDistance;
    List<Pair<Node, Node>> wpps = w.getNodePairs(false);

    Node result = null;

    mainLoop:
    for (Node n : w.getNodes()) {
        EastNorth nEN = n.getEastNorth();

        if (nEN == null) {
            // Might happen if lat/lon for that point are not known.
            continue;
        }

        currentDistance = pEN.distance(nEN);

        if (currentDistance < bestDistance) {
            // Making sure this candidate is not behind any segment.
            for (Pair<Node, Node> wpp : wpps) {
                if (!wpp.a.equals(n)
                        && !wpp.b.equals(n)
                        && Geometry.getSegmentSegmentIntersection(
                        wpp.a.getEastNorth(), wpp.b.getEastNorth(),
                        pEN, nEN) != null) {
                    continue mainLoop;
                }
            }
            result = n;
            bestDistance = currentDistance;
        }
    }

    return result;
}