worldwindearth/worldwindjava

A community supported fork of the NASA WorldWind Java SDK (WWJ) is for building cross-platform 3D geospatial desktop applications in Java.

WorldWind Java - Community Edition (WWJ-CE)

WWJ-CE is community supported fork of the ubiquitous WorldWind Java SDK from NASA.

WorldWind Java is a 3D virtual globe API for desktop Java, developed by NASA. It provides a geographic context with high-resolution terrain, for visualizing geographic or geo-located information in 3D and 2D. Developers can customize the globe's terrain and imagery. The SDK provides a collection of shapes for displaying and interacting with geographic data and representing a range of geometric objects.

• WorldWindJava Wiki has setup instructions, developers guides and more
• API Documentation provides an extensive collection of useful JavaDocs for the WWJ-CE SDK
• WorldWind Forum provides help from the WorldWind community
• IntelliJ IDEA is used by the NASA WorldWind development team

Notice from NASA

On March 8, 2019, NASA announced a suspension of the WorldWind project.

WorldWind team would like to inform you that starting May 3, 2019, NASA WorldWind project will be suspended. All the WorldWind servers providing elevation and imagery will be unavailable. While you can still download the SDKs from GitHub, there will be no technical support. If you have questions and/or concerns, please feel free to email at:

[email protected]

WWJ-CE seeks to mitigate the effects of the suspension and continue the development of WorldWind Java.

Contributing to the Community Edition

Contributions to WWJ-CE are welcomed in the form of issues and pull requests.

Before Submitting an Issue

Please fulfill the following requirements before submitting an issue to this repository:

• Check the Common Problems in the Tutorials wiki
• Check that your issue isn't already filed in the open issues and pull requests
• Check the WorldWind Java Forums for common solutions

Before Submitting a Pull Request

Please read Contributing to WorldWind Java and adhere to the WorldWind Java Design and Coding Guidelines.

Releases and Roadmap

Official WorldWind Java releases have the latest stable features, enhancements and bug fixes ready for production use.

• GitHub Releases documents official releases
• GitHub Milestones documents upcoming releases and the development roadmap
• Travis CI provides continuous integration and build automation

Run a Demo

The following options are available to run a WorldWind Java demo:

From the Apache NetBeans IDE

Clone the SDK with git, open the WorldWind Java project with Apache Netbeans and run demos via the Netbeans interface.

From a Windows Development Environment

• Download and extract the Latest Release
• Open the Command Prompt

cd [WorldWind release]
run-demo.bat

From a Linux or macOS Development Environment

• Download and extract the Latest Release
• Open the Terminal app

cd [WorldWind release]
sh run-demo.bash

Troubleshooting

WorldWind requires a modern graphics card with a current driver. Most display problems are caused by out-of-date graphics drivers. On Windows, visit your graphics card manufacturer's web site for the latest driver: NVIDIA, ATI or Intel. The drivers are typically under a link named Downloads or Support. If you're using a laptop, the latest drivers are found at the laptop manufacturer's web site.

JOGL Native Binaries

JOGL performs runtime extraction of native binaries. Some deployment situations may not allow this because it extracts the binaries to the application user’s temp directory. Runtime extraction can be avoided by by modifying WorldWind Java's JOGL distribution to load native binaries directly from the library path instead of dynamically using the native binary JAR files as follows:

1. Extract the GlueGen and JOGL native binary JAR files for the desired platform. These JAR files follow the naming pattern gluegen-rt-natives-PLATFORM.jar and jogl-all-natives-PLATFORM.jar
2. Place the extracted native binaries either in the program's working directory or in a location specified as the library path. The following JOGL user's guide page outlines supported library path variables: https://jogamp.org/jogl/doc/userguide/index.html#traditionallibraryloading
3. Remove the GlueGen and JOGL native binary JAR files from your application's workspace. JOGL attempts to use the native binary JAR files before loading from the library path, so these files must not be deployed with the application.
4. When running, specify the JVM argument -Djogamp.gluegen.UseTempJarCache=false

GDAL

GDAL is a translator library for raster and vector geospatial data formats provided by the Open Source Geospatial Foundation. GDAL libraries and native binaries are not provided by WorldWindEarth/WorldWind Java, but are needed to build. The Gradle build will pull the necessary libraries from Maven. Please see the file GDAL_README.txt for details on where to obtain the native binaries and other details.

License

Copyright 2006-2009, 2017, 2020 United States Government, as represented by the Administrator of the National Aeronautics and Space Administration. All rights reserved.

The NASA World Wind Java (WWJ) platform is licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

NASA World Wind Java (WWJ) also contains the following 3rd party Open Source software:

Jackson Parser – Licensed under Apache 2.0
GDAL – Licensed under MIT
JOGL – Licensed under  Berkeley Software Distribution (BSD)
Gluegen – Licensed under Berkeley Software Distribution (BSD)

A complete listing of 3rd Party software notices and licenses included in NASA World Wind Java (WWJ) can be found in the WorldWindJava-v2.2 3rd-party notices and licenses PDF found in code directory.

worldwindjava's Issues

No imagery using GDAL library with version > 3.0.0

Description

If GDAL version later than 3.0.0 is used, imagery won't be displayed.

Symptom:
When a raster image is read by GDAL, the error

GDALWarpOptions.Validate(): nBandCount=0, no bands configured!

will be displayed. That will occur when the call to reprojectImage at line 1123 or 1135 to apply the mask dataset to the source image.

Problem analysis:
The intent of the 'reprojectImage' call with the mask dataset was to produce a resulting dataset with alpha=0 outside the ROI, and 1.0 inside the ROI. The mask dataset is used to clip the image to the ROI by GDALUtils.composeDataRaster() (called in GDALDataRaster at line 1154). The alpha raster band is retrieved, and eventually used to clip the image in GDALUtils.applyImageMask.

With the GDAL code in this commit, the 'reprojectImage' for the mask dataset will fail, because GDAL finds no image bands (hence the error message). The alpha band in the mask dataset will be zero everywhere, and 'applyImageMask' will produce an empty image.

Steps to Reproduce

1. Use a GDAL version later than 3.0.0. GISInternals has development releases for Windows.
2. Run the 'InstallImagery' example.
3. Note that the image is empty. Console output should include the error message noted above.

Reproduces how often:
Always.

Operating System and Version

All

Additional Information

This is probably an improper use of 'reprojectImage'. Probably the masking operation should be done without the use of GDAL.

Improvement of image layer level of details calculation

Description

Current approach of details control in TiledImageLayer is based on camera distance to surface and horizontal field of view, but it does not provide stable pixel density of tiles comparing to monitor pixel density (as it usually appears on 2d maps).

I propose to make needToSplit approach from MercatorTiledImageLayer a default approach for any TiledImageLayer. Also I propose to refactor camera calculations to use vertical field of view instead of horizontal.

Actual behavior:
When you resize WordWind window horizontally tile level of details remains unchanged, but from user perspective every tile become using more or less pixels on the screen, because overall window width become wider or narrower displaying the same amount of tiles. This cause tile surface text and other tile elements to have different size depending on window size. Sometimes it make situation when text and other details are too small and unreadable. Sometimes they are too big and looks blur.

Expected behavior:
Web and Android version of WorldWind library provides other better approach. This approach is also implemented in Java MercatorTiledImageLayer and it compare tile pixel density to user monitor pixel density respecting window size and change details during window resizing to have more or less stable tile pixel density in any window size. This approach provides stable text size and other tile elements size. Furthermore, Web and Android libraries base its camera calculations on vertical field of view (not horizontal). This allows to resize window horizontally without change of details simply by changing horizontal field of view during window resize (keeping vertical FOV unchanged). Horizontal resize is more frequent then vertical in horizontal displays.

Steps to Reproduce

Choose any text or other element on the map to be a test object.
Resize worldwind horizontally and see how test object will change its size on the screen.
You will see that details will not change causing text object to become very small and unreadable or very large and blurry.

Reproduces how often:
Always.

Operating System and Version

Any

Additional Information

Try to do same test on WebWorldWind on MercatorLayer an you will see how comfortable to have correct level of details switching.

MercatorTiledImageLayer is a modified copy-paste of BasicTailedImage layer

MercatorTiledImageLayer is a modified copy-paste of BasicTailedImageLayer extended from AbstractLayer, but it can simply extend BasicTailedImageLayer and override several methods. This allow to maintain reusable logic in BasicTailedImageLayer and avoid future bugs.

There is also a copy-pasted MercatorTextureTile cache logic instead of using the cache build in parent TextureTile class.

And one improvement - MercatorUrlBuilder transforms col, row and level into usual x, y, z parameters by inversing row numbering and allowing to make offset of first zoom level to have first level consists of e.g. 8 tiles instead of 1.

To solve this issues just refactor several classes...

1. MercatorTiledImageLayer:

public class MercatorTiledImageLayer extends BasicTiledImageLayer {

    protected String name;

