mercatortiledimagelayer.java

world wind java sdk 源码

					&& !this.currentResourceTile.isTextureInMemory(dc
							.getTextureCache()))
				this.forceTextureLoad(this.currentResourceTile);

			if (this.currentResourceTile
					.isTextureInMemory(dc.getTextureCache()))
			{
				tile.setFallbackTile(currentResourceTile);
				this.addTileToCurrent(tile);
			}
		}
	}

	private void addTileToCurrent(MercatorTextureTile tile)
	{
		this.currentTiles.add(tile);
	}

	private boolean isTileVisible(DrawContext dc, MercatorTextureTile tile)
	{
		//        if (!(tile.getExtent(dc).intersects(dc.getView().getFrustumInModelCoordinates())
		//            && (dc.getVisibleSector() == null || dc.getVisibleSector().intersects(tile.getSector()))))
		//            return false;
		//
		//        Position eyePos = dc.getView().getEyePosition();
		//        LatLon centroid = tile.getSector().getCentroid();
		//        Angle d = LatLon.greatCircleDistance(eyePos.getLatLon(), centroid);
		//        if ((!tile.getLevelName().equals("0")) && d.compareTo(tile.getSector().getDeltaLat().multiply(2.5)) == 1)
		//            return false;
		//
		//        return true;
		//
		return tile.getExtent(dc).intersects(
				dc.getView().getFrustumInModelCoordinates())
				&& (dc.getVisibleSector() == null || dc.getVisibleSector()
						.intersects(tile.getSector()));
	}

	//
	//    private boolean meetsRenderCriteria2(DrawContext dc, TextureTile tile)
	//    {
	//        if (this.levels.isFinalLevel(tile.getLevelNumber()))
	//            return true;
	//
	//        Sector sector = tile.getSector();
	//        Vec4[] corners = sector.computeCornerPoints(dc.getGlobe());
	//        Vec4 centerPoint = sector.computeCenterPoint(dc.getGlobe());
	//
	//        View view = dc.getView();
	//        double d1 = view.getEyePoint().distanceTo3(corners[0]);
	//        double d2 = view.getEyePoint().distanceTo3(corners[1]);
	//        double d3 = view.getEyePoint().distanceTo3(corners[2]);
	//        double d4 = view.getEyePoint().distanceTo3(corners[3]);
	//        double d5 = view.getEyePoint().distanceTo3(centerPoint);
	//
	//        double minDistance = d1;
	//        if (d2 < minDistance)
	//            minDistance = d2;
	//        if (d3 < minDistance)
	//            minDistance = d3;
	//        if (d4 < minDistance)
	//            minDistance = d4;
	//        if (d5 < minDistance)
	//            minDistance = d5;
	//
	//        double r = 0;
	//        if (minDistance == d1)
	//            r = corners[0].getLength3();
	//        if (minDistance == d2)
	//            r = corners[1].getLength3();
	//        if (minDistance == d3)
	//            r = corners[2].getLength3();
	//        if (minDistance == d4)
	//            r = corners[3].getLength3();
	//        if (minDistance == d5)
	//            r = centerPoint.getLength3();
	//
	//        double texelSize = tile.getLevel().getTexelSize(r);
	//        double pixelSize = dc.getView().computePixelSizeAtDistance(minDistance);
	//
	//        return 2 * pixelSize >= texelSize;
	//    }

	private boolean meetsRenderCriteria(DrawContext dc, MercatorTextureTile tile)
	{
		return this.levels.isFinalLevel(tile.getLevelNumber())
				|| !needToSplit(dc, tile.getSector());
	}

	private boolean needToSplit(DrawContext dc, Sector sector)
	{
		Vec4[] corners = sector.computeCornerPoints(dc.getGlobe(), dc.getVerticalExaggeration());
		Vec4 centerPoint = sector.computeCenterPoint(dc.getGlobe(), dc.getVerticalExaggeration());

		View view = dc.getView();
		double d1 = view.getEyePoint().distanceTo3(corners[0]);
		double d2 = view.getEyePoint().distanceTo3(corners[1]);
		double d3 = view.getEyePoint().distanceTo3(corners[2]);
		double d4 = view.getEyePoint().distanceTo3(corners[3]);
		double d5 = view.getEyePoint().distanceTo3(centerPoint);

		double minDistance = d1;
		if (d2 < minDistance)
			minDistance = d2;
		if (d3 < minDistance)
			minDistance = d3;
		if (d4 < minDistance)
			minDistance = d4;
		if (d5 < minDistance)
			minDistance = d5;

		double cellSize = (Math.PI * sector.getDeltaLatRadians() * dc
				.getGlobe().getRadius()) / 20; // TODO

		return !(Math.log10(cellSize) <= (Math.log10(minDistance) - this.splitScale));
	}

	private boolean atMaxLevel(DrawContext dc)
	{
		Position vpc = dc.getViewportCenterPosition();
		if (dc.getView() == null || this.getLevels() == null || vpc == null)
			return false;

		if (!this.getLevels().getSector().contains(vpc.getLatitude(),
				vpc.getLongitude()))
			return true;

		Level nextToLast = this.getLevels().getNextToLastLevel();
		if (nextToLast == null)
			return true;

		Sector centerSector = nextToLast.computeSectorForPosition(vpc.getLatitude(), vpc.getLongitude(),
            this.getLevels().getTileOrigin());
		return this.needToSplit(dc, centerSector);
	}

	// ============== Rendering ======================= //
	// ============== Rendering ======================= //
	// ============== Rendering ======================= //

	@Override
	public void render(DrawContext dc)
	{
		this.atMaxResolution = this.atMaxLevel(dc);
		super.render(dc);
	}

	@Override
	protected final void doRender(DrawContext dc)
	{
		if (this.forceLevelZeroLoads && !this.levelZeroLoaded)
			this.loadAllTopLevelTextures(dc);
		if (dc.getSurfaceGeometry() == null
				|| dc.getSurfaceGeometry().size() < 1)
			return;

		dc.getGeographicSurfaceTileRenderer().setShowImageTileOutlines(
				this.showImageTileOutlines);

		draw(dc);
	}

	private void draw(DrawContext dc)
	{
		this.referencePoint = this.computeReferencePoint(dc);

		this.assembleTiles(dc); // Determine the tiles to draw.

		if (this.currentTiles.size() >= 1)
		{
			MercatorTextureTile[] sortedTiles = new MercatorTextureTile[this.currentTiles
					.size()];
			sortedTiles = this.currentTiles.toArray(sortedTiles);
			Arrays.sort(sortedTiles, levelComparer);

			GL gl = dc.getGL();

			if (this.isUseTransparentTextures() || this.getOpacity() < 1)
			{
				gl.glPushAttrib(GL.GL_COLOR_BUFFER_BIT | GL.GL_POLYGON_BIT
						| GL.GL_CURRENT_BIT);
				gl.glColor4d(1d, 1d, 1d, this.getOpacity());
				gl.glEnable(GL.GL_BLEND);
				gl.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA);
			}
			else
			{
				gl.glPushAttrib(GL.GL_COLOR_BUFFER_BIT | GL.GL_POLYGON_BIT);
			}

			gl.glPolygonMode(GL.GL_FRONT, GL.GL_FILL);
			gl.glEnable(GL.GL_CULL_FACE);
			gl.glCullFace(GL.GL_BACK);

			dc.setPerFrameStatistic(PerformanceStatistic.IMAGE_TILE_COUNT,
					this.tileCountName, this.currentTiles.size());
			dc.getGeographicSurfaceTileRenderer().renderTiles(dc,
					this.currentTiles);

			gl.glPopAttrib();

			if (this.drawTileIDs)
				this.drawTileIDs(dc, this.currentTiles);

			if (this.drawBoundingVolumes)
				this.drawBoundingVolumes(dc, this.currentTiles);

			this.currentTiles.clear();
		}

		this.sendRequests();
		this.requestQ.clear();
	}

	private void sendRequests()
	{
		Runnable task = this.requestQ.poll();
		while (task != null)
		{
			if (!WorldWind.getTaskService().isFull())
			{
				WorldWind.getTaskService().addTask(task);
			}
			task = this.requestQ.poll();
		}
	}

	public boolean isLayerInView(DrawContext dc)
	{
		if (dc == null)
		{
			String message = Logging.getMessage("nullValue.DrawContextIsNull");
			Logging.logger().severe(message);
			throw new IllegalStateException(message);
		}

		if (dc.getView() == null)
		{
			String message = Logging
					.getMessage("layers.AbstractLayer.NoViewSpecifiedInDrawingContext");
			Logging.logger().severe(message);
			throw new IllegalStateException(message);
		}

		return !(dc.getVisibleSector() != null && !this.levels.getSector()
				.intersects(dc.getVisibleSector()));
	}

	private Vec4 computeReferencePoint(DrawContext dc)
	{
		if (dc.getViewportCenterPosition() != null)
			return dc.getGlobe().computePointFromPosition(
					dc.getViewportCenterPosition());

		java.awt.geom.Rectangle2D viewport = dc.getView().getViewport();
		int x = (int) viewport.getWidth() / 2;
		for (int y = (int) (0.5 * viewport.getHeight()); y >= 0; y--)
		{
			Position pos = dc.getView().computePositionFromScreenPoint(x, y);
			if (pos == null)
				continue;

			return dc.getGlobe().computePointFromPosition(pos.getLatitude(),
					pos.getLongitude(), 0d);
		}

		return null;
	}

	protected Vec4 getReferencePoint()
	{
		return this.referencePoint;
	}

	private static class LevelComparer implements
			Comparator<MercatorTextureTile>
	{
		public int compare(MercatorTextureTile ta, MercatorTextureTile tb)
		{
			int la = ta.getFallbackTile() == null ? ta.getLevelNumber() : ta
					.getFallbackTile().getLevelNumber();
			int lb = tb.getFallbackTile() == null ? tb.getLevelNumber() : tb
					.getFallbackTile().getLevelNumber();

			return la < lb ? -1 : la == lb ? 0 : 1;
		}
	}

	private void drawTileIDs(DrawContext dc,
			ArrayList<MercatorTextureTile> tiles)
	{
		java.awt.Rectangle viewport = dc.getView().getViewport();
        TextRenderer textRenderer = dc.getTextRendererCache().getOrCreate(java.awt.Font.decode("Arial-Plain-13"));

		dc.getGL().glDisable(GL.GL_DEPTH_TEST);
		dc.getGL().glDisable(GL.GL_BLEND);
		dc.getGL().glDisable(GL.GL_TEXTURE_2D);

		textRenderer.setColor(java.awt.Color.YELLOW);
		textRenderer.beginRendering(viewport.width, viewport.height);
		for (MercatorTextureTile tile : tiles)
		{
			String tileLabel = tile.getLabel();

			if (tile.getFallbackTile() != null)
				tileLabel += "/" + tile.getFallbackTile().getLabel();

			LatLon ll = tile.getSector().getCentroid();
			Vec4 pt = dc.getGlobe().computePointFromPosition(
					ll.getLatitude(),
					ll.getLongitude(),
					dc.getGlobe().getElevation(ll.getLatitude(),
							ll.getLongitude()));
			pt = dc.getView().project(pt);
			textRenderer.draw(tileLabel, (int) pt.x, (int) pt.y);
		}
		textRenderer.endRendering();
	}

	private void drawBoundingVolumes(DrawContext dc,
			ArrayList<MercatorTextureTile> tiles)
	{
		float[] previousColor = new float[4];
		dc.getGL().glGetFloatv(GL.GL_CURRENT_COLOR, previousColor, 0);
		dc.getGL().glColor3d(0, 1, 0);

		for (MercatorTextureTile tile : tiles)
		{
			((Cylinder) tile.getExtent(dc)).render(dc);
		}

		Cylinder c = dc.getGlobe().computeBoundingCylinder(
				dc.getVerticalExaggeration(), this.levels.getSector());
		dc.getGL().glColor3d(1, 1, 0);
		c.render(dc);

		dc.getGL().glColor4fv(previousColor, 0);
	}

	// ============== Image Composition ======================= //
	// ============== Image Composition ======================= //
	// ============== Image Composition ======================= //

	public ArrayList<String> getAvailableImageFormats()
	{
		return new ArrayList<String>(this.supportedImageFormats);
	}

	public boolean isImageFormatAvailable(String imageFormat)
	{
		return imageFormat != null
				&& this.supportedImageFormats.contains(imageFormat);
	}

	public String getDefaultImageFormat()
	{
		return this.supportedImageFormats.size() > 0 ? this.supportedImageFormats
				.get(0)
				: null;
	}

	protected void setAvailableImageFormats(String[] formats)
	{
		this.supportedImageFormats.clear();

		if (formats != null)
		{
			for (String format : formats)
				this.supportedImageFormats.add(format);
		}
	}

	private BufferedImage requestImage(MercatorTextureTile tile, String mimeType)
			throws URISyntaxException
	{
		String pathBase = tile.getPath().substring(0,
				tile.getPath().lastIndexOf("."));
		String suffix = WWIO.makeSuffixForMimeType(mimeType);
		String path = pathBase + suffix;
		URL url = WorldWind.getDataFileStore().findFile(path, false);

		if (url == null) // image is not local