数据选择
@@ -156,7 +139,7 @@
inputform.minTurnRadius || 0
}}，最大车辆载重{{ inputform.load || 0 }}吨
-
+
新增
-
+
-
+
-
+
-
+
-
+
-
+
编辑
保存
删除
@@ -248,7 +231,7 @@
import Cookies from 'js-cookie'
import axios from 'axios'
import iniParser from 'ini-parser'
-import configIni from '/config.ini';
+import configIni from '/public/config.ini'
export default {
data() {
@@ -321,7 +304,7 @@ export default {
.catch((error) => {})
},
async initMap() {
- const parsedData = iniParser.parse(configIni);
+ const parsedData = iniParser.parse(configIni)
this.viewer = new window.mars3d.Map(
'map',
{
@@ -356,7 +339,7 @@ export default {
this.shortestPathLayer = new window.mars3d.layer.GraphicLayer()
this.viewer.addLayer(this.shortestPathLayer)
-
+
this.accordFactoryLayer = new window.mars3d.layer.GraphicLayer()
this.viewer.addLayer(this.accordFactoryLayer)
this.loadShapefile() // 拿到路网数据
@@ -450,7 +433,7 @@ export default {
outline: false,
},
})
- this.graphicLayer.addGraphic(graphicLine);
+ this.graphicLayer.addGraphic(graphicLine)
})
this.roadNetworkGeoJSONBuild = this.buildGraph(this.roadNetworkGeoJSON)
this.loadFactoryGeoJson() // 拿到厂房数据
@@ -500,7 +483,7 @@ export default {
this.accordPoint = graphic
try {
// 创建缓冲区的宽度
- const bufferWidth = this.hideform.radius; // 避让区的宽度（单位：米）
+ const bufferWidth = this.hideform.radius // 避让区的宽度（单位：米）
// 获取绘制的点的坐标
const pointCoordinates = [
graphic.toGeoJSON().geometry.coordinates[0],
@@ -514,12 +497,12 @@ export default {
coordinates: pointCoordinates,
},
properties: {},
- };
+ }
// 使用 Turf.js 计算缓冲区
- let buffered = turf.buffer(pointFeature, bufferWidth / 1000, { units: 'kilometers' });
+ let buffered = turf.buffer(pointFeature, bufferWidth / 1000, {units: 'kilometers'})
// 将缓冲区存储到数组中
- this.bufferLayerList.push(buffered);
+ this.bufferLayerList.push(buffered)
const polygon = new window.mars3d.graphic.PolygonEntity({
positions: buffered.geometry.coordinates[0],
style: {
@@ -529,19 +512,19 @@ export default {
outlineWidth: 1,
outlineColor: '#ffffff',
},
- time: new Date().getTime()
+ time: new Date().getTime(),
})
- this.accordFactoryLayer.addGraphic(polygon);
+ this.accordFactoryLayer.addGraphic(polygon)
// 检查缓冲区内的厂房
- this.checkFactoryInBuffer('point', pointCoordinates);
+ this.checkFactoryInBuffer('point', pointCoordinates)
} catch (error) {
- console.error("缓冲区生成或检查异常:", error);
+ console.error('缓冲区生成或检查异常:', error)
}
},
})
},
// 获取当前路线的缓冲区
- hadBuffer () {
+ hadBuffer() {
if (this.shortestPathList.length == 0) {
this.$message.warning('请先进行路线规划')
return
@@ -562,30 +545,30 @@ export default {
for (const feature of this.shortestPathList[0]) {
// this.shortestPathList[0].forEach((feature) => {
// 创建缓冲区的宽度
- const bufferWidth = this.hideform.radius; // 避让区的宽度（单位：米）
+ const bufferWidth = this.hideform.radius // 避让区的宽度（单位：米）
if (feature.geometry.type === 'LineString') {
- const positions = feature.geometry.coordinates[0];
+ const positions = feature.geometry.coordinates[0]
// 确保每条线至少有 2 个点
if (positions.length < 2) {
- console.warn('无效的线，跳过:', feature);
- return;
+ console.warn('无效的线，跳过:', feature)
+ return
}
try {
// 使用 Turf.js 计算缓冲区
- var buffered = turf.buffer(feature, bufferWidth / 1000, { units: 'kilometers' });
+ var buffered = turf.buffer(feature, bufferWidth / 1000, {units: 'kilometers'})
// 将缓冲区存储到数组中
- this.bufferLayerList.push(buffered);
+ this.bufferLayerList.push(buffered)
} catch (error) {
- console.error("缓冲分析异常:", error);
+ console.error('缓冲分析异常:', error)
}
} else if (feature.geometry.type === 'MultiLineString') {
// 遍历每个线段
feature.geometry.coordinates.forEach((lineCoordinates) => {
// 检查每个线段是否有效
if (lineCoordinates.length < 2) {
- console.warn('多线段中的无效的线段，跳过:', lineCoordinates);
- return;
+ console.warn('多线段中的无效的线段，跳过:', lineCoordinates)
+ return
}
// 创建单个线段的 GeoJSON 特征
@@ -595,27 +578,27 @@ export default {
type: 'LineString',
coordinates: lineCoordinates,
},
- properties: feature.properties
- };
+ properties: feature.properties,
+ }
try {
// 使用 Turf.js 计算缓冲区
- var buffered = turf.buffer(lineFeature, bufferWidth / 1000, { units: 'kilometers' });
+ var buffered = turf.buffer(lineFeature, bufferWidth / 1000, {units: 'kilometers'})
// 将缓冲区存储到数组中
- this.bufferLayerList.push(buffered);
+ this.bufferLayerList.push(buffered)
} catch (error) {
- console.error("缓冲分析异常:", error);
+ console.error('缓冲分析异常:', error)
}
- });
+ })
} else {
- console.warn('不支持的几何类型:', feature.geometry.type);
+ console.warn('不支持的几何类型:', feature.geometry.type)
}
- }
-
+ }
+
// 去筛选在缓存区的厂房
- this.checkFactoryInBuffer('line');
- }catch (error) {
- console.error("处理路径列表时发生错误:", error);
+ this.checkFactoryInBuffer('line')
+ } catch (error) {
+ console.error('处理路径列表时发生错误:', error)
}
},
checkFactoryInBuffer(type, pointInfo) {
@@ -636,106 +619,106 @@ export default {
// 检查几何对象的类型
if (factory.geometry.type === 'MultiPolygon') {
// 创建多边形集合（MultiPolygon）
- const factoryMultiPoly = turf.multiPolygon(factory.geometry.coordinates);
+ const factoryMultiPoly = turf.multiPolygon(factory.geometry.coordinates)
// 计算整个多边形集合的面积
- const area = turf.area(factoryMultiPoly);
+ const area = turf.area(factoryMultiPoly)
// 计算工厂多边形集合的边界框
- const [minX, minY, maxX, maxY] = turf.bbox(factoryMultiPoly);
+ const [minX, minY, maxX, maxY] = turf.bbox(factoryMultiPoly)
// 筛选与工厂边界框相交的缓冲区
const candidates = this.bufferLayerList.filter((buffer) => {
- const [bminX, bminY, bmaxX, bmaxY] = turf.bbox(buffer);
- return !(bmaxX < minX || bminX > maxX || bmaxY < minY || bminY > maxY);
- });
+ const [bminX, bminY, bmaxX, bmaxY] = turf.bbox(buffer)
+ return !(bmaxX < minX || bminX > maxX || bmaxY < minY || bminY > maxY)
+ })
// 精确相交检测
- let isInside = false;
+ let isInside = false
for (const buffer of candidates) {
if (turf.booleanIntersects(factoryMultiPoly, buffer)) {
// 如果工厂在缓冲区内，绘制所有多边形
- isInside = true;
- this.drawFactory(factory.geometry.coordinates, factory, area, pointInfo);
- break;
+ isInside = true
+ this.drawFactory(factory.geometry.coordinates, factory, area, pointInfo)
+ break
}
}
// 如果工厂不在任何缓冲区内
- resolve();
+ resolve()
} else {
- reject(new Error('不支持的几何类型'));
+ reject(new Error('不支持的几何类型'))
}
})
- });
+ })
// 确保所有工厂处理完成后进行排序
Promise.allSettled(factoryPromises)
.then(async (results) => {
// 只有路线隐蔽规划需要塞入车辆 点的不需要
// 所有工厂处理完成，进行排序 按照距离近到远
- this.accordFactoryInfo.sort((a, b) => a.distance - b.distance);
+ this.accordFactoryInfo.sort((a, b) => a.distance - b.distance)
// 拿到当前的车队车辆信息 并且算出面积 按照从大到小排序
const areaList = JSON.parse(Cookies.get('minTurnRadius'))
areaList.map((item) => {
item.area = Number(item.long) * Number(item.width)
})
- areaList.sort((a, b) => b.area - a.area);
+ areaList.sort((a, b) => b.area - a.area)
// 初始化每个工厂的剩余面积
- this.accordFactoryInfo.forEach(factory => {
- factory.remainingArea = factory.area; // 记录每个工厂的剩余可用面积
- factory.vehicles = []; // 确保每个工厂都有一个 vehicles 属性
- });
+ this.accordFactoryInfo.forEach((factory) => {
+ factory.remainingArea = factory.area // 记录每个工厂的剩余可用面积
+ factory.vehicles = [] // 确保每个工厂都有一个 vehicles 属性
+ })
// 遍历每个车辆，尝试塞入工厂
areaList.forEach((vehicle) => {
- let isPlaced = false;
+ let isPlaced = false
// 遍历每个工厂，尝试塞入车辆
for (let i = 0; i < this.accordFactoryInfo.length; i++) {
- const factory = this.accordFactoryInfo[i];
+ const factory = this.accordFactoryInfo[i]
// 检查工厂是否还有剩余面积
if (factory.remainingArea >= vehicle.area) {
// 塞入车辆
factory.vehicles.push({
...vehicle,
- remainingArea: factory.remainingArea - vehicle.area // 记录车辆塞入后的工厂剩余面积
- });
+ remainingArea: factory.remainingArea - vehicle.area, // 记录车辆塞入后的工厂剩余面积
+ })
// 更新工厂的剩余面积
- factory.remainingArea -= vehicle.area;
+ factory.remainingArea -= vehicle.area
// 标记车辆已放置
- isPlaced = true;
- break;
+ isPlaced = true
+ break
}
}
// 如果车辆没有被放置，可以在这里处理（例如记录日志或显示警告）
if (!isPlaced) {
- console.warn(`车辆 ${vehicle.id} 无法放置在任何工厂中`);
+ console.warn(`车辆 ${vehicle.id} 无法放置在任何工厂中`)
}
- });
+ })
// 更新 this.accordFactoryInfo
- this.accordFactoryInfo = this.accordFactoryInfo.map(factory => {
+ this.accordFactoryInfo = this.accordFactoryInfo.map((factory) => {
// 确保每个工厂都有 vehicles 属性
if (!factory.vehicles) {
- factory.vehicles = [];
+ factory.vehicles = []
}
// 确保 remainingArea 是一个数字且大于 0
- factory.area = factory.area > 0 ? factory.area : 0;
- return factory;
- });
+ factory.area = factory.area > 0 ? factory.area : 0
+ return factory
+ })
// 过滤出有车辆的工厂
- const factoriesWithVehicles = this.accordFactoryInfo.filter(factory => factory.vehicles.length > 0);
+ const factoriesWithVehicles = this.accordFactoryInfo.filter((factory) => factory.vehicles.length > 0)
this.factoriesWithVehicles = factoriesWithVehicles
- await this.showAreaInfoDialog(factoriesWithVehicles);
+ await this.showAreaInfoDialog(factoriesWithVehicles)
})
.catch((error) => {
console.error('数据有问题', error)
- });
+ })
},
drawFactory(factoryMultiPoly, factory, area, pointInfo) {
// 获取当前多边形集合的中心点
- const center = turf.center(turf.multiPolygon(factory.geometry.coordinates));
+ const center = turf.center(turf.multiPolygon(factory.geometry.coordinates))
// 将中心点转换为 Mars3D 的 LngLatPoint 对象
- const popupPosition = new mars3d.LngLatPoint(center.geometry.coordinates[0], center.geometry.coordinates[1]);
+ const popupPosition = new mars3d.LngLatPoint(center.geometry.coordinates[0], center.geometry.coordinates[1])
// 遍历每个多边形集合
factory.geometry.coordinates[0].forEach((coordGroup) => {
// 创建一个多边形图形
@@ -747,35 +730,39 @@ export default {
outline: true,
outlineWidth: 1,
outlineColor: '#ffffff',
- properties: { ...factory.properties },
+ properties: {...factory.properties},
},
- time: new Date().getTime()
+ time: new Date().getTime(),
})
- this.accordFactoryLayer.addGraphic(graphic);
+ this.accordFactoryLayer.addGraphic(graphic)
// 计算多边形中心与参考点的距离
const point = pointInfo && pointInfo.length > 0 ? pointInfo : this.form.endPoint.split(',').map(Number)
- const distance = turf.distance(center.geometry.coordinates, point, { units: 'kilometers' }) * 1000; // 米
+ const distance = turf.distance(center.geometry.coordinates, point, {units: 'kilometers'}) * 1000 // 米
// 将多边形图形添加到地图层
this.accordFactoryInfo.push({
...graphic,
distance: distance,
popupPosition: popupPosition,
- area: this.hideform.redundancy && this.hideform.redundancy != 0 && area > 0
- ? area * (100 - this.hideform.redundancy) * 0.01
- : area > 0
- ? area
- : 0, // 如果 area 不是有效值，设置为 0 或其他默认值
+ area:
+ this.hideform.redundancy && this.hideform.redundancy != 0 && area > 0
+ ? area * (100 - this.hideform.redundancy) * 0.01
+ : area > 0
+ ? area
+ : 0, // 如果 area 不是有效值，设置为 0 或其他默认值
})
})
},
// 显示面积信息弹框的方法
async showAreaInfoDialog(info) {
- const graphics = this.accordFactoryLayer.getGraphics();
- const promises = [];
+ const graphics = this.accordFactoryLayer.getGraphics()
+ const promises = []
info.forEach((item) => {
graphics.forEach((ele) => {
- if (ele.options.time === item.options.time && ele.options.style.properties.FID_1 === item.options.style.properties.FID_1) {
- const textInfo = `${item.area.toFixed(2)}㎡ \n（${item.vehicles.map(e => e.name).join(',')}）`
+ if (
+ ele.options.time === item.options.time &&
+ ele.options.style.properties.FID_1 === item.options.style.properties.FID_1
+ ) {
+ const textInfo = `${item.area.toFixed(2)}㎡ \n（${item.vehicles.map((e) => e.name).join(',')}）`
const labelGraphic = new window.mars3d.graphic.LabelEntity({
id: 'label',
position: item.popupPosition,
@@ -788,34 +775,34 @@ export default {
outlineColor: '#000000',
background: true,
backgroundColor: '#2f705f',
- }
+ },
})
// 使用 Promise 确保标签添加完成后继续执行
const promise = new Promise((resolve, reject) => {
this.accordFactoryLayer.addGraphic(labelGraphic, () => {
- resolve();
- });
- });
+ resolve()
+ })
+ })
- promises.push(promise);
+ promises.push(promise)
}
})
})
- this.$message.success("路线隐蔽规划成功")
- const popupPositionList = info.map(item => item.popupPosition)
- let minLng = Infinity;
- let maxLng = -Infinity;
- let minLat = Infinity;
- let maxLat = -Infinity;
+ this.$message.success('路线隐蔽规划成功')
+ const popupPositionList = info.map((item) => item.popupPosition)
+ let minLng = Infinity
+ let maxLng = -Infinity
+ let minLat = Infinity
+ let maxLat = -Infinity
- popupPositionList.forEach(point => {
- if (point.lng < minLng) minLng = point.lng;
- if (point.lng > maxLng) maxLng = point.lng;
- if (point.lat < minLat) minLat = point.lat;
- if (point.lat > maxLat) maxLat = point.lat;
- });
+ popupPositionList.forEach((point) => {
+ if (point.lng < minLng) minLng = point.lng
+ if (point.lng > maxLng) maxLng = point.lng
+ if (point.lat < minLat) minLat = point.lat
+ if (point.lat > maxLat) maxLat = point.lat
+ })
// 创建一个矩形区域，包含所有点
- const rectangle = Cesium.Rectangle.fromDegrees(minLng, minLat, maxLng, maxLat);
+ const rectangle = Cesium.Rectangle.fromDegrees(minLng, minLat, maxLng, maxLat)
this.viewer.scene.camera.flyTo({
destination: Cesium.Cartesian3.fromDegrees(
@@ -826,29 +813,29 @@ export default {
orientation: {
heading: Cesium.Math.toRadians(0), // 方位角
pitch: Cesium.Math.toRadians(-90), // 俯仰角
- roll: 0.0 // 翻滚角
+ roll: 0.0, // 翻滚角
},
- duration: 2 // 飞行动画持续时间，单位为秒
- });
+ duration: 2, // 飞行动画持续时间，单位为秒
+ })
},
// 弹框
async openDialog() {
this.multipleSelection = []
await fetch('./data/minTurnRadius.json')
- .then((response) => {
- return response.json()
- })
- .then(async (data) => {
- this.dialogVisible = true;
- this.tableData = data
- await this.$nextTick(() => {
- this.multipleSelection = JSON.parse(Cookies.get('minTurnRadius'))
- this.multipleSelection.forEach((item) => {
- this.$refs.vxeTable.setCheckboxRowKey(item.id, true)
+ .then((response) => {
+ return response.json()
+ })
+ .then(async (data) => {
+ this.dialogVisible = true
+ this.tableData = data
+ await this.$nextTick(() => {
+ this.multipleSelection = JSON.parse(Cookies.get('minTurnRadius'))
+ this.multipleSelection.forEach((item) => {
+ this.$refs.vxeTable.setCheckboxRowKey(item.id, true)
+ })
})
})
- })
- .catch((error) => {})
+ .catch((error) => {})
},
handleSelectionChange({records}) {
this.multipleSelection = records
@@ -886,35 +873,39 @@ export default {
load: null,
minTurnRadius: null,
editing: true,
- };
- this.tableData.push(newRow);
+ }
+ this.tableData.push(newRow)
},
handleDelete(row) {
- const index = this.tableData.findIndex(item => item.id === row.id);
+ const index = this.tableData.findIndex((item) => item.id === row.id)
if (index !== -1) {
- this.tableData.splice(index, 1);
+ this.tableData.splice(index, 1)
}
},
handleEdit(row) {
- this.$set(row, 'editing', true);
+ this.$set(row, 'editing', true)
},
handleSave(row) {
- this.$set(row, 'editing', false);
+ this.$set(row, 'editing', false)
},
// 保存列表数据
suerCofirm() {
- const parsedData = iniParser.parse(configIni);
- axios.post(`http://${parsedData.http.address}:${parsedData.http.port}/api/equpment`, JSON.stringify(this.tableData), {
- headers: {
- 'Authorization': 'Bearer your_token_here',
- 'Content-Type': 'application/json'
- }
- })
- .then(response => {
- this.$message.success('保存成功')
- })
- .catch(error => {
- });
+ const parsedData = iniParser.parse(configIni)
+ axios
+ .post(
+ `http://${parsedData.http.address}:${parsedData.http.port}/api/equpment`,
+ JSON.stringify(this.tableData),
+ {
+ headers: {
+ Authorization: 'Bearer your_token_here',
+ 'Content-Type': 'application/json',
+ },
+ }
+ )
+ .then((response) => {
+ this.$message.success('保存成功')
+ })
+ .catch((error) => {})
},
// 导入json文件
triggerFileUpload() {
@@ -981,21 +972,12 @@ export default {
}
},
addPointToMap(type, point, time) {
- const coords = time
- ? point.points.split(',').map(Number)
- : point.split(',').map(Number)
+ const coords = time ? point.points.split(',').map(Number) : point.split(',').map(Number)
const graphic = new window.mars3d.graphic.PointEntity({
position: new window.mars3d.LngLatPoint(coords[0], coords[1]),
style: {
pixelSize: 10,
- color:
- type === 'startPoint'
- ? 'red'
- : type === 'endPoint'
- ? 'red'
- : type === 'viaPoints'
- ? 'blue'
- : 'orange',
+ color: type === 'startPoint' ? 'red' : type === 'endPoint' ? 'red' : type === 'viaPoints' ? 'blue' : 'orange',
label: {
text:
type === 'startPoint'
@@ -1029,9 +1011,7 @@ export default {
addPolygonToMap(type, area, time) {
const coords = JSON.parse(area.points)
const graphic = new window.mars3d.graphic.PolygonEntity({
- positions: coords.map(
- (coord) => new window.mars3d.LngLatPoint(coord[0], coord[1])
- ),
+ positions: coords.map((coord) => new window.mars3d.LngLatPoint(coord[0], coord[1])),
style: {
color: 'red',
opacity: 0.4,
@@ -1086,94 +1066,55 @@ export default {
}
} else if (type === 'viaPoints') {
if (!row.points) {
- const graphic = this.viaPoints.find(
- (viaPoint) => viaPoint.style.time === row.time
- )
- if (
- this.form.viaPoints.length === 1 &&
- this.form.viaPoints[0].points === ''
- ) {
+ const graphic = this.viaPoints.find((viaPoint) => viaPoint.style.time === row.time)
+ if (this.form.viaPoints.length === 1 && this.form.viaPoints[0].points === '') {
// 如果只剩下一个空项，不删除图形，清空输入框值
this.form.viaPoints[0].points = ''
graphic?.remove()
- this.viaPoints = this.viaPoints.filter(
- (viaPoint) => viaPoint.style.time !== row.time
- )
+ this.viaPoints = this.viaPoints.filter((viaPoint) => viaPoint.style.time !== row.time)
} else {
- this.form.viaPoints = this.form.viaPoints.filter(
- (viaPoint) => viaPoint.time !== row.time
- )
+ this.form.viaPoints = this.form.viaPoints.filter((viaPoint) => viaPoint.time !== row.time)
}
graphic?.remove()
- this.viaPoints = this.viaPoints.filter(
- (viaPoint) => viaPoint.style.time !== row.time
- )
+ this.viaPoints = this.viaPoints.filter((viaPoint) => viaPoint.style.time !== row.time)
} else {
- const graphic = this.viaPoints.find(
- (viaPoint) => viaPoint.style.time === row.time
- )
+ const graphic = this.viaPoints.find((viaPoint) => viaPoint.style.time === row.time)
this.updatePointPosition(graphic, row.points)
}
} else if (type === 'avoidPoints') {
if (!row.points) {
- const graphic = this.avoidPoints.find(
- (avoidPoint) => avoidPoint.style.time === row.time
- )
- if (
- this.form.avoidPoints.length === 1 &&
- this.form.avoidPoints[0].points === ''
- ) {
+ const graphic = this.avoidPoints.find((avoidPoint) => avoidPoint.style.time === row.time)
+ if (this.form.avoidPoints.length === 1 && this.form.avoidPoints[0].points === '') {
// 如果只剩下一个空项，不删除图形，清空输入框值
this.form.avoidPoints[0].points = ''
} else {
- this.form.avoidPoints = this.form.avoidPoints.filter(
- (avoidPoint) => avoidPoint.time !== row.time
- )
+ this.form.avoidPoints = this.form.avoidPoints.filter((avoidPoint) => avoidPoint.time !== row.time)
}
graphic?.remove()
- this.avoidPoints = this.avoidPoints.filter(
- (avoidPoint) => avoidPoint.style.time !== row.time
- )
+ this.avoidPoints = this.avoidPoints.filter((avoidPoint) => avoidPoint.style.time !== row.time)
} else {
- const graphic = this.avoidPoints.find(
- (avoidPoint) => avoidPoint.style.time === row.time
- )
+ const graphic = this.avoidPoints.find((avoidPoint) => avoidPoint.style.time === row.time)
this.updatePointPosition(graphic, row.points)
}
} else if (type === 'avoidAreas') {
if (!row.points) {
- const graphic = this.avoidAreas.find(
- (avoidArea) => avoidArea.style.time === row.time
- )
- if (
- this.form.avoidAreas.length === 1 &&
- this.form.avoidAreas[0].points === ''
- ) {
+ const graphic = this.avoidAreas.find((avoidArea) => avoidArea.style.time === row.time)
+ if (this.form.avoidAreas.length === 1 && this.form.avoidAreas[0].points === '') {
// 如果只剩下一个空项，不删除图形，清空输入框值
this.form.avoidAreas[0].points = ''
} else {
- this.form.avoidAreas = this.form.avoidAreas.filter(
- (avoidArea) => avoidArea.time !== row.time
- )
+ this.form.avoidAreas = this.form.avoidAreas.filter((avoidArea) => avoidArea.time !== row.time)
}
graphic?.remove()
- this.avoidAreas = this.avoidAreas.filter(
- (avoidArea) => avoidArea.style.time !== row.time
- )
+ this.avoidAreas = this.avoidAreas.filter((avoidArea) => avoidArea.style.time !== row.time)
} else {
- const graphic = this.avoidAreas.find(
- (avoidArea) => avoidArea.style.time === row.time
- )
+ const graphic = this.avoidAreas.find((avoidArea) => avoidArea.style.time === row.time)
this.updatePolygonPosition(graphic, row.points)
}
}
},
handleEmptyArray(type) {
- if (
- type === 'viaPoints' &&
- this.form.viaPoints.length === 1 &&
- this.form.viaPoints[0].points === ''
- ) {
+ if (type === 'viaPoints' && this.form.viaPoints.length === 1 && this.form.viaPoints[0].points === '') {
this.form.viaPoints = []
} else if (
type === 'avoidPoints' &&
@@ -1181,11 +1122,7 @@ export default {
this.form.avoidPoints[0].points === ''
) {
this.form.avoidPoints = []
- } else if (
- type === 'avoidAreas' &&
- this.form.avoidAreas.length === 1 &&
- this.form.avoidAreas[0].points === ''
- ) {
+ } else if (type === 'avoidAreas' && this.form.avoidAreas.length === 1 && this.form.avoidAreas[0].points === '') {
this.form.avoidAreas = []
}
},
@@ -1200,9 +1137,7 @@ export default {
if (!graphic) return
try {
const coords = JSON.parse(pointsStr)
- graphic.positions = coords.map(
- (coord) => new window.mars3d.LngLatPoint(coord[0], coord[1])
- )
+ graphic.positions = coords.map((coord) => new window.mars3d.LngLatPoint(coord[0], coord[1]))
} catch (error) {
graphic.remove()
}
@@ -1357,9 +1292,7 @@ export default {
success: (graphic) => {
this.avoidAreas.push(graphic)
const avoidAreasGeoJSON = graphic.toGeoJSON()
- const points = JSON.stringify(
- avoidAreasGeoJSON.geometry.coordinates[0]
- )
+ const points = JSON.stringify(avoidAreasGeoJSON.geometry.coordinates[0])
if (
this.form.avoidAreas.length == 1 &&
this.form.avoidAreas[0].points == '' &&
@@ -1392,11 +1325,8 @@ export default {
}
// 计算边权重（距离，单位：米）
const distance =
- turf.distance(
- turf.point(coords[0][0]),
- turf.point(coords[coords.length - 1][0]),
- {units: 'kilometers'}
- ) * 1000
+ turf.distance(turf.point(coords[0][0]), turf.point(coords[coords.length - 1][0]), {units: 'kilometers'}) *
+ 1000
// 构建邻接表（双向图）
graph[startNode] = graph[startNode] ? graph[startNode] : {}
@@ -1430,22 +1360,23 @@ export default {
// 构建临时 graph
const tempGraph = JSON.parse(JSON.stringify(graph))
-
+
// 删除避让的边
if (avoidObstacles) {
for (const [node, edges] of Object.entries(tempGraph)) {
for (const targetNode of Object.keys(edges)) {
- const line = turf.lineString([nodeCoords[node], nodeCoords[targetNode]]);
- const intersectsObstacle = avoidObstacles.features.some(area => {
- return turf.booleanIntersects(line, area.geometry) || // 线段与面相交
- turf.booleanWithin(line, area.geometry) || // 线段在面内
- turf.booleanContains(area.geometry, line) // 面包含线段（冗余判断，覆盖边界场景）
- }
- );
+ const line = turf.lineString([nodeCoords[node], nodeCoords[targetNode]])
+ const intersectsObstacle = avoidObstacles.features.some((area) => {
+ return (
+ turf.booleanIntersects(line, area.geometry) || // 线段与面相交
+ turf.booleanWithin(line, area.geometry) || // 线段在面内
+ turf.booleanContains(area.geometry, line)
+ ) // 面包含线段（冗余判断，覆盖边界场景）
+ })
if (intersectsObstacle) {
- delete tempGraph[node][targetNode];
+ delete tempGraph[node][targetNode]
if (tempGraph[targetNode] && tempGraph[targetNode][node]) {
- delete tempGraph[targetNode][node];
+ delete tempGraph[targetNode][node]
}
}
}
@@ -1453,71 +1384,71 @@ export default {
}
// 按顺序组合点：起点 -> 途经点 -> 终点（保留途经点原始信息，而非仅坐标）
const points = [
- { type: 'start', coord: startCoord }, // 标记点类型：起点
- ...viaPoints.map(p => ({ type: 'via', coord: p.geometry.coordinates, raw: p })), // 途经点
- { type: 'end', coord: endCoord } // 终点
+ {type: 'start', coord: startCoord}, // 标记点类型：起点
+ ...viaPoints.map((p) => ({type: 'via', coord: p.geometry.coordinates, raw: p})), // 途经点
+ {type: 'end', coord: endCoord}, // 终点
]
-
+
const fullPath = []
const infoList = []
- let prevSegmentEndNode = null; // 存储上一个途经点的衔接点（用于下一段复用）
-
+ let prevSegmentEndNode = null // 存储上一个途经点的衔接点（用于下一段复用）
+
for (let i = 0; i < points.length - 1; i++) {
- const currPoint = points[i]; // 当前点（起点/途经点）
- const nextPoint = points[i + 1]; // 下一个点（途经点/终点）
- const segmentStart = currPoint.coord;
- const segmentEnd = nextPoint.coord;
+ const currPoint = points[i] // 当前点（起点/途经点）
+ const nextPoint = points[i + 1] // 下一个点（途经点/终点）
+ const segmentStart = currPoint.coord
+ const segmentEnd = nextPoint.coord
// 匹配最近节点：关键修改——若当前是“途经点之后的段”，复用前一段的衔接点作为起点
- let startNode, endNode;
- if (currPoint.type === 'via' && prevSegmentEndNode ) {
+ let startNode, endNode
+ if (currPoint.type === 'via' && prevSegmentEndNode) {
// 直接使用上一段的结束节点作为起点（确保路径连续性）
- startNode = prevSegmentEndNode;
+ startNode = prevSegmentEndNode
} else {
// 情况2：起点/第一段，正常匹配最近节点
- startNode = this.findNearestNode(segmentStart, nodeCoords);
+ startNode = this.findNearestNode(segmentStart, nodeCoords)
}
- endNode = this.findNearestNodeWithReturn(segmentEnd, nodeCoords, tempGraph, startNode);
+ endNode = this.findNearestNodeWithReturn(segmentEnd, nodeCoords, tempGraph, startNode)
if (!startNode || !endNode) {
console.error('无法匹配到路网节点')
- prevSegmentEndNode = null; // 重置衔接点，避免后续复用错误
+ prevSegmentEndNode = null // 重置衔接点，避免后续复用错误
continue
}
-
+
// 检查路径可行性
if (!this.isPathPossible(tempGraph, startNode, endNode)) {
- this.$message.warning(`无法匹配到路网节点`);
- continue;
+ this.$message.warning(`无法匹配到路网节点`)
+ continue
}
-
+
// 检查路径可行性（考虑死胡同原路返回）
- const {pathNodes, isDeadEnd} = await this.findPathWithReturn(tempGraph, startNode, endNode, nodeCoords);
-
+ const {pathNodes, isDeadEnd} = await this.findPathWithReturn(tempGraph, startNode, endNode, nodeCoords)
+
if (!pathNodes || pathNodes.length === 0) {
- this.$message.warning(`第${i+1}段路径未找到!`)
- prevSegmentEndNode = null;
+ this.$message.warning(`第${i + 1}段路径未找到!`)
+ prevSegmentEndNode = null
continue
}
// 生成当前段的路径（处理死胡同原路返回）
const segmentResult = await this.generatePathWithReturn(
- pathNodes,
- segmentStart,
- segmentEnd,
+ pathNodes,
+ segmentStart,
+ segmentEnd,
i,
points.length,
currPoint.type,
nextPoint.type,
isDeadEnd,
prevSegmentEndNode
- );
-
+ )
+
if (segmentResult.path.length > 0) {
// 合并路径段
- this.mergePathSegments(fullPath, segmentResult.path);
- infoList.push(...segmentResult.segments);
+ this.mergePathSegments(fullPath, segmentResult.path)
+ infoList.push(...segmentResult.segments)
// 记录当前段的结束节点，供下一段使用
- prevSegmentEndNode = pathNodes[pathNodes.length - 1];
+ prevSegmentEndNode = pathNodes[pathNodes.length - 1]
// if (i === 0) {
// // 第一段：直接添加
// fullPath.push(...segmentResult.path);
@@ -1525,7 +1456,7 @@ export default {
// // 后续段：需要检查连接点，避免重复
// this.mergePathSegments(fullPath, segmentResult.path);
// }
-
+
// infoList.push(...segmentResult.segments);
// 关键：若当前段的终点是“途经点”，记录其衔接点，供下一段复用
// if (nextPoint.type === 'via' && segmentResult.viaConnectPoint) {
@@ -1534,7 +1465,7 @@ export default {
// prevSegmentEndNode = null; // 非途经点，重置
// }
} else {
- prevSegmentEndNode = null;
+ prevSegmentEndNode = null
}
}
@@ -1542,226 +1473,249 @@ export default {
},
// 改进：查找最近节点，考虑死胡同情况
findNearestNodeWithReturn(coord, nodeCoords, graph, fromNode = null) {
- const nearestNode = this.findNearestNode(coord, nodeCoords);
-
+ const nearestNode = this.findNearestNode(coord, nodeCoords)
+
// 如果没有起点节点或不是死胡同，直接返回最近节点
if (!fromNode || !this.isDeadEnd(nearestNode, graph)) {
- return nearestNode;
+ return nearestNode
}
-
+
// 如果是死胡同，找到死胡同的入口节点（原路返回点）
- return this.findDeadEndEntry(nearestNode, graph, fromNode, nodeCoords);
+ return this.findDeadEndEntry(nearestNode, graph, fromNode, nodeCoords)
},
// 判断节点是否是死胡同（只有一个连接）
isDeadEnd(node, graph) {
- if (!graph[node]) return true;
- const connections = Object.keys(graph[node]);
- return connections.length === 1;
+ if (!graph[node]) return true
+ const connections = Object.keys(graph[node])
+ return connections.length === 1
},
// 找到死胡同的入口节点（原路返回的衔接点）
findDeadEndEntry(deadEndNode, graph, fromNode, nodeCoords) {
// 从死胡同节点开始，沿着唯一路径往回找，直到找到分支点或起点
- let currentNode = deadEndNode;
- let visited = new Set([currentNode]);
-
+ let currentNode = deadEndNode
+ let visited = new Set([currentNode])
+
while (currentNode) {
- const connections = graph[currentNode] ? Object.keys(graph[currentNode]) : [];
-
+ const connections = graph[currentNode] ? Object.keys(graph[currentNode]) : []
+
// 如果当前节点有多个连接，或者是从起点过来的节点，作为入口点
if (connections.length > 1 || currentNode === fromNode) {
- return currentNode;
+ return currentNode
}
-
+
// 继续往回找（排除已访问的节点）
- const nextNode = connections.find(node => !visited.has(node));
- if (!nextNode) break;
-
- visited.add(nextNode);
- currentNode = nextNode;
+ const nextNode = connections.find((node) => !visited.has(node))
+ if (!nextNode) break
+
+ visited.add(nextNode)
+ currentNode = nextNode
}
-
+
// 如果找不到合适的入口，返回原始最近节点
- return deadEndNode;
+ return deadEndNode
},
// 改进的路径查找，支持原路返回
async findPathWithReturn(graph, startNode, endNode, nodeCoords) {
try {
// 先尝试直接路径
- const directPath = dijkstra.find_path(graph, startNode, endNode);
+ const directPath = dijkstra.find_path(graph, startNode, endNode)
if (directPath && directPath.length > 0) {
- return {pathNodes: directPath, isDeadEnd: false};
+ return {pathNodes: directPath, isDeadEnd: false}
}
-
+
// 如果直接路径失败，检查是否是死胡同情况
if (this.isDeadEnd(endNode, graph)) {
// 找到死胡同入口作为替代终点
- const entryNode = this.findDeadEndEntry(endNode, graph, startNode, nodeCoords);
+ const entryNode = this.findDeadEndEntry(endNode, graph, startNode, nodeCoords)
if (entryNode && entryNode !== endNode) {
- const alternativePath = dijkstra.find_path(graph, startNode, entryNode);
+ const alternativePath = dijkstra.find_path(graph, startNode, entryNode)
if (alternativePath && alternativePath.length > 0) {
return {
- pathNodes: alternativePath,
+ pathNodes: alternativePath,
isDeadEnd: true,
actualEndNode: endNode,
- entryNode: entryNode
- };
+ entryNode: entryNode,
+ }
}
}
}
-
- return {pathNodes: null, isDeadEnd: false};
+
+ return {pathNodes: null, isDeadEnd: false}
} catch (error) {
- console.error('路径查找错误:', error);
- return {pathNodes: null, isDeadEnd: false};
+ console.error('路径查找错误:', error)
+ return {pathNodes: null, isDeadEnd: false}
}
},
// 通过坐标反向查找对应的路网节点（处理浮点数精度）
findNodeByCoord(coord, nodeCoords) {
- const tolerance = 0.000001; // 与findPointIndex保持一致的容差
+ const tolerance = 0.000001 // 与findPointIndex保持一致的容差
for (const [nodeId, nodeCoord] of Object.entries(nodeCoords)) {
- if (
- Math.abs(nodeCoord[0] - coord[0]) < tolerance &&
- Math.abs(nodeCoord[1] - coord[1]) < tolerance
- ) {
- return nodeId;
+ if (Math.abs(nodeCoord[0] - coord[0]) < tolerance && Math.abs(nodeCoord[1] - coord[1]) < tolerance) {
+ return nodeId
}
}
// 若未找到完全匹配的节点，返回最近的节点（降级处理）
- return this.findNearestNode(coord, nodeCoords);
+ return this.findNearestNode(coord, nodeCoords)
},
// 改进的路径生成，支持原路返回
async generatePathWithReturn(
- pathNodes,
- segmentStart,
- segmentEnd,
- segmentIndex,
+ pathNodes,
+ segmentStart,
+ segmentEnd,
+ segmentIndex,
totalPoints,
currPointType,
nextPointType,
isDeadEnd = false,
prevSegmentEndNode = null
) {
- const segmentPath = [];
- const segments = [];
-
+ const segmentPath = []
+ const segments = []
+
// 生成主要路径段
for (let j = 0; j < pathNodes.length - 1; j++) {
- const currentNode = pathNodes[j];
- const nextNode = pathNodes[j + 1];
-
- let segment = null;
+ const currentNode = pathNodes[j]
+ const nextNode = pathNodes[j + 1]
+
+ let segment = null
if (!this.join) {
segment = this.roadNetworkGeoJSON.features.find(
(f) =>
(f.properties.FNODE_ == currentNode && f.properties.TNODE_ == nextNode) ||
(f.properties.FNODE_ == nextNode && f.properties.TNODE_ == currentNode)
- );
+ )
} else {
segment = this.roadNetworkGeoJSON.features.find(
(f) =>
((f.properties.FNODE_ == currentNode && f.properties.TNODE_ == nextNode) ||
- (f.properties.FNODE_ == nextNode && f.properties.TNODE_ == currentNode)) &&
+ (f.properties.FNODE_ == nextNode && f.properties.TNODE_ == currentNode)) &&
f.properties.载重吨 >= this.inputform.load &&
f.properties.宽度 >= this.inputform.width &&
f.properties.曲率半 <= this.inputform.minTurnRadius
- );
+ )
}
-
- if (!segment) continue;
-
- segments.push(segment);
- const segmentCoords = segment.geometry.coordinates[0];
-
+
+ if (!segment) continue
+
+ segments.push(segment)
+ const segmentCoords = segment.geometry.coordinates[0]
+
// 处理段内连接
if (j === 0) {
await this.handleSegmentStartWithReturn(
- segmentPath, segmentStart, segmentCoords, segmentIndex, currPointType, prevSegmentEndNode
- );
+ segmentPath,
+ segmentStart,
+ segmentCoords,
+ segmentIndex,
+ currPointType,
+ prevSegmentEndNode
+ )
} else {
- this.connectSegmentInternally(segmentPath, segmentCoords);
+ this.connectSegmentInternally(segmentPath, segmentCoords)
}
}
-
+
// 处理段结束连接（支持死胡同原路返回）
await this.handleSegmentEndWithReturn(
- segmentPath, segmentEnd, pathNodes, segmentIndex, totalPoints, nextPointType, isDeadEnd
- );
-
- return { path: segmentPath, segments };
+ segmentPath,
+ segmentEnd,
+ pathNodes,
+ segmentIndex,
+ totalPoints,
+ nextPointType,
+ isDeadEnd
+ )
+
+ return {path: segmentPath, segments}
},
// 改进的段起始处理
- async handleSegmentStartWithReturn(segmentPath, segmentStart, segmentCoords, segmentIndex, currPointType, prevSegmentEndNode) {
+ async handleSegmentStartWithReturn(
+ segmentPath,
+ segmentStart,
+ segmentCoords,
+ segmentIndex,
+ currPointType,
+ prevSegmentEndNode
+ ) {
if (segmentIndex === 0 || currPointType === 'start') {
// 第一段或起点：从实际起点开始
- segmentPath.push(segmentStart);
- const nearestPoint = this.findNearestPointOnLine(segmentStart, segmentCoords);
- segmentPath.push(nearestPoint);
-
- const startIndex = this.findPointIndex(segmentCoords, nearestPoint);
+ segmentPath.push(segmentStart)
+ const nearestPoint = this.findNearestPointOnLine(segmentStart, segmentCoords)
+ segmentPath.push(nearestPoint)
+
+ const startIndex = this.findPointIndex(segmentCoords, nearestPoint)
if (startIndex !== -1 && startIndex < segmentCoords.length - 1) {
- segmentPath.push(...segmentCoords.slice(startIndex + 1));
+ segmentPath.push(...segmentCoords.slice(startIndex + 1))
}
} else {
// 途经点之后的段：确保路径连续性
- segmentPath.push(segmentStart);
-
+ segmentPath.push(segmentStart)
+
// 找到与上一段衔接的最佳点
- const connectionPoint = this.findContinuationPoint(segmentCoords, prevSegmentEndNode);
+ const connectionPoint = this.findContinuationPoint(segmentCoords, prevSegmentEndNode)
if (connectionPoint) {
- segmentPath.push(connectionPoint);
- const connectionIndex = this.findPointIndex(segmentCoords, connectionPoint);
+ segmentPath.push(connectionPoint)
+ const connectionIndex = this.findPointIndex(segmentCoords, connectionPoint)
if (connectionIndex !== -1 && connectionIndex < segmentCoords.length - 1) {
- segmentPath.push(...segmentCoords.slice(connectionIndex + 1));
+ segmentPath.push(...segmentCoords.slice(connectionIndex + 1))
}
} else {
// 降级处理：使用最近点
- const nearestPoint = this.findNearestPointOnLine(segmentStart, segmentCoords);
- segmentPath.push(nearestPoint);
- const startIndex = this.findPointIndex(segmentCoords, nearestPoint);
+ const nearestPoint = this.findNearestPointOnLine(segmentStart, segmentCoords)
+ segmentPath.push(nearestPoint)
+ const startIndex = this.findPointIndex(segmentCoords, nearestPoint)
if (startIndex !== -1 && startIndex < segmentCoords.length - 1) {
- segmentPath.push(...segmentCoords.slice(startIndex + 1));
+ segmentPath.push(...segmentCoords.slice(startIndex + 1))
}
}
}
},
// 改进的段结束处理（支持死胡同）
- async handleSegmentEndWithReturn(segmentPath, segmentEnd, pathNodes, segmentIndex, totalPoints, nextPointType, isDeadEnd) {
+ async handleSegmentEndWithReturn(
+ segmentPath,
+ segmentEnd,
+ pathNodes,
+ segmentIndex,
+ totalPoints,
+ nextPointType,
+ isDeadEnd
+ ) {
if (isDeadEnd) {
// 死胡同情况：先到达目标点，然后原路返回到入口点
- const lastRoadNode = pathNodes[pathNodes.length - 1];
- const nearestPoint = this.findBestConnectionPoint(segmentEnd, lastRoadNode);
-
+ const lastRoadNode = pathNodes[pathNodes.length - 1]
+ const nearestPoint = this.findBestConnectionPoint(segmentEnd, lastRoadNode)
+
if (nearestPoint) {
// 前往目标点
- segmentPath.push(nearestPoint);
- segmentPath.push(segmentEnd);
-
+ segmentPath.push(nearestPoint)
+ segmentPath.push(segmentEnd)
+
// 原路返回到入口点（反向路径）
- this.retracePath(segmentPath, pathNodes);
+ this.retracePath(segmentPath, pathNodes)
}
} else {
// 正常情况
if (segmentIndex === totalPoints - 2) {
// 最后一段：连接到实际终点
- const lastRoadNode = pathNodes[pathNodes.length - 1];
- const nearestPoint = this.findBestConnectionPoint(segmentEnd, lastRoadNode);
-
+ const lastRoadNode = pathNodes[pathNodes.length - 1]
+ const nearestPoint = this.findBestConnectionPoint(segmentEnd, lastRoadNode)
+
if (nearestPoint) {
- segmentPath.push(nearestPoint);
- segmentPath.push(segmentEnd);
+ segmentPath.push(nearestPoint)
+ segmentPath.push(segmentEnd)
}
} else {
// 中间段：途经点处理
- const lastRoadNode = pathNodes[pathNodes.length - 1];
- const nearestPoint = this.findBestConnectionPoint(segmentEnd, lastRoadNode);
-
+ const lastRoadNode = pathNodes[pathNodes.length - 1]
+ const nearestPoint = this.findBestConnectionPoint(segmentEnd, lastRoadNode)
+
if (nearestPoint) {
- segmentPath.push(nearestPoint);
- segmentPath.push(segmentEnd);
+ segmentPath.push(nearestPoint)
+ segmentPath.push(segmentEnd)
}
}
}
@@ -1771,63 +1725,63 @@ export default {
retracePath(segmentPath, pathNodes) {
// 从路径节点反向生成返回路径
for (let i = pathNodes.length - 2; i >= 0; i--) {
- const currentNode = pathNodes[i];
- const nextNode = pathNodes[i + 1];
-
+ const currentNode = pathNodes[i]
+ const nextNode = pathNodes[i + 1]
+
let segment = this.roadNetworkGeoJSON.features.find(
(f) =>
(f.properties.FNODE_ == currentNode && f.properties.TNODE_ == nextNode) ||
(f.properties.FNODE_ == nextNode && f.properties.TNODE_ == currentNode)
- );
-
- if (!segment) continue;
-
- const segmentCoords = [...segment.geometry.coordinates[0]].reverse();
- this.connectSegmentInternally(segmentPath, segmentCoords);
+ )
+
+ if (!segment) continue
+
+ const segmentCoords = [...segment.geometry.coordinates[0]].reverse()
+ this.connectSegmentInternally(segmentPath, segmentCoords)
}
},
// 找到路径延续点（确保路径连续性）
findContinuationPoint(segmentCoords, prevEndNode) {
- if (!prevEndNode) return null;
-
- const nodeCoords = this.roadNetworkGeoJSONBuild.nodeCoords[prevEndNode];
- if (!nodeCoords) return null;
-
+ if (!prevEndNode) return null
+
+ const nodeCoords = this.roadNetworkGeoJSONBuild.nodeCoords[prevEndNode]
+ if (!nodeCoords) return null
+
// 在路段上找到与上一段结束点最近的点
- return this.findNearestPointOnLine(nodeCoords, segmentCoords);
+ return this.findNearestPointOnLine(nodeCoords, segmentCoords)
},
// 处理段起始连接
async handleSegmentStart(segmentPath, segmentStart, segmentCoords, segmentIndex) {
if (segmentIndex === 0) {
// 第一段：从实际起点开始
- segmentPath.push(segmentStart);
-
+ segmentPath.push(segmentStart)
+
// 找到距离起点最近的道路点
- const nearestPoint = this.findNearestPointOnLine(segmentStart, segmentCoords);
- segmentPath.push(nearestPoint);
-
+ const nearestPoint = this.findNearestPointOnLine(segmentStart, segmentCoords)
+ segmentPath.push(nearestPoint)
+
// 添加从最近点到路径的剩余部分
- const startIndex = this.findPointIndex(segmentCoords, nearestPoint);
+ const startIndex = this.findPointIndex(segmentCoords, nearestPoint)
if (startIndex !== -1 && startIndex < segmentCoords.length - 1) {
- segmentPath.push(...segmentCoords.slice(startIndex + 1));
+ segmentPath.push(...segmentCoords.slice(startIndex + 1))
}
} else {
// 中间段（途经点之后）：从途经点开始
- segmentPath.push(segmentStart);
-
+ segmentPath.push(segmentStart)
+
// 找到距离途经点最近的道路点
- const nearestPoint = this.findNearestPointOnLine(segmentStart, segmentCoords);
- segmentPath.push(nearestPoint);
-
+ const nearestPoint = this.findNearestPointOnLine(segmentStart, segmentCoords)
+ segmentPath.push(nearestPoint)
+
// 添加从最近点到路径的剩余部分
- const startIndex = this.findPointIndex(segmentCoords, nearestPoint);
+ const startIndex = this.findPointIndex(segmentCoords, nearestPoint)
if (startIndex !== -1 && startIndex < segmentCoords.length - 1) {
- segmentPath.push(...segmentCoords.slice(startIndex + 1));
+ segmentPath.push(...segmentCoords.slice(startIndex + 1))
} else {
// 如果找不到索引，直接添加整段路径
- segmentPath.push(...segmentCoords);
+ segmentPath.push(...segmentCoords)
}
}
},
@@ -1836,214 +1790,213 @@ export default {
async handleSegmentEnd(segmentPath, segmentEnd, pathNodes, segmentIndex, totalPoints) {
if (segmentIndex === totalPoints - 2) {
// 最后一段：连接到实际终点
- const lastRoadNode = pathNodes[pathNodes.length - 1];
- const nearestPoint = this.findBestConnectionPoint(segmentEnd, lastRoadNode);
-
+ const lastRoadNode = pathNodes[pathNodes.length - 1]
+ const nearestPoint = this.findBestConnectionPoint(segmentEnd, lastRoadNode)
+
if (nearestPoint) {
- segmentPath.push(nearestPoint);
- segmentPath.push(segmentEnd);
+ segmentPath.push(nearestPoint)
+ segmentPath.push(segmentEnd)
}
} else {
// 中间段：途经点处理 - 确保正确连接到途经点
- const lastRoadNode = pathNodes[pathNodes.length - 1];
- const nearestPoint = this.findBestConnectionPoint(segmentEnd, lastRoadNode);
-
+ const lastRoadNode = pathNodes[pathNodes.length - 1]
+ const nearestPoint = this.findBestConnectionPoint(segmentEnd, lastRoadNode)
+
if (nearestPoint) {
// 先连接到路径上的最近点
- segmentPath.push(nearestPoint);
+ segmentPath.push(nearestPoint)
// 然后连接到途经点本身
- segmentPath.push(segmentEnd);
+ segmentPath.push(segmentEnd)
}
}
},
// 合并路径段（避免重复点）
mergePathSegments(fullPath, newSegment) {
- if (newSegment.length === 0) return;
-
+ if (newSegment.length === 0) return
+
if (fullPath.length === 0) {
- fullPath.push(...newSegment);
- return;
+ fullPath.push(...newSegment)
+ return
}
-
- const lastPoint = fullPath[fullPath.length - 1];
- const firstNewPoint = newSegment[0];
-
+
+ const lastPoint = fullPath[fullPath.length - 1]
+ const firstNewPoint = newSegment[0]
+
// 检查是否需要连接（如果点不重复）
if (lastPoint[0] !== firstNewPoint[0] || lastPoint[1] !== firstNewPoint[1]) {
// 点不重复，直接添加
- fullPath.push(...newSegment);
+ fullPath.push(...newSegment)
} else {
// 点重复，跳过第一个点
if (newSegment.length > 1) {
- fullPath.push(...newSegment.slice(1));
+ fullPath.push(...newSegment.slice(1))
}
}
},
// 在线段上找到最近的点
findNearestPointOnLine(point, lineCoords) {
- let nearestPoint = lineCoords[0];
- let minDistance = this.calculateDistance(point, nearestPoint);
-
+ let nearestPoint = lineCoords[0]
+ let minDistance = this.calculateDistance(point, nearestPoint)
+
for (let i = 1; i < lineCoords.length; i++) {
- const coord = lineCoords[i];
- const distance = this.calculateDistance(point, coord);
+ const coord = lineCoords[i]
+ const distance = this.calculateDistance(point, coord)
if (distance < minDistance) {
- minDistance = distance;
- nearestPoint = coord;
+ minDistance = distance
+ nearestPoint = coord
}
}
-
- return nearestPoint;
+
+ return nearestPoint
},
// 查找点在数组中的索引
findPointIndex(coords, point) {
- const tolerance = 0.000001; // 容差，处理浮点数精度问题
-
+ const tolerance = 0.000001 // 容差，处理浮点数精度问题
+
for (let i = 0; i < coords.length; i++) {
- if (Math.abs(coords[i][0] - point[0]) < tolerance &&
- Math.abs(coords[i][1] - point[1]) < tolerance) {
- return i;
+ if (Math.abs(coords[i][0] - point[0]) < tolerance && Math.abs(coords[i][1] - point[1]) < tolerance) {
+ return i
}
}
- return -1;
+ return -1
},
// 找到最佳连接点
findBestConnectionPoint(actualPoint, roadNode) {
- const roadNodeCoord = this.roadNetworkGeoJSONBuild.nodeCoords[roadNode];
- if (!roadNodeCoord) return null;
-
+ const roadNodeCoord = this.roadNetworkGeoJSONBuild.nodeCoords[roadNode]
+ if (!roadNodeCoord) return null
+
// 查找连接到该节点的所有道路段
- const connectedRoads = this.roadNetworkGeoJSON.features.filter(road =>
- road.properties.FNODE_ === roadNode || road.properties.TNODE_ === roadNode
- );
-
- if (connectedRoads.length === 0) return roadNodeCoord;
-
- let bestPoint = roadNodeCoord;
- let minDistance = this.calculateDistance(actualPoint, roadNodeCoord);
-
+ const connectedRoads = this.roadNetworkGeoJSON.features.filter(
+ (road) => road.properties.FNODE_ === roadNode || road.properties.TNODE_ === roadNode
+ )
+
+ if (connectedRoads.length === 0) return roadNodeCoord
+
+ let bestPoint = roadNodeCoord
+ let minDistance = this.calculateDistance(actualPoint, roadNodeCoord)
+
// 在所有连接的道路段上寻找最佳连接点
- connectedRoads.forEach(road => {
- const coords = road.geometry.coordinates[0];
-
+ connectedRoads.forEach((road) => {
+ const coords = road.geometry.coordinates[0]
+
// 检查道路段的每个点
- coords.forEach(coord => {
- const distance = this.calculateDistance(actualPoint, coord);
+ coords.forEach((coord) => {
+ const distance = this.calculateDistance(actualPoint, coord)
if (distance < minDistance) {
- minDistance = distance;
- bestPoint = coord;
+ minDistance = distance
+ bestPoint = coord
}
- });
- });
-
- return bestPoint;
+ })
+ })
+
+ return bestPoint
},
// 段内小段连接
connectSegmentInternally(segmentPath, segmentCoords) {
if (segmentPath.length === 0) {
- segmentPath.push(...segmentCoords);
- return;
+ segmentPath.push(...segmentCoords)
+ return
}
-
- const lastPoint = segmentPath[segmentPath.length - 1];
-
+
+ const lastPoint = segmentPath[segmentPath.length - 1]
+
// 找到与上一段终点最接近的点
- const nearestPointInfo = this.findNearestPointWithIndex(segmentCoords, lastPoint);
-
+ const nearestPointInfo = this.findNearestPointWithIndex(segmentCoords, lastPoint)
+
if (nearestPointInfo.index === 0) {
// 最近点是段首，正向连接
if (segmentCoords.length > 1) {
- segmentPath.push(...segmentCoords.slice(1));
+ segmentPath.push(...segmentCoords.slice(1))
}
} else if (nearestPointInfo.index === segmentCoords.length - 1) {
// 最近点是段尾，反向连接
- const reversedCoords = [...segmentCoords].reverse();
+ const reversedCoords = [...segmentCoords].reverse()
if (reversedCoords.length > 1) {
- segmentPath.push(...reversedCoords.slice(1));
+ segmentPath.push(...reversedCoords.slice(1))
}
} else {
// 最近点在中间，需要分割处理
- this.handleMidpointConnection(segmentPath, segmentCoords, nearestPointInfo);
+ this.handleMidpointConnection(segmentPath, segmentCoords, nearestPointInfo)
}
},
// 找到线上最近的点及其索引
findNearestPointWithIndex(coords, point) {
- let nearestIndex = 0;
- let nearestPoint = coords[0];
- let minDistance = this.calculateDistance(point, nearestPoint);
-
+ let nearestIndex = 0
+ let nearestPoint = coords[0]
+ let minDistance = this.calculateDistance(point, nearestPoint)
+
for (let i = 1; i < coords.length; i++) {
- const distance = this.calculateDistance(point, coords[i]);
+ const distance = this.calculateDistance(point, coords[i])
if (distance < minDistance) {
- minDistance = distance;
- nearestIndex = i;
- nearestPoint = coords[i];
+ minDistance = distance
+ nearestIndex = i
+ nearestPoint = coords[i]
}
}
-
- return { index: nearestIndex, point: nearestPoint, distance: minDistance };
+
+ return {index: nearestIndex, point: nearestPoint, distance: minDistance}
},
// 处理中间点连接
handleMidpointConnection(segmentPath, segmentCoords, nearestPointInfo) {
- const { index, point } = nearestPointInfo;
-
+ const {index, point} = nearestPointInfo
+
// 添加最近点
- segmentPath.push(point);
-
+ segmentPath.push(point)
+
// 决定连接方向（选择较短的部分）
- const distanceToStart = this.calculateDistance(point, segmentCoords[0]);
- const distanceToEnd = this.calculateDistance(point, segmentCoords[segmentCoords.length - 1]);
-
+ const distanceToStart = this.calculateDistance(point, segmentCoords[0])
+ const distanceToEnd = this.calculateDistance(point, segmentCoords[segmentCoords.length - 1])
+
if (distanceToStart <= distanceToEnd) {
// 向起点方向连接
if (index > 0) {
- const toStart = segmentCoords.slice(0, index).reverse();
- segmentPath.push(...toStart);
+ const toStart = segmentCoords.slice(0, index).reverse()
+ segmentPath.push(...toStart)
}
} else {
// 向终点方向连接
if (index < segmentCoords.length - 1) {
- const toEnd = segmentCoords.slice(index + 1);
- segmentPath.push(...toEnd);
+ const toEnd = segmentCoords.slice(index + 1)
+ segmentPath.push(...toEnd)
}
}
},
// 计算距离（使用更精确的方法）
calculateDistance(coord1, coord2) {
- const point1 = turf.point(coord1);
- const point2 = turf.point(coord2);
- return turf.distance(point1, point2, { units: 'meters' });
+ const point1 = turf.point(coord1)
+ const point2 = turf.point(coord2)
+ return turf.distance(point1, point2, {units: 'meters'})
},
// 检查路径可行性
isPathPossible(graph, startNode, endNode) {
// 使用广度优先搜索（BFS）检查路径可行性
- const visited = new Set();
- const queue = [startNode];
- visited.add(startNode);
+ const visited = new Set()
+ const queue = [startNode]
+ visited.add(startNode)
while (queue.length > 0) {
- const currentNode = queue.shift();
+ const currentNode = queue.shift()
if (currentNode === endNode) {
- return true;
+ return true
}
- const neighbors = graph[currentNode];
+ const neighbors = graph[currentNode]
if (neighbors) {
for (const neighbor in neighbors) {
if (!visited.has(neighbor)) {
- visited.add(neighbor);
- queue.push(neighbor);
+ visited.add(neighbor)
+ queue.push(neighbor)
}
}
}
}
- return false;
+ return false
},
async calculateShortestPath() {
if (!this.pointQD || !this.pointZD || !this.roadNetworkGeoJSON) {
@@ -2053,20 +2006,13 @@ export default {
this.shortestPathLayer.clear()
this.shortestPathList = []
this.infoList = []
- const startPoint = turf.point(
- this.pointQD.toGeoJSON().geometry.coordinates
- ).geometry.coordinates // 起点
- const endPoint = turf.point(this.pointZD.toGeoJSON().geometry.coordinates)
- .geometry.coordinates // 终点
+ const startPoint = turf.point(this.pointQD.toGeoJSON().geometry.coordinates).geometry.coordinates // 起点
+ const endPoint = turf.point(this.pointZD.toGeoJSON().geometry.coordinates).geometry.coordinates // 终点
// 途经点
- const viaPointsGeoJSON =
- this.viaPoints.map((point) => point.toGeoJSON()) || []
- const viaPointsTurf = viaPointsGeoJSON.map((p) =>
- turf.point(p.geometry.coordinates)
- )
+ const viaPointsGeoJSON = this.viaPoints.map((point) => point.toGeoJSON()) || []
+ const viaPointsTurf = viaPointsGeoJSON.map((p) => turf.point(p.geometry.coordinates))
// 避让点 算成有半径的圆 方便去和线去调整
- const avoidPointsGeoJSON =
- this.avoidPoints.map((point) => point.toGeoJSON()) || []
+ const avoidPointsGeoJSON = this.avoidPoints.map((point) => point.toGeoJSON()) || []
const avoidPointsPolygons = avoidPointsGeoJSON.map((point) => {
return turf.circle(
turf.point(point.geometry.coordinates),
@@ -2074,7 +2020,7 @@ export default {
{
steps: 64,
units: 'meters',
- properties: { type: 'avoid_point' } // 给圆添加属性，方便后续调试区分“点转圆”和“原生区域”
+ properties: {type: 'avoid_point'}, // 给圆添加属性，方便后续调试区分“点转圆”和“原生区域”
} // 显式指定单位
)
})
@@ -2094,17 +2040,10 @@ export default {
// })
// 避让区域
const avoidAreasGeoJSON =
- this.avoidAreas.map((area) => turf.feature(area.toGeoJSON({closure: true}.geometry, { type: 'avoid_area' }))) || []
- const obstaclesGeoJSON = turf.featureCollection([
- ...avoidPointsPolygons,
- ...avoidAreasGeoJSON,
- ])
- const route = await this.planRoute(
- startPoint,
- endPoint,
- viaPointsTurf,
- obstaclesGeoJSON
- )
+ this.avoidAreas.map((area) => turf.feature(area.toGeoJSON({closure: true}.geometry, {type: 'avoid_area'}))) ||
+ []
+ const obstaclesGeoJSON = turf.featureCollection([...avoidPointsPolygons, ...avoidAreasGeoJSON])
+ const route = await this.planRoute(startPoint, endPoint, viaPointsTurf, obstaclesGeoJSON)
this.drawPath(route)
},
@@ -2128,7 +2067,7 @@ export default {
drawPath(path) {
const positions = path
if (positions.fullPath.length == 0) return
-
+
// 1. 绘制主要路径
const polyline = new window.mars3d.graphic.PolylinePrimitive({
positions: positions.fullPath,
@@ -2139,92 +2078,89 @@ export default {
},
})
this.shortestPathLayer.addGraphic(polyline)
-
+
// 2. 添加方向箭头
this.addDirectionArrows(positions.fullPath)
-
+
this.shortestPathList.push(path.infoList)
this.infoList = path.infoList.map((item) => item.properties)
},
// 添加方向箭头
addDirectionArrows(pathCoords) {
- if (pathCoords.length < 2) return;
-
- const arrowLayer = this.shortestPathLayer;
- const baseArrowSpacing = 10000; // 基础间距（米）
- const minArrowSpacing = 1000; // 最小间距（避免过密，可根据需求调整）
- const minSegmentLength = 500; // 最小线段长度（短于该值的线段合并，可调整）
+ if (pathCoords.length < 2) return
+
+ const arrowLayer = this.shortestPathLayer
+ const baseArrowSpacing = 10000 // 基础间距（米）
+ const minArrowSpacing = 1000 // 最小间距（避免过密，可根据需求调整）
+ const minSegmentLength = 500 // 最小线段长度（短于该值的线段合并，可调整）
// 预处理：合并过近的连续点
- const filteredCoords = this.filterClosePoints(pathCoords, minSegmentLength);
+ const filteredCoords = this.filterClosePoints(pathCoords, minSegmentLength)
for (let i = 0; i < filteredCoords.length - 1; i++) {
- const startCoord = filteredCoords[i];
- const endCoord = filteredCoords[i + 1];
- const segmentDistance = this.calculateDistance(startCoord, endCoord);
+ const startCoord = filteredCoords[i]
+ const endCoord = filteredCoords[i + 1]
+ const segmentDistance = this.calculateDistance(startCoord, endCoord)
// 跳过过短的线段（已合并但仍可能存在的极短线段）
- if (segmentDistance < minSegmentLength) continue;
+ if (segmentDistance < minSegmentLength) continue
// 动态计算当前线段的箭头间距：
// 线段越长，间距越接近基础值；线段越短，间距按比例缩小，但不小于最小间距
const dynamicSpacing = Math.max(
minArrowSpacing,
Math.min(baseArrowSpacing, segmentDistance / 5) // 最多在该线段放5个箭头
- );
+ )
// 在当前段上放置箭头（从起点开始，按动态间距排列）
- let segmentAccumulated = 0;
+ let segmentAccumulated = 0
while (segmentAccumulated < segmentDistance) {
- const ratio = segmentAccumulated / segmentDistance;
- const arrowPosition = this.interpolatePoint(startCoord, endCoord, ratio);
- const arrowDirection = this.calculateDirection(startCoord, endCoord);
- this.createArrow(arrowLayer, arrowPosition, arrowDirection);
+ const ratio = segmentAccumulated / segmentDistance
+ const arrowPosition = this.interpolatePoint(startCoord, endCoord, ratio)
+ const arrowDirection = this.calculateDirection(startCoord, endCoord)
+ this.createArrow(arrowLayer, arrowPosition, arrowDirection)
- segmentAccumulated += dynamicSpacing;
+ segmentAccumulated += dynamicSpacing
}
}
// 终点箭头（基于过滤后的坐标）
if (filteredCoords.length >= 2) {
- const lastPoint = filteredCoords[filteredCoords.length - 1];
- const secondLastPoint = filteredCoords[filteredCoords.length - 2];
- const finalDirection = this.calculateDirection(secondLastPoint, lastPoint);
- this.createArrow(arrowLayer, lastPoint, finalDirection);
+ const lastPoint = filteredCoords[filteredCoords.length - 1]
+ const secondLastPoint = filteredCoords[filteredCoords.length - 2]
+ const finalDirection = this.calculateDirection(secondLastPoint, lastPoint)
+ this.createArrow(arrowLayer, lastPoint, finalDirection)
}
},
// 辅助方法：过滤过近的连续点（保留关键转折点）
filterClosePoints(coords, minDistance) {
- if (coords.length <= 1) return coords;
- const filtered = [coords[0]];
- let lastCoord = coords[0];
+ if (coords.length <= 1) return coords
+ const filtered = [coords[0]]
+ let lastCoord = coords[0]
for (let i = 1; i < coords.length; i++) {
- const currentCoord = coords[i];
- const distance = this.calculateDistance(lastCoord, currentCoord);
+ const currentCoord = coords[i]
+ const distance = this.calculateDistance(lastCoord, currentCoord)
// 只有当当前点与上一个保留点的距离超过阈值时，才保留当前点
if (distance >= minDistance) {
- filtered.push(currentCoord);
- lastCoord = currentCoord;
+ filtered.push(currentCoord)
+ lastCoord = currentCoord
}
}
// 确保终点被保留（避免因最后一段过短而丢失终点）
if (filtered[filtered.length - 1] !== coords[coords.length - 1]) {
- filtered.push(coords[coords.length - 1]);
+ filtered.push(coords[coords.length - 1])
}
- return filtered;
+ return filtered
},
// 插值计算点位置
interpolatePoint(start, end, ratio) {
- return [
- start[0] + (end[0] - start[0]) * ratio,
- start[1] + (end[1] - start[1]) * ratio
- ]
+ return [start[0] + (end[0] - start[0]) * ratio, start[1] + (end[1] - start[1]) * ratio]
},
// 计算方向（角度）
@@ -2245,8 +2181,8 @@ export default {
extrudedHeight: 10, // 稍微抬升避免重叠
outline: true,
outlineColor: Cesium.Color.WHITE,
- outlineWidth: 1
- }
+ outlineWidth: 1,
+ },
})
layer.addGraphic(arrow)
},
@@ -2255,23 +2191,20 @@ export default {
calculateArrowShape(center, direction) {
const size = 0.0001 // 箭头大小（经纬度）
const angle = direction * (Math.PI / 180) // 转换为弧度
-
+
// 箭头三角形的三个点
- const tip = [
- center[0] + Math.cos(angle) * size * 2,
- center[1] + Math.sin(angle) * size * 2
- ]
-
+ const tip = [center[0] + Math.cos(angle) * size * 2, center[1] + Math.sin(angle) * size * 2]
+
const left = [
center[0] + Math.cos(angle + Math.PI * 0.8) * size,
- center[1] + Math.sin(angle + Math.PI * 0.8) * size
+ center[1] + Math.sin(angle + Math.PI * 0.8) * size,
]
-
+
const right = [
center[0] + Math.cos(angle - Math.PI * 0.8) * size,
- center[1] + Math.sin(angle - Math.PI * 0.8) * size
+ center[1] + Math.sin(angle - Math.PI * 0.8) * size,
]
-
+
return [tip, left, right, tip] // 闭合三角形
},
},
@@ -2347,14 +2280,14 @@ export default {
display: flex;
justify-content: space-between;
}
-.control-panel .title .joinCheck {
+.control-panel .title .joinCheck {
font-size: 14px;
color: #555;
}
.el-checkbox {
- margin-right: 5px!important;
+ margin-right: 5px !important;
}
-
+
.importJson {
display: flex;
flex-direction: row;
@@ -2404,6 +2337,4 @@ export default {
.popDiloag .popDiloag-title {
font-weight: 500;
}
-.popDiloag .popDiloag-p {
-}
diff --git a/src/views/residentAnalysis/index.vue b/src/views/residentAnalysis/index.vue
index 86d0c59..36c10a6 100644
--- a/src/views/residentAnalysis/index.vue
+++ b/src/views/residentAnalysis/index.vue
@@ -3,13 +3,8 @@
![]()
- 确定
+ 确定
+ 导出
@@ -20,21 +15,14 @@
-
-
+
-
-
@@ -72,71 +60,232 @@
范围
- 导入json文件
-
+
+ 导入json文件