XdCxRhDW/Service/CheckServer/Controllers/CheckController.cs


using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using System.Web.Http;
using XdCxRhDW.Dto;
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
            {
                dto.file1 = GetLocalFile(dto.file1);
                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 dmcResult = await CheckHelper.DmcCheckAsync(dto.file1, dto.fsHz, EnumSigCheckTypeDto.DAMA, dto.band);
                    dmcResults.AddRange(dmcResult);
                }
                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);
                    }
                }
                return Success(list);
            }
            catch (Exception ex)
            {
                Serilog.Log.Error(ex, $"{dto.dmcType}检测异常");
                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(() =>
            {
                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, dto.TimeoutSeconds);
                    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)
                {
                    Serilog.Log.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)
        {
            return await Task.Run(() =>
            {
                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()
                        {
                            Ffc = item.Ffc,
                            Rate = item.Rate,
                            ModType = (EnumSignalTypeDto)(int)item.SignalType
                        };
                        list.Add(resItem);
                    }
                    return Success(list);
                }
                catch (Exception ex)
                {
                    Serilog.Log.Error(ex, "信号识别算法执行异常");
                    return Error<List<SignalProcResDto>>($"信号识别算法执行异常");
                }
            });

        }

        //求最大公约数
        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;
        }
    }
}