import mil.nga.geopackage.tiles.user.TileDao; //导入依赖的package包/类
/**
 * Create the elevation tile table with metadata and extension
 *
 * @param geoPackage
 * @param tableName
 * @param contentsBoundingBox
 * @param contentsSrsId
 * @param tileMatrixSetBoundingBox
 * @param tileMatrixSetSrsId
 * @return elevation tiles
 */
public static ElevationTilesPng createTileTableWithMetadata(
        GeoPackage geoPackage, String tableName,
        BoundingBox contentsBoundingBox, long contentsSrsId,
        BoundingBox tileMatrixSetBoundingBox, long tileMatrixSetSrsId) {

    TileMatrixSet tileMatrixSet = ElevationTilesCore
            .createTileTableWithMetadata(geoPackage, tableName,
                    contentsBoundingBox, contentsSrsId,
                    tileMatrixSetBoundingBox, tileMatrixSetSrsId);
    TileDao tileDao = geoPackage.getTileDao(tileMatrixSet);
    ElevationTilesPng elevationTiles = new ElevationTilesPng(geoPackage, tileDao);
    elevationTiles.getOrCreate();

    return elevationTiles;
}
 

import mil.nga.geopackage.tiles.user.TileDao; //导入依赖的package包/类
/**
 * Create the elevation tile table with metadata and extension
 *
 * @param geoPackage
 * @param tableName
 * @param contentsBoundingBox
 * @param contentsSrsId
 * @param tileMatrixSetBoundingBox
 * @param tileMatrixSetSrsId
 * @return elevation tiles
 */
public static ElevationTilesTiff createTileTableWithMetadata(
        GeoPackage geoPackage, String tableName,
        BoundingBox contentsBoundingBox, long contentsSrsId,
        BoundingBox tileMatrixSetBoundingBox, long tileMatrixSetSrsId) {

    TileMatrixSet tileMatrixSet = ElevationTilesCore
            .createTileTableWithMetadata(geoPackage, tableName,
                    contentsBoundingBox, contentsSrsId,
                    tileMatrixSetBoundingBox, tileMatrixSetSrsId);
    TileDao tileDao = geoPackage.getTileDao(tileMatrixSet);
    ElevationTilesTiff elevationTiles = new ElevationTilesTiff(geoPackage,
            tileDao);
    elevationTiles.getOrCreate();

    return elevationTiles;
}
 

import mil.nga.geopackage.tiles.user.TileDao; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public TileDao getTileDao(Contents contents) {

    if (contents == null) {
        throw new GeoPackageException("Non null "
                + Contents.class.getSimpleName()
                + " is required to create " + TileDao.class.getSimpleName());
    }

    TileMatrixSet tileMatrixSet = contents.getTileMatrixSet();
    if (tileMatrixSet == null) {
        throw new GeoPackageException("No "
                + TileMatrixSet.class.getSimpleName() + " exists for "
                + Contents.class.getSimpleName() + " " + contents.getId());
    }

    return getTileDao(tileMatrixSet);
}
 

import mil.nga.geopackage.tiles.user.TileDao; //导入依赖的package包/类
/**
 * Create the elevation tile table with metadata and extension
 * 
 * @param geoPackage
 * @param tableName
 * @param contentsBoundingBox
 * @param contentsSrsId
 * @param tileMatrixSetBoundingBox
 * @param tileMatrixSetSrsId
 * @return elevation tiles
 */
public static ElevationTilesPng createTileTableWithMetadata(
		GeoPackage geoPackage, String tableName,
		BoundingBox contentsBoundingBox, long contentsSrsId,
		BoundingBox tileMatrixSetBoundingBox, long tileMatrixSetSrsId) {

	TileMatrixSet tileMatrixSet = ElevationTilesCore
			.createTileTableWithMetadata(geoPackage, tableName,
					contentsBoundingBox, contentsSrsId,
					tileMatrixSetBoundingBox, tileMatrixSetSrsId);
	TileDao tileDao = geoPackage.getTileDao(tileMatrixSet);
	ElevationTilesPng elevationTiles = new ElevationTilesPng(geoPackage,
			tileDao);
	elevationTiles.getOrCreate();

	return elevationTiles;
}
 

import mil.nga.geopackage.tiles.user.TileDao; //导入依赖的package包/类
/**
 * Create the elevation tile table with metadata and extension
 *
 * @param geoPackage
 * @param tableName
 * @param contentsBoundingBox
 * @param contentsSrsId
 * @param tileMatrixSetBoundingBox
 * @param tileMatrixSetSrsId
 * @return elevation tiles
 */
