Java FeatureDao类代码示例

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);

}