Java MercatorProjection类代码示例

import org.oscim.core.MercatorProjection; //导入依赖的package包/类
void populate(int size) {

        InternalItem[] tmp = new InternalItem[size];

        for (int i = 0; i < size; i++) {
            InternalItem it = new InternalItem();
            tmp[i] = it;
            it.item = mMarkerLayer.createItem(i);

			/* pre-project polygonPoints */
            MercatorProjection.project(it.item.getPoint(), mMapPoint);
            it.px = mMapPoint.x;
            it.py = mMapPoint.y;
        }
        synchronized (this) {
            mUpdate = true;
            mItems = tmp;
        }
    }
 

import org.oscim.core.MercatorProjection; //导入依赖的package包/类
protected void populate(int size) {

		InternalItem[] tmp = new InternalItem[size];

		for (int i = 0; i < size; i++) {
			InternalItem it = new InternalItem();
			tmp[i] = it;
			it.item = mMarkerLayer.createItem(i);

			/* pre-project points */
			MercatorProjection.project(it.item.getPoint(), mMapPoint);
			it.px = mMapPoint.x;
			it.py = mMapPoint.y;
		}
		synchronized (this) {
			mUpdate = true;
			mItems = tmp;
		}
	}
 

import org.oscim.core.MercatorProjection; //导入依赖的package包/类
public synchronized void animateTo(GeoPoint geoPoint) {
	double f = Tile.SIZE << ABS_ZOOMLEVEL;

	mStartX = mAbsX * f;
	mStartY = mAbsY * f;

	mEndX = MercatorProjection.longitudeToX(geoPoint.getLongitude()) * f;
	mEndY = MercatorProjection.latitudeToY(geoPoint.getLatitude()) * f;

	mEndX -= mStartX;
	mEndY -= mStartY;

	mAnimMove = true;
	mAnimScale = false;
	mAnimFling = false;
	animStart(300);
}
 

import org.oscim.core.MercatorProjection; //导入依赖的package包/类
@Test
void constructor() {

    double latTopLeft = 52.581;
    double lonTopLeft = 13.396;
    double latBotomRight = 52.579;
    double lonBotomright = 13.400;
    double latCenter = 52.580;
    double lonCenter = 13.398;

    GeoPoint leftTop = new GeoPoint(latTopLeft, lonTopLeft);
    GeoPoint rightBotom = new GeoPoint(latBotomRight, lonBotomright);
    GeoPoint geoPoint = new GeoPoint(latCenter, lonCenter);


    GeoBoundingBoxInt gbb = new GeoBoundingBoxInt(leftTop, rightBotom);
    assertThat("Point must inside Box", gbb.contains(geoPoint));


    Box box = new Box(MercatorProjection.longitudeToX(lonTopLeft)
            , MercatorProjection.latitudeToY(latTopLeft)
            , MercatorProjection.longitudeToX(lonBotomright)
            , MercatorProjection.latitudeToY(latBotomRight));

    box.map2mercator();
    assertThat("Point must inside Box", box.contains(lonCenter, latCenter));

    GeoBoundingBoxInt geoBoundingBox = new GeoBoundingBoxInt(box);
    assertThat("Point must inside Box", geoBoundingBox.contains(geoPoint));

}
 

import org.oscim.core.MercatorProjection; //导入依赖的package包/类
static TileSource.OpenResult initialize(SQLiteTileSource tileSource, SQLiteDatabase database) {
    try {
        int minZoom = (int) database.compileStatement(SQL_GET_MIN_ZOOM).simpleQueryForLong();
        int maxZoom = (int) database.compileStatement(SQL_GET_MAX_ZOOM).simpleQueryForLong();
        tileSource.setMinZoom(minZoom);
        tileSource.setMaxZoom(maxZoom);

        String[] args = {String.valueOf(17 - maxZoom)};
        int minX = getInt(database, SQL_GET_MIN_X, args);
        int minY = getInt(database, SQL_GET_MIN_Y, args);
        int maxX = getInt(database, SQL_GET_MAX_X, args) + 1;
        int maxY = getInt(database, SQL_GET_MAX_Y, args) + 1;

        double scale = 1 << maxZoom;
        tileSource.mBoundingBox = new BoundingBox(
                MercatorProjection.toLatitude(maxY / scale),
                MercatorProjection.toLongitude(minX / scale),
                MercatorProjection.toLatitude(minY / scale),
                MercatorProjection.toLongitude(maxX / scale)
        );

        //TODO Try to fill zoom table and see what happens
    } catch (SQLException e) {
        return new TileSource.OpenResult(e.getMessage());
    }
    return TileSource.OpenResult.SUCCESS;
}
 

import org.oscim.core.MercatorProjection; //导入依赖的package包/类
/**
 * Checks if map contains given point
 */
