XdCxRhDW/Service/CheckServer/Controllers/CheckController.cs


using CheckServer.AddIns;
using System;
using System.Collections.Generic;
using System.Configuration;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using System.Web.Http;
using XdCxRhDW.Dto;
using XdCxRhDW.Framework;
using XdCxRhDW.UI.Lib;
using XdCxRhDW.WebApi;

namespace CheckServer.Controllers
{

    /// <summary>
    /// 信号检测、识别、变采样接口
    /// </summary>
    public class CheckController : BaseController
    {
        /// <summary>
        /// 信号检测(支持DAMA、IBS、能量检测)(需要先上传文件、会根据信号带宽自动对文件进行滤波)
        /// </summary>
        /// <param name="dto">信号检测参数</param>
        /// <returns></returns>
        [HttpPost]
        public async Task<AjaxResult<List<DetectResDto>>> Calc(DetectDto dto)
        {
            try
            {
                GC.Collect();
                dto.file1 = GetLocalFile(dto.file1);
                var bandHz = dto.band * 1e3;
                string outFile = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "wwwroot", $"{Path.GetFileNameWithoutExtension(dto.file1)}_filter.dat");
                dto.file1 = await SigFilterHelper.SigFilter(new SigFilterDto()
                {
                    BandHz = bandHz,
                    File = dto.file1,
                    FsHz = dto.fsHz,
                }, outFile);
                if (!File.Exists(dto.file1))
                {
                    return Error<List<DetectResDto>>("滤波后的文件未能生成");
                }
                List<DetectResDto> list = new List<DetectResDto>();
                List<DmcResult> listRes = new List<DmcResult>();
                List<DmcResult> dmcResults = new List<DmcResult>();
                List<DmcResult> ibsResults = new List<DmcResult>();
                List<DmcResult> kyResults = new List<DmcResult>();
                if (dto.dmcType.HasFlag(EnumSigCheckTypeDto.DAMA))
                {
                    //var damaVersion = AppConfigHelper.Get("DamaVersion");
                    //if (string.IsNullOrWhiteSpace(damaVersion) || damaVersion.Trim() == "1")
                    //{
                    //    var dmcResult = await CheckHelper.DmcCheckAsync(dto.file1, dto.fsHz, EnumSigCheckTypeDto.DAMA, dto.band);
                    //    dmcResults.AddRange(dmcResult);
                    //}
                    //else if (damaVersion.Trim() == "2")
                    //{
                    //    var dmcResult = await CheckHelper.DAMACheckAsync(dto.file1, dto.fsHz, EnumSigCheckTypeDto.DAMA, dto.band);
                    //    dmcResults.AddRange(dmcResult);
                    //}
                    //else
                    //{
                    var dmcResult = await CheckHelper.DmcCheckAsync(dto.file1, dto.fsHz, EnumSigCheckTypeDto.DAMA, dto.band);
                    dmcResults.AddRange(dmcResult);
                    if (dmcResult == null || !dmcResult.Any())
                    {
                        var dmcResult2 = await CheckHelper.DAMACheckAsync(dto.file1, dto.fsHz, EnumSigCheckTypeDto.DAMA, dto.band);
                        dmcResults.AddRange(dmcResult2);
                    }
                    //}

                }
                if (dto.dmcType.HasFlag(EnumSigCheckTypeDto.IBS))
                {
                    var dmcResult = await CheckHelper.DmcCheckAsync(dto.file1, dto.fsHz, EnumSigCheckTypeDto.IBS, dto.band);
                    ibsResults.AddRange(dmcResult);
                }
                if (dto.dmcType.HasFlag(EnumSigCheckTypeDto.Ky5758))
                {
                    var dmcResult = await CheckHelper.DmcCheckAsync(dto.file1, dto.fsHz, EnumSigCheckTypeDto.Ky5758, dto.band);
                    kyResults.AddRange(dmcResult);
                }
                if (dto.mergeRes)
                {
                    listRes.AddRange(dmcResults);
                    var ibsCopy = ibsResults.Skip(0).ToList();
                    foreach (var item in ibsResults)
                    {
                        if (listRes.Any(p => CalcIntersecLen(p, item) > 500))
                            ibsCopy.Remove(item);//IBS结果在DAMA中重叠超过500长度,忽略
                    }
                    listRes.AddRange(ibsCopy);
                    var kyCopy = kyResults.Skip(0).ToList();
                    foreach (var item in kyResults)
                    {
                        if (listRes.Any(p => CalcIntersecLen(p, item) > 500))
                            kyCopy.Remove(item);//KY结果在DAMA或IBS中重叠超过500长度,忽略
                    }
                    listRes.AddRange(kyCopy);
                    foreach (var dmcItem in listRes)
                    {
                        DetectResDto detectRes = new DetectResDto(dmcItem.Start, dmcItem.Length, dmcItem.UserName);
                        detectRes.ModType = dmcItem.ModType;
                        detectRes.DmcType = dmcItem.DmcType;
                        detectRes.File1 = dto.file1;
                        detectRes.TimeMs = dmcItem.Times;
                        list.Add(detectRes);
                    }
                }
                else
                {
                    listRes.AddRange(dmcResults);
                    listRes.AddRange(ibsResults);
                    listRes.AddRange(kyResults);
                    foreach (var dmcItem in listRes)
                    {
                        DetectResDto detectRes = new DetectResDto(dmcItem.Start, dmcItem.Length, dmcItem.UserName);
                        detectRes.ModType = dmcItem.ModType;
                        detectRes.DmcType = dmcItem.DmcType;
                        detectRes.File1 = dto.file1;
                        detectRes.TimeMs = dmcItem.Times;
                        list.Add(detectRes);
                    }
                }
                await LogUI.Info($"文件{Path.GetFileName(dto.file1)}检测完成");
                return Success(list);
            }
            catch (Exception ex)
            {
                await LogUI.Error($"文件【{Path.GetFileName(dto.file1)}】{dto.dmcType}检测异常", ex);
                return Error<List<DetectResDto>>($"{dto.dmcType}检测异常");
            }
        }


