import mil.nga.geopackage.features.user.FeatureDao; //导入依赖的package包/类
/**
 * Constructor
 *
 * @param context
 * @param boundedOverlay
 * @param featureTiles
 * @since 1.2.5
 */
public FeatureOverlayQuery(Context context, BoundedOverlay boundedOverlay, FeatureTiles featureTiles) {
    this.boundedOverlay = boundedOverlay;
    this.featureTiles = featureTiles;

    Resources resources = context.getResources();

    // Get the screen percentage to determine when a feature is clicked
    TypedValue screenPercentage = new TypedValue();
    resources.getValue(R.dimen.map_feature_overlay_click_screen_percentage, screenPercentage, true);
    screenClickPercentage = screenPercentage.getFloat();

    maxFeaturesInfo = resources.getBoolean(R.bool.map_feature_overlay_max_features_info);
    featuresInfo = resources.getBoolean(R.bool.map_feature_overlay_features_info);

    FeatureDao featureDao = featureTiles.getFeatureDao();
    featureInfoBuilder = new FeatureInfoBuilder(context, featureDao);
}
 

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

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

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

    return getFeatureDao(geometryColumns);
}
 

import mil.nga.geopackage.features.user.FeatureDao; //导入依赖的package包/类
/**
 * Create feature dao
 *
 * @return
 */
public static FeatureDao createFeatureDao(GeoPackage geoPackage) {

    BoundingBox boundingBox = new BoundingBox();

    GeometryColumns geometryColumns = new GeometryColumns();
    geometryColumns.setId(new TableColumnKey("feature_tiles",
            "geom"));
    geometryColumns.setGeometryType(GeometryType.GEOMETRY);
    geometryColumns.setZ((byte) 0);
    geometryColumns.setM((byte) 0);

    geoPackage.createFeatureTableWithMetadata(
            geometryColumns, boundingBox, ProjectionConstants.EPSG_WORLD_GEODETIC_SYSTEM);

    FeatureDao featureDao = geoPackage.getFeatureDao(geometryColumns);

    return featureDao;
}
 

import mil.nga.geopackage.features.user.FeatureDao; //导入依赖的package包/类
/**
 * Constructor
 *
 * @param task
 * @param database
 * @param featureDao
 * @param row
 * @param count
 * @param maxFeatures
 * @param editable
 * @param converter
 * @param filterBoundingBox
 * @param maxLongitude
 * @param filter
 */
public FeatureRowProcessor(MapFeaturesUpdateTask task, String database, FeatureDao featureDao,
                           FeatureRow row, AtomicInteger count, int maxFeatures,
                           boolean editable, GoogleMapShapeConverter converter,
                           BoundingBox filterBoundingBox, double maxLongitude, boolean filter) {
    this.task = task;
    this.database = database;
    this.featureDao = featureDao;
    this.row = row;
    this.count = count;
    this.maxFeatures = maxFeatures;
    this.editable = editable;
    this.converter = converter;
    this.filterBoundingBox = filterBoundingBox;
    this.maxLongitude = maxLongitude;
    this.filter = filter;
}
 

import mil.nga.geopackage.features.user.FeatureDao; //导入依赖的package包/类
/**
 * Info feature click
 *
 * @param marker
 * @param markerFeature
 */
private void infoFeatureClick(final Marker marker, MarkerFeature markerFeature) {
    final GeoPackage geoPackage = manager.open(markerFeature.database);
    final FeatureDao featureDao = geoPackage
            .getFeatureDao(markerFeature.tableName);

    final FeatureRow featureRow = featureDao.queryForIdRow(markerFeature.featureId);

    if (featureRow != null) {
        final GeoPackageGeometryData geomData = featureRow.getGeometry();
        final GeometryType geometryType = geomData.getGeometry()
                .getGeometryType();

        String title = getTitle(geometryType, marker);
        infoExistingFeatureOption(geoPackage, featureRow, title, geomData);
    } else {
        geoPackage.close();
    }
}
 

import mil.nga.geopackage.features.user.FeatureDao; //导入依赖的package包/类
/**
 * Create feature dao
 *
 * @return feature dao
 */
public static FeatureDao createFeatureDao(GeoPackage geoPackage) {

	BoundingBox boundingBox = new BoundingBox();

	GeometryColumns geometryColumns = new GeometryColumns();
	geometryColumns.setId(new TableColumnKey(TABLE_NAME, "geom"));
	geometryColumns.setGeometryType(GeometryType.GEOMETRY);
	geometryColumns.setZ((byte) 0);
	geometryColumns.setM((byte) 0);

	geoPackage.createFeatureTableWithMetadata(geometryColumns, boundingBox,
			ProjectionConstants.EPSG_WORLD_GEODETIC_SYSTEM);

	FeatureDao featureDao = geoPackage.getFeatureDao(geometryColumns);

	return featureDao;
}
 

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

    List<FeatureDao> featureDaos = new ArrayList<FeatureDao>();

    List<String> featureTables = getFeatureTablesForTileTable(tileTable);
    for (String featureTable : featureTables) {
        if (geoPackage.isFeatureTable(featureTable)) {
            FeatureDao featureDao = geoPackage.getFeatureDao(featureTable);
            featureDaos.add(featureDao);
        }
    }

    return featureDaos;
}
 