public boolean contains(double x, double y) {
    if (polygonPoints == null) {
        GeoPoint geoPoint = new GeoPoint(MercatorProjection.toLatitude(y), MercatorProjection.toLongitude(x));
        return boundingBox.contains(geoPoint);
    }
    // http://www.ecse.rpi.edu/Homepages/wrf/Research/Short_Notes/pnpoly.html
    //  Note that division by zero is avoided because the division is protected
    //  by the "if" clause which surrounds it.
    int j = polygonPoints.length - 2;
    boolean inside = false;

    for (int i = 0; i < polygonPoints.length; i += 2) {
        double ix = polygonPoints[i];
        double iy = polygonPoints[i + 1];
        double jx = polygonPoints[j];
        double jy = polygonPoints[j + 1];
        if (iy < y && jy >= y || jy < y && iy >= y) {
            if (ix + (y - iy) * 1. / (jy - iy) * (jx - ix) < x) {
                inside = !inside;
            }
        }
        j = i;
    }

    return inside;
}
 

import org.oscim.core.MercatorProjection; //导入依赖的package包/类
public static LatLngBounds toLatLngBounds(Box box) {
    double minLon = MercatorProjection.toLongitude(box.xmin);
    double maxLon = MercatorProjection.toLongitude(box.xmax);
    double minLat = MercatorProjection.toLatitude(box.ymax);
    double maxLat = MercatorProjection.toLatitude(box.ymin);
    if (Double.isNaN(minLon) || Double.isNaN(maxLon) || Double.isNaN(minLat) || Double.isNaN(maxLat))
        minLon = maxLon = minLat = maxLat = 0;
    return new LatLngBounds(new LatLng(minLat, minLon), new LatLng(maxLat, maxLon));
}
 

import org.oscim.core.MercatorProjection; //导入依赖的package包/类
/**
 * Get the minimal axis-aligned BoundingBox that encloses
 * the visible part of the map.
 * 
 * @return BoundingBox containing view
 */
public synchronized BoundingBox getBBox(int expand) {
	getBBox(mMapBBox, expand);

	/* scale map-pixel coordinates at current scale to
	 * absolute coordinates and apply mercator projection. */
	double minLon = MercatorProjection.toLongitude(mMapBBox.xmin);
	double maxLon = MercatorProjection.toLongitude(mMapBBox.xmax);
	double minLat = MercatorProjection.toLatitude(mMapBBox.ymax);
	double maxLat = MercatorProjection.toLatitude(mMapBBox.ymin);

	return new BoundingBox(minLat, minLon, maxLat, maxLon);
}
 

import org.oscim.core.MercatorProjection; //导入依赖的package包/类
private void initTile(MapTile tile) {
	double lat = MercatorProjection.toLatitude(tile.y);
	mGroundScale = (float) MercatorProjection
	    .groundResolution(lat, 1 << mTile.zoomLevel);

	mRoofs = new ExtrusionBucket(0, mGroundScale, Color.get(247, 249, 250));

	mParts = new ExtrusionBucket(0, mGroundScale, Color.get(255, 254, 252));
	//mRoofs = new ExtrusionLayer(0, mGroundScale, Color.get(207, 209, 210));
	mRoofs.next = mParts;

	BuildingLayer.get(tile).setBuckets(mRoofs);

	process(mTilePlane);
}
 

import org.oscim.core.MercatorProjection; //导入依赖的package包/类
void loooop(final int i) {
	final long time = (long) (500 + Math.random() * 1000);
	mMapView.postDelayed(new Runnable() {
		@Override
		public void run() {

			MapPosition p = new MapPosition();
			if (i == 1) {
				mMapView.map().getMapPosition(p);
				p.setScale(4);
				mMapView.map().animator().animateTo(time, p);
			} else {
				//mMapView.map().setMapPosition(p);
				p.setScale(2 + (1 << (int) (Math.random() * 13)));
				//	p.setX((p.getX() + (Math.random() * 4 - 2) / p.getScale()));
				//	p.setY((p.getY() + (Math.random() * 4 - 2) / p.getScale()));
				p.setX(MercatorProjection.longitudeToX(Math.random() * 180));
				p.setY(MercatorProjection.latitudeToY(Math.random() * 60));

				p.setTilt((float) (Math.random() * 60));
				p.setBearing((float) (Math.random() * 360));
				//mMapView.map().setMapPosition(p);

				mMapView.map().animator().animateTo(time, p);
			}
			loooop((i + 1) % 2);

		}
	}, time);
}
 

