Java GeoPackageGeometryData.getGeometry方法代码示例

import mil.nga.geopackage.geom.GeoPackageGeometryData; //导入方法依赖的package包/类
/**
 * Build a JSON compatible object
 *
 * @param includePoints     true to include point geometries, ignored if includeGeometries is true
 * @param includeGeometries true to include all geometry types
 * @return JSON compatiable object
 */
public Object jsonCompatible(boolean includePoints, boolean includeGeometries) {

    Map<String, Object> jsonValues = new HashMap<>();

    for (String key : values.keySet()) {
        Object jsonValue = null;
        Object value = values.get(key);
        if (key.equals(geometryColumn)) {
            GeoPackageGeometryData geometryData = (GeoPackageGeometryData) value;
            if (geometryData.getGeometry() != null) {
                if (includeGeometries || (includePoints && geometryData.getGeometry().getGeometryType() == GeometryType.POINT)) {
                    jsonValue = GeometryJSONCompatible.getJSONCompatibleGeometry(geometryData.getGeometry());
                }
            } else {
                jsonValue = value;
            }
            if (jsonValue != null) {
                jsonValues.put(key, jsonValue);
            }
        }
    }

    return jsonValues;
}
 

import mil.nga.geopackage.geom.GeoPackageGeometryData; //导入方法依赖的package包/类
/**
 * Draw the feature
 *
 * @param zoom
 *            zoom level
 * @param boundingBox
 * @param transform
 * @param graphics
 * @param row
 */
private void drawFeature(int zoom, BoundingBox boundingBox,
		ProjectionTransform transform, Graphics2D graphics, FeatureRow row) {
	try {
		GeoPackageGeometryData geomData = row.getGeometry();
		if (geomData != null) {
			Geometry geometry = geomData.getGeometry();
			double simplifyTolerance = TileBoundingBoxUtils
					.toleranceDistance(zoom, tileWidth, tileHeight);
			drawGeometry(simplifyTolerance, boundingBox, transform,
					graphics, geometry);
		}
	} catch (Exception e) {
		log.log(Level.SEVERE, "Failed to draw feature in tile. Table: "
				+ featureDao.getTableName(), e);
	}
}
 

import mil.nga.geopackage.geom.GeoPackageGeometryData; //导入方法依赖的package包/类
/**
 * Project the geometry into the provided projection
 *
 * @param geometryData geometry data
 * @param projection   projection
 */
public void projectGeometry(GeoPackageGeometryData geometryData, Projection projection) {

    if (geometryData.getGeometry() != null) {

        try {
            SpatialReferenceSystemDao srsDao = DaoManager.createDao(featureDao.getDb().getConnectionSource(), SpatialReferenceSystem.class);
            int srsId = geometryData.getSrsId();
            SpatialReferenceSystem srs = srsDao.queryForId((long) srsId);

            if (!projection.equals(srs.getOrganization(), srs.getOrganizationCoordsysId())) {

                Projection geomProjection = ProjectionFactory.getProjection(srs);
                ProjectionTransform transform = geomProjection.getTransformation(projection);

                Geometry projectedGeometry = transform.transform(geometryData.getGeometry());
                geometryData.setGeometry(projectedGeometry);
                SpatialReferenceSystem projectionSrs = srsDao.getOrCreateCode(projection.getAuthority(), Long.parseLong(projection.getCode()));
                geometryData.setSrsId((int) projectionSrs.getSrsId());
            }
        } catch (SQLException e) {
            throw new GeoPackageException("Failed to project geometry to projection with Authority: "
                    + projection.getAuthority() + ", Code: " + projection.getCode(), e);
        }
    }

}
 

import mil.nga.geopackage.geom.GeoPackageGeometryData; //导入方法依赖的package包/类
/**
 * Index the feature row
 *
 * @param geoPackageId
 * @param row
 * @param possibleUpdate
 * @return true if indexed
 */
