package com.xiaopeng.map.utils.mangoUtils;
|
|
import com.fasterxml.jackson.databind.ObjectMapper;
|
import com.mongodb.client.*;
|
import com.mongodb.client.model.Filters;
|
import com.mongodb.client.model.geojson.Point;
|
import com.mongodb.client.model.geojson.Position;
|
import org.bson.Document;
|
import org.bson.conversions.Bson;
|
|
import java.util.*;
|
|
/**
|
* MongoDB地理空间查询工具类
|
*/
|
public class MongoGeoFenceUtil {
|
|
private final MongoClient mongoClient;
|
private final MongoDatabase database;
|
private final ObjectMapper objectMapper;
|
|
/**
|
* 地理坐标点
|
*/
|
public static class GeoPoint {
|
private final double longitude;
|
private final double latitude;
|
|
public GeoPoint(double longitude, double latitude) {
|
this.longitude = longitude;
|
this.latitude = latitude;
|
}
|
|
public double getLongitude() {
|
return longitude;
|
}
|
|
public double getLatitude() {
|
return latitude;
|
}
|
|
public Position toPosition() {
|
return new Position(longitude, latitude);
|
}
|
|
public Point toGeoJsonPoint() {
|
return new Point(new Position(longitude, latitude));
|
}
|
|
public Document toDocument() {
|
return new Document()
|
.append("type", "Point")
|
.append("coordinates", Arrays.asList(longitude, latitude));
|
}
|
|
@Override
|
public String toString() {
|
return String.format("[%.6f, %.6f]", longitude, latitude);
|
}
|
}
|
|
/**
|
* 电子围栏类型
|
*/
|
public enum FenceType {
|
CIRCLE, // 圆形
|
POLYGON, // 多边形
|
LINESTRING, // 线形
|
MULTI_POLYGON // 多个多边形
|
}
|
|
/**
|
* 电子围栏
|
*/
|
public static class GeoFence {
|
private String id;
|
private String name;
|
private FenceType type;
|
private List<GeoPoint> coordinates;
|
private GeoPoint center;
|
private double radius; // 半径（米）
|
private Map<String, Object> properties;
|
|
public GeoFence(String id, String name, FenceType type) {
|
this.id = id;
|
this.name = name;
|
this.type = type;
|
this.coordinates = new ArrayList<>();
|
this.properties = new HashMap<>();
|
}
|
|
// Getters and Setters
|
public String getId() {
|
return id;
|
}
|
|
public void setId(String id) {
|
this.id = id;
|
}
|
|
public String getName() {
|
return name;
|
}
|
|
public void setName(String name) {
|
this.name = name;
|
}
|
|
public FenceType getType() {
|
return type;
|
}
|
|
public void setType(FenceType type) {
|
this.type = type;
|
}
|
|
public List<GeoPoint> getCoordinates() {
|
return coordinates;
|
}
|
|
public void setCoordinates(List<GeoPoint> coordinates) {
|
this.coordinates = coordinates;
|
}
|
|
public GeoPoint getCenter() {
|
return center;
|
}
|
|
public void setCenter(GeoPoint center) {
|
this.center = center;
|
}
|
|
public double getRadius() {
|
return radius;
|
}
|
|
public void setRadius(double radius) {
|
this.radius = radius;
|
}
|
|
public Map<String, Object> getProperties() {
|
return properties;
|
}
|
|
public void setProperties(Map<String, Object> properties) {
|
this.properties = properties;
|
}
|
|
public void addCoordinate(GeoPoint point) {
|
this.coordinates.add(point);
|
}
|
|
public void addCoordinate(double lng, double lat) {
|
this.coordinates.add(new GeoPoint(lng, lat));
|
}
|
|
public void addProperty(String key, Object value) {
|
this.properties.put(key, value);
|
}
|
}
|
|
public MongoGeoFenceUtil(String connectionString, String databaseName) {
|
this.mongoClient = MongoClients.create(connectionString);
|
this.database = mongoClient.getDatabase(databaseName);
|
this.objectMapper = new ObjectMapper();
|
}
|
|
/**
|
* 创建地理空间索引
|
*/
|
public void create2dSphereIndex(String collectionName, String fieldName) {
|
MongoCollection<Document> collection = database.getCollection(collectionName);
|
collection.createIndex(new Document(fieldName, "2dsphere"));
|
System.out.println("创建2dsphere索引成功: " + collectionName + "." + fieldName);
|
}
|
|
/**
|
* 创建2d索引（平面坐标）
|
*/
|
public void create2dIndex(String collectionName, String fieldName) {
|
MongoCollection<Document> collection = database.getCollection(collectionName);
|
collection.createIndex(new Document(fieldName, "2d"));
|
System.out.println("创建2d索引成功: " + collectionName + "." + fieldName);
|
}
|
|
/**
|
* 保存电子围栏到数据库
|
*/
|
public void saveGeoFence(String collectionName, GeoFence fence) {
|
MongoCollection<Document> collection = database.getCollection(collectionName);
|
|
Document geometry = createGeometryDocument(fence);
|
|
Document fenceDoc = new Document()
|
.append("_id", fence.getId())
|
.append("name", fence.getName())
|
.append("type", fence.getType().name())
|
.append("geometry", geometry)
|
.append("properties", fence.getProperties())
|
.append("createdAt", new Date())
|
.append("updatedAt", new Date());
|
|
// 添加中心点用于快速查询
|
if (fence.getCenter() != null) {
|
fenceDoc.append("center", fence.getCenter().toDocument());
|
}
|
|
if (fence.getRadius() > 0) {
|
fenceDoc.append("radius", fence.getRadius());
|
}
|
|
collection.insertOne(fenceDoc);
|
System.out.println("保存围栏成功: " + fence.getName());
|
}
|
|
/**
|
* 创建几何图形文档
|
*/
|
private Document createGeometryDocument(GeoFence fence) {
|
Document geometry = new Document();
|
|
switch (fence.getType()) {
|
case POLYGON:
|
geometry.append("type", "Polygon");
|
List<List<Position>> polygonPositions = new ArrayList<>();
|
List<Position> positions = new ArrayList<>();
|
|
for (GeoPoint point : fence.getCoordinates()) {
|
positions.add(point.toPosition());
|
}
|
// 闭合多边形：最后一个点等于第一个点
|
if (!positions.isEmpty() && !positions.get(0).equals(positions.get(positions.size() - 1))) {
|
positions.add(positions.get(0));
|
}
|
|
polygonPositions.add(positions);
|
geometry.append("coordinates", polygonPositions);
|
break;
|
|
case CIRCLE:
|
// MongoDB原生不支持圆形，使用多边形近似
|
geometry.append("type", "Polygon");
|
List<List<Position>> circlePositions = new ArrayList<>();
|
List<Position> circlePoints = new ArrayList<>();
|
|
int segments = 36; // 36边形近似圆形
|
for (int i = 0; i < segments; i++) {
|
double angle = 2 * Math.PI * i / segments;
|
double lat = fence.getCenter().getLatitude() +
|
(fence.getRadius() / 111320.0) * Math.cos(angle); // 1度≈111320米
|
double lng = fence.getCenter().getLongitude() +
|
(fence.getRadius() / (111320.0 * Math.cos(Math.toRadians(fence.getCenter().getLatitude())))) * Math.sin(angle);
|
|
circlePoints.add(new Position(lng, lat));
|
}
|
// 闭合
|
if (!circlePoints.isEmpty()) {
|
circlePoints.add(circlePoints.get(0));
|
}
|
|
circlePositions.add(circlePoints);
|
geometry.append("coordinates", circlePositions);
|
break;
|
|
case LINESTRING:
|
geometry.append("type", "LineString");
|
List<Position> linePositions = new ArrayList<>();
|
for (GeoPoint point : fence.getCoordinates()) {
|
linePositions.add(point.toPosition());
|
}
|
geometry.append("coordinates", linePositions);
|
break;
|
|
default:
|
throw new IllegalArgumentException("不支持的围栏类型: " + fence.getType());
|
}
|
|
return geometry;
|
}
|
|
/**
|
* 方法1：使用$geoWithin判断点是否在多边形内
|
*/
|
public boolean isPointInPolygonGeoWithin(GeoPoint point, String fenceId, String collectionName) {
|
MongoCollection<Document> collection = database.getCollection(collectionName);
|
|
// 获取围栏的多边形数据
|
Document fence = collection.find(Filters.eq("_id", fenceId)).first();
|
if (fence == null) {
|
throw new IllegalArgumentException("围栏不存在: " + fenceId);
|
}
|
|
// 创建查询：点是否在多边形内
|
Bson filter = Filters.and(
|
Filters.eq("_id", fenceId),
|
Filters.geoWithin(
|
"geometry",
|
point.toGeoJsonPoint()
|
)
|
);
|
|
long count = collection.countDocuments(filter);
|
return count > 0;
|
}
|
|
/**
|
* 方法2：使用$geoIntersects判断点是否与几何图形相交
|
*/
|
public boolean isPointInPolygonGeoIntersects(GeoPoint point, String fenceId, String collectionName) {
|
MongoCollection<Document> collection = database.getCollection(collectionName);
|
|
Bson filter = Filters.and(
|
Filters.eq("_id", fenceId),
|
Filters.geoIntersects("geometry", point.toGeoJsonPoint())
|
);
|
|
long count = collection.countDocuments(filter);
|
return count > 0;
|
}
|
|
|
|
/**
|
* 方法3：查找包含指定点的所有围栏（支持自定义地理字段名称）
|
*/
|
public List<String> findFencesContainingPoint(GeoPoint point, String collectionName, String geoFieldName) {
|
MongoCollection<Document> collection = database.getCollection(collectionName);
|
List<String> fenceIds = new ArrayList<>();
|
|
// 查询所有包含该点的围栏
|
Bson filter = Filters.geoIntersects(geoFieldName, point.toGeoJsonPoint());
|
|
collection.find(filter).forEach(doc -> {
|
fenceIds.add( doc.getString("_id"));
|
});
|
|
return fenceIds;
|
}
|
|
|
public List<Document> findPointsInFence(String fenceId,
|
String pointsCollectionName,
|
String fencesCollectionName) {
|
// 1. 从围栏集合获取围栏的几何数据
|
Document fence = getFenceGeometry(fenceId, fencesCollectionName);
|
if (fence == null) {
|
throw new IllegalArgumentException("围栏不存在: " + fenceId);
|
}
|
|
// 2. 构建地理空间查询
|
Bson filter = Filters.geoWithin("location", fence.get("geometry", Document.class));
|
|
// 3. 执行查询
|
MongoCollection<Document> pointsCollection = database.getCollection(pointsCollectionName);
|
List<Document> results = new ArrayList<>();
|
|
try (MongoCursor<Document> cursor = pointsCollection.find(filter).iterator()) {
|
while (cursor.hasNext()) {
|
results.add(cursor.next());
|
}
|
}
|
|
return results;
|
}
|
/**
|
* 获取围栏的几何数据
|
*/
|
private Document getFenceGeometry(String fenceId, String fencesCollectionName) {
|
MongoCollection<Document> fencesCollection = database.getCollection(fencesCollectionName);
|
return fencesCollection.find(Filters.eq("_id", fenceId)).first();
|
}
|
|
|
/**
|
* 方法4：使用聚合管道进行复杂的地理查询
|
*/
|
public Map<String, Object> analyzePointInFences(GeoPoint point, String collectionName) {
|
MongoCollection<Document> collection = database.getCollection(collectionName);
|
|
List<Document> pipeline = Arrays.asList(
|
// 阶段1：筛选包含该点的围栏
|
new Document("$match",
|
new Document("geometry",
|
new Document("$geoIntersects",
|
new Document("$geometry", point.toDocument())
|
)
|
)
|
),
|
// 阶段2：投影所需字段
|
new Document("$project",
|
new Document("_id", 1)
|
.append("name", 1)
|
.append("type", 1)
|
.append("properties", 1)
|
.append("area", 1)
|
),
|
// 阶段3：统计
|
new Document("$group",
|
new Document("_id", null)
|
.append("totalFences", new Document("$sum", 1))
|
.append("fences", new Document("$push",
|
new Document("id", "$_id")
|
.append("name", "$name")
|
.append("type", "$type")
|
))
|
)
|
);
|
|
Document result = collection.aggregate(pipeline).first();
|
if (result != null) {
|
return result;
|
}
|
|
return new Document("totalFences", 0)
|
.append("fences", new ArrayList<>());
|
}
|
|
/**
|
* 方法5：查找距离点最近的围栏
|
*/
|
public Document findNearestFence(GeoPoint point, String collectionName, int maxDistance) {
|
MongoCollection<Document> collection = database.getCollection(collectionName);
|
|
List<Document> pipeline = Arrays.asList(
|
// 阶段1：添加距离字段
|
new Document("$geoNear",
|
new Document("near", point.toDocument())
|
.append("distanceField", "distance")
|
.append("spherical", true)
|
.append("maxDistance", maxDistance)
|
.append("query", new Document("type", "Polygon")) // 只查询多边形
|
.append("key", "geometry")
|
),
|
// 阶段2：按距离排序
|
new Document("$sort", new Document("distance", 1)),
|
// 阶段3：限制返回数量
|
new Document("$limit", 1)
|
);
|
|
return collection.aggregate(pipeline).first();
|
}
|
|
|
/**
|
* 方法7：批量判断多个点是否在围栏内
|
*/
|
public Map<GeoPoint, List<String>> batchCheckPointsInFences(List<GeoPoint> points, String collectionName) {
|
MongoCollection<Document> collection = database.getCollection(collectionName);
|
Map<GeoPoint, List<String>> result = new HashMap<>();
|
|
for (GeoPoint point : points) {
|
Bson filter = Filters.geoIntersects("geometry", point.toGeoJsonPoint());
|
List<String> fenceNames = new ArrayList<>();
|
|
collection.find(filter).forEach(doc -> {
|
fenceNames.add(doc.getString("name"));
|
});
|
|
result.put(point, fenceNames);
|
}
|
|
return result;
|
}
|
|
|
/**
|
* 查找与指定点距离在一定范围内的围栏
|
*/
|
public List<Document> findFencesNearPoint(GeoPoint point, double maxDistanceMeters, String collectionName) {
|
MongoCollection<Document> collection = database.getCollection(collectionName);
|
|
// 将米转换为弧度（适用于球面几何）
|
double maxDistanceRadians = maxDistanceMeters / 6378100; // 地球半径
|
|
Bson filter = Filters.nearSphere("geometry", point.toGeoJsonPoint(), maxDistanceRadians, 0.0);
|
|
List<Document> results = new ArrayList<>();
|
collection.find(filter).into(results);
|
|
return results;
|
}
|
|
/**
|
* 创建圆形围栏（使用$centerSphere）
|
*/
|
public void createCircleFenceUsingCenterSphere(String fenceId, String name, GeoPoint center,
|
double radiusMeters, String collectionName) {
|
MongoCollection<Document> collection = database.getCollection(collectionName);
|
|
// 将米转换为弧度
|
double radiusRadians = radiusMeters / 6378100;
|
|
Document fenceDoc = new Document()
|
.append("_id", fenceId)
|
.append("name", name)
|
.append("type", "Circle")
|
.append("center", Arrays.asList(center.getLongitude(), center.getLatitude()))
|
.append("radius", radiusRadians) // 以弧度存储
|
.append("radiusMeters", radiusMeters)
|
.append("geometry", new Document()
|
.append("type", "Point")
|
.append("coordinates", Arrays.asList(center.getLongitude(), center.getLatitude())))
|
.append("createdAt", new Date());
|
|
collection.insertOne(fenceDoc);
|
}
|
|
/**
|
* 使用$centerSphere查询圆形区域内的点
|
*/
|
public boolean isPointInCircleUsingCenterSphere(GeoPoint point, String fenceId, String collectionName) {
|
MongoCollection<Document> collection = database.getCollection(collectionName);
|
|
Document fence = collection.find(Filters.eq("_id", fenceId)).first();
|
if (fence == null) return false;
|
|
List<Double> center = (List<Double>) fence.get("center");
|
double radius = fence.getDouble("radius");
|
|
Bson filter = Filters.geoWithinCenterSphere(
|
"location", // 假设点存储在location字段
|
center.get(0), // 经度
|
center.get(1), // 纬度
|
radius
|
);
|
|
// 查找该点是否在圆形内
|
MongoCollection<Document> pointsCollection = database.getCollection("tracking_points");
|
Document pointDoc = pointsCollection.find(
|
Filters.and(
|
Filters.eq("location.coordinates",
|
Arrays.asList(point.getLongitude(), point.getLatitude())),
|
filter
|
)
|
).first();
|
|
return pointDoc != null;
|
}
|
|
/**
|
* 关闭连接
|
*/
|
public void close() {
|
if (mongoClient != null) {
|
mongoClient.close();
|
}
|
}
|
|
|
/**
|
* 查找指定父围栏ID的禁行区域点位
|
* @param parentId 父围栏ID
|
* @param parentIdField 父围栏ID字段名
|
* @param collectionName 集合名称
|
* @return 禁行区域点位列表
|
*/
|
public List<Document> findPointsByParentId(String parentId, String parentIdField, String collectionName) {
|
MongoCollection<Document> collection = database.getCollection(collectionName);
|
List<Document> points = new ArrayList<>();
|
|
// 查询父围栏ID等于指定值的所有文档
|
Bson filter = Filters.eq(parentIdField, parentId);
|
|
collection.find(filter).forEach(doc -> {
|
points.add(doc);
|
});
|
|
return points;
|
}
|
|
/**
|
* 根据围栏ID获取电子围栏点位
|
* @param fenceId 围栏ID
|
* @param collectionName 集合名称
|
* @return 电子围栏点位
|
*/
|
public Document getFenceById(String fenceId, String collectionName) {
|
MongoCollection<Document> collection = database.getCollection(collectionName);
|
return collection.find(Filters.eq("_id", fenceId)).first();
|
}
|
|
|
|
/**
|
* 根据经纬度点位判断是否在指定的电子围栏中
|
* @param longitude 经度
|
* @param latitude 纬度
|
* @param fenceId 围栏ID
|
* @param collectionName 集合名称
|
* @return 是否在围栏中
|
*/
|
public boolean isInFence(double longitude, double latitude, String fenceId, String collectionName) {
|
// 创建GeoPoint对象
|
MongoGeoFenceUtil.GeoPoint geoPoint = new MongoGeoFenceUtil.GeoPoint(longitude, latitude);
|
|
// 调用MongoGeoFenceUtil的方法查询包含该点的围栏
|
List<String> fences = findFencesContainingPoint(geoPoint, collectionName, "points");
|
|
// 检查查询结果中是否包含指定的fenceId
|
return fences.contains(fenceId);
|
}
|
|
|
}
|