import org.oscim.core.MercatorProjection; //导入依赖的package包/类
void loooop(final int i) {
	final long time = (long) (500 + Math.random() * 1000);
	mMapView.postDelayed(new Runnable() {
		@Override
		public void run() {

			mMapView.map().setTheme(themes[i]);

			MapPosition p = new MapPosition();
			if (i == 1) {
				mMapView.map().getMapPosition(p);
				p.setScale(4);
				mMapView.map().animator().animateTo(time, p);
			} else {
				//mMapView.map().setMapPosition(p);

				p.setScale(2 + (1 << (int) (Math.random() * 13)));
				//	p.setX((p.getX() + (Math.random() * 4 - 2) / p.getScale()));
				//	p.setY((p.getY() + (Math.random() * 4 - 2) / p.getScale()));
				p.setX(MercatorProjection.longitudeToX(Math.random() * 180));
				p.setY(MercatorProjection.latitudeToY(Math.random() * 60));

				p.setTilt((float) (Math.random() * 60));
				p.setBearing((float) (Math.random() * 360));
				//mMapView.map().setMapPosition(p);

				mMapView.map().animator().animateTo(time, p);
			}
			loooop((i + 1) % 2);

		}
	}, time);
}
 

import org.oscim.core.MercatorProjection; //导入依赖的package包/类
protected int transformPath(MapPosition pos, GeometryBuffer g, CoordinatePath path) {

		double scale = pos.scale * Tile.SIZE / UNSCALE_COORD;
		int cnt = 0;
		O: while (path.hasNext()) {
			Coordinate c = path.next();
			float x = (float) ((MercatorProjection.longitudeToX(c.x) - pos.x) * scale);
			float y = (float) ((MercatorProjection.latitudeToY(c.y) - pos.y) * scale);

			switch (path.getStep()) {
				case MOVE_TO:
					if (g.isPoly())
						g.startPolygon();
					else if (g.isLine())
						g.startLine();

					cnt++;
					g.addPoint(x, y);
					break;
				case LINE_TO:
					cnt++;
					g.addPoint(x, y);
					break;
				case CLOSE:
					//g.addPoint(x, y);
					//if (g.type == GeometryType.POLY)
					break;
				case STOP:
					break O;
			}
		}
		return cnt;
	}
 

import org.oscim.core.MercatorProjection; //导入依赖的package包/类
@Override
public void run() {
	mMap.viewport().getMapPosition(pos);
	int lat = (int) (MercatorProjection.toLatitude(pos.y) * 1000);
	int lon = (int) (MercatorProjection.toLongitude(pos.x) * 1000);
	int rot = (int) (pos.bearing);
	rot = (int) (pos.bearing) % 360;
	//rot = rot < 0 ? -rot : rot;

	if (curZoom != pos.zoomLevel || curLat != lat || curLon != lon
	        || curTilt != rot || curRot != (int) (pos.bearing)) {

		curLat = lat;
		curLon = lon;
		curZoom = pos.zoomLevel;
		curTilt = (int) pos.tilt;
		curRot = rot;

		String newURL = Window.Location
		    .createUrlBuilder()
		    .setHash(mParams
		            + "scale=" + pos.zoomLevel
		            + "&rot=" + curRot
		            + "&tilt=" + curTilt
		            + "&lat=" + (curLat / 1000f)
		            + "&lon=" + (curLon / 1000f))
		    .buildString();
		Window.Location.replace(newURL);
	}
}
 

import org.oscim.core.MercatorProjection; //导入依赖的package包/类
/**
 * Get the minimal axis-aligned BoundingBox that encloses
 * the visible part of the map.
 *
 * @return BoundingBox containing view
 */
public synchronized BoundingBox getViewBox() {
	getViewBox(mMapBBox);

	// scale map-pixel coordinates at current scale to
	// absolute coordinates and apply mercator projection.
	double minLon = MercatorProjection.toLongitude(mMapBBox.minX);
	double maxLon = MercatorProjection.toLongitude(mMapBBox.maxX);
	// sic(k)
	double minLat = MercatorProjection.toLatitude(mMapBBox.maxY);
	double maxLat = MercatorProjection.toLatitude(mMapBBox.minY);

	return new BoundingBox(minLat, minLon, maxLat, maxLon);
}
 

import org.oscim.core.MercatorProjection; //导入依赖的package包/类
/**
 * Utility method to perform all processing on a new ItemizedOverlay.
 * Subclasses provide Items through the createItem(int) method. The subclass
 * should call this as soon as it has data, before anything else gets
 * called.
 */
protected final void populate() {
	synchronized (lock) {
		final int size = size();
		mSize = size;

		// reuse previous items
		InternalItem pool = mItems;
		mItems = null;

		// flip order to draw in backward cycle, so the items
		// with the least index are on the front.
		for (int a = 0; a < size; a++) {
			InternalItem it;
			if (pool != null) {
				it = pool;
				it.visible = false;
				it.changes = false;
				pool = pool.next;
			} else {
				it = new InternalItem();
			}
			it.next = mItems;
			mItems = it;

			it.item = createItem(a);

			// pre-project points
			MercatorProjection.project(it.item.mGeoPoint, mMapPoint);
			it.px = mMapPoint.x;
			it.py = mMapPoint.y;
		}
		mUpdate = true;
	}
}