private boolean index(long geoPackageId, FeatureRow row, boolean possibleUpdate) {

    boolean indexed = false;

    GeoPackageGeometryData geomData = row.getGeometry();
    if (geomData != null) {

        // Get the envelope
        GeometryEnvelope envelope = geomData.getEnvelope();

        // If no envelope, build one from the geometry
        if (envelope == null) {
            Geometry geometry = geomData.getGeometry();
            if (geometry != null) {
                envelope = GeometryEnvelopeBuilder.buildEnvelope(geometry);
            }
        }

        // Create the new index row
        if (envelope != null) {
            GeometryMetadata metadata = geometryMetadataDataSource.populate(geoPackageId, featureDao.getTableName(), row.getId(), envelope);
            if (possibleUpdate) {
                geometryMetadataDataSource.createOrUpdate(metadata);
            } else {
                geometryMetadataDataSource.create(metadata);
            }
            indexed = true;
        }
    }

    return indexed;
}
 

import mil.nga.geopackage.geom.GeoPackageGeometryData; //导入方法依赖的package包/类
/**
 * Draw the feature on the canvas
 *
 * @param zoom        zoom level
 * @param boundingBox
 * @param transform
 * @param canvas
 * @param row
 */
private void drawFeature(int zoom, BoundingBox boundingBox, ProjectionTransform transform, Canvas canvas, FeatureRow row) {
    try {
        GeoPackageGeometryData geomData = row.getGeometry();
        if (geomData != null) {
            Geometry geometry = geomData.getGeometry();
            double simplifyTolerance = TileBoundingBoxUtils.toleranceDistance(zoom, tileWidth, tileHeight);
            drawShape(simplifyTolerance, boundingBox, transform, canvas, geometry);
        }
    } catch (Exception e) {
        Log.e(DefaultFeatureTiles.class.getSimpleName(), "Failed to draw feature in tile. Table: "
                + featureDao.getTableName(), e);
    }
}
 

import mil.nga.geopackage.geom.GeoPackageGeometryData; //导入方法依赖的package包/类
/**
 * Validate a Geometry Index result
 *
 * @param featureTableIndex
 * @param geometryIndex
 */
private static void validateGeometryIndex(
        FeatureTableIndex featureTableIndex, GeometryIndex geometryIndex) {
    FeatureRow featureRow = featureTableIndex.getFeatureRow(geometryIndex);
    TestCase.assertNotNull(featureRow);
    TestCase.assertEquals(featureTableIndex.getTableName(),
            geometryIndex.getTableName());
    TestCase.assertEquals(geometryIndex.getGeomId(), featureRow.getId());
    GeoPackageGeometryData geometryData = featureRow.getGeometry();
    GeometryEnvelope envelope = geometryData.getEnvelope();
    if (envelope == null) {
        Geometry geometry = geometryData.getGeometry();
        if (geometry != null) {
            envelope = GeometryEnvelopeBuilder.buildEnvelope(geometry);
        }
    }

    TestCase.assertNotNull(envelope);

    TestCase.assertEquals(envelope.getMinX(), geometryIndex.getMinX());
    TestCase.assertEquals(envelope.getMaxX(), geometryIndex.getMaxX());
    TestCase.assertEquals(envelope.getMinY(), geometryIndex.getMinY());
    TestCase.assertEquals(envelope.getMaxY(), geometryIndex.getMaxY());
    if (envelope.isHasZ()) {
        TestCase.assertEquals(envelope.getMinZ(), geometryIndex.getMinZ());
        TestCase.assertEquals(envelope.getMaxZ(), geometryIndex.getMaxZ());
    } else {
        TestCase.assertNull(geometryIndex.getMinZ());
        TestCase.assertNull(geometryIndex.getMaxZ());
    }
    if (envelope.isHasM()) {
        TestCase.assertEquals(envelope.getMinM(), geometryIndex.getMinM());
        TestCase.assertEquals(envelope.getMaxM(), geometryIndex.getMaxM());
    } else {
        TestCase.assertNull(geometryIndex.getMinM());
        TestCase.assertNull(geometryIndex.getMaxM());
    }
}
 

import mil.nga.geopackage.geom.GeoPackageGeometryData; //导入方法依赖的package包/类
/**
 * Index the geometry id and geometry data
 * 
 * @param tableIndex
 * @param geomId
 * @param geomData
 * 
 * @return true if indexed
 */
