import org.openstreetmap.josm.data.Bounds; //导入依赖的package包/类
@Override
protected void finish() {
    if (isFailed() || isCanceled())
        return;
    if (dataSet == null)
        return; // user canceled download or error occurred
    if (dataSet.allPrimitives().isEmpty()) {
        rememberErrorMessage(tr("No data found in this area."));
        // need to synthesize a download bounds lest the visual indication of downloaded
        // area doesn't work
        dataSet.dataSources.add(new DataSource(new Bounds(new LatLon(0, 0)), "i-locate server"));
    }
    saveUploadInfo();
    downloadedData = dataSet;
    Main.debug("[DownloadIlocateTask.DownloadTask.finish] Load data, type: "+type.toString());
    loadData(newLayerName, null);
}
 

import org.openstreetmap.josm.data.Bounds; //导入依赖的package包/类
public BoundedDataSet build(final GeoJsonObject data) {
    dataSet = new DataSet();

    if (data instanceof FeatureCollection) {
        processFeatureCollection((FeatureCollection) data);
    } else if (data instanceof GeometryCollection) {
        processGeometryCollection(null, (GeometryCollection) data);
    } else if (data instanceof Feature) {
        processFeature((Feature) data);
    } else {
        processGeometry(null, data);
    }

    Bounds bounds = null;
    for (OsmPrimitive osmPrimitive : dataSet.allPrimitives()) {
        bounds = mergeBounds(bounds, osmPrimitive);
    }
    return new BoundedDataSet(dataSet, bounds);
}
 

import org.openstreetmap.josm.data.Bounds; //导入依赖的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.data.Bounds; //导入依赖的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.data.Bounds; //导入依赖的package包/类
public void execute(List<Note> dataset, Bounds bounds) throws IOException {

        int zoom = OsmUrlToBounds.getZoom(Main.map.mapView.getRealBounds());
        double requestArea = Main.map.mapView.getRealBounds().getArea();

        //API limits requests to 25 square degrees.
        //If zoomed in beyond 16 it is pointless to redownload such a small area.
        if(requestArea > 25 || zoom > 15) {
        	return;
        }

        try {
            List<Note> notes = NotesCapableOsmApi.getNotesApi().getNotesInBoundingBox(bounds);
            dataset.clear();
            dataset.addAll(notes);
        }
        catch(OsmTransferException e) {
        	e.printStackTrace();
        	return;
        }
    }
 

import org.openstreetmap.josm.data.Bounds; //导入依赖的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.data.Bounds; //导入依赖的package包/类
private Bounds mergeBounds(final Bounds bounds, final LatLon coords) {
    if (bounds == null) {
        return new Bounds(coords);
    } else {
        bounds.extend(coords);
        return bounds;
    }
}
 

import org.openstreetmap.josm.data.Bounds; //导入依赖的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.data.Bounds; //导入依赖的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.data.Bounds; //导入依赖的package包/类
@Override
public void run() {
    if (Main.map != null && Main.map.mapView != null) {
        final Bounds bounds = new Bounds(Main.map.mapView.getLatLon(0, Main.map.mapView.getHeight()),
                Main.map.mapView.getLatLon(Main.map.mapView.getWidth(), 0));

        final BoundingBox bbox = new BoundingBox(bounds.getMax().lat(), bounds.getMin().lat(),
                bounds.getMax().lon(), bounds.getMin().lon());
        final int zoom = Util.zoom(Main.map.mapView.getRealBounds());
        final DataSet<T> result = searchData(bbox, zoom);

        // update UI
        updateUI(result);
    }
}
 

import org.openstreetmap.josm.data.Bounds; //导入依赖的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.data.Bounds; //导入依赖的package包/类
public List<Note> getNotesInBoundingBox(Bounds bounds) throws OsmTransferException {
	ProgressMonitor monitor = NullProgressMonitor.INSTANCE;
	
	String url = new StringBuilder()
		.append("notes?bbox=")
		.append(bounds.getMin().lon())
		.append(",").append(bounds.getMin().lat())
           .append(",").append(bounds.getMax().lon())
           .append(",").append(bounds.getMax().lat())
           .toString();
	String response = sendRequest("GET", url, null, monitor, false, false);
	return parseNotes(response);
}
 

import org.openstreetmap.josm.data.Bounds; //导入依赖的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.data.Bounds; //导入依赖的package包/类
public static void setAppletZoom() {

		KatApplet applet = KaporMenuActionListener.applet;
		if (Main.map != null && applet != null) {
			EastNorth center = Main.map.mapView.getCenter();
			LatLon centerLatLon = Main.map.mapView.getProjection()
					.eastNorth2latlon(center);

			Bounds b = Main.map.mapView.getRealBounds();
			LatLon p1 = b.getMin(), p2 = b.getMax();

			double x = centerLatLon.getX();
			double y = centerLatLon.getY();

			if (16 < x && x < 24 && 47 < y && y < 50) {
				Coordinate newcenter = new Coordinate();
				Coordinate newp1 = new Coordinate(), newp2 = new Coordinate();

				try {
					// Ignore difference between S-JTSK and S-JTSK/03
					JTS.transform(new Coordinate(x, y), newcenter, 
							Projection.etrs89_to_s_jtsk_03);

					JTS.transform(new Coordinate(p1.getX(), p1.getY()), newp1,
							Projection.etrs89_to_s_jtsk_03);
					JTS.transform(new Coordinate(p2.getX(), p2.getY()), newp2,
							Projection.etrs89_to_s_jtsk_03);
				} catch (TransformException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}

				double width = Math.abs(newp1.x - newp2.x);
				if (width < 1)
					width = 1;

				applet.zoomWidth(-newcenter.x, -newcenter.y, width, "M");
			}
		}
	}
 

import org.openstreetmap.josm.data.Bounds; //导入依赖的package包/类
@Override
public Future<?> download(boolean newLayer, Bounds downloadArea, ProgressMonitor progressMonitor) {
    return null;
}
 

import org.openstreetmap.josm.data.Bounds; //导入依赖的package包/类
public Bounds getBounds() {
    return this.bounds;
}
 

import org.openstreetmap.josm.data.Bounds; //导入依赖的package包/类
public BoundedDataSet(final DataSet dataSet, final Bounds bounds) {
    this.dataSet = dataSet;
    this.bounds = bounds;
}
 

import org.openstreetmap.josm.data.Bounds; //导入依赖的package包/类
@Override
public void paint(Graphics2D g, MapView mv, Bounds box) {
	Rendering painter = MapRendererFactory.getInstance().createActiveRenderer(g, mv, false);
	painter.render(data, false, box);
}
 

import org.openstreetmap.josm.data.Bounds; //导入依赖的package包/类
/**
 * Returns the zoom level based on the given bounds.
 *
 * @param bounds the map bounds
 * @return an integer
 */
public static int zoom(final Bounds bounds) {
    return Main.map.mapView.getScale() >= ZOOM1_SCALE ? 1 : (int) Math.min(MAX_ZOOM,
            Math.max(MIN_ZOOM, Math.round(Math.floor(Math.log(TILE_SIZE / bounds.asRect().height) / Math.log(2)))));
}