import mil.nga.geopackage.features.user.FeatureDao; //导入依赖的package包/类
/**
 * Constructor
 *
 * @param context    context
 * @param geoPackage GeoPackage
 * @param featureDao feature DAO
 */
public FeatureIndexManager(Context context, GeoPackage geoPackage, FeatureDao featureDao) {
    this.featureDao = featureDao;
    featureTableIndex = new FeatureTableIndex(geoPackage, featureDao);
    featureIndexer = new FeatureIndexer(context, featureDao);

    // Set the default indexed check and query order
    indexLocationQueryOrder.add(FeatureIndexType.GEOPACKAGE);
    indexLocationQueryOrder.add(FeatureIndexType.METADATA);
}
 

import mil.nga.geopackage.features.user.FeatureDao; //导入依赖的package包/类
/**
 * Constructor
 *
 * @param context
 * @param featureDao
 */
public FeatureIndexer(Context context, FeatureDao featureDao) {
    this.context = context;
    this.featureDao = featureDao;
    db = new GeoPackageMetadataDb(context);
    db.open();
    geometryMetadataDataSource = new GeometryMetadataDataSource(db);
}
 

import mil.nga.geopackage.features.user.FeatureDao; //导入依赖的package包/类
/**
 * Constructor
 *
 * @param context
 * @param featureDao
 */
public FeatureTiles(Context context, FeatureDao featureDao) {
    this.context = context;
    this.featureDao = featureDao;
    if (featureDao != null) {
        this.projection = featureDao.getProjection();
    }

    Resources resources = context.getResources();
    tileWidth = resources.getInteger(R.integer.feature_tiles_width);
    tileHeight = resources.getInteger(R.integer.feature_tiles_height);

    compressFormat = CompressFormat.valueOf(context.getString(R.string.feature_tiles_compress_format));

    pointPaint.setAntiAlias(true);
    pointRadius = Float.valueOf(context.getString(R.string.feature_tiles_point_radius));

    linePaint.setAntiAlias(true);
    linePaint.setStrokeWidth(Float.valueOf(context.getString(R.string.feature_tiles_line_stroke_width)));
    linePaint.setStyle(Paint.Style.STROKE);

    polygonPaint.setAntiAlias(true);
    polygonPaint.setStrokeWidth(Float.valueOf(context.getString(R.string.feature_tiles_polygon_stroke_width)));
    polygonPaint.setStyle(Paint.Style.STROKE);

    fillPolygon = resources.getBoolean(R.bool.feature_tiles_polygon_fill);
    polygonFillPaint.setAntiAlias(true);
    polygonFillPaint.setStyle(Paint.Style.FILL_AND_STROKE);
    polygonFillPaint.setAlpha(resources.getInteger(R.integer.feature_tiles_polygon_fill_alpha));

    calculateDrawOverlap();
}
 

import mil.nga.geopackage.features.user.FeatureDao; //导入依赖的package包/类
/**
 * Insert features
 *
 * @param featureDao
 * @return number of features
 */
public static int insertFeatures(GeoPackage geoPackage, FeatureDao featureDao) throws SQLException {

    int count = 0;

    count += 5;
    insertPoint(featureDao, 0, 0);
    insertPoint(featureDao, 0, ProjectionConstants.WEB_MERCATOR_MAX_LAT_RANGE - 1);
    insertPoint(featureDao, 0, ProjectionConstants.WEB_MERCATOR_MIN_LAT_RANGE + 1);
    insertPoint(featureDao, -179, 0);
    insertPoint(featureDao, 179, 0);

    count += 4;
    insertFourPoints(featureDao, 179, ProjectionConstants.WEB_MERCATOR_MAX_LAT_RANGE - 1);
    count += 4;
    insertFourPoints(featureDao, 90, 45);

    count += 4;
    insertFourLines(featureDao, new double[][]{{135.0, 67.5}, {90.0, 45.0}, {135.0, 45.0}});

    count += 4;
    insertFourPolygons(featureDao, new double[][]{{60.0, 35.0}, {65.0, 15.0}, {15.0, 20.0}, {20.0, 40.0}}, new double[][]{{50.0, 30.0}, {48.0, 22.0}, {30.0, 23.0}, {25.0, 34.0}});

    updateLastChange(geoPackage, featureDao);

    return count;
}
 