protected boolean index(TableIndex tableIndex, long geomId,
		GeoPackageGeometryData geomData) {

	boolean indexed = false;

	if (geomData != null) {

		// Get the envelope
		GeometryEnvelope envelope = geomData.getEnvelope();

		// If no envelope, build one from the geometry
		if (envelope == null) {
			Geometry geometry = geomData.getGeometry();
			if (geometry != null) {
				envelope = GeometryEnvelopeBuilder.buildEnvelope(geometry);
			}
		}

		// Create the new index row
		if (envelope != null) {
			GeometryIndex geometryIndex = geometryIndexDao.populate(
					tableIndex, geomId, envelope);
			try {
				geometryIndexDao.createOrUpdate(geometryIndex);
				indexed = true;
			} catch (SQLException e) {
				throw new GeoPackageException(
						"Failed to create or update Geometry Index. GeoPackage: "
								+ geoPackage.getName() + ", Table Name: "
								+ tableName + ", Geom Id: " + geomId, e);
			}
		}
	}

	return indexed;
}
 

import mil.nga.geopackage.geom.GeoPackageGeometryData; //导入方法依赖的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.geom.GeoPackageGeometryData; //导入方法依赖的package包/类
/**
 * Validate a Geometry Index result
 * 
 * @param featureTableIndex
 * @param geometryIndex
 */
private static void validateGeometryIndex(
		FeatureTableIndex featureTableIndex, GeometryIndex geometryIndex) {
	FeatureRow featureRow = featureTableIndex.getFeatureRow(geometryIndex);
	TestCase.assertNotNull(featureRow);
	TestCase.assertEquals(featureTableIndex.getTableName(),
			geometryIndex.getTableName());
	TestCase.assertEquals(geometryIndex.getGeomId(), featureRow.getId());
	GeoPackageGeometryData geometryData = featureRow.getGeometry();
	GeometryEnvelope envelope = geometryData.getEnvelope();
	if (envelope == null) {
		Geometry geometry = geometryData.getGeometry();
		if (geometry != null) {
			envelope = GeometryEnvelopeBuilder.buildEnvelope(geometry);
		}
	}

	TestCase.assertNotNull(envelope);

	TestCase.assertEquals(envelope.getMinX(), geometryIndex.getMinX());
	TestCase.assertEquals(envelope.getMaxX(), geometryIndex.getMaxX());
	TestCase.assertEquals(envelope.getMinY(), geometryIndex.getMinY());
	TestCase.assertEquals(envelope.getMaxY(), geometryIndex.getMaxY());
	if (envelope.isHasZ()) {
		TestCase.assertEquals(envelope.getMinZ(), geometryIndex.getMinZ());
		TestCase.assertEquals(envelope.getMaxZ(), geometryIndex.getMaxZ());
	} else {
		TestCase.assertNull(geometryIndex.getMinZ());
		TestCase.assertNull(geometryIndex.getMaxZ());
	}
	if (envelope.isHasM()) {
		TestCase.assertEquals(envelope.getMinM(), geometryIndex.getMinM());
		TestCase.assertEquals(envelope.getMaxM(), geometryIndex.getMaxM());
	} else {
		TestCase.assertNull(geometryIndex.getMinM());
		TestCase.assertNull(geometryIndex.getMaxM());
	}
}
 

import mil.nga.geopackage.geom.GeoPackageGeometryData; //导入方法依赖的package包/类
/**
 * Fine filter the index results verifying the click location is within the tolerance of each feature row
 *
 * @param results       feature index results
 * @param tolerance     distance tolerance
 * @param clickLocation click location
 * @return filtered feature index results
 */
