feiyu02
2025-02-07 e133600480d5f688a8375db7708fe531b4726f4a
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
package com.flightfeather.uav.lightshare.service.impl
 
import com.flightfeather.uav.biz.satellite.SatelliteGridManage
import com.flightfeather.uav.common.exception.BizException
import com.flightfeather.uav.domain.entity.GridCell
import com.flightfeather.uav.domain.entity.GridData
import com.flightfeather.uav.domain.entity.GridDataDetail
import com.flightfeather.uav.domain.entity.GridGroup
import com.flightfeather.uav.domain.repository.SatelliteGridRep
import com.flightfeather.uav.lightshare.eunm.GridType
import com.flightfeather.uav.lightshare.eunm.SatelliteDataType
import com.flightfeather.uav.lightshare.service.SatelliteDataCalculateService
import org.springframework.beans.BeanUtils
import org.springframework.stereotype.Service
import org.springframework.transaction.annotation.Transactional
import java.util.Date
import kotlin.math.round
 
/**
 * 卫星网格坐标及监测数据二次计算
 * @date 2025/1/15
 * @author feiyu02
 */
@Service
class SatelliteDataCalculateServiceImpl(private val satelliteGridRep: SatelliteGridRep) : SatelliteDataCalculateService {
 
 
    override fun calGridVertex(groupId: Int): List<GridCell?> {
        val cellList = satelliteGridRep.fetchGridCell(groupId)
        val vertexList = SatelliteGridManage.calGridVertex(cellList.map {
            if (it?.longitude == null || it.latitude == null) {
                throw BizException("卫星遥测网格计算顶点坐标点失败,存在中心点坐标为空的情况")
            }
            it.longitude?.toDouble()!! to it.latitude?.toDouble()!!
        })
 
        cellList.forEachIndexed { i, c ->
            val v = vertexList[i]
            c?.point1Lon = v.point1Lon.toBigDecimal()
            c?.point1Lat = v.point1Lat.toBigDecimal()
 
            c?.point2Lon = v.point2Lon.toBigDecimal()
            c?.point2Lat = v.point2Lat.toBigDecimal()
 
            c?.point3Lon = v.point3Lon.toBigDecimal()
            c?.point3Lat = v.point3Lat.toBigDecimal()
 
            c?.point4Lon = v.point4Lon.toBigDecimal()
            c?.point4Lat = v.point4Lat.toBigDecimal()
        }
 
        satelliteGridRep.updateGridCellBatch(cellList)
 
        return cellList
    }
 
    override fun splitGrid(groupId: Int, scale: Int): List<GridCell?> {
        // 检查该网格属性是否合规
        val gridGroup =
            satelliteGridRep.fetchGridGroup(groupId) ?: throw BizException("该网格组不存在,无法进行网格细分")
        if (gridGroup.length == null) throw BizException("该网格组没有设定网格边长,无法进行网格细分")
 
        // 检查该网格下该种类的细分网格是否存在,若不存在,则新建
        val searchGridGroup = GridGroup().apply {
            type = GridType.Sub.name.lowercase()
            fatherGroupId = gridGroup.id
            length = round(gridGroup.length / scale)
        }
        val subGridGroupList = satelliteGridRep.fetchGridGroup(searchGridGroup)
        // 若细分网格记录超过1个,说明业务逻辑存在问题,相同边长的细分网格应该只有1个
        if (subGridGroupList.size > 1) {
            throw BizException("该网格组下${searchGridGroup.length}米边长的网格记录超过1个,无法再进行网格细分,并且请检查生成逻辑是否问题")
        }
        // 若细分网格记录有且只有1个,则无需再次细分,直接返回已有结果
        else if (subGridGroupList.size == 1) {
            val g = subGridGroupList.first()
                ?: throw BizException("该网格组下的细分网格记录已损坏,无法使用,请检查数据库记录")
            return satelliteGridRep.fetchGridCell(g.id)
        }
        // 当没有记录时,执行生成逻辑
 
        // 生成新的细分网格组记录
        val newGridGroup = GridGroup()
        BeanUtils.copyProperties(gridGroup, newGridGroup)
        newGridGroup.apply {
            id = null
            name += "${searchGridGroup.length.toInt()}米细分"
            createTime = Date()
            length = searchGridGroup.length
            type = GridType.Sub.name.lowercase()
            fatherGroupId = groupId
        }
        satelliteGridRep.insertGridGroup(newGridGroup)
 
        // 获取具体网格信息
        val cellList = satelliteGridRep.fetchGridCell(groupId)
        // 按照给定的拆分系数进行拆分
        val subCellList = SatelliteGridManage.splitGrid(cellList, scale, newGridGroup.id)
        satelliteGridRep.insertGridCell(subCellList)
 
        return subCellList
    }
 
    @Transactional
    override fun splitData(groupId: Int, dataId:Int): List<GridDataDetail?> {
        // 检查是否是细分网格类型
        val gridGroup = satelliteGridRep.fetchGridGroup(groupId) ?: throw BizException("该网格组不存在,无法进行细分网格数据映射")
        if (gridGroup.type != GridType.Sub.name.lowercase()) throw BizException("该网格组不是细分网格类型存在,无法进行细分网格数据映射")
 
        val subGridCellList = satelliteGridRep.fetchGridCell(groupId)
        val originGridData = satelliteGridRep.fetchGridData(dataId)
        val originGridDataDetailList = satelliteGridRep.fetchGridDataDetail(dataId, null, null)
 
        val subGridData = GridData().apply {
            this.groupId = groupId
            dataTime = originGridData?.dataTime
            type = SatelliteDataType.Sub.value.toByte()
        }
        satelliteGridRep.insertGridData(subGridData)
 
        val subGridDataDetailList =
            SatelliteGridManage.splitData(subGridCellList, subGridData, originGridDataDetailList)
 
        satelliteGridRep.insertGridDataDetail(subGridDataDetailList)
 
        return subGridDataDetailList
    }
}