        /// <summary>
        /// 文件变采样(需要先上传文件)
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        public async Task<AjaxResult<ResampleResponseDto>> Resample(ResampleRequestDto dto)
        {
            var res = await Task.Run(async () =>
            {
                try
                {
                    string fileIn = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "wwwroot", dto.File);
                    string fileOut = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "wwwroot", Guid.NewGuid() + ".dat");
                    var val = Gcd(dto.FsHz, dto.OutFsHz);//最大公约数
                    var insertFactor = dto.OutFsHz / val;
                    var extFactor = dto.FsHz / val;
                    var outFile = ReSampleHelper.Resample(fileIn, fileOut, insertFactor, extFactor);
                    if (!string.IsNullOrWhiteSpace(outFile))
                    {
                        if (!File.Exists(outFile))
                            return Error<ResampleResponseDto>("变采样后的文件未能生成");
                        else
                            return Success(new ResampleResponseDto() { File = Path.GetFileName(outFile), OutFsHz = dto.OutFsHz });
                    }
                    else
                    {
                        return Error<ResampleResponseDto>("变采样算法返回失败");
                    }
                }
                catch (Exception ex)
                {
                    await LogUI.Error($"变采样算法执行异常", ex);
                    return Error<ResampleResponseDto>("变采样算法执行异常");
                }
            });
            return res;
        }

        /// <summary>
        /// 信号识别(调制类型、调制速率、频偏)
        /// </summary>
        /// <param name="dto">信号检测参数</param>
        /// <returns></returns>
        [HttpPost]
        public async Task<AjaxResult<List<SignalProcResDto>>> SignalProc(SignalProcDto dto)
        {
            await LogUI.Info($"正在识别文件{dto.File}");
            return await Task.Run(async () =>
            {
                try
                {
                    dto.File = GetLocalFile(dto.File);
                    List<SignalProcResDto> list = new List<SignalProcResDto>();
                    var res = SignalProcHelper.SigalEst(dto.File, dto.Fs
                         , dto.Smps.Select(p => (int)p.smpStart).ToArray()
                         , dto.Smps.Select(p => (int)p.smpCount).ToArray());
                    foreach (var item in res)
                    {
                        SignalProcResDto resItem = new SignalProcResDto()
                        {
                            Snr = item.Snr,
                            Ffc = item.Ffc,
                            Rate = item.Rate,
                            ModType = (EnumSignalTypeDto)(int)item.SignalType
                        };
                        list.Add(resItem);
                    }
                    await LogUI.Info($"文件{Path.GetFileName(dto.File)}识别完成");
                    return Success(list);
                }
                catch (Exception ex)
                {
                    await LogUI.Error($"文件{Path.GetFileName(dto.File)}识别异常", ex);
                    return Error<List<SignalProcResDto>>($"信号识别算法执行异常");
                }
            });

        }


        /// <summary>
        /// 对信号文件进行滤波处理(需要先上传文件)
        /// </summary>
        /// <param name="dto">信号滤波参数</param>
        /// <returns></returns>
        [HttpPost]
        public async Task<AjaxResult<SigFilterResponseDto>> SigFilterProc(SigFilterDto dto)
        {
            try
            {
                await LogUI.Info($"正在滤波处理文件{dto.File}");
                dto.File = GetLocalFile(dto.File);
                string outFile = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "wwwroot", Guid.NewGuid() + "filter.dat");
                outFile = await SigFilterHelper.SigFilter(dto, outFile);
                if (!File.Exists(outFile))
                {
                    return Error<SigFilterResponseDto>("滤波后的文件未能生成");
                }
                else
                {
                    await LogUI.Info($"文件{Path.GetFileName(dto.File)}滤波完成");

                    return Success(new SigFilterResponseDto() { File = Path.GetFileName(outFile) });
                }

            }
            catch (Exception ex)
            {
                await LogUI.Error($"文件{Path.GetFileName(dto.File)}滤波异常", ex);
                return Error<SigFilterResponseDto>($"信号滤波算法执行异常");
            }
        }


        //求最大公约数
        private int Gcd(int M, int N)
        {
            int Rem;
            while (N > 0)
            {
                Rem = M % N;
                M = N;
                N = Rem;
            }
            return M;
        }

        //计算两个时隙交集的长度，无交集返回0
        private int CalcIntersecLen(DmcResult dto1, DmcResult dto2)
        {
            if (dto2.Start >= dto1.Start + dto1.Length) return 0;
            if (dto1.Start >= dto2.Start + dto2.Length) return 0;
            int maxStart = Math.Max(dto1.Start, dto2.Start);
            int minEnd = Math.Min(dto1.Start + dto1.Length, dto2.Start + dto2.Length);
            return minEnd - maxStart + 1;
        }
    }
}