import mil.nga.geopackage.features.user.FeatureDao; //导入依赖的package包/类
/**
 * Create a new feature tiles
 *
 * @return
 */
public static FeatureTiles createFeatureTiles(Context context, GeoPackage geoPackage, FeatureDao featureDao) {

    FeatureTiles featureTiles = new DefaultFeatureTiles(context, featureDao);

    Paint pointPaint = featureTiles.getPointPaint();
    //pointPaint.setColor(Color.BLUE);
    Bitmap bitmap = BitmapFactory.decodeResource(context.getResources(), mil.nga.geopackage.test.R.drawable.ic_launcher);
    bitmap = Bitmap.createScaledBitmap(bitmap, 25, 25, false);
    FeatureTilePointIcon icon = new FeatureTilePointIcon(bitmap);
    featureTiles.setPointIcon(icon);

    Paint linePaint = featureTiles.getLinePaint();
    linePaint.setColor(Color.GREEN);

    Paint polygonPaint = featureTiles.getPolygonPaint();
    polygonPaint.setColor(Color.RED);

    featureTiles.setFillPolygon(true);
    Paint polygonFillPaint = featureTiles.getPolygonFillPaint();
    polygonFillPaint.setColor(Color.RED);
    polygonFillPaint.setAlpha(50);

    featureTiles.calculateDrawOverlap();

    return featureTiles;
}
 

import mil.nga.geopackage.features.user.FeatureDao; //导入依赖的package包/类
public static long insertLine(FeatureDao featureDao, double[][] points) {
    FeatureRow featureRow = featureDao.newRow();
    GeoPackageGeometryData geomData = new GeoPackageGeometryData(
            ProjectionConstants.EPSG_WORLD_GEODETIC_SYSTEM);
    LineString lineString = getLineString(points);
    geomData.setGeometry(lineString);
    featureRow.setGeometry(geomData);
    return featureDao.insert(featureRow);
}
 

import mil.nga.geopackage.features.user.FeatureDao; //导入依赖的package包/类
public static long insertPolygon(FeatureDao featureDao, double[][]... points) {
    FeatureRow featureRow = featureDao.newRow();
    GeoPackageGeometryData geomData = new GeoPackageGeometryData(
            ProjectionConstants.EPSG_WORLD_GEODETIC_SYSTEM);
    Polygon polygon = new Polygon(false, false);
    for (double[][] ring : points) {
        LineString lineString = getLineString(ring);
        polygon.addRing(lineString);
    }
    geomData.setGeometry(polygon);
    featureRow.setGeometry(geomData);
    return featureDao.insert(featureRow);
}
 

import mil.nga.geopackage.features.user.FeatureDao; //导入依赖的package包/类
/**
 * Test tile generator
 *
 * @throws java.io.IOException
 * @throws java.sql.SQLException
 */
public void testTileGenerator() throws IOException, SQLException {

    int minZoom = 0;
    int maxZoom = 4;

    FeatureDao featureDao = FeatureTileUtils.createFeatureDao(geoPackage);

    FeatureTileUtils.insertFeatures(geoPackage, featureDao);

    FeatureTiles featureTiles = FeatureTileUtils.createFeatureTiles(activity, geoPackage, featureDao);

    BoundingBox boundingBox = new BoundingBox();
    boundingBox = TileBoundingBoxUtils.boundWgs84BoundingBoxWithWebMercatorLimits(boundingBox);
    boundingBox = ProjectionFactory.getProjection(ProjectionConstants.EPSG_WORLD_GEODETIC_SYSTEM)
            .getTransformation(ProjectionConstants.EPSG_WEB_MERCATOR)
            .transform(boundingBox);
    TileGenerator tileGenerator = new FeatureTileGenerator(activity, geoPackage,
            "gen_feature_tiles", featureTiles, minZoom, maxZoom, boundingBox,
            ProjectionFactory.getProjection(ProjectionConstants.EPSG_WEB_MERCATOR));
    tileGenerator.setGoogleTiles(false);

    int tiles = tileGenerator.generateTiles();

    int expectedTiles = 0;
    for (int i = minZoom; i <= maxZoom; i++) {
        int tilesPerSide = TileBoundingBoxUtils.tilesPerSide(i);
        expectedTiles += (tilesPerSide * tilesPerSide);
    }

    assertEquals(expectedTiles, tiles);

}
 

import mil.nga.geopackage.features.user.FeatureDao; //导入依赖的package包/类
/**
 * Add editable shape back after editing is complete
 */
