419 lines
13 KiB
Go
419 lines
13 KiB
Go
package memory
|
|
|
|
import (
|
|
"fmt"
|
|
"sort"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"joylink.club/bj-rtsts-server/ats/verify/protos/graphicData"
|
|
"joylink.club/bj-rtsts-server/ats/verify/protos/state"
|
|
"joylink.club/bj-rtsts-server/dto"
|
|
"joylink.club/ecs"
|
|
"joylink.club/rtsssimulation/repository"
|
|
"joylink.club/rtsssimulation/repository/model/proto"
|
|
"joylink.club/rtsssimulation/simulation"
|
|
"joylink.club/rtsssimulation/system"
|
|
)
|
|
|
|
// 轨旁仿真定义
|
|
type VerifySimulation struct {
|
|
//地图id
|
|
MapIds []int32
|
|
// 项目ID
|
|
ProjectId int32
|
|
//仿真id
|
|
SimulationId string
|
|
//仿真内存数据
|
|
Memory *WaysideMemory
|
|
//模型仓库
|
|
Repo *repository.Repository
|
|
//Rtss仿真世界的id
|
|
WorldId int
|
|
}
|
|
|
|
// 创建仿真对象
|
|
func CreateSimulation(projectId int32, mapIds []int32) (*VerifySimulation, error) {
|
|
//构建Repository
|
|
sort.Slice(mapIds, func(i, j int) bool {
|
|
return mapIds[i] < mapIds[j]
|
|
})
|
|
var mapIdStrSlice []string
|
|
for _, id := range mapIds {
|
|
mapIdStrSlice = append(mapIdStrSlice, strconv.Itoa(int(id)))
|
|
}
|
|
repoId := strings.Join(mapIdStrSlice, "|")
|
|
repoVersion := "0.1"
|
|
repo := repository.FindRepository(repoId, repoVersion)
|
|
if repo == nil {
|
|
var storages []*graphicData.RtssGraphicStorage
|
|
var rmapIds []int32
|
|
for _, mapId := range mapIds {
|
|
storage := QueryGraphicStorage(mapId)
|
|
if storage == nil {
|
|
continue
|
|
}
|
|
storages = append(storages, storage)
|
|
rmapIds = append(rmapIds, mapId)
|
|
}
|
|
protoRepo := buildProtoRepository(storages, rmapIds)
|
|
newRepo, err := repository.BuildRepository(protoRepo)
|
|
repo = newRepo
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
//创建仿真
|
|
worldId := simulation.CreateSimulation(repo, system.SWITCH_ZDJ9_2)
|
|
verifySimulation := &VerifySimulation{
|
|
MapIds: mapIds,
|
|
ProjectId: projectId,
|
|
Memory: NewWaysideMemory(),
|
|
Repo: repo,
|
|
WorldId: worldId,
|
|
}
|
|
return verifySimulation, nil
|
|
}
|
|
|
|
// 获取全量状态
|
|
func (s *VerifySimulation) GetAllState(mapId int32) *state.PushedDevicesStatus {
|
|
return &state.PushedDevicesStatus{
|
|
All: true,
|
|
AllStatus: &state.AllDevicesStatus{
|
|
SwitchState: GetMapAllTurnoutState(s, mapId),
|
|
TrainState: GetAllTrainState(s),
|
|
SectionState: append(GetAllAxleSectionState(s), GetAllPhysicalSectionState(s, mapId)...),
|
|
},
|
|
}
|
|
}
|
|
|
|
// 获取仿真世界信息
|
|
func (s *VerifySimulation) GetSimulationWorld() ecs.World {
|
|
ecsSimulation := simulation.FindSimulation(ecs.WorldId(s.WorldId))
|
|
if ecsSimulation == nil {
|
|
panic(&dto.ErrorDto{Code: dto.DataNotExist, Message: "ecs 仿真不存在"})
|
|
}
|
|
return ecsSimulation.GetWorld()
|
|
}
|
|
|
|
func buildProtoRepository(storages []*graphicData.RtssGraphicStorage, mapIds []int32) *proto.Repository {
|
|
repo := &proto.Repository{}
|
|
for i, storage := range storages {
|
|
fillProtoRepository(repo, storage, mapIds[i])
|
|
}
|
|
return repo
|
|
}
|
|
|
|
func fillProtoRepository(repo *proto.Repository, storage *graphicData.RtssGraphicStorage, mapId int32) {
|
|
axleCountingMap := make(map[string]*graphicData.AxleCounting)
|
|
uidsMap := getMapElementIdMap(mapId)
|
|
for _, data := range storage.AxleCountings {
|
|
axleCountingMap[data.Common.Id] = data
|
|
cpType := proto.CheckPointType_AxleCounter
|
|
if data.Type == graphicData.AxleCounting_SectionBoundary {
|
|
cpType = proto.CheckPointType_Boundary
|
|
}
|
|
cp := &proto.CheckPoint{
|
|
Id: data.Common.Id,
|
|
Km: convertKm(data.KilometerSystem),
|
|
Type: cpType,
|
|
DevicePorts: convertDevicePorts(data.AxleCountingRef),
|
|
}
|
|
repo.CheckPoints = append(repo.CheckPoints, converCheckPointUid(cp, uidsMap))
|
|
}
|
|
for _, data := range storage.Section {
|
|
var turnoutIds []string
|
|
if data.SectionType == graphicData.Section_TurnoutPhysical {
|
|
turnoutIds = findTurnoutIds(axleCountingMap, data.AxleCountings)
|
|
}
|
|
physicalSection := &proto.PhysicalSection{
|
|
Id: data.Common.Id,
|
|
ADevicePort: convertDevicePort(data.PaRef),
|
|
BDevicePort: convertDevicePort(data.PbRef),
|
|
TurnoutIds: turnoutIds,
|
|
}
|
|
repo.PhysicalSections = append(repo.PhysicalSections, converSectionUid(physicalSection, uidsMap))
|
|
}
|
|
for _, data := range storage.Turnouts {
|
|
var km *proto.Kilometer
|
|
for _, ks := range data.KilometerSystem {
|
|
if ks.Kilometer != 0 {
|
|
km = convertKm(ks)
|
|
break
|
|
}
|
|
}
|
|
repo.KilometerConverts = append(repo.KilometerConverts, buildKmConverts(data.KilometerSystem)...)
|
|
turnout := &proto.Turnout{
|
|
Id: data.Common.Id,
|
|
Km: km,
|
|
ADevicePort: convertDevicePort(data.PaRef),
|
|
BDevicePort: convertDevicePort(data.PbRef),
|
|
CDevicePort: convertDevicePort(data.PcRef),
|
|
}
|
|
repo.Turnouts = append(repo.Turnouts, converTurnoutUid(turnout, uidsMap))
|
|
}
|
|
for _, data := range storage.Signals {
|
|
var sectionId string
|
|
var turnoutPort *proto.DevicePort
|
|
switch data.RefDev.DeviceType {
|
|
case graphicData.RelatedRef_Section:
|
|
sectionId = data.RefDev.Id
|
|
case graphicData.RelatedRef_Turnout:
|
|
turnoutPort = convertDevicePort(data.RefDev)
|
|
}
|
|
signal := &proto.Signal{
|
|
Id: data.Common.Id,
|
|
Km: convertKm(data.KilometerSystem),
|
|
SectionId: sectionId,
|
|
TurnoutPort: turnoutPort,
|
|
}
|
|
repo.Signals = append(repo.Signals, converSignalUid(signal, uidsMap))
|
|
}
|
|
for _, data := range storage.Transponders {
|
|
var sectionId string
|
|
var turnoutPort *proto.DevicePort
|
|
switch data.TransponderRef.DeviceType {
|
|
case graphicData.RelatedRef_Section:
|
|
sectionId = data.TransponderRef.Id
|
|
case graphicData.RelatedRef_Turnout:
|
|
turnoutPort = convertDevicePort(data.TransponderRef)
|
|
}
|
|
responder := &proto.Transponder{
|
|
Id: data.Common.Id,
|
|
Km: convertKm(data.KilometerSystem),
|
|
SectionId: sectionId,
|
|
TurnoutPort: turnoutPort,
|
|
}
|
|
repo.Transponders = append(repo.Transponders, converTransponderUid(responder, uidsMap))
|
|
}
|
|
slopeKsMap := make(map[string]*graphicData.SlopeKiloMarker)
|
|
for _, data := range storage.SlopeKiloMarker {
|
|
slopeKsMap[data.Common.Id] = data
|
|
repo.KilometerConverts = append(repo.KilometerConverts, buildKmConverts(data.KilometerSystem)...)
|
|
}
|
|
curveKsMap := make(map[string]*graphicData.CurvatureKiloMarker)
|
|
for _, data := range storage.CurvatureKiloMarker {
|
|
curveKsMap[data.Common.Id] = data
|
|
repo.KilometerConverts = append(repo.KilometerConverts, buildKmConverts(data.KilometerSystem)...)
|
|
}
|
|
for _, data := range storage.Slopes {
|
|
var kms []*proto.Kilometer
|
|
for _, id := range data.RefDeviceId {
|
|
kms = append(kms, convertKm(slopeKsMap[id].KilometerSystem[0]))
|
|
}
|
|
slope := &proto.Slope{
|
|
Id: data.Common.Id,
|
|
Kms: kms,
|
|
Degree: data.SlopeNumber,
|
|
}
|
|
repo.Slopes = append(repo.Slopes, converSlopeUid(slope, uidsMap))
|
|
}
|
|
for _, data := range storage.Curvatures {
|
|
var kms []*proto.Kilometer
|
|
for _, id := range data.RefDeviceId {
|
|
kms = append(kms, convertKm(curveKsMap[id].KilometerSystem[0]))
|
|
}
|
|
slope := &proto.SectionalCurvature{
|
|
Id: data.Common.Id,
|
|
Kms: kms,
|
|
Radius: data.CurvatureNumber,
|
|
}
|
|
repo.SectionalCurvatures = append(repo.SectionalCurvatures, converCurvatureUid(slope, uidsMap))
|
|
}
|
|
}
|
|
|
|
func converCheckPointUid(data *proto.CheckPoint, uidsMap *GraphicMapElementIdStructure) *proto.CheckPoint {
|
|
data.Id = uidsMap.AxlePointIds[data.Id].Uid
|
|
for _, c := range data.DevicePorts {
|
|
c.DeviceId = converRefUid(c.DeviceId, c.DeviceType, uidsMap)
|
|
}
|
|
return data
|
|
}
|
|
|
|
func converSectionUid(data *proto.PhysicalSection, uidsMap *GraphicMapElementIdStructure) *proto.PhysicalSection {
|
|
data.Id = uidsMap.PhysicalSectionIds[data.Id].Uid
|
|
if data.ADevicePort != nil {
|
|
data.ADevicePort.DeviceId = converRefUid(data.ADevicePort.DeviceId, data.ADevicePort.DeviceType, uidsMap)
|
|
}
|
|
if data.BDevicePort != nil {
|
|
data.BDevicePort.DeviceId = converRefUid(data.BDevicePort.DeviceId, data.BDevicePort.DeviceType, uidsMap)
|
|
}
|
|
tids := make([]string, len(data.TurnoutIds))
|
|
for i, tid := range data.TurnoutIds {
|
|
tids[i] = converRefUid(tid, proto.DeviceType_DeviceType_Turnout, uidsMap)
|
|
}
|
|
data.TurnoutIds = tids
|
|
return data
|
|
}
|
|
|
|
func converTurnoutUid(data *proto.Turnout, uidsMap *GraphicMapElementIdStructure) *proto.Turnout {
|
|
data.Id = uidsMap.TurnoutIds[data.Id].Uid
|
|
if data.ADevicePort != nil {
|
|
data.ADevicePort.DeviceId = converRefUid(data.ADevicePort.DeviceId, data.ADevicePort.DeviceType, uidsMap)
|
|
}
|
|
if data.BDevicePort != nil {
|
|
data.BDevicePort.DeviceId = converRefUid(data.BDevicePort.DeviceId, data.BDevicePort.DeviceType, uidsMap)
|
|
}
|
|
if data.CDevicePort != nil {
|
|
data.CDevicePort.DeviceId = converRefUid(data.CDevicePort.DeviceId, data.CDevicePort.DeviceType, uidsMap)
|
|
}
|
|
return data
|
|
}
|
|
|
|
func converSignalUid(data *proto.Signal, uidsMap *GraphicMapElementIdStructure) *proto.Signal {
|
|
data.Id = uidsMap.SignalIds[data.Id].Uid
|
|
if data.SectionId != "" {
|
|
data.SectionId = converRefUid(data.SectionId, proto.DeviceType_DeviceType_PhysicalSection, uidsMap)
|
|
}
|
|
if data.TurnoutPort != nil {
|
|
data.TurnoutPort.DeviceId = converRefUid(data.TurnoutPort.DeviceId, data.TurnoutPort.DeviceType, uidsMap)
|
|
}
|
|
return data
|
|
}
|
|
|
|
func converTransponderUid(data *proto.Transponder, uidsMap *GraphicMapElementIdStructure) *proto.Transponder {
|
|
data.Id = uidsMap.TransponderIds[data.Id].Uid
|
|
if data.SectionId != "" {
|
|
data.SectionId = converRefUid(data.SectionId, proto.DeviceType_DeviceType_PhysicalSection, uidsMap)
|
|
}
|
|
if data.TurnoutPort != nil {
|
|
data.TurnoutPort.DeviceId = converRefUid(data.TurnoutPort.DeviceId, data.TurnoutPort.DeviceType, uidsMap)
|
|
}
|
|
return data
|
|
}
|
|
|
|
func converSlopeUid(data *proto.Slope, uidsMap *GraphicMapElementIdStructure) *proto.Slope {
|
|
data.Id = uidsMap.SlopeIds[data.Id].Uid
|
|
return data
|
|
}
|
|
|
|
func converCurvatureUid(data *proto.SectionalCurvature, uidsMap *GraphicMapElementIdStructure) *proto.SectionalCurvature {
|
|
data.Id = uidsMap.CurvatureIds[data.Id].Uid
|
|
return data
|
|
}
|
|
|
|
func converRefUid(id string, d proto.DeviceType, uidsMap *GraphicMapElementIdStructure) string {
|
|
var elementId *ElementIdStructure
|
|
switch d {
|
|
case proto.DeviceType_DeviceType_CheckPoint:
|
|
elementId = uidsMap.AxlePointIds[id]
|
|
case proto.DeviceType_DeviceType_PhysicalSection:
|
|
elementId = uidsMap.PhysicalSectionIds[id]
|
|
case proto.DeviceType_DeviceType_SectionalCurvature:
|
|
elementId = uidsMap.CurvatureIds[id]
|
|
case proto.DeviceType_DeviceType_Signal:
|
|
elementId = uidsMap.SignalIds[id]
|
|
case proto.DeviceType_DeviceType_Slope:
|
|
elementId = uidsMap.SlopeIds[id]
|
|
case proto.DeviceType_DeviceType_Transponder:
|
|
elementId = uidsMap.TransponderIds[id]
|
|
case proto.DeviceType_DeviceType_Turnout:
|
|
elementId = uidsMap.TurnoutIds[id]
|
|
default:
|
|
panic(&dto.ErrorDto{Code: dto.ArgumentParseError, Message: "异常的设备类型-" + d.String()})
|
|
}
|
|
return elementId.Uid
|
|
}
|
|
|
|
func convertKm(ks *graphicData.KilometerSystem) *proto.Kilometer {
|
|
var dir proto.Direction
|
|
switch ks.Direction {
|
|
case graphicData.Direction_LEFT:
|
|
dir = proto.Direction_LEFT
|
|
case graphicData.Direction_RIGHT:
|
|
dir = proto.Direction_RIGHT
|
|
}
|
|
return &proto.Kilometer{
|
|
Value: ks.Kilometer,
|
|
CoordinateSystem: ks.CoordinateSystem,
|
|
Direction: dir,
|
|
}
|
|
}
|
|
|
|
func convertDevicePort(ref *graphicData.RelatedRef) *proto.DevicePort {
|
|
if ref == nil {
|
|
return nil
|
|
}
|
|
var deviceType proto.DeviceType
|
|
var port proto.Port
|
|
switch ref.DevicePort {
|
|
case graphicData.RelatedRef_A:
|
|
port = proto.Port_A
|
|
case graphicData.RelatedRef_B:
|
|
port = proto.Port_B
|
|
case graphicData.RelatedRef_C:
|
|
port = proto.Port_C
|
|
}
|
|
switch ref.DeviceType {
|
|
case graphicData.RelatedRef_Section:
|
|
deviceType = proto.DeviceType_DeviceType_PhysicalSection
|
|
case graphicData.RelatedRef_Turnout:
|
|
deviceType = proto.DeviceType_DeviceType_Turnout
|
|
default:
|
|
panic(fmt.Sprintf("异常的设备类型-%s", ref.DeviceType))
|
|
}
|
|
return &proto.DevicePort{
|
|
DeviceId: ref.Id,
|
|
DeviceType: deviceType,
|
|
Port: port,
|
|
}
|
|
}
|
|
|
|
func convertDevicePorts(refList []*graphicData.RelatedRef) []*proto.DevicePort {
|
|
var dps []*proto.DevicePort
|
|
for _, ref := range refList {
|
|
dps = append(dps, convertDevicePort(ref))
|
|
}
|
|
return dps
|
|
}
|
|
|
|
func findTurnoutIds(axleCountingMap map[string]*graphicData.AxleCounting, axleIds []string) []string {
|
|
if len(axleIds) <= 2 {
|
|
return nil
|
|
}
|
|
turnoutMap := make(map[string]bool)
|
|
for _, axleId := range axleIds {
|
|
axle := axleCountingMap[axleId]
|
|
relTurnoutCount := 0
|
|
var turnoutId string
|
|
for _, ref := range axle.AxleCountingRef {
|
|
if ref.DeviceType == graphicData.RelatedRef_Turnout {
|
|
relTurnoutCount++
|
|
turnoutId = ref.Id
|
|
}
|
|
}
|
|
if relTurnoutCount == 1 {
|
|
turnoutMap[turnoutId] = true
|
|
}
|
|
}
|
|
var turnoutIds []string
|
|
for id := range turnoutMap {
|
|
turnoutIds = append(turnoutIds, id)
|
|
}
|
|
return turnoutIds
|
|
}
|
|
|
|
func buildKmConverts(ksList []*graphicData.KilometerSystem) []*proto.KilometerConvert {
|
|
var kmConverts []*proto.KilometerConvert
|
|
for i, ks := range ksList {
|
|
if ks.Kilometer == 0 {
|
|
continue
|
|
}
|
|
for j := i + 1; j < len(ksList); j++ {
|
|
if ks.Kilometer == 0 {
|
|
continue
|
|
}
|
|
kmConverts = append(kmConverts, buildKmConvert(ks, ksList[j]))
|
|
}
|
|
}
|
|
return kmConverts
|
|
}
|
|
|
|
func buildKmConvert(ks1 *graphicData.KilometerSystem, ks2 *graphicData.KilometerSystem) *proto.KilometerConvert {
|
|
return &proto.KilometerConvert{
|
|
KmA: convertKm(ks1),
|
|
KmB: convertKm(ks2),
|
|
SameTrend: false,
|
|
}
|
|
}
|