1. 添加了动态污染溯源相关功能逻辑

feiyu02

2025-05-08 9a9a27f185bc0cf9dc0001cfc6839e6d13dbccd9

 src/main/kotlin/com/flightfeather/uav/biz/dataanalysis/BaseExceptionContinuous.kt

@@ -1,7 +1,9 @@
package com.flightfeather.uav.biz.dataanalysis

import com.flightfeather.uav.biz.FactorFilter
import com.flightfeather.uav.biz.dataanalysis.model.DataAnalysisConfig
import com.flightfeather.uav.domain.entity.BaseRealTimeData
import com.flightfeather.uav.socket.eunm.FactorType

/**
 * 连续类型的异常分析基类,适用于当前数据与相邻数据之间有关联关系的情况
@@ -13,72 +15,111 @@
        private const val OFFSET = 10
    }

    // 起始数据下标
    protected var sIndex = mutableListOf<Int>()
    inner class Tag {
        // 起始数据下标
        var sIndex = 0

    // 起始数据对象
    protected var startData = mutableListOf<BaseRealTimeData?>()
        // 起始数据对象
        var startData :BaseRealTimeData? = null

    // 末尾数据下标
    protected var eIndex = mutableListOf<Int>()
        // 末尾数据下标
        var eIndex = -1

    // 末尾数据对象
    protected var lastData: BaseRealTimeData? = null
        // 末尾数据对象
        var endData: BaseRealTimeData? = null

    // 异常数据段
    protected var exceptionData = mutableListOf<MutableList<BaseRealTimeData>>()
        // 异常数据段
        var exceptionData = mutableListOf<BaseRealTimeData>()

        // 是否存在异常
        var existException = false

        fun refreshAfterCheckResult(data: BaseRealTimeData) {
            sIndex = eIndex
            startData = data
            exceptionData.clear()
            exceptionData.add(data)
        }
    }

    protected val tagMap = mutableMapOf<FactorType, Tag>()

//    // 起始数据下标
//    protected var sIndex = mutableListOf<Int>()
//
//    // 起始数据对象
//    protected var startData = mutableListOf<BaseRealTimeData?>()
//
//    // 末尾数据下标
//    protected var eIndex = mutableListOf<Int>()
//
//    // 异常数据段
//    protected var exceptionData = mutableListOf<MutableList<BaseRealTimeData>>()

//    protected var existException = mutableListOf<Boolean>()

    // 起始数据与末尾数据间隔
    open var durationCount = 1
    protected var existException = mutableListOf<Boolean>()
    // 末尾数据对象
    protected var lastData: BaseRealTimeData? = null

    /**
     * 判断是否满足异常条件
     */
    abstract fun judgeException(p: BaseRealTimeData?, n: BaseRealTimeData): List<Boolean>
    abstract fun judgeException(p: BaseRealTimeData?, n: BaseRealTimeData): MutableMap<FactorType, Boolean>

    /**
     * 判断异常出现的连续时长是否满足条件
     * @param sIndex
     * @param eIndex
     */
    abstract fun judgeDuration(sIndex: Int, eIndex: Int): Boolean

    override fun init() {
        super.init()
        lastData = null
        repeat(config.factorCount) {
            startData.add(null)
            sIndex.add(0)
            eIndex.add(-1)
            existException.add(false)
            exceptionData.add(mutableListOf())
//        repeat(config.factorCount) {
//            startData.add(null)
//            sIndex.add(0)
//            eIndex.add(-1)
//            existException.add(false)
//            exceptionData.add(mutableListOf())
//        }
        tagMap.clear()
        config.factorFilter.mainList().forEach {f->
            tagMap[f] = Tag()
        }
    }

    override fun onNextData(data: BaseRealTimeData) {
        val isContinue = isContinuous(lastData, data)
        val hasException = judgeException(lastData, data)
        repeat(config.factorCount) { i ->
            eIndex[i]++
            // 起始数据
            if (lastData == null) {
                refreshAfterCheckResult(i, data)
            }
            // 判断相邻数据是否连续并且是否满足异常判断
            if (!isContinue) {
                checkResult()
                // 数据不连续时，记录异常情况
                if (eIndex[i] - sIndex[i] >= durationCount) {
                    refreshAfterCheckResult(i, data)
        config.factorFilter.selectedList.forEach {s->
            val f = s.main
            tagMap[f]?.let {
                it.eIndex++
                // 起始数据
                it.endData = lastData
                if (it.endData == null) {
                    it.refreshAfterCheckResult(data)
                }
            } else {
                if (hasException[i]) {
                    existException[i] = true
                    exceptionData[i].add(data)
                // 判断相邻数据是否连续并且是否满足异常判断
                if (!isContinue) {
                    checkResult(s)
                    // 数据不连续时，记录异常情况
                    if (it.eIndex - it.sIndex >= durationCount) {
                        it.refreshAfterCheckResult(data)
                    }
                } else {
                    // 异常不再重复出现时，记录异常情况
                    checkResult()
                    if (eIndex[i] - sIndex[i] >= durationCount) {
                        refreshAfterCheckResult(i, data)
                    if (hasException[f] == true) {
                        it.existException = true
                        it.exceptionData.add(data)
                    } else {
                        // 异常不再重复出现时，记录异常情况
                        checkResult(s)
                        if (it.eIndex - it.sIndex >= durationCount) {
                            it.refreshAfterCheckResult(data)
                        }
                    }
                }
            }
@@ -90,33 +131,43 @@
        checkResult()
    }

    fun refreshAfterCheckResult(i:Int, data: BaseRealTimeData) {
        sIndex[i] = eIndex[i]
        startData[i] = data
        exceptionData[i].clear()
        exceptionData[i].add(data)
    }
//    fun refreshAfterCheckResult(i:Int, data: BaseRealTimeData) {
//        sIndex[i] = eIndex[i]
//        startData[i] = data
//        exceptionData[i].clear()
//        exceptionData[i].add(data)
//    }

    /**
     * 检查连续异常结束时，是否符合异常存储条件
     */
    open fun checkResult(index: Int? = null) {
        if (index != null) {
            if (existException[index] && judgeDuration(sIndex[index], eIndex[index])) {
                startData[index]?.let {
                    resultList.add(newResult(it, lastData, index, exceptionData[index]))
    open fun checkResult(factor: FactorFilter.SelectedFactor? = null) {
        val tag = tagMap[factor?.main]
        if (factor != null && tag != null) {
            if (tag.existException && judgeDuration(tag.sIndex, tag.eIndex - 1)) {
                tag.startData?.let {
                    resultList.add(newResult(it, lastData, factor, tag.exceptionData))
                }
                existException[index] = false
                tag.existException = false
            }
        } else {
            repeat(config.factorCount) { i ->
                if (existException[i] && judgeDuration(sIndex[i], eIndex[i])) {
                    startData[i]?.let {
                        resultList.add(newResult(it, lastData, i, exceptionData[i]))
            config.factorFilter.selectedList.forEach { f ->
                val tag1 = tagMap[f.main] ?: return@forEach
                if (tag1.existException && judgeDuration(tag1.sIndex, tag1.eIndex - 1)) {
                    tag1.startData?.let {
                        resultList.add(newResult(it, lastData, f, tag1.exceptionData))
                    }
                    existException[i] = false
                    tag1.existException = false
                }
            }
//            repeat(config.factorCount) { i ->
//                if (existException[i] && judgeDuration(sIndex[i], eIndex[i])) {
//                    startData[i]?.let {
//                        resultList.add(newResult(it, lastData, i, exceptionData[i]))
//                    }
//                    existException[i] = false
//                }
//            }
        }
    }
}