private void addEditableShapeBack() {

    Long featureId = editFeatureIds.get(editFeatureMarker.getId());
    final GeoPackage geoPackage = manager.open(editFeaturesDatabase);
    try {
        final FeatureDao featureDao = geoPackage
                .getFeatureDao(editFeaturesTable);
        final FeatureRow featureRow = featureDao.queryForIdRow(featureId);
        GeoPackageGeometryData geomData = featureRow.getGeometry();
        if (geomData != null) {
            Geometry geometry = geomData.getGeometry();
            if (geometry != null) {
                GoogleMapShapeConverter converter = new GoogleMapShapeConverter(
                        featureDao.getProjection());
                GoogleMapShape shape = converter.toShape(geometry);
                prepareShapeOptions(shape, true, true);
                GoogleMapShape mapShape = GoogleMapShapeConverter
                        .addShapeToMap(map, shape);
                addEditableShape(featureId, mapShape);
            }
        }
    } finally {
        if (geoPackage != null) {
            geoPackage.close();
        }
    }
}
 

import mil.nga.geopackage.features.user.FeatureDao; //导入依赖的package包/类
/**
 * Process the feature index results
 *
 * @param task
 * @param threadPool
 * @param indexResults
 * @param database
 * @param featureDao
 * @param converter
 * @param count
 * @param maxFeatures
 * @param editable
 * @param filter
 */
private void processFeatureIndexResults(MapFeaturesUpdateTask task, ExecutorService threadPool, FeatureIndexResults indexResults, String database, FeatureDao featureDao,
                                        GoogleMapShapeConverter converter, AtomicInteger count, final int maxFeatures, final boolean editable,
                                        boolean filter) {

    try {
        for (FeatureRow row : indexResults) {

            if (task.isCancelled() || count.get() >= maxFeatures) {
                break;
            }

            try {

                if (threadPool != null) {
                    // Process the feature row in the thread pool
                    FeatureRowProcessor processor = new FeatureRowProcessor(
                            task, database, featureDao, row, count, maxFeatures, editable, converter,
                            null, 0, filter);
                    threadPool.execute(processor);
                } else {

                    processFeatureRow(task, database, featureDao, converter, row, count, maxFeatures, editable, null, 0, filter);
                }

            } catch (Exception e) {
                Log.e(GeoPackageMapFragment.class.getSimpleName(),
                        "Failed to display feature. database: " + database
                                + ", feature table: " + featureDao.getTableName()
                                + ", row id: " + row.getId(), e);
            }
        }
    } finally {
        indexResults.close();
    }
}
 

import mil.nga.geopackage.features.user.FeatureDao; //导入依赖的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.features.user.FeatureDao; //导入依赖的package包/类
/**
 * Update the last change date of the contents
 *
 * @param geoPackage
 * @param featureDao
 */
private static void updateLastChange(GeoPackage geoPackage, FeatureDao featureDao) {
    try {
        Contents contents = featureDao.getGeometryColumns().getContents();
        contents.setLastChange(new Date());
        ContentsDao contentsDao = geoPackage.getContentsDao();
        contentsDao.update(contents);
    } catch (Exception e) {
        Log.e(GeoPackageMapFragment.class.getSimpleName(),
                "Failed to update contents last change date. GeoPackage: "
                        + geoPackage.getName() + ", Table: " + featureDao.getTableName(), e);
    }
}
 

import mil.nga.geopackage.features.user.FeatureDao; //导入依赖的package包/类
/**
 * Index features
 *
 * @param activity
 * @param callback
 * @param database
 * @param tableName
 * @param indexLocation
 */
public static void indexFeatures(Activity activity, IIndexerTask callback,
                                 String database, String tableName,
                                 FeatureIndexType indexLocation) {

    GeoPackageManager manager = GeoPackageFactory.getManager(activity);
    GeoPackage geoPackage = manager.open(database);

    FeatureDao featureDao = geoPackage.getFeatureDao(tableName);

    FeatureIndexManager indexer = new FeatureIndexManager(activity, geoPackage, featureDao);
    indexer.setIndexLocation(indexLocation);

    ProgressDialog progressDialog = new ProgressDialog(activity);
    final IndexerTask indexTask = new IndexerTask(activity,
            callback, progressDialog, geoPackage, indexer);

    int max = featureDao.count();
    indexTask.setMax(max);
    indexer.setProgress(indexTask);

    progressDialog.setMessage(activity
            .getString(R.string.geopackage_table_index_features_index_title)
            + ": "
            + geoPackage.getName() + " - " + tableName);
    progressDialog.setCancelable(false);
    progressDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
    progressDialog.setIndeterminate(false);
    progressDialog.setMax(max);
    progressDialog.setButton(ProgressDialog.BUTTON_NEGATIVE,
            activity.getString(R.string.button_cancel_label),
            new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface dialog, int which) {
                    indexTask.cancel(true);
                }
            });

    indexTask.execute();
}