    private static LevelSet makeLevels(String name, int numLevels, int tileSize, String formatSuffix, MercatorTileUrlBuilder buider) {
        double delta = Angle.POS360.degrees / (1 << buider.getFirstLevelOffset());

        AVList params = new AVListImpl();
        params.setValue(AVKey.SECTOR, new MercatorSector(-1.0, 1.0, Angle.NEG180, Angle.POS180));
        params.setValue(AVKey.LEVEL_ZERO_TILE_DELTA, new LatLon(Angle.fromDegrees(delta / 2), Angle.fromDegrees(delta)));
        params.setValue(AVKey.NUM_LEVELS, numLevels - buider.getFirstLevelOffset());
        params.setValue(AVKey.FORMAT_SUFFIX, formatSuffix);
        params.setValue(AVKey.TILE_WIDTH, tileSize);
        params.setValue(AVKey.TILE_HEIGHT, tileSize);
        params.setValue(AVKey.DATASET_NAME, "*");
        params.setValue(AVKey.DATA_CACHE_NAME, "Earth/Mercator/" + name);
        params.setValue(AVKey.TILE_URL_BUILDER, buider);

        return new LevelSet(params);
    }

    public MercatorTiledImageLayer(String name, int numLevels, int tileSize, boolean overlay, String formatSuffix, MercatorTileUrlBuilder builder) {
        this(makeLevels(name, numLevels, tileSize, formatSuffix, builder), name);
        setUseTransparentTextures(overlay);
    }

    public MercatorTiledImageLayer(LevelSet levelSet, String name) {
        super(levelSet);
        this.name = name;
        this.detailHintOrigin = 1.5;
    }

    @Override
    public String toString() {
        return name;
    }

    @Override
    protected void createTopLevelTiles() {
        MercatorSector sector = (MercatorSector) this.levels.getSector();

        Level level = levels.getFirstLevel();
        Angle dLat = level.getTileDelta().getLatitude();
        Angle dLon = level.getTileDelta().getLongitude();

        Angle latOrigin = this.levels.getTileOrigin().getLatitude();
        Angle lonOrigin = this.levels.getTileOrigin().getLongitude();

        // Determine the row and column offset from the common WorldWind global tiling origin.
        int firstRow = Tile.computeRow(dLat, sector.getMinLatitude(), latOrigin);
        int firstCol = Tile.computeColumn(dLon, sector.getMinLongitude(), lonOrigin);
        int lastRow = Tile.computeRow(dLat, sector.getMaxLatitude(), latOrigin);
        int lastCol = Tile.computeColumn(dLon, sector.getMaxLongitude(), lonOrigin);

        int nLatTiles = lastRow - firstRow + 1;
        int nLonTiles = lastCol - firstCol + 1;

        this.topLevels = new ArrayList<>(nLatTiles * nLonTiles);

        double deltaLat = dLat.degrees / 90;
        double d1 = sector.getMinLatPercent() + deltaLat * firstRow;
        for (int row = firstRow; row <= lastRow; row++) {
            double d2 = d1 + deltaLat;
            Angle t1 = Tile.computeColumnLongitude(firstCol, dLon, lonOrigin);
            for (int col = firstCol; col <= lastCol; col++) {
                Angle t2;
                t2 = t1.add(dLon);
                this.topLevels.add(new MercatorTextureTile(new MercatorSector(d1, d2, t1, t2), level, row, col));
                t1 = t2;
            }
            d1 = d2;
        }
    }

    @Override
    protected boolean needToSplit(DrawContext dc, Sector sector, Level level) {
        double texelSize = level.getTexelSize() * dc.getGlobe().getRadius();
        double pixelSize = dc.getView().computePixelSizeAtDistance(sector.distanceTo(dc, dc.getView().getEyePoint()));
        return texelSize > pixelSize * this.getDetailFactor();
    }

    @Override
    protected DownloadPostProcessor createDownloadPostProcessor(TextureTile tile) {
        return new MercatorDownloadPostProcessor((MercatorTextureTile) tile, this);
    }

    private static class MercatorDownloadPostProcessor extends DownloadPostProcessor {

        MercatorDownloadPostProcessor(MercatorTextureTile tile, MercatorTiledImageLayer layer) {
            super(tile, layer);
        }

        @Override
        protected BufferedImage transformPixels() {
            // Make parent transformations
            BufferedImage image = super.transformPixels();

            // Read image from buffer
            if(image == null) {
                try {
                    image = ImageIO.read(new ByteArrayInputStream(this.getRetriever().getBuffer().array()));
                } catch (IOException ignored) {
                    return null;
                }
            }

            // Transform mercator tile to equirectangular projection
            if(image != null) {
                int type = image.getType();
                if (type == BufferedImage.TYPE_CUSTOM) type = BufferedImage.TYPE_INT_RGB;
                else if (type == BufferedImage.TYPE_BYTE_INDEXED) type = BufferedImage.TYPE_INT_ARGB;

                BufferedImage trans = new BufferedImage(image.getWidth(), image.getHeight(), type);
                double miny = ((MercatorSector) tile.getSector()).getMinLatPercent();
                double maxy = ((MercatorSector) tile.getSector()).getMaxLatPercent();
                for (int y = 0; y < image.getHeight(); y++) {
                    double sy = 1.0 - y / (double) (image.getHeight() - 1);
                    Angle lat = Angle.fromRadians(sy * tile.getSector().getDeltaLatRadians() + tile.getSector().getMinLatitude().radians);
                    double dy = 1.0 - (MercatorSector.gudermannianInverse(lat) - miny) / (maxy - miny);
                    dy = Math.max(0.0, Math.min(1.0, dy));
                    int iy = (int) (dy * (image.getHeight() - 1));
                    for (int x = 0; x < image.getWidth(); x++) {
                        trans.setRGB(x, y, image.getRGB(x, iy));
                    }
                }

                return trans;
            } else {
                return null;
            }
        }

    }

}

2. MercatorTextureTile:

public class MercatorTextureTile extends TextureTile {

	MercatorTextureTile(MercatorSector mercatorSector, Level level, int row, int col) {
		super(mercatorSector, level, row, col);
	}

	@Override
	public TextureTile[] createSubTiles(Level nextLevel) {
		if (nextLevel == null) {
			String msg = Logging.getMessage("nullValue.LevelIsNull");
			Logging.logger().severe(msg);
			throw new IllegalArgumentException(msg);
		}

		MercatorSector sector = (MercatorSector) this.getSector();

		double d0 = sector.getMinLatPercent();
		double d2 = sector.getMaxLatPercent();
		double d1 = d0 + (d2 - d0) / 2.0;

		Angle t0 = sector.getMinLongitude();
		Angle t2 = sector.getMaxLongitude();
		Angle t1 = Angle.midAngle(t0, t2);

		String nextLevelCacheName = nextLevel.getCacheName();
		int nextLevelNum = nextLevel.getLevelNumber();

		int northRow = 2 * this.getRow();
		int southRow = northRow + 1;
		int westCol = 2 * this.getColumn();
		int eastCol = westCol + 1;

		TextureTile[] subTiles = new TextureTile[4];

		TextureTile subTile = this.getTileFromMemoryCache(new TileKey(nextLevelNum, northRow, westCol, nextLevelCacheName));
		subTiles[0] = subTile != null ? subTile : new MercatorTextureTile(new MercatorSector(d0, d1, t0, t1), nextLevel, northRow, westCol);

		subTile = this.getTileFromMemoryCache(new TileKey(nextLevelNum, northRow, eastCol, nextLevelCacheName));
		subTiles[1] = subTile != null ? subTile : new MercatorTextureTile(new MercatorSector(d0, d1, t1, t2), nextLevel, northRow, eastCol);

		subTile = this.getTileFromMemoryCache(new TileKey(nextLevelNum, southRow, westCol, nextLevelCacheName));
		subTiles[2] = subTile != null ? subTile : new MercatorTextureTile(new MercatorSector(d1, d2, t0, t1), nextLevel, southRow, westCol);

		subTile = this.getTileFromMemoryCache(new TileKey(nextLevelNum, southRow, eastCol, nextLevelCacheName));
		subTiles[3] = subTile != null ? subTile : new MercatorTextureTile(new MercatorSector(d1, d2, t1, t2), nextLevel, southRow, eastCol);

		return subTiles;
	}

}

3. MercatorTileUrlBuilder:

public abstract class MercatorTileUrlBuilder implements TileUrlBuilder {

    private int firstLevelOffset;

    public MercatorTileUrlBuilder setFirstLevelOffset(int firstLevelOffset) {
        this.firstLevelOffset = firstLevelOffset;
        return this;
    }

    public int getFirstLevelOffset() {
        return firstLevelOffset;
    }

    @Override
    public URL getURL(Tile tile, String imageFormat) throws MalformedURLException {
        return getMercatorURL(tile.getColumn(), (1 << (tile.getLevelNumber() + firstLevelOffset)) - 1 - tile.getRow(), tile.getLevelNumber() + firstLevelOffset);
    }

    protected abstract URL getMercatorURL(int x, int y, int z) throws MalformedURLException;

}

Cleanup tags

There's an errant tag in the repo that is cluttering the releases: daily/20170112 (b81455c). This tag has no value. I propose we delete this tag.

Mirror release artifacts from upstream repository

The release artifacts from the upstream repo releases should be mirrored in this repository to safeguard them from any potential NASA suspension activities.

Null-Globe bug in FlyToOrbitViewAnimator

There is a bug in the FlyToOrbitViewAnimator that causes a NullPointerException during startup. I've seen this issue manifest itself in the gov.nasa.worldwindx.examples.dataimport.ImportImagery example application. However, the issue only pops up when I set the GDAL_DATA and GDAL_PLUGINS manually in the launch script. The script I'm using is:

