2025.8.14 1. 动态溯源模块添加滑动平均异常计算（调试中）

feiyu02

2025-08-14 b10c22af595bd995e56946bff63b8f2f984b13e8

 src/main/kotlin/com/flightfeather/uav/biz/sourcetrace/exceptiontype/BaseRealTimeException.kt

@@ -2,9 +2,11 @@

import com.flightfeather.uav.biz.FactorFilter
import com.flightfeather.uav.biz.dataanalysis.BaseExceptionContinuous
import com.flightfeather.uav.biz.dataanalysis.model.ExceptionTag
import com.flightfeather.uav.biz.sourcetrace.RealTimeAnalysisConfig
import com.flightfeather.uav.biz.sourcetrace.model.RealTimeExceptionResult
import com.flightfeather.uav.domain.entity.BaseRealTimeData
import com.flightfeather.uav.lightshare.eunm.ExceptionStatusType

// 异常数据生成回调类
typealias NewExceptionCallback = (ex: RealTimeExceptionResult) -> Unit
@@ -15,59 +17,59 @@
 * @date 2025/5/13
 * @author feiyu02
 */
abstract class BaseRealTimeException(config: RealTimeAnalysisConfig) :
    BaseExceptionContinuous<RealTimeAnalysisConfig, RealTimeExceptionResult>(config) {
@Deprecated("2025.5.29, 逻辑与业务不匹配，后续删除")
abstract class BaseRealTimeException<T : ExceptionTag>(config: RealTimeAnalysisConfig, tagClz: Class<T>) :
    BaseExceptionContinuous<T, RealTimeAnalysisConfig, RealTimeExceptionResult>(config, tagClz) {

    constructor(config: RealTimeAnalysisConfig, callback: NewExceptionCallback) : this(config){
    constructor(config: RealTimeAnalysisConfig, callback: NewExceptionCallback, tagClz: Class<T>) : this(config, tagClz){
        this.callback = callback
    }

    var callback: NewExceptionCallback? = null

    override fun onNextData(data: BaseRealTimeData) {
        val isContinue = isContinuous(lastData, data)
        val hasException = judgeException(lastData, data)
        config.factorFilter.selectedList.forEach { s ->
            val f = s.main
            tagMap[f]?.let {
                it.eIndex++
                // 起始数据
                it.endData = data
                if (it.startData == null) {
                    it.refreshAfterCheckResult(data)
                }
                // 判断相邻数据是否连续或者是否满足自定义截取条件
                if (!isContinue || needCut(it)) {
                    // 记录异常，结束异常的实时状态播报
                    recordException(s, it, data)
                } else {
                    if (hasException[f] == true) {
                        it.existException = true
                        it.exceptionData.add(data)
                    }
                    // 移除了父类原有逻辑，改为当满足异常条件时，需要实时推送播报异常的状态变化，但不截取异常
                    checkResult(s)
                }
            }
        }
        lastData = data
    }
//    override fun onNextData(data: BaseRealTimeData) {
//        val isContinue = isContinuous(lastData, data)
//        val hasException = judgeException(lastData, data)
//        config.factorFilter.selectedList.forEach { s ->
//            val f = s.main
//            tagMap[f]?.let {
//                it.eIndex++
//                // 起始数据
//                it.endData = data
//                if (it.startData == null) {
//                    it.refreshWithNextException(data)
//                }
//                // 判断相邻数据是否连续或者是否满足自定义截取条件
//                if (!isContinue || needCut(it)) {
//                    // 记录异常，结束异常的实时状态播报
//                    recordException(s, it, data)
//                } else {
//                    // 移除了父类原有逻辑，改为当满足异常条件时，需要实时推送播报异常的状态变化，但不截取异常
//                    if (hasException[f] == true) {
//                        it.addExceptionData(data)
//                        checkResult(s)
//                    }
//                }
//            }
//        }
//        lastData = data
//    }

    override fun newResult(
        start: BaseRealTimeData,
        end: BaseRealTimeData?,
        factor: FactorFilter.SelectedFactor,
        exceptionData: List<BaseRealTimeData>,
    ): RealTimeExceptionResult {

    override fun newResult(tag:T, factor: FactorFilter.SelectedFactor): RealTimeExceptionResult {
        val eType = getExceptionType()
        return RealTimeExceptionResult(start, end, factor, exceptionData, eType)
        return RealTimeExceptionResult(tag.startData!!, tag.endData, factor, tag.exceptionData, eType)
    }

    override fun onNewException(tag: Tag, factor: FactorFilter.SelectedFactor) {
        super.onNewException(tag, factor)
    override fun newResult(exceptions: List<Pair<FactorFilter.SelectedFactor, ExceptionTag>>): RealTimeExceptionResult {
        return RealTimeExceptionResult()
    }

    override fun onNewException(tag: T, factor: FactorFilter.SelectedFactor, exceptionStatus: ExceptionStatusType) {
        super.onNewException(tag, factor, exceptionStatus)
        callback?.let { func ->
            val exc = resultList.last()
            func.invoke(exc)
            val exc = tag.exceptionResult.last()
            func.invoke(exc as RealTimeExceptionResult)
        }
    }
}