private FeatureIndexResults fineFilterResults(FeatureIndexResults results, double tolerance, LatLng clickLocation) {

    FeatureIndexResults filteredResults = null;
    if(ignoreGeometryTypes.contains(geometryType)){
        filteredResults = new FeatureIndexListResults();
    }else if(clickLocation == null && ignoreGeometryTypes.isEmpty()){
        filteredResults = results;
    } else {

        FeatureIndexListResults filteredListResults = new FeatureIndexListResults();

        GoogleMapShapeConverter converter = new GoogleMapShapeConverter(
                featureDao.getProjection());

        for (FeatureRow featureRow : results) {

            GeoPackageGeometryData geomData = featureRow.getGeometry();
            if (geomData != null) {
                Geometry geometry = geomData.getGeometry();
                if (geometry != null) {

                    if(!ignoreGeometryTypes.contains(geometry.getGeometryType())) {

                        if(clickLocation != null) {

                            GoogleMapShape mapShape = converter.toShape(geometry);
                            if (MapUtils.isPointOnShape(clickLocation, mapShape, geodesic, tolerance)) {

                                filteredListResults.addRow(featureRow);

                            }
                        }else{
                            filteredListResults.addRow(featureRow);
                        }

                    }
                }
            }

        }

        filteredResults = filteredListResults;
    }

    return filteredResults;
}
 

import mil.nga.geopackage.geom.GeoPackageGeometryData; //导入方法依赖的package包/类
/**
 * Validate a Feature Row result
 *
 * @param featureIndexManager
 * @param featureRow
 * @param queryEnvelope
 */
private static void validateFeatureRow(
        FeatureIndexManager featureIndexManager, FeatureRow featureRow, GeometryEnvelope queryEnvelope) {
    TestCase.assertNotNull(featureRow);
    GeoPackageGeometryData geometryData = featureRow.getGeometry();
    GeometryEnvelope envelope = geometryData.getEnvelope();
    if (envelope == null) {
        Geometry geometry = geometryData.getGeometry();
        if (geometry != null) {
            envelope = GeometryEnvelopeBuilder.buildEnvelope(geometry);
        }
    }

    TestCase.assertNotNull(envelope);

    if (queryEnvelope != null) {
        TestCase.assertTrue(envelope.getMinX() <= queryEnvelope.getMaxX());
        TestCase.assertTrue(envelope.getMaxX() >= queryEnvelope.getMinX());
        TestCase.assertTrue(envelope.getMinY() <= queryEnvelope.getMaxY());
        TestCase.assertTrue(envelope.getMaxY() >= queryEnvelope.getMinY());
        if (envelope.isHasZ()) {
            if (queryEnvelope.hasZ()) {
                TestCase.assertTrue(envelope.getMinZ() <= queryEnvelope.getMaxZ());
                TestCase.assertTrue(envelope.getMaxZ() >= queryEnvelope.getMinZ());
            }
        } else {
            TestCase.assertFalse(queryEnvelope.hasZ());
            TestCase.assertNull(queryEnvelope.getMinZ());
            TestCase.assertNull(queryEnvelope.getMaxZ());
        }
        if (envelope.isHasM()) {
            if (queryEnvelope.hasM()) {
                TestCase.assertTrue(envelope.getMinM() <= queryEnvelope.getMaxM());
                TestCase.assertTrue(envelope.getMaxM() >= queryEnvelope.getMinM());
            }
        } else {
            TestCase.assertFalse(queryEnvelope.hasM());
            TestCase.assertNull(queryEnvelope.getMinM());
            TestCase.assertNull(queryEnvelope.getMaxM());
        }
    }
}
 

import mil.nga.geopackage.geom.GeoPackageGeometryData; //导入方法依赖的package包/类
/**
 * Test transforming geometries between projections
 *
 * @param geoPackage
 * @throws SQLException
 * @throws IOException
 */