#!/bin/sh

export GDAL_DATA=/usr/share/gdal/2.2
export GDAL_PLUGINS=/usr/lib/gdalplugins
export LD_LIBRARY_PATH=/usr/lib/jni:/usr/lib/grass74/lib

java -Xmx1024m -Djava.library.path=/usr/lib/jni -classpath ./worldwind.jar:./worldwindx.jar:/usr/share/java/gdal.jar:./jogl-all.jar:./gluegen-rt.jar gov.nasa.worldwindx.examples.dataimport.ImportImagery

This results in the following exception being printed out continuously:

Jun 25, 2019 1:53:19 PM gov.nasa.worldwind.WorldWindowGLAutoDrawable display
SEVERE: Exception while attempting to repaint WorldWindow
java.lang.NullPointerException
        at gov.nasa.worldwind.view.orbit.FlyToOrbitViewAnimator$OnSurfacePositionAnimator.nextPosition(FlyToOrbitViewAnimator.java:124)
        at gov.nasa.worldwind.animation.PositionAnimator.setImpl(PositionAnimator.java:78)
        at gov.nasa.worldwind.animation.BasicAnimator.set(BasicAnimator.java:66)
        at gov.nasa.worldwind.animation.CompoundAnimator.setImpl(CompoundAnimator.java:89)
        at gov.nasa.worldwind.animation.BasicAnimator.set(BasicAnimator.java:66)
        at gov.nasa.worldwind.animation.BasicAnimator.next(BasicAnimator.java:55)
        at gov.nasa.worldwind.animation.AnimationController.stepAnimators(AnimationController.java:78)
        at gov.nasa.worldwind.view.orbit.OrbitViewInputHandler.apply(OrbitViewInputHandler.java:522)
        at gov.nasa.worldwind.view.BasicView.apply(BasicView.java:172)
        at gov.nasa.worldwind.AbstractSceneController.applyView(AbstractSceneController.java:538)
        at gov.nasa.worldwind.BasicSceneController.doNormalRepaint(BasicSceneController.java:40)
        at gov.nasa.worldwind.BasicSceneController.doRepaint(BasicSceneController.java:30)
        at gov.nasa.worldwind.AbstractSceneController.repaint(AbstractSceneController.java:400)
        at gov.nasa.worldwind.WorldWindowGLAutoDrawable.doDisplay(WorldWindowGLAutoDrawable.java:459)
        at gov.nasa.worldwind.WorldWindowGLAutoDrawable.display(WorldWindowGLAutoDrawable.java:332)
        at jogamp.opengl.GLDrawableHelper.displayImpl(GLDrawableHelper.java:692)
        at jogamp.opengl.GLDrawableHelper.display(GLDrawableHelper.java:674)
        at com.jogamp.opengl.awt.GLCanvas$11.run(GLCanvas.java:1424)
        at jogamp.opengl.GLDrawableHelper.invokeGLImpl(GLDrawableHelper.java:1293)
        at jogamp.opengl.GLDrawableHelper.invokeGL(GLDrawableHelper.java:1147)
        at com.jogamp.opengl.awt.GLCanvas$12.run(GLCanvas.java:1438)
        at com.jogamp.opengl.Threading.invoke(Threading.java:223)
        at com.jogamp.opengl.awt.GLCanvas.display(GLCanvas.java:505)
        at com.jogamp.opengl.awt.GLCanvas.paint(GLCanvas.java:559)
        at com.jogamp.opengl.awt.GLCanvas.update(GLCanvas.java:866)
        at sun.awt.RepaintArea.updateComponent(RepaintArea.java:255)
        at sun.awt.X11.XRepaintArea.updateComponent(XRepaintArea.java:51)
        at sun.awt.RepaintArea.paint(RepaintArea.java:232)
        at sun.awt.X11.XComponentPeer.handleEvent(XComponentPeer.java:584)
        at java.awt.Component.dispatchEventImpl(Component.java:4965)
        at java.awt.Component.dispatchEvent(Component.java:4711)
        at java.awt.EventQueue.dispatchEventImpl(EventQueue.java:760)
        at java.awt.EventQueue.access$500(EventQueue.java:97)
        at java.awt.EventQueue$3.run(EventQueue.java:709)
        at java.awt.EventQueue$3.run(EventQueue.java:703)
        at java.security.AccessController.doPrivileged(Native Method)
        at java.security.ProtectionDomain$JavaSecurityAccessImpl.doIntersectionPrivilege(ProtectionDomain.java:74)
        at java.security.ProtectionDomain$JavaSecurityAccessImpl.doIntersectionPrivilege(ProtectionDomain.java:84)
        at java.awt.EventQueue$4.run(EventQueue.java:733)
        at java.awt.EventQueue$4.run(EventQueue.java:731)
        at java.security.AccessController.doPrivileged(Native Method)
        at java.security.ProtectionDomain$JavaSecurityAccessImpl.doIntersectionPrivilege(ProtectionDomain.java:74)
        at java.awt.EventQueue.dispatchEvent(EventQueue.java:730)
        at java.awt.EventDispatchThread.pumpOneEventForFilters(EventDispatchThread.java:205)
        at java.awt.EventDispatchThread.pumpEventsForFilter(EventDispatchThread.java:116)
        at java.awt.EventDispatchThread.pumpEventsForHierarchy(EventDispatchThread.java:105)
        at java.awt.EventDispatchThread.pumpEvents(EventDispatchThread.java:101)
        at java.awt.EventDispatchThread.pumpEvents(EventDispatchThread.java:93)
        at java.awt.EventDispatchThread.run(EventDispatchThread.java:82)

I've dug around in the code a bit and I believe that it is a timing issue that causes this bug. When the environment variables are not set, the GDAL initialisation code attempts to search for the correct values for the GDAL_DATA and GDAL_PLUGINS variables. This search causes enough time to go by so that the View can be initialised resulting in no breakage. Thus, I think I've traced the issue to the FlyToOrbitViewAnimator class itself. The bugfix is in PR #56.

MGRS conversion fixes

Pull in fixes for MGRS coordinate conversion from upstream PR #157 of @gbburkhardt. The corresponding description from the PR is:

Fix two problems:

a) Index out of bounds error due to typo in convertMGRSToUPS; clearly the index should have been 1 instead of 12.
b) Conversions from geodetic to MGRS would fail for low southern latitudes (zone 0). Geotrans 3.7 has this problem fixed. The WorldWind conversion code was derived from NGA's Geotrans. Test case:
Lat: -89.345400 deg, Lon: -48.930600 deg ==> MGRS: AZN 45208 47747

See issue #160 in upstream repository as well.

Fix javadoc errors in build

The build output is littered with 200 javadoc warnings and errors. For instance,

 error: self-closing element not allowed
 * <p/>

error: block element not allowed within inline element <code>: pre
 * <pre>

warning: empty <p> tag
 * <p/> <p>blah blah blah:</p>

The javadoc text should be edited to eliminate this noisy output from the build.

Add NetBeans project for the community edition

Add a NetBeans project and settings for building the WorldWindJava community edition.

Incorrect Latitude normalization

Description

Angle has incorrect normalization function. It does not determine whether whether the latitude is in the north or south hemisphere.
For example 182 degrees of latitude should be normalized -2 degree not 2.

Expected behavior:

    public static double normalizedDegreesLatitude(double degrees) {
        double lat = degrees % 180;
        double normalizedLat = lat > 90 ? 180 - lat : lat < -90 ? -180 - lat : lat;
        // Determine whether whether the latitude is in the north or south hemisphere
        int numEquatorCrosses = (int) (degrees / 180);
        return (numEquatorCrosses % 2 == 0) ? normalizedLat : -normalizedLat;
    }

Actual behavior:

    public static double normalizedDegreesLatitude(double degrees) {
        double lat = degrees % 180;
        return lat > 90 ? 180 - lat : lat < -90 ? -180 - lat : lat;
    }

Steps to Reproduce

Try to put 182 degrees into new Location or any other latitude logic.

Reproduces how often:
This bug almost never appears. I found it just by comparing Java and Android sources when I have searched solution to normalize latitude in my application.

Operating System and Version

Any

Update IntelliJ IDE settings for community edition

Update the JetBrains IntelliJ settings to reflect the community edition of WorldWindJava. Use the IntelliJ Community Edition for the settings.

Migrate to Gradle wrapper build

Migrated this issue from upstream originally logged by @pdavidc: NASAWorldWind#60

Migrate World Wind Java to a Gradle wrapper based build system. Gradle builds integrate fully with the IntelliJ IDE internal build system, eliminating the duplicity of separate IDE build and ANT build process.

More fine-grained control over XML-output

We can add additional flexibility to WorldWind's XML output logic to allow for a bit more fine-grained control. The original pull-request (NASAWorldWind#23) adds configuration that allows for XML output to be pretty-printed and to allow the XML-declaration to be emitted (useful for embedding WorldWind-produced XML in other XML documents). We can have a look at what @rougeSE did in the above-mentioned pull-request to get an idea of where to start with this.

SurfaceText has no rotation support

Sometimes it is required to put SurfaceText rotated according North.
This possibility is absent but easy to add.