public static ElevationTilesTiff createTileTableWithMetadata(
		GeoPackage geoPackage, String tableName,
		BoundingBox contentsBoundingBox, long contentsSrsId,
		BoundingBox tileMatrixSetBoundingBox, long tileMatrixSetSrsId) {

	TileMatrixSet tileMatrixSet = ElevationTilesCore
			.createTileTableWithMetadata(geoPackage, tableName,
					contentsBoundingBox, contentsSrsId,
					tileMatrixSetBoundingBox, tileMatrixSetSrsId);
	TileDao tileDao = geoPackage.getTileDao(tileMatrixSet);
	ElevationTilesTiff elevationTiles = new ElevationTilesTiff(geoPackage,
			tileDao);
	elevationTiles.getOrCreate();

	return elevationTiles;
}
 

import mil.nga.geopackage.tiles.user.TileDao; //导入依赖的package包/类
/**
 * returns ALL available raster tile sources for all "imported" geopackage databases
 *
 * @return
 */
public List<GeopackageRasterTileSource> getTileSources() {
    List<GeopackageRasterTileSource> srcs = new ArrayList<>();

    List<String> databases = manager.databases();
    for (int i = 0; i < databases.size(); i++) {

        GeoPackage open = manager.open(databases.get(i));
        List<String> tileTables = open.getTileTables();
        for (int k = 0; k < tileTables.size(); k++) {
            TileDao tileDao = open.getTileDao(tileTables.get(k));
            mil.nga.geopackage.BoundingBox boundingBox = tileDao.getBoundingBox();
            ProjectionTransform transformation = tileDao.getProjection().getTransformation(tileDao.getProjection());
            boundingBox = transformation.transform(boundingBox);
            BoundingBox bounds = new BoundingBox(boundingBox.getMaxLatitude(), boundingBox.getMaxLongitude(), boundingBox.getMinLatitude(), boundingBox.getMinLongitude());
            srcs.add(new GeopackageRasterTileSource(databases.get(i), tileTables.get(k), (int)tileDao.getMinZoom(), (int)tileDao.getMaxZoom(), bounds));

        }
        open.close();
    }

    return srcs;
}
 

import mil.nga.geopackage.tiles.user.TileDao; //导入依赖的package包/类
public GeopackageRasterTileSource getTileSource(String database, String table) {
    Iterator<GeoPackage> iterator = geopackage.tileSources.iterator();
    while (iterator.hasNext()){
        GeoPackage next = iterator.next();
        if (next.getName().equalsIgnoreCase(database)) {
            //found the database
            if (next.getTileTables().contains(table)) {
                //find the tile table
                TileDao tileDao = next.getTileDao(table);
                mil.nga.geopackage.BoundingBox boundingBox = tileDao.getBoundingBox();
                ProjectionTransform transformation = tileDao.getProjection().getTransformation(tileDao.getProjection());
                boundingBox=transformation.transform(boundingBox);
                BoundingBox bounds =new BoundingBox(boundingBox.getMaxLatitude(),boundingBox.getMaxLongitude(),boundingBox.getMinLatitude(),boundingBox.getMinLongitude());
                return new GeopackageRasterTileSource(database,table, (int)tileDao.getMinZoom(),(int)tileDao.getMaxZoom(), bounds);
            }
        }
    }

    return null;
}
 

import mil.nga.geopackage.tiles.user.TileDao; //导入依赖的package包/类
/**
 * Ignore drawing tiles if they exist in the tile tables represented by the tile daos
 *
 * @param tileDaos tile data access objects
 * @since 1.2.6
 */
public void ignoreTileDaos(List<TileDao> tileDaos) {

    for (TileDao tileDao : tileDaos) {
        ignoreTileDao(tileDao);
    }

}
 

import mil.nga.geopackage.tiles.user.TileDao; //导入依赖的package包/类
/**
 * Get a Bounded Overlay Tile Provider for the Tile DAO
 *
 * @param tileDao
 * @return bounded overlay
 * @since 1.2.5
 */
public static BoundedOverlay getBoundedOverlay(TileDao tileDao) {

    BoundedOverlay overlay = null;

    if (tileDao.isGoogleTiles()) {
        overlay = new GoogleAPIGeoPackageOverlay(tileDao);
    } else {
        overlay = new GeoPackageOverlay(tileDao);
    }

    return overlay;
}
 

