package com.se.simu.service;
|
|
import cn.hutool.core.io.FileUtil;
|
import cn.hutool.json.JSONArray;
|
import cn.hutool.json.JSONObject;
|
import cn.hutool.json.JSONUtil;
|
import com.se.simu.config.PropertiesConfig;
|
import com.se.simu.domain.dto.GeDb;
|
import com.se.simu.domain.dto.GeField;
|
import com.se.simu.domain.dto.GeFile;
|
import com.se.simu.domain.dto.GeLayer;
|
import com.se.simu.domain.po.DataPo;
|
import com.se.simu.helper.CaffeineHelper;
|
import com.se.simu.helper.RsaHelper;
|
import com.se.simu.helper.ShpHelper;
|
import com.se.simu.helper.StringHelper;
|
import lombok.extern.slf4j.Slf4j;
|
import org.gdal.gdal.Dataset;
|
import org.gdal.gdal.WarpOptions;
|
import org.gdal.gdal.gdal;
|
import org.gdal.gdalconst.gdalconst;
|
import org.gdal.ogr.Geometry;
|
import org.gdal.osr.SpatialReference;
|
import org.springframework.stereotype.Service;
|
import org.springframework.util.CollectionUtils;
|
import org.springframework.web.client.RestTemplate;
|
|
import javax.annotation.Resource;
|
import java.io.File;
|
import java.io.FileOutputStream;
|
import java.io.IOException;
|
import java.io.InputStream;
|
import java.net.URL;
|
import java.net.URLConnection;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
@Slf4j
|
@Service
|
@SuppressWarnings("ALL")
|
public class GedbService {
|
String password;
|
|
@Resource
|
PropertiesConfig config;
|
|
@Resource
|
RestTemplate restTemplate;
|
|
private final static String DB_KEY = "gedb_db";
|
|
private final static String TOKEN_KEY = "gedb_token";
|
|
public boolean test(DataPo data) throws Exception {
|
createPath(config.getInPath() + File.separator + data.getInPath());
|
|
String token = getToken();
|
GeDb db = connectGedb(token, data);
|
|
copeVectors(token, data, db);
|
|
copeDem(token, data);
|
|
return true;
|
}
|
|
private void createPath(String path) {
|
File f = new File(path);
|
if (f.exists() && f.isDirectory()) {
|
FileUtil.del(f);
|
}
|
f.mkdirs();
|
}
|
|
public String getToken() throws Exception {
|
Object obj = CaffeineHelper.get(TOKEN_KEY);
|
if (obj instanceof String) {
|
return obj.toString();
|
}
|
|
String token = getTokenByServer();
|
if (null == token) throw new Exception("获取GEDB令牌失败");
|
|
CaffeineHelper.put(TOKEN_KEY, token);
|
|
return token;
|
}
|
|
private String getTokenByServer() throws Exception {
|
Map<String, Object> map = new HashMap<>(2);
|
map.put("userid", config.getUser());
|
map.put("password", getPassword());
|
|
JSONObject obj = restTemplate.postForObject(config.getHost() + "account-service/security/login", map, JSONObject.class);
|
log.info(obj.toString());
|
|
JSONObject data = obj.getJSONObject("data");
|
|
return data.getStr("token");
|
}
|
|
private String getPassword() throws Exception {
|
if (StringHelper.isEmpty(password)) {
|
String key = getPublicKey();
|
RsaHelper.setPublicKey(key);
|
password = RsaHelper.encrypt(config.getPwd());
|
}
|
|
return password;
|
}
|
|
public String getPublicKey() {
|
//{"datetime":"2024-09-12 17:24:38","code":200,"data":"MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCtFwJCh2taVTEi05C8qT2oG7Y+rDmJhlO4zicpSeRtiro9LsytePeWI7BXM6sfDU0WeKun1izawcfgGkZgnoJuMBluAOKI1tL0uCrR+DreNLqMVtnXHwoWEIk/hGJedDWaf3q22aGDyEB5h9qCq0JklSShP1Ih4ppap4LmgxdTPQIDAQAB"}
|
JSONObject obj = restTemplate.getForObject(config.getHost() + "account-service/security/publickey", JSONObject.class);
|
|
return obj.getStr("data");
|
}
|
|
public GeDb connectGedb(String token, DataPo data) {
|
GeDb db = getGeDb(token);
|
db.setBbox(data.getBbox());
|
data.setEpsg(db.getEpsg());
|
|
return db;
|
}
|
|
public GeDb getGeDb(String token) {
|
Object obj = CaffeineHelper.get(DB_KEY);
|
if (obj instanceof GeDb) {
|
return (GeDb) obj;
|
}
|
|
Map<String, Object> map = new HashMap<>(1);
|
map.put("token", token);
|
|
JSONObject jsonObject = restTemplate.postForObject(config.getHost() + "geo-service/entitydb/list/canview", map, JSONObject.class);
|
JSONArray data = jsonObject.getJSONArray("data");
|
|
List<GeDb> list = JSONUtil.toList(data, GeDb.class);
|
if (CollectionUtils.isEmpty(list)) return null;
|
|
GeDb gedb = list.stream().filter(db -> null != db.getName() && db.getName().contains(config.getDbName())).findFirst().orElse(null);
|
if (null != gedb) CaffeineHelper.put(DB_KEY, gedb);
|
|
return gedb;
|
}
|
|
public List<GeLayer> getLayers(String token, GeDb db) {
|
String uri = String.format("%sgeo-service/entitydb/map/config?dbid=%s&token=%s", config.getHost(), db.getDbid(), token);
|
JSONObject obj = restTemplate.getForObject(uri, JSONObject.class);
|
|
JSONObject data = obj.getJSONObject("data");
|
JSONArray arr = data.getJSONArray("layers");
|
if (null == arr || arr.size() == 0) return null;
|
|
List<GeLayer> layers = new ArrayList<>();
|
for (int i = 0, c = arr.size(); i < c; i++) {
|
JSONObject jb = arr.getJSONObject(i);
|
String name = jb.getStr("name");
|
if (config.getLayerNames().contains(name)) {
|
String id = jb.getStr("id");
|
String queryType = getQueryType(jb);
|
List<GeField> fields = JSONUtil.toList(jb.getJSONArray("fields"), GeField.class);
|
fields = fields.stream().filter(f -> !config.getSysFields().contains(f.getName())).collect(Collectors.toList());
|
String shpName = config.getShpNames().get(config.getLayerNames().indexOf(name));
|
|
layers.add(new GeLayer(id, name, queryType, fields, shpName, db));
|
}
|
}
|
|
return layers;
|
}
|
|
public static String getQueryType(JSONObject jb) {
|
String qt = jb.getStr("pointlod");
|
if (!StringHelper.isEmpty(qt)) {
|
return "point";
|
}
|
|
qt = jb.getStr("polylinelod");
|
if (!StringHelper.isEmpty(qt)) {
|
return "polyline";
|
}
|
|
return "polygon";
|
}
|
|
public void queryData(String token, GeDb db, List<GeLayer> layers) throws Exception {
|
for (GeLayer layer : layers) {
|
int count = getCount(token, db, layer);
|
if (0 == count) throw new Exception(layer.getName() + "，图层数据为空");
|
|
int pageCount = (count - 1) / config.getPageSize() + 1;
|
for (int i = 0; i < pageCount; i++) {
|
JSONArray data = query(token, db, layer, i + 1, config.getPageSize());
|
if (null != data && data.size() > 0) {
|
layer.addData(data);
|
}
|
}
|
}
|
}
|
|
public boolean queryBboxCount(String token, GeDb db, List<GeLayer> layers) {
|
for (GeLayer layer : layers) {
|
int count = getCount(token, db, layer);
|
if (0 == count) return false;
|
}
|
|
return true;
|
}
|
|
private int getCount(String token, GeDb db, GeLayer layer) {
|
Map<String, Object> map = new HashMap<>(6);
|
map.put("token", token);
|
map.put("dbid", db.getDbid());
|
map.put("bbox", db.getBbox());
|
map.put("layerid", layer.getId());
|
map.put("returnCountOnly", true);
|
map.put("inSR", 4326);
|
|
JSONObject obj = restTemplate.postForObject(config.getHost() + "geo-service/entitydbdata/layer/query", map, JSONObject.class);
|
if (null == obj || 200 != obj.getInt("code")) return 0;
|
|
return obj.getInt("data");
|
}
|
|
private JSONArray query(String token, GeDb db, GeLayer layer, int start, int count) {
|
Map<String, Object> map = new HashMap<>(9);
|
map.put("token", token);
|
map.put("start", start);
|
map.put("count", count);
|
map.put("dbid", db.getDbid());
|
map.put("bbox", db.getBbox());
|
map.put("containCount", false);
|
map.put("layerid", layer.getId());
|
map.put("querytype", layer.getQueryType());
|
map.put("inSR", 4326);
|
|
JSONObject obj = restTemplate.postForObject(config.getHost() + "geo-service/entitydbdata/layer/query", map, JSONObject.class);
|
if (null == obj || 200 != obj.getInt("code")) return null;
|
|
JSONObject data = obj.getJSONObject("data");
|
|
return data.getJSONArray("features");
|
}
|
|
public void copeVectors(String token, DataPo data, GeDb db) throws Exception {
|
String basePath = config.getInPath() + File.separator + data.getInPath();
|
|
List<GeLayer> layers = getLayers(token, db);
|
queryData(token, db, layers);
|
checkData(data, db, layers);
|
createShps(basePath, layers);
|
createZoneShp(basePath, data, db.getSpatialReference());
|
if (data.getPid() > 0) {
|
createFloodShp(basePath, data, db.getSpatialReference());
|
}
|
}
|
|
private void checkData(DataPo data, GeDb db, List<GeLayer> layers) {
|
GeLayer point = getLayerByName(layers, config.getLayerNames().get(0));
|
GeLayer line = getLayerByName(layers, config.getLayerNames().get(1));
|
GeLayer build = getLayerByName(layers, config.getLayerNames().get(2));
|
|
Geometry extent = ShpHelper.createPolygon(db.getSpatialReference(), data.getMinx(), data.getMiny(), data.getMaxx(), data.getMaxy());
|
checkSpatialRange(extent, point);
|
checkSpatialRange(extent, build);
|
|
List<String> bsm = getValues(point, "bsm");
|
List<String> bsm2 = new ArrayList<>(bsm);
|
List<String> qdbsm = getValues(line, "qdbsm");
|
List<String> qdbsm2 = new ArrayList<>(qdbsm);
|
List<String> zdbsm = getValues(line, "zdbsm");
|
List<String> zdbsm2 = new ArrayList<>(zdbsm);
|
|
qdbsm.removeAll(bsm2);
|
zdbsm.removeAll(bsm2);
|
removeValues(line, "qdbsm", qdbsm);
|
removeValues(line, "zdbsm", zdbsm);
|
|
qdbsm = getValues(line, "qdbsm");
|
zdbsm = getValues(line, "zdbsm");
|
bsm.removeAll(qdbsm);
|
bsm.removeAll(zdbsm);
|
removeValues(point, "bsm", bsm);
|
|
GeLayer juncLayer = new GeLayer(point, filterLayerData(point.getData()));
|
juncLayer.setName("集水点");
|
juncLayer.setShpName(config.getJunctionName());
|
layers.add(juncLayer);
|
}
|
|
private void checkSpatialRange(Geometry extent, GeLayer geLayer) {
|
int i = 0;
|
while (i < geLayer.getData().size()) {
|
JSONObject geom = geLayer.getData().getJSONObject(i).getJSONObject("geometry");
|
Geometry g = ShpHelper.createGeometry(geLayer, geom);
|
g.AssignSpatialReference(extent.GetSpatialReference());
|
|
if (!extent.Intersects(g)) {
|
geLayer.getData().remove(i);
|
continue;
|
}
|
i++;
|
}
|
}
|
|
private GeLayer getLayerByName(List<GeLayer> layers, String name) {
|
return layers.stream().filter(a -> a.getName().equals(name)).findFirst().orElse(null);
|
}
|
|
private List<String> getValues(GeLayer layer, String field) {
|
JSONArray data = layer.getData();
|
List<String> list = new ArrayList<>();
|
|
int i = 0;
|
while (i < data.size()) {
|
JSONObject obj = data.getJSONObject(i).getJSONObject("properties");
|
if (StringHelper.isEmpty(obj.getStr(field))) {
|
data.remove(i);
|
continue;
|
}
|
list.add(obj.getStr(field));
|
i++;
|
}
|
|
return list;
|
}
|
|
private void removeValues(GeLayer layer, String field, List<String> values) {
|
if (CollectionUtils.isEmpty(values)) return;
|
|
int i = 0;
|
JSONArray data = layer.getData();
|
while (i < data.size()) {
|
JSONObject obj = data.getJSONObject(i).getJSONObject("properties");
|
if (values.contains(obj.getStr(field))) {
|
data.remove(i);
|
continue;
|
}
|
i++;
|
}
|
}
|
|
private void createShps(String basePath, List<GeLayer> layers) throws Exception {
|
for (GeLayer layer : layers) {
|
String path = basePath + File.separator + layer.getShpName();
|
if (layer.getData().isEmpty() || !ShpHelper.createShp(path, layer)) {
|
throw new Exception(layer.getName() + "，创建ShapeFile文件失败！");
|
}
|
}
|
}
|
|
private JSONArray filterLayerData(JSONArray data) {
|
JSONArray arr = new JSONArray();
|
String[] strs = config.getJunctionFilter().split("=");
|
for (int i = 0, c = data.size(); i < c; i++) {
|
JSONObject obj = data.getJSONObject(i).getJSONObject("properties");
|
if (strs[1].equals(obj.getStr(strs[0]))) {
|
arr.put(data.getJSONObject(i));
|
}
|
}
|
|
return arr;
|
}
|
|
private void createZoneShp(String basePath, DataPo data, SpatialReference sr) {
|
String filePath = basePath + File.separator + config.getZoneName();
|
ShpHelper.createShp(filePath, null, sr, data.getMinx(), data.getMiny(), data.getMaxx(), data.getMaxy());
|
}
|
|
private void createFloodShp(String basePath, DataPo data, SpatialReference sr) {
|
String filePath = basePath + File.separator + config.getBarrierName();
|
Map<String, Object> map = new HashMap<>();
|
map.put("height", data.getFloodHeight());
|
map.put("type", data.getFloodType());
|
|
ShpHelper.createShp(filePath, map, sr, data.getFloodMinx(), data.getFloodMiny(), data.getFloodMaxx(), data.getFloodMaxy());
|
}
|
|
public void copeDem(String token, DataPo data) throws Exception {
|
GeDb fileDb = getFileDb(token);
|
String fileId = getFileId(token, fileDb.getDbid());
|
List<GeFile> files = getFileNames(token, fileDb.getDbid(), fileId);
|
|
String filePath = config.getInPath() + File.separator + fileDb.getDbid();
|
downloadFiles(token, filePath, files, fileDb.getDbid(), fileId);
|
clipDemFile(filePath, files, data);
|
}
|
|
private GeDb getFileDb(String token) {
|
String uri = String.format("%sfile-service/docdb/query/canview?token=%s", config.getHost(), token);
|
JSONObject obj = restTemplate.getForObject(uri, JSONObject.class);
|
JSONArray data = obj.getJSONArray("data");
|
|
List<GeDb> list = JSONUtil.toList(data, GeDb.class);
|
if (CollectionUtils.isEmpty(list)) return null;
|
|
return list.stream().filter(db -> null != db.getName() && db.getName().contains(config.getDbName())).findFirst().orElse(null);
|
}
|
|
private String getFileId(String token, String dbid) {
|
String uri = String.format("%sfile-service/doc/catagory/file/query?token=%s&dbid=%s&catagory=%s&count=%d&start=%d&like=",
|
config.getHost(), token, dbid, "image", 9999, 1);
|
|
JSONObject obj = restTemplate.getForObject(uri, JSONObject.class);
|
JSONArray items = obj.getJSONObject("data").getJSONArray("items");
|
|
for (int i = 0, c = items.size(); i < c; i++) {
|
JSONObject jb = items.getJSONObject(i);
|
if (config.getDemName().equals(jb.getStr("filename"))) {
|
return jb.getStr("fileid");
|
}
|
}
|
|
return null;
|
}
|
|
private List<GeFile> getFileNames(String token, String dbid, String fileId) {
|
String uri = String.format("%sfile-service/doc/cluster/struct/list?token=%s&dbid=%s&cluster_fileid=%s&onlychild=true&folder_stairs=",
|
config.getHost(), token, dbid, fileId);
|
|
JSONObject obj = restTemplate.getForObject(uri, JSONObject.class);
|
JSONArray data = obj.getJSONArray("data");
|
|
return JSONUtil.toList(data, GeFile.class);
|
}
|
|
private void downloadFiles(String token, String path, List<GeFile> files, String dbid, String fileId) throws IOException {
|
File f = new File(path);
|
if (!f.exists() || !f.isDirectory()) {
|
f.mkdirs();
|
}
|
|
for (GeFile geFile : files) {
|
String filePath = path + File.separator + geFile.getName();
|
f = new File(filePath);
|
if (f.exists() && f.length() == geFile.getSize()) {
|
continue;
|
}
|
if (f.exists() && f.length() < geFile.getSize()) {
|
f.delete();
|
}
|
|
String uri = String.format("%sfile-service/fileparser/cluster/download/%s?token=%s&dbid=%s&cluster_fileid=%s",
|
config.getHost(), geFile.getName(), token, dbid, fileId);
|
downloadFile(uri, filePath);
|
}
|
}
|
|
private void downloadFile(String uri, String filePath) throws IOException {
|
URL url = new URL(uri);
|
URLConnection conn = url.openConnection();
|
InputStream is = conn.getInputStream();
|
|
byte[] buffer = new byte[1024];
|
FileOutputStream fs = new FileOutputStream(filePath);
|
|
int read = 0, sum = 0;
|
while ((read = is.read(buffer)) != -1) {
|
sum += read;
|
fs.write(buffer, 0, read);
|
}
|
|
fs.flush();
|
fs.close();
|
is.close();
|
}
|
|
private void clipDemFile(String filePath, List<GeFile> files, DataPo data) throws Exception {
|
String target = config.getInPath() + File.separator + data.getInPath() + File.separator + config.getDemFile();
|
for (GeFile file : files) {
|
if (file.getName().toLowerCase().endsWith(config.getDemType())) {
|
String source = filePath + File.separator + file.getName();
|
clipDem(source, target, data);
|
break;
|
}
|
}
|
}
|
|
private void clipDem(String source, String target, DataPo data) throws Exception {
|
Dataset ds = null;
|
try {
|
ds = gdal.Open(source, gdalconst.GA_ReadOnly);
|
if (null == ds || ds.getRasterCount() < 1 || null == ds.GetSpatialRef()) throw new Exception("DEM数据无效");
|
|
// String bbox = "116.64388473935195,39.884315914604464,116.64754729082588,39.887069143903496";
|
Vector<String> vector = new Vector<>();
|
//vector.add("-s_srs");
|
//vector.add("EPSG:" + 4326);
|
vector.add("-t_srs");
|
vector.add("EPSG:" + data.getEpsg());
|
vector.add("-r");
|
vector.add("bilinear");
|
vector.add("-of");
|
vector.add("GTiff");
|
vector.add("-te");
|
vector.add(data.getMinx().toString());
|
vector.add(data.getMiny().toString());
|
vector.add(data.getMaxx().toString());
|
vector.add(data.getMaxy().toString());
|
vector.add("-te_srs");
|
vector.add("EPSG:" + 4326);
|
WarpOptions warpOptions = new WarpOptions(vector);
|
|
// gdalwarp -ot UInt16 -s_srs EPSG:4326 -t_srs EPSG:2382 -r bilinear -of GTiff -te 116.526854182 40.0481829856 116.532848182 40.0541769856
|
// -te_srs EPSG:4326 -co COMPRESS=DEFLATE -co PREDICTOR=1 -co ZLEVEL=6 -co TILED=YES -wo OPTIMIZE_SIZE=TRUE E:\GDALhomework\000002.tif E:/CSDN/warped1.tif
|
|
Dataset destDs = gdal.Warp(target, new Dataset[]{ds}, warpOptions);
|
destDs.delete();
|
} finally {
|
if (null != ds) ds.delete();
|
}
|
}
|
}
|