1. Add angle attribute, its setter and getter to SurfaceText class.
2. Add glRotated method call into applyDrawTransform.

See example of overridden class:

public class CustomSurfaceText extends SurfaceText {

    private double angle;

    public CustomSurfaceText(String text, Position position) {
        super(text, position);
    }

    public CustomSurfaceText(String text, Position position, Font font, Color color) {
        super(text, position, font, color);
    }

    public double getAngle() {
        return angle;
    }

    public void setAngle(double angle) {
        this.angle = angle;
    }

    @Override
    protected void applyDrawTransform(DrawContext dc, SurfaceTileDrawContext sdc) {
        super.applyDrawTransform(dc, sdc);
        dc.getGL().getGL2().glRotated(-angle, 0, 0, 1);
    }
}

Publish artifacts to Maven central

We need to get the WorldWind jars published on Maven central so that developers can easily include it in their projects. One of the forks that are doing this that we can reference for help or get help from is: https://github.com/pcmehlitz/WorldWindJava-pcm (Peter C Mehlitz's fork)

Alternative servers for NASA core imagery

At https://worldwind.earth/#about one can read

WorldWindJava
I have alternative servers for NASA core imagery (from worldwind25.arc.nasa.gov/wms) and NASA elevations (from worldwind26.arc.nasa.gov/elev) staged for production should the WorldWind shutdown become a reality. I will make these servers available if needed.

I need them. :)
Would it be possible to gain access to the old layers?
I would be happy to use them in https://mapton.org/

WebView on Linux

Description

WebViews do not work on Linux. They work fine on OSX and Windows. The BasicWebViewFactory has a placeholder for createLinuxWebView, but it has TODO: implement native WebView for Linux.

Expected behavior:

WebViews appear in Linux as they do in Windows and OSX

Actual behavior:

WebViews do not appear on Linux and an UnsupportedOperationException is thrown

Operating System and Version

Any flavor of Linux

Additional Information

Unclear if this would be possible or if it could be implemented similarly to how the OSX and Windows libraries are.

Improve XML parsing with variable substitution