import mil.nga.geopackage.tiles.user.TileDao; //导入依赖的package包/类
/**
 * Query for the tile tables linked to a feature table and return tile DAOs
 * to those tables
 *
 * @param featureTable feature table
 * @return tiles DAOs
 */
public List<TileDao> getTileDaosForFeatureTable(String featureTable) {

    List<TileDao> tileDaos = new ArrayList<TileDao>();

    List<String> tileTables = getTileTablesForFeatureTable(featureTable);
    for (String tileTable : tileTables) {
        if (geoPackage.isTileTable(tileTable)) {
            TileDao tileDao = geoPackage.getTileDao(tileTable);
            tileDaos.add(tileDao);
        }
    }

    return tileDaos;
}
 

import mil.nga.geopackage.tiles.user.TileDao; //导入依赖的package包/类
/**
 * Constructor, specified tile size and projection
 *
 * @param tileDao           tile dao
 * @param width             requested width
 * @param height            requested height
 * @param requestProjection requested projection
 */
public TileCreator(TileDao tileDao, Integer width, Integer height, Projection requestProjection) {
    this.tileDao = tileDao;
    this.width = width;
    this.height = height;
    this.requestProjection = requestProjection;

    tileMatrixSet = tileDao.getTileMatrixSet();
    tilesProjection = ProjectionFactory.getProjection(tileDao.getTileMatrixSet().getSrs());
    tileSetBoundingBox = tileMatrixSet.getBoundingBox();

    // Check if the projections have the same units
    sameProjection = (requestProjection.getUnit().name.equals(tilesProjection.getUnit().name));
}
 

import mil.nga.geopackage.tiles.user.TileDao; //导入依赖的package包/类
/**
 * Get the elevation at the coordinate
 *
 * @param geoPackage GeoPackage
 * @param algorithm  algorithm
 * @param latitude   latitude
 * @param longitude  longitude
 * @return elevation
 * @throws Exception
 */
public static Double getElevation(GeoPackage geoPackage,
                                  ElevationTilesAlgorithm algorithm, double latitude,
                                  double longitude, long epsg) throws Exception {

    Double elevation = null;

    List<String> elevationTables = ElevationTilesPng.getTables(geoPackage);
    TileMatrixSetDao dao = geoPackage.getTileMatrixSetDao();

    for (String elevationTable : elevationTables) {

        TileMatrixSet tileMatrixSet = dao.queryForId(elevationTable);
        TileDao tileDao = geoPackage.getTileDao(tileMatrixSet);

        Projection requestProjection = ProjectionFactory
                .getProjection(epsg);

        // Test getting the elevation of a single coordinate
        ElevationTilesPng elevationTiles = new ElevationTilesPng(geoPackage,
                tileDao, requestProjection);
        elevationTiles.setAlgorithm(algorithm);
        elevation = elevationTiles.getElevation(latitude, longitude);
    }

    return elevation;
}
 

import mil.nga.geopackage.tiles.user.TileDao; //导入依赖的package包/类
/**
 * Get the elevations for the bounding box
 *
 * @param geoPackage  GeoPackage
 * @param algorithm   algorithm
 * @param boundingBox bounding box
 * @param width       results width
 * @param width       results height
 * @return elevation tile results
 * @throws Exception
 */
public static ElevationTileResults getElevations(GeoPackage geoPackage,
                                                 ElevationTilesAlgorithm algorithm, BoundingBox boundingBox,
                                                 int width, int height, long epsg) throws Exception {

    ElevationTileResults elevations = null;

    List<String> elevationTables = ElevationTilesPng.getTables(geoPackage);
    TileMatrixSetDao dao = geoPackage.getTileMatrixSetDao();

    for (String elevationTable : elevationTables) {

        TileMatrixSet tileMatrixSet = dao.queryForId(elevationTable);
        TileDao tileDao = geoPackage.getTileDao(tileMatrixSet);

        Projection requestProjection = ProjectionFactory
                .getProjection(epsg);

        // Test getting the elevation of a single coordinate
        ElevationTilesPng elevationTiles = new ElevationTilesPng(geoPackage,
                tileDao, requestProjection);
        elevationTiles.setAlgorithm(algorithm);
        elevationTiles.setWidth(width);
        elevationTiles.setHeight(height);
        elevations = elevationTiles.getElevations(boundingBox);
    }

    return elevations;
}
 