public static void testGeometryProjectionTransform(GeoPackage geoPackage)
		throws SQLException, IOException {

	GeometryColumnsDao geometryColumnsDao = geoPackage
			.getGeometryColumnsDao();

	if (geometryColumnsDao.isTableExists()) {
		List<GeometryColumns> results = geometryColumnsDao.queryForAll();

		for (GeometryColumns geometryColumns : results) {

			FeatureDao dao = geoPackage.getFeatureDao(geometryColumns);
			TestCase.assertNotNull(dao);

			FeatureCursor cursor = dao.queryForAll();

			while (cursor.moveToNext()) {

				GeoPackageGeometryData geometryData = cursor.getGeometry();
				if (geometryData != null) {

					Geometry geometry = geometryData.getGeometry();

					if (geometry != null) {

						SpatialReferenceSystemDao srsDao = geoPackage
								.getSpatialReferenceSystemDao();
						long srsId = geometryData.getSrsId();
						SpatialReferenceSystem srs = srsDao
								.queryForId(srsId);

						long epsg = srs.getOrganizationCoordsysId();
						Projection projection = ProjectionFactory
								.getProjection(srs);
						long toEpsg = -1;
						if (epsg == ProjectionConstants.EPSG_WORLD_GEODETIC_SYSTEM) {
							toEpsg = ProjectionConstants.EPSG_WEB_MERCATOR;
						} else {
							toEpsg = ProjectionConstants.EPSG_WORLD_GEODETIC_SYSTEM;
						}
						ProjectionTransform transformTo = projection
								.getTransformation(toEpsg);
						ProjectionTransform transformFrom = transformTo
								.getToProjection().getTransformation(srs);

						byte[] bytes = geometryData.getWkbBytes();

						Geometry projectedGeometry = transformTo
								.transform(geometry);
						GeoPackageGeometryData projectedGeometryData = new GeoPackageGeometryData(
								-1);
						projectedGeometryData
								.setGeometry(projectedGeometry);
						projectedGeometryData.toBytes();
						byte[] projectedBytes = projectedGeometryData
								.getWkbBytes();

						if (epsg > 0) {
							TestCase.assertFalse(equalByteArrays(bytes,
									projectedBytes));
						}

						Geometry restoredGeometry = transformFrom
								.transform(projectedGeometry);

						compareGeometries(geometry, restoredGeometry, .001);
					}
				}

			}
			cursor.close();
		}
	}
}
 

import mil.nga.geopackage.geom.GeoPackageGeometryData; //导入方法依赖的package包/类
/**
 * Process the feature row
 *
 * @param task
 * @param database
 * @param featureDao
 * @param row
 * @param count
 * @param maxFeatures
 * @param editable
 * @param boundingBox
 * @param maxLongitude
 * @param filter
 */
private void processFeatureRow(MapFeaturesUpdateTask task, String database, FeatureDao featureDao,
                               GoogleMapShapeConverter converter, FeatureRow row, AtomicInteger count,
                               int maxFeatures, boolean editable, BoundingBox boundingBox, double maxLongitude,
                               boolean filter) {

    boolean exists = false;
    synchronized (featureShapes) {
        exists = featureShapes.exists(row.getId(), database, featureDao.getTableName());
    }

    if (!exists) {

        GeoPackageGeometryData geometryData = row.getGeometry();
        if (geometryData != null && !geometryData.isEmpty()) {

            final Geometry geometry = geometryData.getGeometry();

            if (geometry != null) {

                boolean passesFilter = true;

                if (filter && boundingBox != null) {
                    GeometryEnvelope envelope = geometryData.getEnvelope();
                    if (envelope == null) {
                        envelope = GeometryEnvelopeBuilder.buildEnvelope(geometry);
                    }
                    if (envelope != null) {
                        if (geometry.getGeometryType() == GeometryType.POINT) {
                            mil.nga.wkb.geom.Point point = (mil.nga.wkb.geom.Point) geometry;
                            passesFilter = TileBoundingBoxUtils.isPointInBoundingBox(point, boundingBox, maxLongitude);
                        } else {
                            BoundingBox geometryBoundingBox = new BoundingBox(envelope);
                            passesFilter = TileBoundingBoxUtils.overlap(boundingBox, geometryBoundingBox, maxLongitude) != null;
                        }
                    }
                }

                if (passesFilter && count.getAndIncrement() < maxFeatures) {
                    final long featureId = row.getId();
                    final GoogleMapShape shape = converter.toShape(geometry);
                    updateFeaturesBoundingBox(shape);
                    prepareShapeOptions(shape, editable, true);
                    task.addToMap(featureId, database, featureDao.getTableName(), shape);
                }
            }
        }
    }
}
 

import mil.nga.geopackage.geom.GeoPackageGeometryData; //导入方法依赖的package包/类
/**
 * Test transforming geometries between projections
 * 
 * @param geoPackage
 * @throws SQLException
 * @throws IOException
 */