We can improve the XML parsing logic in WorldWind so that we can have some rudimentary features such as property-substitution. There are various scenarios where this can be an advantage. The original pull-request (located at: NASAWorldWind#22) describes a scenario where we have a server that serves imagery or elevation data and the server-name can be configured as a Java system property. Everywhere the server is referenced in one of the layer XML files we use something like ${map-server-name} and let WorldWind do the replacement internally based on what the value of that property is. We can have a look at what @rougeSE has done in this pull request as a starting point.

GDAL upgrade

Continuing the conversation started here.

I had submitted changes to GDAL to clean up the generation of the JNI interface shared libraries, to use a single library, which were accepted and incorporated (see OSGeo/gdal#286) starting in release 2.3.2. The Ubuntu 18.04 LTS contains an older version, 2.2.3, and there are 5 JNI shared libraries. The Ubuntu 18.10 version sports version 2.3.2, so it has the single libgdalalljni.so file.

Both the GisInternals binary distribution and the Ubuntu libgdal-java packages include ‘gdal.jar’, and there’s only one class that not included in both (Ubuntu GDAL 2.2.3 includes ‘AsyncReader’). I’m pretty confident that Worldwind will work with both.

One possibility If we want the ERDAS-ECW and MrSID support in Linux is to compile GDAL and enable those two formats, in addition to whatever is available in the distribution. But my brief reading of the process this morning indicates that support needs to be enabled in the core GDAL code if those two formats are to be supported. I have no idea how important Linux is to WorldWind, nor if those two formats are important. We happen to want to use both. Also, I don’t have the bandwidth to try to work with a number of different Linux editions.

NASA originally included the LizardTech MrSID modules in their GDAL release. The licensing requirements haven’t changed as far as I can tell. One can redistribute the object code for free as long as the end product’s about box credits them (MrSID License).

I don’t see the ERDAS-ECW included in the NASA release. The license is similar to the MrSID license, in that redistribution is permitted without charge for the read-only portion, but the end user should include language in the their own license that Intergraph dictates (ERDAS-ECW license).

I’ll try to put something together that’s flexible and allows the user to drop his own GDAL packages in, for both Windows and Linux with x64. For Windows, I'll include all the required DLLs from the GISInternals build, and note the source. For Linux, I would like a decision about whether the MrSID and ERDAS-ECW formats are needed. If so, I'd need to build GDAL accordingly. If not, I'd want to rely on 'gdal.jar' and 'libgdalalljni.so' as supplied with Ubuntu.

GDAL Webstart Issues

There are currently issues in getting GDAL working when deploying WorldWind in a webstart environment. The original discussion is here: #42. This needs to be addressed in some way as this used to work in the upstream repository with the custom version of GDAL.

Update README for community edition

Objectives include:

• Add "Community Edition" and/or "community supported fork"
• Remove NASA branding
• Update links

Normalize latitude should work with latitude values greater than 180 degrees.

WorldWindJava/src/gov/nasa/worldwind/geom/Angle.java

Line 684 in dcb0413

return lat > 90 ? 180 - lat : lat < -90 ? -180 - lat : lat;

The normalize longitude method is doing the correct thing but the latitude method is not.

If you make an Angle with fromDMS that is meant to be in the southern hemisphere, you have to make it a positive number. But when you call the normalize latitude method, you do not get your negative value back. So, -11 degrees becomes 169 degrees, but then becomes 11, not -11 when you normalize.

Maybe I'm missing something and someone could explain.

        int lat = -11;
        Angle angTest = Angle.fromDMS(180 + lat, 0, 0);
        angTest = angTest.normalizedLatitude();

        assertEquals("not working", "-11.0°", angTest.toString());

Failed to build via jitpack.io

Hi.

Is it possible to fix build scripts to be able to import develop-SNAPSHOT from github via jitpack.io?

Now it shows following errors:
https://jitpack.io/com/github/WorldWindEarth/WorldWindJava/develop-a840f19ad8-1/build.log

Tilting Globe no longer possible

Description

Up to at least version 2.0.0-986, it was possible to tilt the plane in Flat mode. This is no longer possible with the latest version of WorldWindJava.

Expected behavior:
The view should tilt and provide some kind of 2.5D view.

Actual behavior:
No effect.

Steps to Reproduce

1. Run the demo
2. Switch to Globe -> Flat
3. Try to tilt using Shift-Mouse-Up/Down or using the buttons

Reproduces how often:
Always

Operating System and Version

Windows, macOS, and Linux using version 2.2.0

Additional Information

There was a similar report posted in the WorldWind Forum:
https://forum.worldwindcentral.com/forum/world-wind-java-forums/development-help/156698-world-wind-java-2-1-0-earthflat-no-longer-allows-tilt

I am happy to investigate more, but it would be very useful to get any information on what may have triggered this change of behavior, i.e. was this intentional, a side effect of a change, or a raw bug?

Problem with the anchor point of Military Symbology and NullPointerException when SPEED_LEADER_SCALE is not set

Description

1. When direction of movement arrow is added to Military Symbol, symbols with ground heading indicator has wrong anchor point. Because of this, when earth is rotated the symbol's direction of movement shows offset.

SOLUTION: Inside the MilStd2525TacticalSymbol class, at line 547, we need to add the following code:

if (this.useGroundHeadingIndicator) {
    List<? extends Point2D> points = MilStd2525Util.computeGroundHeadingIndicatorPoints(dc, osym.placePoint,
                   (Angle) o, length, this.iconRect.getHeight(), directionOnly);
    if (directionOnly) {
        this.addLine(dc, Offset.BOTTOM_CENTER, points, LAYOUT_RELATIVE, points.size() - 4, osym);
    } else {
        this.addLine(dc, Offset.BOTTOM_CENTER, points, LAYOUT_RELATIVE, points.size() - 1, osym);
    }
}

2. When SPEED_LEADER_SCALE is not set NullPointerException is get.

SOLUTION: Inside the MilStd2525TacticalSymbol class, at line 543, we need to add curly brackets to if clause as below:

if (d != null && d instanceof Number) {
    directionOnly = false;
    length *= ((Number) d).doubleValue();
}

Remove Jackson sources

The embedded Jackson sources should be removed and we should instead add the Jackson jar as an external dependency. See this pull request of mine for some details: NASAWorldWind#14

Unable to Refresh Map Layer Cache with "setExpiryTime"

Description

The method "setExpiryTime" in the Layer class has the following description:
/**
* Specifies the time of the layer's most recent dataset update. If greater than zero, the layer ignores and
* eliminates any previously cached data older than the time specified, and requests new information from the data
* source. If zero, the layer uses any expiry times intrinsic to the layer, typically initialized at layer
* construction. The default expiry time is 0, thereby enabling a layer's intrinsic expiration criteria.
*
* @param expiryTime the expiry time of any cached data, expressed as a number of milliseconds beyond the epoch.
*
* @see System#currentTimeMillis() for a description of milliseconds beyond the epoch.
*/

And reading through the WorldWind Java Forum there are several posts claiming that using "setExpiryTime(System.currentTimeMillis())" will invalidate a layer's tile cache both in memory and on disc causing new tiles to be retrieved from the source.

However, when I use this method as described nothing seems to happen. Even though the "setExpiryTime" seemed to execute without issue the return value for "tile.getLevel().getExpiryTime()" is the default value of 0 (zero).

Expected behavior:
The documentation says that setting "setExpiryTime(System.currentTimeMillis())" should invalidate the tiles for the specified layer both in memory and on disc and force new tiles to be retrieved from their source.

Actual behavior:
The cached tiles are used instead of fetching the tiles from the source.

Steps to Reproduce

1. Call layer.setExpiryTime(System.currentTimeMillis()); for the desired map layer

Reproduces how often:
Always

Operating System and Version

Windows 10 version 1903

Additional Information

Maybe I'm missing something. Are there other flags that need to be set or other calls that need to be made to mark a layer's current cache as expired and force tiles to be downloaded from their source?

Edit
Per Patrick's request I've submitted this issue at the NASA WWJ repo:
NASAWorldWind#174

Port Developers Guide to community edition Wiki

Port the contents of the NASA WWJ Developers Guide to the community edition's Wiki. Minimally, to include the following:

• Features
• Get Started
• Examples
• Tutorials

JAR files in v2.1.0 release archive contain Java sources

Migrated this issue from upstream originally logged by @pdavidc: NASAWorldWind#87

JAR files bundled with the v2.1.0 release archive, worldwind.jar and worldwindx.jar, contain the Java sources as well as the compiled class files. This causes each release JAR file to increase in size by about 40%, but has no effect on runtime operation.

World Wind Java's build assembles two types of JAR files:

Release: includes only the compiled class files
Debug: includes the compiled class files and the corresponding Java sources
JAR files bundled into all release archives (worldwind-vA.B.C.zip) must contain only the release JAR files. Debug JAR files may be assembled in a local development environment.

Enable publishing of community edition API docs

Activate publication of the WorldWindJava API docs on the gh_pages branch at https://worldwind.earth/WorldWindJava/

Mapbox Tiling Problems (Possibly Since Changes to MercatorTiledImageLayer)

Description

We had created a copy of MercatorTiledImageLayer from WWJ v2.1.0 with the only change being that we made the "splitScale" variable public. This allowed us to influence the "needToSplit" resulting in better looking maps from Mapbox.

We have several Mapbox layers containing raster data and several containing vector data. ALL of these layer worked with WWJ v2.1.0, but after the change in the MercatorTiledImageLayer in WWJ-CE we are having problems with the layers that contain vector data (streets, boundaries, etc.).

When the layers that contain vector data load it looks like there are missing tiles in various locations as you zoom in and out. We know the tiles aren't missing, so I'm guessing there's something about the way the tiles are being requested that's changed.

If I revert to WWJ v2.1.0 ALL of these same Mapbox layers display without any problems. I'm new to Git/GitHub, but I'm wondering if there's a way for me to revert my local copy of WWJ-CE to a point before the change to the MercatorTiledImageLayer was merged in order to confirm if this is when the issue appeared? I'll poke around and see if I can figure out how to do that.

If there's another/better way to display all our Mapbox maps in WWJ I'd love some pointers. Otherwise I need to figure out what happened and get this corrected one way or another.

Edit
I figured out how to revert to just before the change to MercatorTiledImageLayer, but this did not fix the issue. If I use WWJ v2.1.0 the problem goes away. I guess I can keep reverting until I discover the point at which the problem goes away. Any thoughts on what may have caused this and how to fix it are certainly welcome.

Expected behavior:
All of our Mapbox maps should load as they did while using WWJ v2.1.0.

Actual behavior:
Mapbox maps containing vector data (streets, boundaries, etc.) look like they are missing tiles at various locations as the map is zoomed in and out.

Steps to Reproduce

I suppose this would be hard for anyone that doesn't use Mapbox maps. However, simply set up a map from Mapbox that contains vector data (using the OSMMapnikLayer as an example).

Reproduces how often:
100% of the time

Operating System and Version

Windows 10

Additional Information

worldwind java 2.1.0 goes wrong on ubuntu 20.0.4

Description

worldwind java 2.1.0 goes wrong on ubuntu 20.04
in the previous version, like ubuntu 18.04 ,Centos 7 linux distribution, worldwind java works well.
i think something about opengl goes wrong.

i hope the official developer can see this,and fix it

Expected behavior:
the 3D globe window cannot show up.
and errors showed in a dialogue window.

Actual behavior:

Steps to Reproduce

1. put the program in ubuntu 20.04
2. run the application,then goes wrong

Reproduces how often:
everytime

Operating System and Version

ubuntu 20.04

Additional Information

glxinfo in my ubuntu 20.04

name of display: :0
display: :0 screen: 0
direct rendering: Yes
server glx vendor string: SGI
server glx version string: 1.4
server glx extensions:
GLX_ARB_create_context, GLX_ARB_create_context_no_error,
GLX_ARB_create_context_profile, GLX_ARB_create_context_robustness,
GLX_ARB_fbconfig_float, GLX_ARB_framebuffer_sRGB, GLX_ARB_multisample,
GLX_EXT_create_context_es2_profile, GLX_EXT_create_context_es_profile,
GLX_EXT_fbconfig_packed_float, GLX_EXT_framebuffer_sRGB,
GLX_EXT_import_context, GLX_EXT_libglvnd, GLX_EXT_no_config_context,
GLX_EXT_texture_from_pixmap, GLX_EXT_visual_info, GLX_EXT_visual_rating,
GLX_INTEL_swap_event, GLX_MESA_copy_sub_buffer, GLX_OML_swap_method,
GLX_SGIS_multisample, GLX_SGIX_fbconfig, GLX_SGIX_pbuffer,
GLX_SGIX_visual_select_group, GLX_SGI_make_current_read,
GLX_SGI_swap_control
client glx vendor string: Mesa Project and SGI
client glx version string: 1.4
client glx extensions:
GLX_ARB_context_flush_control, GLX_ARB_create_context,
GLX_ARB_create_context_no_error, GLX_ARB_create_context_profile,
GLX_ARB_create_context_robustness, GLX_ARB_fbconfig_float,
GLX_ARB_framebuffer_sRGB, GLX_ARB_get_proc_address, GLX_ARB_multisample,
GLX_EXT_buffer_age, GLX_EXT_create_context_es2_profile,
GLX_EXT_create_context_es_profile, GLX_EXT_fbconfig_packed_float,
GLX_EXT_framebuffer_sRGB, GLX_EXT_import_context,
GLX_EXT_texture_from_pixmap, GLX_EXT_visual_info, GLX_EXT_visual_rating,
GLX_INTEL_swap_event, GLX_MESA_copy_sub_buffer,
GLX_MESA_multithread_makecurrent, GLX_MESA_query_renderer,
GLX_MESA_swap_control, GLX_OML_swap_method, GLX_OML_sync_control,
GLX_SGIS_multisample, GLX_SGIX_fbconfig, GLX_SGIX_pbuffer,
GLX_SGIX_visual_select_group, GLX_SGI_make_current_read,
GLX_SGI_swap_control, GLX_SGI_video_sync
GLX version: 1.4
GLX extensions:
GLX_ARB_create_context, GLX_ARB_create_context_no_error,
GLX_ARB_create_context_profile, GLX_ARB_create_context_robustness,
GLX_ARB_fbconfig_float, GLX_ARB_framebuffer_sRGB,
GLX_ARB_get_proc_address, GLX_ARB_multisample, GLX_EXT_buffer_age,
GLX_EXT_create_context_es2_profile, GLX_EXT_create_context_es_profile,
GLX_EXT_fbconfig_packed_float, GLX_EXT_framebuffer_sRGB,
GLX_EXT_import_context, GLX_EXT_texture_from_pixmap, GLX_EXT_visual_info,
GLX_EXT_visual_rating, GLX_INTEL_swap_event, GLX_MESA_copy_sub_buffer,
GLX_MESA_query_renderer, GLX_MESA_swap_control, GLX_OML_swap_method,
GLX_OML_sync_control, GLX_SGIS_multisample, GLX_SGIX_fbconfig,
GLX_SGIX_pbuffer, GLX_SGIX_visual_select_group, GLX_SGI_make_current_read,
GLX_SGI_swap_control, GLX_SGI_video_sync
Extended renderer info (GLX_MESA_query_renderer):
Vendor: Intel (0x8086)
Device: Mesa Intel(R) HD Graphics 520 (SKL GT2) (0x1916)
Version: 20.0.4
Accelerated: yes
Video memory: 3072MB
Unified memory: yes
Preferred profile: core (0x1)
Max core profile version: 4.6
Max compat profile version: 4.6
Max GLES1 profile version: 1.1
Max GLES[23] profile version: 3.2
OpenGL vendor string: Intel
OpenGL renderer string: Mesa Intel(R) HD Graphics 520 (SKL GT2)
OpenGL core profile version string: 4.6 (Core Profile) Mesa 20.0.4
OpenGL core profile shading language version string: 4.60
OpenGL core profile context flags: (none)
OpenGL core profile profile mask: core profile
OpenGL core profile extensions:
GL_3DFX_texture_compression_FXT1, GL_AMD_conservative_depth,
GL_AMD_depth_clamp_separate, GL_AMD_draw_buffers_blend,
GL_AMD_gpu_shader_int64, GL_AMD_multi_draw_indirect,
GL_AMD_performance_monitor, GL_AMD_pinned_memory,
GL_AMD_query_buffer_object, GL_AMD_seamless_cubemap_per_texture,
GL_AMD_shader_stencil_export, GL_AMD_shader_trinary_minmax,
GL_AMD_texture_texture4, GL_AMD_vertex_shader_layer,
GL_AMD_vertex_shader_viewport_index, GL_ANGLE_texture_compression_dxt3,
GL_ANGLE_texture_compression_dxt5, GL_ARB_ES2_compatibility,
GL_ARB_ES3_1_compatibility, GL_ARB_ES3_2_compatibility,
GL_ARB_ES3_compatibility, GL_ARB_arrays_of_arrays, GL_ARB_base_instance,
GL_ARB_blend_func_extended, GL_ARB_buffer_storage,
GL_ARB_clear_buffer_object, GL_ARB_clear_texture, GL_ARB_clip_control,
GL_ARB_compressed_texture_pixel_storage, GL_ARB_compute_shader,
GL_ARB_conditional_render_inverted, GL_ARB_conservative_depth,
GL_ARB_copy_buffer, GL_ARB_copy_image, GL_ARB_cull_distance,
GL_ARB_debug_output, GL_ARB_depth_buffer_float, GL_ARB_depth_clamp,
GL_ARB_derivative_control, GL_ARB_direct_state_access,
GL_ARB_draw_buffers, GL_ARB_draw_buffers_blend,
GL_ARB_draw_elements_base_vertex, GL_ARB_draw_indirect,
GL_ARB_draw_instanced, GL_ARB_enhanced_layouts,
GL_ARB_explicit_attrib_location, GL_ARB_explicit_uniform_location,
GL_ARB_fragment_coord_conventions, GL_ARB_fragment_layer_viewport,
GL_ARB_fragment_shader, GL_ARB_fragment_shader_interlock,
GL_ARB_framebuffer_no_attachments, GL_ARB_framebuffer_object,
GL_ARB_framebuffer_sRGB, GL_ARB_get_program_binary,
GL_ARB_get_texture_sub_image, GL_ARB_gl_spirv, GL_ARB_gpu_shader5,
GL_ARB_gpu_shader_fp64, GL_ARB_gpu_shader_int64, GL_ARB_half_float_pixel,
GL_ARB_half_float_vertex, GL_ARB_indirect_parameters,
GL_ARB_instanced_arrays, GL_ARB_internalformat_query,
GL_ARB_internalformat_query2, GL_ARB_invalidate_subdata,
GL_ARB_map_buffer_alignment, GL_ARB_map_buffer_range, GL_ARB_multi_bind,
GL_ARB_multi_draw_indirect, GL_ARB_occlusion_query2,
GL_ARB_parallel_shader_compile, GL_ARB_pipeline_statistics_query,
GL_ARB_pixel_buffer_object, GL_ARB_point_sprite,
GL_ARB_polygon_offset_clamp, GL_ARB_post_depth_coverage,
GL_ARB_program_interface_query, GL_ARB_provoking_vertex,
GL_ARB_query_buffer_object, GL_ARB_robust_buffer_access_behavior,
GL_ARB_robustness, GL_ARB_sample_shading, GL_ARB_sampler_objects,
GL_ARB_seamless_cube_map, GL_ARB_seamless_cubemap_per_texture,
GL_ARB_separate_shader_objects, GL_ARB_shader_atomic_counter_ops,
GL_ARB_shader_atomic_counters, GL_ARB_shader_ballot,
GL_ARB_shader_bit_encoding, GL_ARB_shader_clock,
GL_ARB_shader_draw_parameters, GL_ARB_shader_group_vote,
GL_ARB_shader_image_load_store, GL_ARB_shader_image_size,
GL_ARB_shader_objects, GL_ARB_shader_precision,
GL_ARB_shader_stencil_export, GL_ARB_shader_storage_buffer_object,
GL_ARB_shader_subroutine, GL_ARB_shader_texture_image_samples,
GL_ARB_shader_texture_lod, GL_ARB_shader_viewport_layer_array,
GL_ARB_shading_language_420pack, GL_ARB_shading_language_include,
GL_ARB_shading_language_packing, GL_ARB_spirv_extensions,
GL_ARB_stencil_texturing, GL_ARB_sync, GL_ARB_tessellation_shader,
GL_ARB_texture_barrier, GL_ARB_texture_buffer_object,
GL_ARB_texture_buffer_object_rgb32, GL_ARB_texture_buffer_range,
GL_ARB_texture_compression_bptc, GL_ARB_texture_compression_rgtc,
GL_ARB_texture_cube_map_array, GL_ARB_texture_filter_anisotropic,
GL_ARB_texture_float, GL_ARB_texture_gather,
GL_ARB_texture_mirror_clamp_to_edge, GL_ARB_texture_multisample,
GL_ARB_texture_non_power_of_two, GL_ARB_texture_query_levels,
GL_ARB_texture_query_lod, GL_ARB_texture_rectangle, GL_ARB_texture_rg,
GL_ARB_texture_rgb10_a2ui, GL_ARB_texture_stencil8,
GL_ARB_texture_storage, GL_ARB_texture_storage_multisample,
GL_ARB_texture_swizzle, GL_ARB_texture_view, GL_ARB_timer_query,
GL_ARB_transform_feedback2, GL_ARB_transform_feedback3,
GL_ARB_transform_feedback_instanced,
GL_ARB_transform_feedback_overflow_query, GL_ARB_uniform_buffer_object,
GL_ARB_vertex_array_bgra, GL_ARB_vertex_array_object,
GL_ARB_vertex_attrib_64bit, GL_ARB_vertex_attrib_binding,
GL_ARB_vertex_buffer_object, GL_ARB_vertex_shader,
GL_ARB_vertex_type_10f_11f_11f_rev, GL_ARB_vertex_type_2_10_10_10_rev,
GL_ARB_viewport_array, GL_ATI_blend_equation_separate,
GL_ATI_texture_float, GL_EXT_EGL_image_storage, GL_EXT_EGL_sync,
GL_EXT_abgr, GL_EXT_blend_equation_separate,
GL_EXT_demote_to_helper_invocation, GL_EXT_draw_buffers2,
GL_EXT_draw_instanced, GL_EXT_framebuffer_blit,
GL_EXT_framebuffer_multisample, GL_EXT_framebuffer_multisample_blit_scaled,
GL_EXT_framebuffer_object, GL_EXT_framebuffer_sRGB,
GL_EXT_packed_depth_stencil, GL_EXT_packed_float,
GL_EXT_pixel_buffer_object, GL_EXT_polygon_offset_clamp,
GL_EXT_provoking_vertex, GL_EXT_shader_framebuffer_fetch,
GL_EXT_shader_framebuffer_fetch_non_coherent, GL_EXT_shader_integer_mix,
GL_EXT_shader_samples_identical, GL_EXT_texture_array,
GL_EXT_texture_compression_dxt1, GL_EXT_texture_compression_rgtc,
GL_EXT_texture_compression_s3tc, GL_EXT_texture_filter_anisotropic,
GL_EXT_texture_integer, GL_EXT_texture_sRGB, GL_EXT_texture_sRGB_R8,
GL_EXT_texture_sRGB_decode, GL_EXT_texture_shadow_lod,
GL_EXT_texture_shared_exponent, GL_EXT_texture_snorm,
GL_EXT_texture_swizzle, GL_EXT_timer_query, GL_EXT_transform_feedback,
GL_EXT_vertex_array_bgra, GL_EXT_vertex_attrib_64bit,
GL_IBM_multimode_draw_arrays, GL_INTEL_conservative_rasterization,
GL_INTEL_performance_query, GL_INTEL_shader_atomic_float_minmax,
GL_INTEL_shader_integer_functions2, GL_KHR_blend_equation_advanced,
GL_KHR_blend_equation_advanced_coherent, GL_KHR_context_flush_control,
GL_KHR_debug, GL_KHR_no_error, GL_KHR_parallel_shader_compile,
GL_KHR_robust_buffer_access_behavior, GL_KHR_robustness,
GL_KHR_texture_compression_astc_ldr,
GL_KHR_texture_compression_astc_sliced_3d, GL_MESA_framebuffer_flip_y,
GL_MESA_pack_invert, GL_MESA_shader_integer_functions,
GL_MESA_texture_signed_rgba, GL_NV_compute_shader_derivatives,
GL_NV_conditional_render, GL_NV_depth_clamp,
GL_NV_fragment_shader_interlock, GL_NV_packed_depth_stencil,
GL_NV_texture_barrier, GL_OES_EGL_image, GL_S3_s3tc

OpenGL version string: 4.6 (Compatibility Profile) Mesa 20.0.4
OpenGL shading language version string: 4.60
OpenGL context flags: (none)
OpenGL profile mask: compatibility profile
OpenGL extensions:
GL_3DFX_texture_compression_FXT1, GL_AMD_conservative_depth,
GL_AMD_depth_clamp_separate, GL_AMD_draw_buffers_blend,
GL_AMD_multi_draw_indirect, GL_AMD_performance_monitor,
GL_AMD_pinned_memory, GL_AMD_query_buffer_object,
GL_AMD_seamless_cubemap_per_texture, GL_AMD_shader_stencil_export,
GL_AMD_shader_trinary_minmax, GL_AMD_texture_texture4,
GL_AMD_vertex_shader_layer, GL_AMD_vertex_shader_viewport_index,
GL_ANGLE_texture_compression_dxt3, GL_ANGLE_texture_compression_dxt5,
GL_APPLE_packed_pixels, GL_ARB_ES2_compatibility,
GL_ARB_ES3_1_compatibility, GL_ARB_ES3_compatibility,
GL_ARB_arrays_of_arrays, GL_ARB_base_instance, GL_ARB_blend_func_extended,
GL_ARB_buffer_storage, GL_ARB_clear_buffer_object, GL_ARB_clear_texture,
GL_ARB_clip_control, GL_ARB_color_buffer_float, GL_ARB_compatibility,
GL_ARB_compressed_texture_pixel_storage, GL_ARB_compute_shader,
GL_ARB_conditional_render_inverted, GL_ARB_conservative_depth,
GL_ARB_copy_buffer, GL_ARB_copy_image, GL_ARB_cull_distance,
GL_ARB_debug_output, GL_ARB_depth_buffer_float, GL_ARB_depth_clamp,
GL_ARB_depth_texture, GL_ARB_derivative_control,
GL_ARB_direct_state_access, GL_ARB_draw_buffers,
GL_ARB_draw_buffers_blend, GL_ARB_draw_elements_base_vertex,
GL_ARB_draw_indirect, GL_ARB_draw_instanced, GL_ARB_enhanced_layouts,
GL_ARB_explicit_attrib_location, GL_ARB_explicit_uniform_location,
GL_ARB_fragment_coord_conventions, GL_ARB_fragment_layer_viewport,
GL_ARB_fragment_program, GL_ARB_fragment_program_shadow,
GL_ARB_fragment_shader, GL_ARB_fragment_shader_interlock,
GL_ARB_framebuffer_no_attachments, GL_ARB_framebuffer_object,
GL_ARB_framebuffer_sRGB, GL_ARB_get_program_binary,
GL_ARB_get_texture_sub_image, GL_ARB_gl_spirv, GL_ARB_gpu_shader5,
GL_ARB_gpu_shader_fp64, GL_ARB_gpu_shader_int64, GL_ARB_half_float_pixel,
GL_ARB_half_float_vertex, GL_ARB_indirect_parameters,
GL_ARB_instanced_arrays, GL_ARB_internalformat_query,
GL_ARB_internalformat_query2, GL_ARB_invalidate_subdata,
GL_ARB_map_buffer_alignment, GL_ARB_map_buffer_range, GL_ARB_multi_bind,
GL_ARB_multi_draw_indirect, GL_ARB_multisample, GL_ARB_multitexture,
GL_ARB_occlusion_query, GL_ARB_occlusion_query2,
GL_ARB_parallel_shader_compile, GL_ARB_pipeline_statistics_query,
GL_ARB_pixel_buffer_object, GL_ARB_point_parameters, GL_ARB_point_sprite,
GL_ARB_polygon_offset_clamp, GL_ARB_post_depth_coverage,
GL_ARB_program_interface_query, GL_ARB_provoking_vertex,
GL_ARB_query_buffer_object, GL_ARB_robust_buffer_access_behavior,
GL_ARB_robustness, GL_ARB_sample_shading, GL_ARB_sampler_objects,
GL_ARB_seamless_cube_map, GL_ARB_seamless_cubemap_per_texture,
GL_ARB_separate_shader_objects, GL_ARB_shader_atomic_counter_ops,
GL_ARB_shader_atomic_counters, GL_ARB_shader_ballot,
GL_ARB_shader_bit_encoding, GL_ARB_shader_clock,
GL_ARB_shader_draw_parameters, GL_ARB_shader_group_vote,
GL_ARB_shader_image_load_store, GL_ARB_shader_image_size,
GL_ARB_shader_objects, GL_ARB_shader_precision,
GL_ARB_shader_stencil_export, GL_ARB_shader_storage_buffer_object,
GL_ARB_shader_subroutine, GL_ARB_shader_texture_image_samples,
GL_ARB_shader_texture_lod, GL_ARB_shader_viewport_layer_array,
GL_ARB_shading_language_100, GL_ARB_shading_language_420pack,
GL_ARB_shading_language_include, GL_ARB_shading_language_packing,
GL_ARB_shadow, GL_ARB_spirv_extensions, GL_ARB_stencil_texturing,
GL_ARB_sync, GL_ARB_tessellation_shader, GL_ARB_texture_barrier,
GL_ARB_texture_border_clamp, GL_ARB_texture_buffer_object,
GL_ARB_texture_buffer_object_rgb32, GL_ARB_texture_buffer_range,
GL_ARB_texture_compression, GL_ARB_texture_compression_bptc,
GL_ARB_texture_compression_rgtc, GL_ARB_texture_cube_map,
GL_ARB_texture_cube_map_array, GL_ARB_texture_env_add,
GL_ARB_texture_env_combine, GL_ARB_texture_env_crossbar,
GL_ARB_texture_env_dot3, GL_ARB_texture_filter_anisotropic,
GL_ARB_texture_float, GL_ARB_texture_gather,
GL_ARB_texture_mirror_clamp_to_edge, GL_ARB_texture_mirrored_repeat,
GL_ARB_texture_multisample, GL_ARB_texture_non_power_of_two,
GL_ARB_texture_query_levels, GL_ARB_texture_query_lod,
GL_ARB_texture_rectangle, GL_ARB_texture_rg, GL_ARB_texture_rgb10_a2ui,
GL_ARB_texture_stencil8, GL_ARB_texture_storage,
GL_ARB_texture_storage_multisample, GL_ARB_texture_swizzle,
GL_ARB_texture_view, GL_ARB_timer_query, GL_ARB_transform_feedback2,
GL_ARB_transform_feedback3, GL_ARB_transform_feedback_instanced,
GL_ARB_transform_feedback_overflow_query, GL_ARB_transpose_matrix,
GL_ARB_uniform_buffer_object, GL_ARB_vertex_array_bgra,
GL_ARB_vertex_array_object, GL_ARB_vertex_attrib_64bit,
GL_ARB_vertex_attrib_binding, GL_ARB_vertex_buffer_object,
GL_ARB_vertex_program, GL_ARB_vertex_shader,
GL_ARB_vertex_type_10f_11f_11f_rev, GL_ARB_vertex_type_2_10_10_10_rev,
GL_ARB_viewport_array, GL_ARB_window_pos, GL_ATI_blend_equation_separate,
GL_ATI_draw_buffers, GL_ATI_fragment_shader, GL_ATI_separate_stencil,
GL_ATI_texture_env_combine3, GL_ATI_texture_float,
GL_EXT_EGL_image_storage, GL_EXT_EGL_sync, GL_EXT_abgr, GL_EXT_bgra,
GL_EXT_blend_color, GL_EXT_blend_equation_separate,
GL_EXT_blend_func_separate, GL_EXT_blend_minmax, GL_EXT_blend_subtract,
GL_EXT_compiled_vertex_array, GL_EXT_copy_texture,
GL_EXT_demote_to_helper_invocation, GL_EXT_direct_state_access,
GL_EXT_draw_buffers2, GL_EXT_draw_instanced, GL_EXT_draw_range_elements,
GL_EXT_fog_coord, GL_EXT_framebuffer_blit, GL_EXT_framebuffer_multisample,
GL_EXT_framebuffer_multisample_blit_scaled, GL_EXT_framebuffer_object,
GL_EXT_framebuffer_sRGB, GL_EXT_gpu_program_parameters,
GL_EXT_gpu_shader4, GL_EXT_multi_draw_arrays, GL_EXT_packed_depth_stencil,
GL_EXT_packed_float, GL_EXT_packed_pixels, GL_EXT_pixel_buffer_object,
GL_EXT_point_parameters, GL_EXT_polygon_offset_clamp,
GL_EXT_provoking_vertex, GL_EXT_rescale_normal, GL_EXT_secondary_color,
GL_EXT_separate_specular_color, GL_EXT_shader_framebuffer_fetch,
GL_EXT_shader_framebuffer_fetch_non_coherent, GL_EXT_shader_integer_mix,
GL_EXT_shader_samples_identical, GL_EXT_shadow_funcs,
GL_EXT_stencil_two_side, GL_EXT_stencil_wrap, GL_EXT_subtexture,
GL_EXT_texture, GL_EXT_texture3D, GL_EXT_texture_array,
GL_EXT_texture_buffer_object, GL_EXT_texture_compression_dxt1,
GL_EXT_texture_compression_rgtc, GL_EXT_texture_compression_s3tc,
GL_EXT_texture_cube_map, GL_EXT_texture_edge_clamp,
GL_EXT_texture_env_add, GL_EXT_texture_env_combine,
GL_EXT_texture_env_dot3, GL_EXT_texture_filter_anisotropic,
GL_EXT_texture_integer, GL_EXT_texture_lod_bias, GL_EXT_texture_object,
GL_EXT_texture_rectangle, GL_EXT_texture_sRGB, GL_EXT_texture_sRGB_R8,
GL_EXT_texture_sRGB_decode, GL_EXT_texture_shadow_lod,
GL_EXT_texture_shared_exponent, GL_EXT_texture_snorm,
GL_EXT_texture_swizzle, GL_EXT_timer_query, GL_EXT_transform_feedback,
GL_EXT_vertex_array, GL_EXT_vertex_array_bgra, GL_EXT_vertex_attrib_64bit,
GL_IBM_multimode_draw_arrays, GL_IBM_rasterpos_clip,
GL_IBM_texture_mirrored_repeat, GL_INGR_blend_func_separate,
GL_INTEL_performance_query, GL_INTEL_shader_atomic_float_minmax,
GL_INTEL_shader_integer_functions2, GL_KHR_blend_equation_advanced,
GL_KHR_blend_equation_advanced_coherent, GL_KHR_context_flush_control,
GL_KHR_debug, GL_KHR_no_error, GL_KHR_parallel_shader_compile,
GL_KHR_robust_buffer_access_behavior, GL_KHR_robustness,
GL_KHR_texture_compression_astc_ldr,
GL_KHR_texture_compression_astc_sliced_3d, GL_MESA_framebuffer_flip_y,
GL_MESA_pack_invert, GL_MESA_shader_integer_functions,
GL_MESA_texture_signed_rgba, GL_MESA_window_pos, GL_NV_blend_square,
GL_NV_compute_shader_derivatives, GL_NV_conditional_render,
GL_NV_depth_clamp, GL_NV_fog_distance, GL_NV_fragment_shader_interlock,
GL_NV_light_max_exponent, GL_NV_packed_depth_stencil,
GL_NV_primitive_restart, GL_NV_texgen_reflection, GL_NV_texture_barrier,
GL_NV_texture_env_combine4, GL_NV_texture_rectangle, GL_OES_EGL_image,
GL_OES_read_format, GL_S3_s3tc, GL_SGIS_generate_mipmap,
GL_SGIS_texture_border_clamp, GL_SGIS_texture_edge_clamp,
GL_SGIS_texture_lod, GL_SUN_multi_draw_arrays

OpenGL ES profile version string: OpenGL ES 3.2 Mesa 20.0.4
OpenGL ES profile shading language version string: OpenGL ES GLSL ES 3.20
OpenGL ES profile extensions:
GL_AMD_performance_monitor, GL_ANDROID_extension_pack_es31a,
GL_ANGLE_texture_compression_dxt3, GL_ANGLE_texture_compression_dxt5,
GL_APPLE_texture_max_level, GL_EXT_EGL_image_storage,
GL_EXT_base_instance, GL_EXT_blend_func_extended, GL_EXT_blend_minmax,
GL_EXT_buffer_storage, GL_EXT_clip_control, GL_EXT_clip_cull_distance,
GL_EXT_color_buffer_float, GL_EXT_compressed_ETC1_RGB8_sub_texture,
GL_EXT_copy_image, GL_EXT_demote_to_helper_invocation, GL_EXT_depth_clamp,
GL_EXT_discard_framebuffer, GL_EXT_disjoint_timer_query,
GL_EXT_draw_buffers, GL_EXT_draw_buffers_indexed,
GL_EXT_draw_elements_base_vertex, GL_EXT_float_blend, GL_EXT_frag_depth,
GL_EXT_geometry_point_size, GL_EXT_geometry_shader, GL_EXT_gpu_shader5,
GL_EXT_map_buffer_range, GL_EXT_multi_draw_arrays,
GL_EXT_occlusion_query_boolean, GL_EXT_polygon_offset_clamp,
GL_EXT_primitive_bounding_box, GL_EXT_read_format_bgra,
GL_EXT_render_snorm, GL_EXT_robustness, GL_EXT_sRGB_write_control,
GL_EXT_separate_shader_objects, GL_EXT_shader_framebuffer_fetch,
GL_EXT_shader_framebuffer_fetch_non_coherent,
GL_EXT_shader_implicit_conversions, GL_EXT_shader_integer_mix,
GL_EXT_shader_io_blocks, GL_EXT_shader_samples_identical,
GL_EXT_tessellation_point_size, GL_EXT_tessellation_shader,
GL_EXT_texture_border_clamp, GL_EXT_texture_buffer,
GL_EXT_texture_compression_bptc, GL_EXT_texture_compression_dxt1,
GL_EXT_texture_compression_rgtc, GL_EXT_texture_compression_s3tc,
GL_EXT_texture_compression_s3tc_srgb, GL_EXT_texture_cube_map_array,
GL_EXT_texture_filter_anisotropic, GL_EXT_texture_format_BGRA8888,
GL_EXT_texture_norm16, GL_EXT_texture_query_lod, GL_EXT_texture_rg,
GL_EXT_texture_sRGB_R8, GL_EXT_texture_sRGB_decode,
GL_EXT_texture_shadow_lod, GL_EXT_texture_type_2_10_10_10_REV,
GL_EXT_texture_view, GL_EXT_unpack_subimage,
GL_INTEL_conservative_rasterization, GL_INTEL_performance_query,
GL_KHR_blend_equation_advanced, GL_KHR_blend_equation_advanced_coherent,
GL_KHR_context_flush_control, GL_KHR_debug, GL_KHR_no_error,
GL_KHR_parallel_shader_compile, GL_KHR_robust_buffer_access_behavior,
GL_KHR_robustness, GL_KHR_texture_compression_astc_ldr,
GL_KHR_texture_compression_astc_sliced_3d, GL_MESA_framebuffer_flip_y,
GL_MESA_shader_integer_functions, GL_NV_compute_shader_derivatives,
GL_NV_conditional_render, GL_NV_draw_buffers, GL_NV_fbo_color_attachments,
GL_NV_fragment_shader_interlock, GL_NV_image_formats, GL_NV_read_buffer,
GL_NV_read_depth, GL_NV_read_depth_stencil, GL_NV_read_stencil,
GL_OES_EGL_image, GL_OES_EGL_image_external,
GL_OES_EGL_image_external_essl3, GL_OES_EGL_sync,
GL_OES_compressed_ETC1_RGB8_texture, GL_OES_copy_image, GL_OES_depth24,
GL_OES_depth_texture, GL_OES_depth_texture_cube_map,
GL_OES_draw_buffers_indexed, GL_OES_draw_elements_base_vertex,
GL_OES_element_index_uint, GL_OES_fbo_render_mipmap,
GL_OES_geometry_point_size, GL_OES_geometry_shader,
GL_OES_get_program_binary, GL_OES_gpu_shader5, GL_OES_mapbuffer,
GL_OES_packed_depth_stencil, GL_OES_primitive_bounding_box,
GL_OES_required_internalformat, GL_OES_rgb8_rgba8, GL_OES_sample_shading,
GL_OES_sample_variables, GL_OES_shader_image_atomic,
GL_OES_shader_io_blocks, GL_OES_shader_multisample_interpolation,
GL_OES_standard_derivatives, GL_OES_stencil8, GL_OES_surfaceless_context,
GL_OES_tessellation_point_size, GL_OES_tessellation_shader,
GL_OES_texture_3D, GL_OES_texture_border_clamp, GL_OES_texture_buffer,
GL_OES_texture_cube_map_array, GL_OES_texture_float,
GL_OES_texture_float_linear, GL_OES_texture_half_float,
GL_OES_texture_half_float_linear, GL_OES_texture_npot,
GL_OES_texture_stencil8, GL_OES_texture_storage_multisample_2d_array,
GL_OES_texture_view, GL_OES_vertex_array_object, GL_OES_vertex_half_float,
GL_OES_viewport_array

Adding WMTS Layer Feature

Prerequisites

Please fulfill the following requirements before submitting an issue to this repository.

• Check the "Common Problems" page on the WorldWind website: https://worldwind.arc.nasa.gov/java/tutorials/common-problems
• Check that your issue isn't already filed: https://github.com/NASAWorldWind/WorldWindJava/issues
• Check the WorldWind forum for common solutions: https://forum.worldwindcentral.com/forum/world-wind-java-forums

Description

Although there is WMTS layer implementation in WorldWind Android and WorldWind Kotlin, there is no WMTS layer feature in WorldWind Java

Steps to Reproduce

1. None

Expected behavior: WorldWind Java to have WMTS Layer feature

Actual behavior: WorldWind Java does not have WMTS layer feature

Reproduces how often:

Operating System and Version

Windows, Linux, MacOS

Additional Information

None

Update issue template for community edition

Update the ISSUE_TEMPLATE.md file for the community edition. Objectives include:

• Update links
• Simplify

Perform continuous integration with multiple versions of Java

Consider modifying the .travis.yml to test the WorldWindJava build with multiple versions of Java, for instance:

• openjdk8
• oraclejdk8
• oraclejdk9
• oraclejdk11

See: https://docs.travis-ci.com/user/languages/java/#testing-against-multiple-jdks

Terrain profile doesn't display on 2D globe

Migrated issue from: NASAWorldWind#55.

The TerrainProfile example exposes a flat globe option, which when selected, causes the terrain profile window to disappear.

I just ran the TerrainProfiler example and it still seems to be an issue in the latest build.

3D Globe:

Flat Globe:

Update and enable TravisCI for community edition

Update .travis.yml and enable TravisCI for the WorldWindEarth organization.

• Activate TravisCI for WorldWindEarth/WorldWindJava
• Update .travis.yml to publish API docs
• Update .travis.yml to publish releases