import mil.nga.geopackage.tiles.user.TileDao; //导入依赖的package包/类
/**
 * Get the elevation at the coordinate
 *
 * @param geoPackage GeoPackage
 * @param algorithm  algorithm
 * @param latitude   latitude
 * @param longitude  longitude
 * @return elevation
 * @throws Exception
 */
public static Double getElevation(GeoPackage geoPackage,
                                  ElevationTilesAlgorithm algorithm, double latitude,
                                  double longitude, long epsg) throws Exception {

    Double elevation = null;

    List<String> elevationTables = ElevationTilesTiff.getTables(geoPackage);
    TileMatrixSetDao dao = geoPackage.getTileMatrixSetDao();

    for (String elevationTable : elevationTables) {

        TileMatrixSet tileMatrixSet = dao.queryForId(elevationTable);
        TileDao tileDao = geoPackage.getTileDao(tileMatrixSet);

        Projection requestProjection = ProjectionFactory
                .getProjection(epsg);

        // Test getting the elevation of a single coordinate
        ElevationTilesTiff elevationTiles = new ElevationTilesTiff(
                geoPackage, tileDao, requestProjection);
        elevationTiles.setAlgorithm(algorithm);
        elevation = elevationTiles.getElevation(latitude, longitude);
    }

    return elevation;
}
 

import mil.nga.geopackage.tiles.user.TileDao; //导入依赖的package包/类
/**
 * Get the elevations for the bounding box
 *
 * @param geoPackage  GeoPackage
 * @param algorithm   algorithm
 * @param boundingBox bounding box
 * @param width       results width
 * @param width       results height
 * @return elevation tile results
 * @throws Exception
 */
public static ElevationTileResults getElevations(GeoPackage geoPackage,
                                                 ElevationTilesAlgorithm algorithm, BoundingBox boundingBox,
                                                 int width, int height, long epsg) throws Exception {

    ElevationTileResults elevations = null;

    List<String> elevationTables = ElevationTilesTiff.getTables(geoPackage);
    TileMatrixSetDao dao = geoPackage.getTileMatrixSetDao();

    for (String elevationTable : elevationTables) {

        TileMatrixSet tileMatrixSet = dao.queryForId(elevationTable);
        TileDao tileDao = geoPackage.getTileDao(tileMatrixSet);

        Projection requestProjection = ProjectionFactory
                .getProjection(epsg);

        // Test getting the elevation of a single coordinate
        ElevationTilesTiff elevationTiles = new ElevationTilesTiff(
                geoPackage, tileDao, requestProjection);
        elevationTiles.setAlgorithm(algorithm);
        elevationTiles.setWidth(width);
        elevationTiles.setHeight(height);
        elevations = elevationTiles.getElevations(boundingBox);
    }

    return elevations;
}
 

import mil.nga.geopackage.tiles.user.TileDao; //导入依赖的package包/类
/**
 * Display tiles
 *
 * @param tiles
 */
private void displayTiles(GeoPackageTileTable tiles) {

    GeoPackage geoPackage = geoPackages.get(tiles.getDatabase());

    TileDao tileDao = geoPackage.getTileDao(tiles.getName());

    BoundedOverlay overlay = GeoPackageOverlayFactory
            .getBoundedOverlay(tileDao);

    TileMatrixSet tileMatrixSet = tileDao.getTileMatrixSet();

    FeatureTileTableLinker linker = new FeatureTileTableLinker(geoPackage);
    List<FeatureDao> featureDaos = linker.getFeatureDaosForTileTable(tileDao.getTableName());
    for (FeatureDao featureDao : featureDaos) {

        // Create the feature tiles
        FeatureTiles featureTiles = new DefaultFeatureTiles(getActivity(), featureDao);

        // Create an index manager
        FeatureIndexManager indexer = new FeatureIndexManager(getActivity(), geoPackage, featureDao);
        featureTiles.setIndexManager(indexer);

        featureOverlayTiles = true;

        // Add the feature overlay query
        FeatureOverlayQuery featureOverlayQuery = new FeatureOverlayQuery(getActivity(), overlay, featureTiles);
        featureOverlayQueries.add(featureOverlayQuery);
    }

    // Set the tiles index to be -2 of it is behind features and tiles drawn from features
    int zIndex = -2;

    // If these tiles are linked to features, set the zIndex to -1 so they are placed before imagery tiles
    if (!featureDaos.isEmpty()) {
        zIndex = -1;
    }

    displayTiles(overlay, tileMatrixSet.getBoundingBox(), tileMatrixSet.getSrs(), zIndex, null);
}
 