public static void testGeometryProjectionTransform(GeoPackage geoPackage)
		throws SQLException, IOException {

	GeometryColumnsDao geometryColumnsDao = geoPackage
			.getGeometryColumnsDao();

	if (geometryColumnsDao.isTableExists()) {
		List<GeometryColumns> results = geometryColumnsDao.queryForAll();

		for (GeometryColumns geometryColumns : results) {

			FeatureDao dao = geoPackage.getFeatureDao(geometryColumns);
			TestCase.assertNotNull(dao);

			FeatureResultSet cursor = dao.queryForAll();

			while (cursor.moveToNext()) {

				GeoPackageGeometryData geometryData = cursor.getGeometry();
				if (geometryData != null) {

					Geometry geometry = geometryData.getGeometry();

					if (geometry != null) {

						SpatialReferenceSystemDao srsDao = geoPackage
								.getSpatialReferenceSystemDao();
						long srsId = geometryData.getSrsId();
						SpatialReferenceSystem srs = srsDao
								.queryForId(srsId);

						long epsg = srs.getOrganizationCoordsysId();
						Projection projection = ProjectionFactory
								.getProjection(srs);
						long toEpsg = -1;
						if (epsg == ProjectionConstants.EPSG_WORLD_GEODETIC_SYSTEM) {
							toEpsg = ProjectionConstants.EPSG_WEB_MERCATOR;
						} else {
							toEpsg = ProjectionConstants.EPSG_WORLD_GEODETIC_SYSTEM;
						}
						ProjectionTransform transformTo = projection
								.getTransformation(toEpsg);
						ProjectionTransform transformFrom = transformTo
								.getToProjection().getTransformation(srs);

						byte[] bytes = geometryData.getWkbBytes();

						Geometry projectedGeometry = transformTo
								.transform(geometry);
						GeoPackageGeometryData projectedGeometryData = new GeoPackageGeometryData(
								-1);
						projectedGeometryData
								.setGeometry(projectedGeometry);
						projectedGeometryData.toBytes();
						byte[] projectedBytes = projectedGeometryData
								.getWkbBytes();

						if (epsg > 0) {
							TestCase.assertFalse(equalByteArrays(bytes,
									projectedBytes));
						}

						Geometry restoredGeometry = transformFrom
								.transform(projectedGeometry);

						compareGeometries(geometry, restoredGeometry, .001);
					}
				}

			}
			cursor.close();
		}
	}
}
 

import mil.nga.geopackage.geom.GeoPackageGeometryData; //导入方法依赖的package包/类
/**
 * Build a map click location message from the clicked marker
 *
 * @param marker clicked marker
 * @return click message
 */
public String mapClickMessage(Marker marker) {
    String message = null;
    if (selectedReport == null) {
        MarkerFeature markerFeature = markerIds.get(marker.getId());
        if (markerFeature != null) {
            final GeoPackage geoPackage = manager.open(markerFeature.database);
            try {
                final FeatureDao featureDao = geoPackage
                        .getFeatureDao(markerFeature.tableName);

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

                if (featureRow != null) {
                    GeoPackageGeometryData geomData = featureRow.getGeometry();
                    if (geomData != null && !geomData.isEmpty()) {
                        Geometry geometry = geomData.getGeometry();
                        if (geometry != null) {
                            StringBuilder messageBuilder = new StringBuilder();
                            messageBuilder.append(markerFeature.database).append(" - ").append(markerFeature.tableName).append("\n");
                            int geometryColumn = featureRow.getGeometryColumnIndex();
                            for (int i = 0; i < featureRow.columnCount(); i++) {
                                if (i != geometryColumn) {
                                    Object value = featureRow.getValue(i);
                                    if (value != null) {
                                        messageBuilder.append("\n").append(featureRow.getColumnName(i)).append(": ").append(value);
                                    }
                                }
                            }

                            if (messageBuilder.length() > 0) {
                                messageBuilder.append("\n\n");
                            }
                            messageBuilder.append(GeometryPrinter.getGeometryString(geometry));
                            message = messageBuilder.toString();
                        }
                    }
                }
            } finally {
                geoPackage.close();
            }
        }
    }
    return message;
}