import mil.nga.geopackage.tiles.user.TileDao; //导入依赖的package包/类
/**
 * Query for the tile tables linked to a feature table and return tile DAOs
 * to those tables
 * 
 * @param featureTable
 *            feature table
 * @return tiles DAOs
 */
public List<TileDao> getTileDaosForFeatureTable(String featureTable) {

	List<TileDao> tileDaos = new ArrayList<TileDao>();

	List<String> tileTables = getTileTablesForFeatureTable(featureTable);
	for (String tileTable : tileTables) {
		if (geoPackage.isTileTable(tileTable)) {
			TileDao tileDao = geoPackage.getTileDao(tileTable);
			tileDaos.add(tileDao);
		}
	}

	return tileDaos;
}
 

import mil.nga.geopackage.tiles.user.TileDao; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public TileDao getTileDao(Contents contents) {

	if (contents == null) {
		throw new GeoPackageException("Non null "
				+ Contents.class.getSimpleName()
				+ " is required to create " + TileDao.class.getSimpleName());
	}

	TileMatrixSet tileMatrixSet = null;
	try {
		tileMatrixSet = getTileMatrixSetDao().queryForId(
				contents.getTableName());
	} catch (SQLException e) {
		throw new GeoPackageException("No "
				+ TileMatrixSet.class.getSimpleName()
				+ " could be retrieved for "
				+ Contents.class.getSimpleName() + " " + contents.getId());
	}

	if (tileMatrixSet == null) {
		throw new GeoPackageException("No "
				+ TileMatrixSet.class.getSimpleName() + " exists for "
				+ Contents.class.getSimpleName() + " " + contents.getId());
	}

	return getTileDao(tileMatrixSet);
}
 

import mil.nga.geopackage.tiles.user.TileDao; //导入依赖的package包/类
/**
 * Constructor
 *
 * @param tileDao
 * @param width
 * @param height
 * @param requestProjection
 * @param imageFormat
 */
public TileCreator(TileDao tileDao, Integer width, Integer height,
		Projection requestProjection, String imageFormat) {
	this.tileDao = tileDao;
	this.width = width;
	this.height = height;
	this.requestProjection = requestProjection;
	this.imageFormat = imageFormat;

	if (imageFormat == null && (width != null || height != null)) {
		throw new GeoPackageException(
				"The width and height request size can not be specified when requesting raw tiles (no image format specified)");
	}

	tileMatrixSet = tileDao.getTileMatrixSet();
	tilesProjection = ProjectionFactory.getProjection(tileDao
			.getTileMatrixSet().getSrs());
	tileSetBoundingBox = tileMatrixSet.getBoundingBox();

	// Check if the projections have the same units
	sameProjection = (requestProjection.getUnit().name
			.equals(tilesProjection.getUnit().name));

	if (imageFormat == null && !sameProjection) {
		throw new GeoPackageException(
				"The requested projection must be the same as the stored tiles when requesting raw tiles (no image format specified)");
	}
}
 

import mil.nga.geopackage.tiles.user.TileDao; //导入依赖的package包/类
/**
 * Build text from a tile table
 * 
 * @param table
 *            tile table
 * @return text
 */
public String tileTable(String table) {

	StringBuilder output = new StringBuilder();
	TileDao tileDao = geoPackage.getTileDao(table);
	output.append("Table Name: " + tileDao.getTableName());
	long minZoom = tileDao.getMinZoom();
	long maxZoom = tileDao.getMaxZoom();
	output.append("\nMin Zoom: " + minZoom);
	output.append("\nMax Zoom: " + maxZoom);
	output.append("\nTiles: " + tileDao.count());

	TileMatrixSet tileMatrixSet = tileDao.getTileMatrixSet();

	output.append("\n\nContents\n\n").append(
			textOutput(tileMatrixSet.getContents()));

	output.append("\n\nTile Matrix Set\n\n").append(
			textOutput(tileMatrixSet));

	output.append("\n\n Tile Matrices");

	for (long zoom = minZoom; zoom <= maxZoom; zoom++) {
		TileMatrix tileMatrix = tileDao.getTileMatrix(zoom);
		if (tileMatrix != null) {
			output.append("\n\n").append(textOutput(tileMatrix));
			output.append("\n\tTiles: " + tileDao.count(zoom));
			BoundingBox boundingBox = tileDao.getBoundingBox(zoom);
			output.append("\n\tTile Bounds: \n").append(
					textOutput(boundingBox));
		}
	}

	return output.toString();
}