BlowingScanAnaylze.cs

using FLY.Thick.Blowing;
using FLY.Thick.Blowing.UI;
using FLY.Thick.BlowingScan.Common;
using MathNet.Numerics.LinearAlgebra.Double;
using Misc;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.IO;
using System.Linq;
using System.Text;

namespace FLY.Thick.BlowingScan.UI.Client
{
    public class BlowingScanAnaylze : INotifyPropertyChanged
    {
        const double FilmLengthMin = 5;
        const double FilmLengthMax = 70;
        const double RAngleMin = 200;
        const double RAngleMax = 360;
        #region 缓存区


        /// <summary>
        /// 从BlowingScanService 接收过来的数据；
        /// 缓冲区最后一个记录序号
        /// </summary>
        public int BufListLastNo { get; private set; } = -1;

        /// <summary>
        /// 从BlowingScanService 接收过来的数据；
        /// 缓冲区数量
        /// </summary>
        public int BufListCount { get; private set; } = 0;

        /// <summary>
        /// 从BlowingScanService 接收过来的数据；
        /// 缓冲区
        /// </summary>
        public List<FlyData_BlowingScan> mBufList = new List<FlyData_BlowingScan>();
        public ObservableCollection<ScanInfoCell> ScanInfoList { get; } = new ObservableCollection<ScanInfoCell>();
        #endregion

        #region 试调整参数
        private int solvecnt = 4;
        /// <summary>
        /// 多少次扫描解一次方程
        /// </summary>
        public int SolveCnt
        {
            get { return solvecnt; }
            set
            {
                if (value < 4)
                    value = 4;

                if (solvecnt != value)
                {
                    solvecnt = value;
                }
            }
        }

        private int smooth = 1;
        /// <summary>
        /// 平滑
        /// </summary>
        public int Smooth
        {
            get { return smooth; }
            set
            {
                if (value < 0)
                    value = 0;
                if (smooth != value)
                {
                    smooth = value;
                }
            }
        }



        /// <summary>
        /// 旋转架转动角度
        /// </summary>
        public double RAngle { get; set; } = 350;


        /// <summary>
        /// 人字架到测厚仪膜的长度 单位m
        /// </summary>
        public double FilmLength { get; set; } = 23;

        #endregion

        #region 常量参数

        public int N2 { get; set; } = 400;

        public int Sensor { get; set; } = 240;


        public int OrgBoltNo { get; set; } = 1;

        public int NBolts { get; set; } = 88;

        #endregion

        #region 状态

        public bool IsStep2Ing { get; set; }

        #endregion

        #region 自动
        /// <summary>
        /// 旋转架转动角度 查找范围 50°
        /// </summary>
        public int RAngleRange { get; set; } = 90;

        /// <summary>
        /// 旋转架转动角度 查找范围 20m
        /// </summary>
        public int FilmLengthRange { get; set; } = 20;

        /// <summary>
        /// 查找过程信息
        /// </summary>
        public string SearchMsg { get; private set; }
        #endregion
        
        BlowingDetectCore mRDetectCore;

        public BlowingScanAnaylze()
        {
            MarkNos = new List<MarkData> { MarkNo1, MarkNo2 };
            for (int i = 0; i < MarkNos.Count(); i++) {
                var markData = MarkNos[i];
                markData.Name = $"记录{i+1}";
                markData.PropertyChanged += MarkNo_PropertyChanged;
            }
           
            MarkNos[0].IsFocus = true;
        }
        public void Init(BlowingDetectCore mRDetectCore) {
            this.mRDetectCore = mRDetectCore;
        }
        public int GetMarkNoFromRList(int idx)
        {
            if (idx >= ScanInfoList.Count())
                return BufListLastNo;
            else if (idx < 0)
                return (BufListLastNo - (ScanInfoList.Count() - 1));


            int markno = idx + (BufListLastNo - (ScanInfoList.Count() - 1));

            return markno;
        }
        int GetIdxFromRList(int markno)
        {
            int idx = markno - (BufListLastNo - (ScanInfoList.Count() - 1));
            if (idx >= ScanInfoList.Count())
                return -1;
            else if (idx < 0)
                return -1;
            return idx;
        }


        private void MarkNo_PropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            MarkData markdata = sender as MarkData;
            if (e.PropertyName == nameof(MarkData.Number))
            {
                int idx = GetIdxFromRList(markdata.Number);
                if (idx >= 0)
                {
                    markdata.IsValid = true;
                    var scanInfo = ScanInfoList[idx];
                    var flydata = mBufList[idx];
                    if (!scanInfo.HasCast)//解方程
                        ToThicks_SolveEquation(idx);

                    markdata.StartTime = scanInfo.StartTime;
                    markdata.ThicksDT = scanInfo.ThicksDT;
                    markdata.Thks = scanInfo.thks;
                    markdata.R = scanInfo.R;

                    markdata.Direction = scanInfo.Direction;
                    markdata.Border = flydata.FilmRange;
                    markdata.PosOfGrid = flydata.PosOfGrid;
                    markdata.Time = flydata.Time;
                }
                else
                {
                    markdata.IsValid = false;
                }
                UpdateCurrR();
                UpdateIsFocus();
            }
        }
        /// <summary>
        /// 能进入第2步解方程
        /// </summary>
        /// <returns></returns>
        public bool CanStep2()
        {
            if (mBufList.Count() == 0)
                return false;
            else if (IsStep2Ing)
                return false;
            return true;
        }



        /// <summary>
        /// 更新 BufList
        /// </summary>
        /// <param name="firstbm"></param>
        /// <param name="lastbm"></param>
        /// <param name="datas"></param>
        public void Step1(int lastNo, List<FlyData_BlowingScan> datas, bool isAdd)
        {
            if (!isAdd)
                mBufList.Clear();
            
            BufListLastNo = lastNo;
            mBufList.AddRange(datas);
            BufListCount = mBufList.Count();

            if (mBufList.Count()==0)
                return;

            BufList2ScanInfoList();


            //当MarkNo1.Number 不在范围内， 限制它们
            for (int i = 0; i < MarkNos.Count(); i++) {
                var markData = MarkNos[i];
                if (markData.Number == -1)
                    markData.Number = GetDefaultNumber();
                markData.Number = KeepInRange(markData.Number);

                if (i > 0) {
                    if (markData.Number == MarkNos[i-1].Number)
                    {
                        markData.Number = MarkNos[i - 1].Number + SolveCnt;
                    }
                }
            }
        }
        int GetDefaultNumber()
        {
            int count = mBufList.Count();
            int endNo = BufListLastNo;

            int beginNo = endNo - count + 1;
            return beginNo + SolveCnt;
        }
        public int KeepInRange(int no)
        {
            int count = mBufList.Count();
            int endNo = BufListLastNo;

            int beginNo = endNo - count + 1;

            int index = no - beginNo;
            if (index < 0)
                index = 0;
            else if (index >= count)
                index = count;
            no = beginNo + index;

            return no;

        }
        /// <summary>
        /// 解方程
        /// </summary>
        public void Step2()
        {
            IsStep2Ing = true;
            if (mBufList.Count()==0)
            {
                IsStep2Ing = false;
                return;
            }
            GetSolveEquation();
            ClearAllResult();
            foreach (var markData in MarkNos)
                markData.Refresh();

            //ToThicks_SolveEquation();
            IsStep2Ing = false;
        }

        /// <summary>
        /// 自动查找旋转角度
        /// </summary>
        public void StepAutoSearchRAngle()
        {
            if (mBufList.Count() == 0)
                return;
            int idx1 = GetIdxFromRList(MarkNo1.Number);
            int idx2 = GetIdxFromRList(MarkNo2.Number);
            if (idx1 < 0 || idx2 < 0)
                return;
            if (idx1 == idx2)
            {
                SearchMsg = "查找失败！！记录1 与 记录2 必须不一样";
                return;
            }

            List<Range> sameDirScanInfoIdxs = GetSameDirScanInfoIdxs();
            //两个都必须在相同的方向
            var r1 = sameDirScanInfoIdxs.Find(r => r.Contain(idx1));
            if (r1 == null)
                return;//异常，居然不属于任何一个方向
            if (!r1.Contain(idx2)) {
                SearchMsg = "查找失败！！记录1 与 记录2 必须在相同的方向";
                return;
            }



            IsStep2Ing = true;

            
            if (autoSearchRAngle(idx1, idx2, out double bestParam))
            {
                RAngle = bestParam;
                GetSolveEquation();
                ClearAllResult();
                MarkNos.ForEach(m => m.Refresh());
            }
            
            IsStep2Ing = false;
        }
        bool autoSearchRAngle(int idx1, int idx2, out double bestRa)
        {
            ParamRs.Clear();
            NotifyPropertyChanged(nameof(ParamRs));

            double minParam = RAngle - RAngleRange / 2;
            double maxParam = RAngle + RAngleRange / 2;
            if (minParam < RAngleMin)
                minParam = RAngleMin;
            if (maxParam > RAngleMax)
                maxParam = RAngleMax;

            double bestParam = RAngle;
            double bestR;

            //安全第一，刷新一下
            GetSolveEquationRange(RAngle, FilmLength, idx1, idx2);
            TrySolveEquationAndGetR(idx1, idx2, out bestR);

            while (true)
            {
                double step = (maxParam - minParam) / 8;
                if (step < 0.1)
                    step = 0.1;
                searchMsgHeader = $"最佳旋转角度={bestParam:F1}°相关性={bestR:F5} 步长={step:F1}";
                if (!SearchParam(minParam, maxParam, step, 0.05, out bestParam, out bestR,
                    (double par, out double r) =>
                    {
                        //GetSolveEquation(par, FilmLength, idx1);
                        //GetSolveEquation(par, FilmLength, idx2);
                        //获取角度信息
                        //for (int i = 0; i < mBufList.Count(); i++)
                        //{
                        //    GetSolveEquation(par, FilmLength, i);
                        //}
                        GetSolveEquationRange(par, FilmLength, idx1, idx2);

                        return TrySolveEquationAndGetR(idx1, idx2, out r);
                    })
                )
                {
                    //异常停止
                    bestRa = bestParam;
                    SearchMsg = $"最佳旋转角度={bestParam:F1}°相关性={bestR:F5}| 异常停止";
                    return false;
                }
                if (step <= 0.1)
                {
                    //查找完成
                    bestRa = bestParam;
                    SearchMsg = $"最佳旋转角度={bestParam:F1}°相关性={bestR:F5}| 查找完成";
                    return true;
                }
                minParam = bestParam - step * 2;
                maxParam = bestParam + step * 2;
                if (minParam < RAngleMin)
                    minParam = RAngleMin;
                if (maxParam > RAngleMax)
                    maxParam = RAngleMax;
            }

        }

        /// <summary>
        /// 自动查找膜距离
        /// </summary>
        public void StepAutoSearchFilmLength()
        {
            if (mBufList.Count() == 0)
                return;

            int idx1 = GetIdxFromRList(MarkNo1.Number);
            int idx2 = GetIdxFromRList(MarkNo2.Number);
            if (idx1 < 0 || idx2 < 0)
                return;
            if (idx1 == idx2)
            {
                SearchMsg = "查找失败！！记录1 与 记录2 必须不一样";
                return;
            }

            List<Range> sameDirScanInfoIdxs = GetSameDirScanInfoIdxs();
            //两个都必须在不相同的方向
            var r1 = sameDirScanInfoIdxs.Find(r => r.Contain(idx1));
            if (r1 == null)
                return;//异常，居然不属于任何一个方向
            if (r1.Contain(idx2))
            {
                SearchMsg = "查找失败！！记录1 与 记录2 必须在不相同的方向";
                return;
            }


            IsStep2Ing = true;

            if (autoSearchFilmLength(idx1, idx2, out double bestParam))
            {
                FilmLength = bestParam;
                GetSolveEquation();
                ClearAllResult();
                MarkNos.ForEach(m => m.Refresh());
            }
            
            IsStep2Ing = false;
        }
        bool autoSearchFilmLength(int idx1, int idx2, out double bestFl)
        {
            ParamRs.Clear();

            double minParam = FilmLength - FilmLengthRange / 2;
            double maxParam = FilmLength + FilmLengthRange / 2;
            if (minParam < FilmLengthMin)
                minParam = FilmLengthMin;
            if (maxParam > FilmLengthMax)
                maxParam = FilmLengthMax;

            double bestParam = FilmLength;
            double bestR;

            //安全第一，刷新一下
            GetSolveEquationRange(RAngle, FilmLength, idx1, idx2);
            TrySolveEquationAndGetR(idx1, idx2, out bestR);
            

            while (true)
            {
                double step = (maxParam - minParam) / 8;
                if (step < 0.1)
                    step = 0.1;
                searchMsgHeader = $"最佳膜距离={bestParam:F1}m 相关性={bestR:F5} 步长={step:F1}";
                if (!SearchParam(minParam, maxParam, step, 0.05, out bestParam, out bestR,
                    (double par, out double r) =>
                    {
                        //GetSolveEquation(RAngle,par, SearchIdx1);
                        //GetSolveEquation(RAngle,par, SearchIdx2);
                        //获取角度信息
                        //for (int i = 0; i < mBufList.Count(); i++)
                        //{
                        //    GetSolveEquation(RAngle, par, i);
                        //}
                        GetSolveEquationRange(RAngle, par, idx1, idx2);
                        return TrySolveEquationAndGetR(idx1, idx2, out r);
                    })
                )
                {
                    //异常停止
                    bestFl = bestParam;
                    SearchMsg = $"最佳膜距离={bestParam:F1}m 相关性={bestR:F5}| 异常停止";
                    return false;
                }
                if (step <= 0.1)
                {
                    //查找完成
                    bestFl = bestParam;
                    SearchMsg = $"最佳膜距离={bestParam:F1}m 相关性={bestR:F5}| 查找完成";
                    return true;
                }
                minParam = bestParam - step * 2;
                maxParam = bestParam + step * 2;
                if (minParam < FilmLengthMin)
                    minParam = FilmLengthMin;
                if (maxParam > FilmLengthMax)
                    maxParam = FilmLengthMax;
            }
        }


        /// <summary>
        /// 自动查找膜距离2
        /// </summary>
        public void StepAutoSearchFilmLength2()
        {
            if (mBufList.Count() == 0)
                return;

            var markData = MarkNos.Find(m => m.IsFocus);
            if (markData == null)
                return;
            int idx = GetIdxFromRList(markData.Number);
            if (idx < 0)
                return;

            List<Range> sameDirScanInfoIdxs = GetSameDirScanInfoIdxs();
            //整个范围，必须横跨一个转向

            var r1 = sameDirScanInfoIdxs.Find(r => r.Contain(idx));
            if (r1 == null)
                return;//异常，居然不属于任何一个方向
            
            int idx2 = idx - SolveCnt + 1;

            if (r1.Contain(idx2))
            {
                SearchMsg = "查找失败！！解方程范围，必须横跨一个转向点";
                return;
            }



            IsStep2Ing = true;
            

  
            
           if (idx >= 0)
            {
                if (autoSearchFilmLength2(idx, out double bestParam))
                {
                    FilmLength = bestParam;
                    GetSolveEquation();
                    ClearAllResult();
                    MarkNos.ForEach(m => m.Refresh());
                }
            }
            IsStep2Ing = false;
        }
        bool autoSearchFilmLength2(int idx, out double bestFl)
        {
            ParamRs.Clear();

            double minParam = FilmLength - FilmLengthRange / 2;
            double maxParam = FilmLength + FilmLengthRange / 2;
            if (minParam < FilmLengthMin)
                minParam = FilmLengthMin;
            if (maxParam > FilmLengthMax)
                maxParam = FilmLengthMax;

            double bestParam = FilmLength;
            double bestR;

            GetSolveEquationRange(RAngle, FilmLength, idx);
            ToThicks_SolveEquation(idx);
            bestR = ScanInfoList[idx].R;

            while (true)
            {
                double step = (maxParam - minParam) / 8;
                if (step < 0.1)
                    step = 0.1;
                searchMsgHeader = $"最佳膜距离={bestParam:F1}m 自相关性={bestR:F5} 步长={step:F1}";

                if (!SearchParam(minParam, maxParam, step, 0.05, out bestParam, out bestR,
                    (double par, out double r) =>
                    {
                        //更新连续N个扫描的方程
                        GetSolveEquationRange(RAngle, par, idx);

                        bool ret = ToThicks_SolveEquation(idx);
                        r = ScanInfoList[idx].R;
                        return ret;
                    })
                )
                {
                    //异常停止
                    bestFl = bestParam;
                    SearchMsg = $"最佳膜距离={bestParam:F1}m 自相关性={bestR:F5}| 异常停止";
                    return false;
                }

                if (step <= 0.1)
                {
                    //查找完成
                    bestFl = bestParam;
                    SearchMsg = $"最佳膜距离={bestParam:F1}m 自相关性={bestR:F5}| 查找完成";
                    return true;
                }
                minParam = bestParam - step * 2;
                maxParam = bestParam + step * 2;

                if (minParam < FilmLengthMin)
                    minParam = FilmLengthMin;
                if (maxParam > FilmLengthMax)
                    maxParam = FilmLengthMax;
            }
        }




        /// <summary>
        /// 自动查找旋转角度
        /// </summary>
        public void StepAutoSearchRAngle2()
        {
            if (mBufList.Count() == 0)
                return;
            
            var markData = MarkNos.Find(m => m.IsFocus);
            if (markData == null)
                return;

            int idx = GetIdxFromRList(markData.Number);
            if (idx < 0)
                return;

            IsStep2Ing = true;
            

            if (autoSearchRAngle2(idx, out double bestParam))
            {
                RAngle = bestParam;
                GetSolveEquation();
                ClearAllResult();

                MarkNos.ForEach(m => m.Refresh());
            }
            
            IsStep2Ing = false;
        }
        bool autoSearchRAngle2(int idx, out double bestRa)
        {
            ParamRs.Clear();
            NotifyPropertyChanged(nameof(ParamRs));

            double minParam = RAngle - RAngleRange / 2;
            double maxParam = RAngle + RAngleRange / 2;
            if (minParam < RAngleMin)
                minParam = RAngleMin;
            if (maxParam > RAngleMax)
                maxParam = RAngleMax;

            double bestParam = RAngle;
            double bestR;

            GetSolveEquationRange(RAngle, FilmLength, idx);
            ToThicks_SolveEquation(idx);
            bestR = ScanInfoList[idx].R;

            while (true)
            {
                double step = (maxParam - minParam) / 8;
                if (step < 0.1)
                    step = 0.1;
                searchMsgHeader = $"最佳旋转角度={bestParam:F1}°自相关性={bestR:F5} 步长={step:F1}";

                if (!SearchParam(minParam, maxParam, step, 0.05, out bestParam, out bestR,
                    (double par, out double r) =>
                    {

                        GetSolveEquationRange(par, FilmLength, idx);

                        bool ret = ToThicks_SolveEquation(idx);
                        r = ScanInfoList[idx].R;
                        return ret;
                    })
                )
                {
                    //异常停止
                    bestRa = bestParam;
                    SearchMsg = $"最佳旋转角度={bestParam:F1}°自相关性={bestR:F5}| 异常停止";
                    return false;
                }
                if (step <= 0.1)
                {
                    //查找完成
                    bestRa = bestParam;
                    SearchMsg = $"最佳旋转角度={bestParam:F1}°自相关性={bestR:F5}| 查找完成";
                    return true;
                }
                minParam = bestParam - step * 2;
                maxParam = bestParam + step * 2;

                if (minParam < RAngleMin)
                    minParam = RAngleMin;
                if (maxParam > RAngleMax)
                    maxParam = RAngleMax;
            }
            
        }


        List<Range> GetSameDirScanInfoIdxs() {

            List<Range> sameDirScanInfoIdxs = new List<Range>();

            //必须有个方向切换点
            for (int i = 0; i < ScanInfoList.Count(); i++)
            {
                int idx = i;
                var direction = ScanInfoList[idx].Direction;

                if (direction != DIRECTION.FIX)
                {
                    if (sameDirScanInfoIdxs.Count() == 0)
                        sameDirScanInfoIdxs.Add(new Range() { Begin = idx, End = idx });
                    else
                    {
                        Range range = sameDirScanInfoIdxs.Last();
                        int idxEnd = range.End;
                        if (ScanInfoList[idxEnd].Direction == direction)
                        {
                            range.End = idx;
                        }
                        else
                        {
                            //另一个方向
                            sameDirScanInfoIdxs.Add(new Range() { Begin = idx, End = idx });
                        }
                    }
                }
            }
            return sameDirScanInfoIdxs;
        }
        /// <summary>
        /// 自动查找全部参数
        /// </summary>
        public void StepAutoSearchParams()
        {
            IsStep2Ing = true;
            if (mBufList.Count() == 0)
            {
                IsStep2Ing = false;
                return;
            }

            List<Range> sameDirScanInfoIdxs = GetSameDirScanInfoIdxs();
            if (sameDirScanInfoIdxs.Count < 3)
            {
                SearchMsg = "查找失败！！旋转次数<3";
                goto _end;
            }

            int IdxOfSameDirRangeForSearchRAngle = -1;
            int IdxOfSameDirRangeForSearchFilmLength = -1;
            int minInfoCnt = SolveCnt * 2 + 2;
            for (int i = 1; i < sameDirScanInfoIdxs.Count - 1; i++)
            {
                int idx = sameDirScanInfoIdxs.Count - 1 - i;

                if (sameDirScanInfoIdxs[idx].Width > minInfoCnt)
                {
                    //合符要求
                    if (IdxOfSameDirRangeForSearchRAngle == -1)
                    {
                        IdxOfSameDirRangeForSearchRAngle = i;
                    }
                    else
                    {
                        IdxOfSameDirRangeForSearchFilmLength = i;
                        break;
                    }
                }
            }
            if (IdxOfSameDirRangeForSearchFilmLength == -1)
            {
                SearchMsg = $"查找失败！！不能找到连续2次 在相同旋转内 扫描次数大于 {minInfoCnt}";
                goto _end;
            }
            int idx1 = sameDirScanInfoIdxs[IdxOfSameDirRangeForSearchRAngle].Mid;
            int idx2 = sameDirScanInfoIdxs[IdxOfSameDirRangeForSearchRAngle].Mid + SolveCnt - 1;

            if (!autoSearchRAngle(idx1, idx2, out double bestRa))
            {
                SearchMsg = $"查找失败！！旋转角度查找失败";
                goto _end;
            }
            RAngle = bestRa;

            idx1 = sameDirScanInfoIdxs[IdxOfSameDirRangeForSearchRAngle].Mid + SolveCnt / 2;
            idx2 = sameDirScanInfoIdxs[IdxOfSameDirRangeForSearchFilmLength].Mid + SolveCnt / 2;
            if (!autoSearchFilmLength(idx1, idx2, out double bestFl))
            {
                SearchMsg = $"查找失败！！膜距离查找失败";
                goto _end;
            }
            FilmLength = bestFl;
            GetSolveEquation();
            ClearAllResult();

            MarkNos.ForEach(m => m.Refresh());

            MarkNo1.Number = GetMarkNoFromRList(idx1);
            MarkNo2.Number = GetMarkNoFromRList(idx2);

            _end:
            IsStep2Ing = false;
        }

        /// <summary>
        /// 通过自相关性 自动查找全部参数
        /// </summary>
        public void StepAutoSearchParams2()
        {
            IsStep2Ing = true;
            if (mBufList.Count() == 0)
            {
                IsStep2Ing = false;
                return;
            }
            List<Range> sameDirScanInfoIdxs = GetSameDirScanInfoIdxs();

            if (sameDirScanInfoIdxs.Count < 3)
            {
                SearchMsg = "查找失败！！旋转次数<3";
                goto _end;
            }

            //最后两个方向扫描数量误差不能大于2
            int width = sameDirScanInfoIdxs[sameDirScanInfoIdxs.Count() - 2].Width;

            int solveCnt = width;
            if (solveCnt < 5)
                solveCnt = 5;

            int IdxOfSameDirRangeForSearch=-1;

            for (int i = 0; i < sameDirScanInfoIdxs.Count; i++)
            {
                int index = sameDirScanInfoIdxs.Count - 1 - i;
                int index0 = index - 1;
                //需要让 解方程 数为 minInfoCnt 对称 卡在 转向点 
                if (index0 >= 0)
                {
                    if ((sameDirScanInfoIdxs[index0].Width > solveCnt / 2) && (sameDirScanInfoIdxs[index].Width > solveCnt / 2))
                    {
                        IdxOfSameDirRangeForSearch = sameDirScanInfoIdxs[index].Begin + solveCnt / 2 - 1;
                        break;
                    }
                }
            }
            if (IdxOfSameDirRangeForSearch == -1)
            {
                SearchMsg = $"查找失败！！不能找到解方程 数为 {solveCnt} 对称 卡在 转向点";
                goto _end;
            }
            SolveCnt = solveCnt;

            if (!autoSearchFilmLength2(IdxOfSameDirRangeForSearch, out double bestFl))
            {
                SearchMsg = $"查找失败！！膜距离查找失败";
                goto _end;
            }
            FilmLength = bestFl;


            if (!autoSearchRAngle2(IdxOfSameDirRangeForSearch, out double bestRa))
            {
                SearchMsg = $"查找失败！！旋转角度查找失败";
                goto _end;
            }
            RAngle = bestRa;


            GetSolveEquation();
            ClearAllResult();

            MarkNos.ForEach(m => m.Refresh());

            MarkNo1.Number = GetMarkNoFromRList(IdxOfSameDirRangeForSearch);
            MarkNo2.Number = MarkNo1.Number - SolveCnt;

            _end:
            IsStep2Ing = false;
        }
        public class ParamR:INotifyPropertyChanged
        {
            public double Param { get; set; }
            public double R { get; set; }
            public ParamR(double par, double r)
            {
                Param = par;
                R = r;
            }

            public event PropertyChangedEventHandler PropertyChanged;

            public override string ToString()
            {
                return $"{Param:F2}:R={R:F5}";
            }
        }
        /// <summary>
        /// 旋转角度查找过程！！！
        /// </summary>
        public List<ParamR> ParamRs { get; set; } = new List<ParamR>();

        delegate bool GetRHandler(double param, out double r);

        string searchMsgHeader;
        /// <summary>
        /// 给定范围，步距，查找最大相关性时的旋转角度
        /// 中间过程记录在RaRs
        /// </summary>
        /// <param name="minPar">参数最小值</param>
        /// <param name="maxPar">参数最大值</param>
        /// <param name="step">步距</param>
        /// <param name="minStep">最小步距</param>
        /// <param name="bestPar">最佳参数</param>
        /// <param name="getR">更新参数解方程且获取相关性</param>
        /// <returns>不能解方程返回 false</returns>
        bool SearchParam(double minPar, double maxPar, double step, double minStep, out double bestPar, out double bestR, GetRHandler getR)
        {
            bestPar = 0;
            bestR = -1;
            List<ParamR> parList = new List<ParamR>();

            for (double par = minPar; par <= maxPar; par += step)
            {
                var rar = ParamRs.Find(_rar => Math.Abs(_rar.Param - par) < minStep);
                if (rar != null)
                {
                    //已经测试过！！！！
                    parList.Add(rar);
                    continue;
                }
                double r;
                bool ret = getR(par, out r);
                if (ret)
                {
                    parList.Add(new ParamR(par, r));
                }
                SearchMsg = searchMsgHeader + $"| 参数:{par:F1} 相关性={r:F5}";
            }
            if (parList.Count() == 0)
                return false;
            //找到最大值
            {
                double r = parList.Max(rar => rar.R);
                bestR = r;
                bestPar = parList.Find(_r => _r.R == r).Param;
            }
            //把列表插入到 RaRs
            foreach (var rar in parList)
            {
                if (ParamRs.Find(_rar => _rar.Param == rar.Param) == null)
                {
                    ParamRs.Add(rar);
                }
            }
            ParamRs.Sort((rar1, rar2) => { return rar1.Param.CompareTo(rar2.Param); });
            NotifyPropertyChanged(nameof(ParamRs));

            return true;
        }
        /// <summary>
        /// 清除全部计算结果
        /// </summary>
        void ClearAllResult()
        {
            for (int i = 0; i < mBufList.Count(); i++)
            {
                ScanInfoCell scaninfo = ScanInfoList[i];
                scaninfo.HasCast = false;
            }
        }



        /// <summary>
        /// 转为 位置与厚度信息
        /// </summary>
        void BufList2ScanInfoList()
        {
            ScanInfoList.Clear();
            for (int i = 0; i < mBufList.Count(); i++)
            {
                FlyData_BlowingScan f = mBufList[i];
                int posOfGrid = f.PosOfGrid;
                //有效数据范围
                Range boltrange = new Range() { Begin = f.FilmRange.Begin + Sensor / 2 + N2, End = f.FilmRange.End - (Sensor / 2 + N2) };
                //膜边界
                Range border = f.FilmRange;

                ScanInfoCell scaninfocell = new ScanInfoCell(NBolts, OrgBoltNo);

                //对应的grid号
                int bp_idx = boltrange.Begin / posOfGrid;
                int ep_idx = boltrange.End / posOfGrid;

                if (bp_idx < 0)
                    bp_idx = 0;

                if (ep_idx > (f.Thks.Length - 1))
                    ep_idx = f.Thks.Length - 1;

                double sum = 0;
                int cnt = 0;
                for (int j = bp_idx; j <= ep_idx; j++)
                {
                    int idx = j;
                    int pos = j * posOfGrid + posOfGrid / 2;//一个grid的中间脉冲，也就是大概而已
                    double thk = f.Thks[idx];
                    sum += thk;
                    cnt++;

                    pos -= border.Begin;//膜上面的位置
                    ScanPosCell scanpos = new ScanPosCell() { pos = pos, thk = thk, dt = f.ThicksDt[idx] };

                    //scaninfocell.StartTime 为整幅数据最早的时间
                    if (j == bp_idx)
                    {
                        scaninfocell.StartTime = scanpos.dt;
                    }
                    else
                    {
                        if (scaninfocell.StartTime > scanpos.dt)
                            scaninfocell.StartTime = scanpos.dt;
                    }
                    scaninfocell.frame.Add(scanpos);
                }
                if (cnt > 0)
                    sum = sum / cnt;
                scaninfocell.Avg = sum;

                ScanInfoList.Add(scaninfocell);
            }



        }

        /// <summary>
        /// 第2步，修改 旋转角度，膜距离 执行, 耗时很短
        /// </summary>
        void GetSolveEquation()
        {
            //获取角度信息
            for (int i = 0; i < mBufList.Count(); i++)
            {
                GetSolveEquation(RAngle, FilmLength, i);
            }
        }

        /// <summary>
        /// 更新idx1, idx2前面连续SolveCnt个扫描的方程
        /// </summary>
        /// <param name="rAngle"></param>
        /// <param name="filmLength"></param>
        /// <param name="idx1"></param>
        /// <param name="idx2"></param>
        void GetSolveEquationRange(double rAngle, double filmLength, int idx1, int idx2) 
        {
            List<int> getSolveIdxs = new List<int>();

            for (int i = 0; i < SolveCnt; i++)
            {
                int index = idx1 - i;
                if (index >= 0)
                {
                    if (!getSolveIdxs.Contains(index))
                        getSolveIdxs.Add(index);
                }
                index = idx2 - i;
                if (index >= 0)
                {
                    if (!getSolveIdxs.Contains(index))
                        getSolveIdxs.Add(index);
                }
            }
            foreach (var index in getSolveIdxs)
            {
                GetSolveEquation(rAngle, filmLength, index);
            }
        }

        /// <summary>
        /// 更新idx前面连续SolveCnt个扫描的方程
        /// </summary>
        /// <param name="rAngle"></param>
        /// <param name="filmLength"></param>
        /// <param name="idx"></param>
        void GetSolveEquationRange(double rAngle, double filmLength, int idx) 
        {
            for (int i = 0; i < SolveCnt; i++)
            {
                int index = idx - i;
                if (index < 0)
                    break;
                GetSolveEquation(rAngle, filmLength, index);
            }
        }

        /// <summary>
        /// 只获取某次扫描的方程
        /// </summary>
        /// <param name="rAngle"></param>
        /// <param name="filmLength"></param>
        /// <param name="idx"></param>
        void GetSolveEquation(double rAngle, double filmLength, int idx)
        {
            FlyData_BlowingScan f = mBufList[idx];
            ScanInfoCell scaninfocell = ScanInfoList[idx];

            scaninfocell.equationList.Clear();

            scaninfocell.State = ScanInfoCell.STATE.OK;

            for (int j = 0; j < scaninfocell.frame.Count(); j++)
            {
                ScanPosCell scanpos = scaninfocell.frame[j];

                mRDetectCore.RAngle = rAngle;
                mRDetectCore.FilmLength = filmLength;

                int ret = mRDetectCore.GetFilmInfo(
                    out FilmInfo filminfo,
                    scanpos.dt, f.FilmRange.Width, scanpos.pos);

                //探头直径转为角度范围
                double sensor_angle = 180.0 * Sensor / f.FilmRange.Width;

                if (ret == 0)
                {
                    scanpos.angle1 = filminfo.angle1;
                    scanpos.angle2 = filminfo.angle2;
                    scanpos.direction = filminfo.direction;
                    //TODO
                    scanpos.rotateAngle = 180 * scanpos.pos / f.FilmRange.Width;
                }
                else
                {
                    scaninfocell.State = ScanInfoCell.STATE.Err_GetAngle;
                    break;
                }
                if (j == 0)
                    scaninfocell.Direction = scanpos.direction;
                else
                {
                    if (scaninfocell.Direction != scanpos.direction)
                    {
                        scaninfocell.Direction = DIRECTION.FIX;
                        scaninfocell.State = ScanInfoCell.STATE.Err_Solve;
                        break;
                    }
                }
                scaninfocell.AddEquation(j, sensor_angle);
            }
        }

        /// <summary>
        /// 解2次扫描的方程，且计算它们的相关性
        /// </summary>
        /// <param name="scaninfo_idx0"></param>
        /// <param name="scaninfo_idx1"></param>
        /// <param name="r"></param>
        /// <returns></returns>
        bool TrySolveEquationAndGetR(int scaninfo_idx0, int scaninfo_idx1, out double r)
        {
            if (ToThicks_SolveEquation(scaninfo_idx0) && ToThicks_SolveEquation(scaninfo_idx1))
            {
                ScanInfoCell scaninfo0 = ScanInfoList[scaninfo_idx0];
                ScanInfoCell scaninfo1 = ScanInfoList[scaninfo_idx1];
                r = Misc.MyMath.Correl(scaninfo0.thks, scaninfo1.thks);
                return true;
            }
            else
            {
                r = -1;
                return false;

            }
        }


        bool ToThicks_SolveEquation(int scaninfo_idx)
        {
            ScanInfoCell scaninfo = ScanInfoList[scaninfo_idx];

            scaninfo.HasCast = true;

            if (scaninfo.State != ScanInfoCell.STATE.OK)
                return false;

            if (scaninfo.Direction == DIRECTION.FIX)//当前是Fix 不解方程
            {
                scaninfo.State = ScanInfoCell.STATE.Err_Solve;
                return false;
            }

            //全部方向都必须一致，当然也不能是Fix
            //for (int i = 0; i < (SolveCnt - 1); i++)
            //{
            //    if (scaninfo.Direction != ScanInfoList[scaninfo_idx - 1 - i].Direction)
            //    {
            //        scaninfo.State = ScanInfoCell.STATE.ERR_Solve_Maybe;
            //        break;
            //    }
            //}

            List<EquationCell> equationlist = new List<EquationCell>();
            scaninfo.solveMember.Clear();

            
            for (int i = 0; i < SolveCnt; i++)
            {
                int index = scaninfo_idx - i;
                if (index < 0)
                    break;
                if (ScanInfoList[index].Direction == DIRECTION.FIX)
                    continue;

                equationlist.AddRange(ScanInfoList[index].equationList);
                //用到的扫描副
                scaninfo.solveMember.Add(index);
            }
            
            //计算 每个分区的权
            for (int i = 0; i < scaninfo.power.Count(); i++)
            {
                scaninfo.power[i] = 0;
            }
            foreach (EquationCell e in equationlist)
            {
                foreach (KeyValuePair<int, int> kv in e.boltPower)
                {
                    //if(e.mainBolt == kv.Key)
                    scaninfo.power[kv.Key] += kv.Value;
                    //else
                    //    scaninfo.power[kv.Key+scaninfo.nbolts] += kv.Value;
                }
            }

            if (scaninfo.solveMember.Count() < 3) //方程不够！！！！
            {
                scaninfo.State = ScanInfoCell.STATE.Err_Solve;
                return false;
            }

            if (equationlist.Count < 100)//方程数太少
            {
                scaninfo.State = ScanInfoCell.STATE.Err_Solve;
                return false;
            }
            double[] thks = scaninfo.thks;
            SolveEquation(equationlist, thks);


            //2105 条方程，耗时 0.3s
            //SolveEquation(equationlist, ScanInfoList[scaninfo_idx].thicks);

            //不能有任何一个double.NaN
            if (thks.Any(thk => double.IsNaN(thk)))
            {
                scaninfo.State = ScanInfoCell.STATE.Err_Solve;
                return false;
            }


            SmoothFrame(thks, Smooth);
            scaninfo.R = SingleR(equationlist, thks);


            scaninfo.ThicksDT = ScanInfoList[scaninfo.solveMember.Last()].StartTime;

            return true;
        }
        /// <summary>
        /// 平滑thks
        /// </summary>
        /// <param name="thks"></param>
        /// <param name="smooth">平滑半径</param>
        static void SmoothFrame(double[] thks, int smooth)
        {
            if (smooth > 0)
            {
                double[] data = new double[thks.Count()];

                for (int i = 0; i < thks.Count(); i++)
                {
                    double sum = 0;

                    for (int j = 0; j < (smooth * 2 + 1); j++)
                    {
                        int index = i + j - smooth;
                        if (index < 0)
                            index += thks.Count();
                        else if (index >= thks.Count())
                            index -= thks.Count();
                        sum += thks[index];
                    }
                    data[i] = sum / (smooth * 2 + 1);
                }
                Array.Copy(data, thks, thks.Count());
            }
        }
        /// <summary>
        /// 计算方程每个原始数据 与 结果的相关性
        /// </summary>
        /// <param name="equationList"></param>
        /// <param name="frame_out"></param>
        /// <returns></returns>
        static double SingleR(List<EquationCell> equationList, double[] frame_out)
        {
            List<double> calThks = new List<double>();
            List<double> actThks = new List<double>();
            foreach (EquationCell ec in equationList)
            {
                double[] datas = ec.GetPower(frame_out.Count());
                double sum = 0;
                double cnt = 0;
                foreach (var kv in ec.boltPower)
                {
                    sum += frame_out[kv.Key] * kv.Value;
                    cnt += kv.Value;
                }
                if (cnt > 0)
                {
                    double totalThk = sum / cnt;
                    calThks.Add(totalThk);
                    
                    actThks.Add(ec.thk);
                }
            }
            return Misc.MyMath.Correl(calThks, actThks);
        }
        /// <summary>
        /// 解方程
        /// </summary>
        /// <param name="equationList">N条方程</param>
        /// <param name="frame_out">输出的结果</param>
        void SolveEquation(List<EquationCell> equationList, double[] frame_out)
        {

            int nrow = equationList.Count();
            //A~AX = A~B
            //转换为 DenseMatrix 与 DenseVector
            DenseMatrix matrixA = new DenseMatrix(nrow, NBolts);
            DenseMatrix matrixAT = new DenseMatrix(NBolts, nrow);
            DenseVector vectorB = new DenseVector(nrow);
            DenseVector vectorATB = new DenseVector(NBolts);


            int rowindex = 0;

            foreach (EquationCell ec in equationList)
            {

                double[] datas = ec.GetPower(NBolts);

                matrixA.SetRow(rowindex, datas);

                matrixAT.SetColumn(rowindex, datas);
                vectorB[rowindex] = ec.thk;
                rowindex++;
            }

            DenseMatrix ATA = (DenseMatrix)matrixA.TransposeThisAndMultiply(matrixA);
            DenseVector ATB = (DenseVector)matrixA.TransposeThisAndMultiply(vectorB);

            DenseVector X = (DenseVector)ATA.Solve(ATB);

            int j;
            for (int i = 0; i < NBolts; i++)
            {
                frame_out[i] = X[i];
            }
        }

        #region INotifyPropertyChanged 接口
        protected void NotifyPropertyChanged(string propertyName)
        {
            if (PropertyChanged != null)
            {
                PropertyChanged.Invoke(this, new PropertyChangedEventArgs(propertyName));
            }
        }
        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
        #endregion



        #region 两组数据

        public double CurrR { get; set; } = -1;

        public MarkData MarkNo1 { get; } = new MarkData();
        public MarkData MarkNo2 { get; } = new MarkData();

        public List<MarkData> MarkNos { get; private set; }
        void UpdateCurrR()
        {
            if (MarkNo1.IsValid && MarkNo2.IsValid)
            {
                CurrR = Misc.MyMath.Correl(MarkNo1.Thks, MarkNo2.Thks);
            }
            else
            {
                CurrR = -1;
            }
        }
        void UpdateIsFocus()
        {
            int idx1 = GetIdxFromRList(MarkNo1.Number);
            int idx2 = GetIdxFromRList(MarkNo2.Number);

            for (int i = 0; i < ScanInfoList.Count(); i++)
            {
                ScanInfoList[i].IsFocus = false;
                ScanInfoList[i].IsFocus2 = false;
            }

            if (idx1 > 0)
            {
                ScanInfoList[idx1].IsFocus = true;
                foreach (int i in ScanInfoList[idx1].solveMember)
                {
                    ScanInfoList[i].IsFocus = true;
                }
            }

            if (idx2 > 0)
            {
                ScanInfoList[idx2].IsFocus2 = true;
                foreach (int i in ScanInfoList[idx2].solveMember)
                {
                    ScanInfoList[i].IsFocus2 = true;
                }
            }
        }


        #endregion

        #region 调试
        public bool Save(string path)
        {
            try
            {
                using (StreamWriter sw = new StreamWriter(path, false, Encoding.GetEncoding("GB2312")))
                {
                    bool hasHeader = false;
                    foreach (FlyData_BlowingScan f in mBufList)
                    {
                        if (!hasHeader)
                        {
                            hasHeader = true;
                            sw.WriteLine(f.GetHeader());
                        }
                        sw.WriteLine(f.ToString());
                    }
                    sw.Flush();
                    sw.Close();
                }
                return true;
            }
            catch (Exception e)
            {
                return false;
            }
        }
        public bool Load(string path, out List<FlyData_BlowingScan> bufList)
        {
            bufList = new List<FlyData_BlowingScan>();

            using (StreamReader sr = new StreamReader(path, Encoding.GetEncoding("GB2312")))
            {
                string header = sr.ReadLine();

                while (!sr.EndOfStream)
                {
                    string s = sr.ReadLine();
                    FlyData_BlowingScan f = new FlyData_BlowingScan();
                    if (f.TryParse(header, s))
                    {
                        bufList.Add(f);
                    }
                    else
                    {
                        return false;
                    }
                }
            }
            return true;
        }

        #endregion

    }

    public class GageData : INotifyPropertyChanged
    {
        private Range border = new Range();
        /// <summary>
        /// 膜边界，单位脉冲
        /// </summary>
        [PropertyChanged.DoNotCheckEquality]
        public Range Border { get; set; }


        /// <summary>
        /// pos / grid
        /// </summary>
        public int PosOfGrid { get; set; } = 10;



        /// <summary>
        /// 厚度数据,  大小 grid总数
        /// </summary>
        [PropertyChanged.DoNotCheckEquality]
        public int[] OrgThicks { get; set; }




        #region INotifyPropertyChanged 接口

        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
        #endregion
    }
    public class MarkData : INotifyPropertyChanged
    {
        public string Name { get; set; } = "记录";

        public int Number { get; set; } = -1;

        /// <summary>
        /// 获取了焦点
        /// </summary>
        public bool IsFocus { get; set; }
        /// <summary>
        /// 有效
        /// </summary>
        public bool IsValid { get; set; }

        /// <summary>
        /// 扫描时间
        /// </summary>
        public DateTime StartTime { get; set; } = DateTime.MinValue;


        /// <summary>
        /// 旋转架旋转的方向，当同一次扫描中，有两个方向，Direction= Fix；
        /// </summary>
        public Misc.DIRECTION Direction { get; set; } = DIRECTION.FORWARD;


        /// <summary>
        /// 下面解方程得到的一幅数据对应的数据，与 StartTime 不一样
        /// </summary>
        public DateTime ThicksDT { get; set; } = DateTime.MinValue;


        /// <summary>
        /// 一幅数据
        /// </summary>
        [PropertyChanged.DoNotCheckEquality]
        public double[] Thks { get; set; }


        /// <summary>
        /// 膜边界，单位脉冲
        /// </summary>
        [PropertyChanged.DoNotCheckEquality]
        public Range Border { get; set; }


        /// <summary>
        /// pos / grid
        /// </summary>
        public int PosOfGrid { get; set; } = 10;

        /// <summary>
        /// orgthick时间
        /// </summary>
        public DateTime Time { get; set; } = DateTime.MinValue;

        /// <summary>
        /// 方程数据与解方程后的结果相关性
        /// </summary>
        public double R { get; set; } = -1;
        public MarkData()
        {

        }

        public void Refresh()
        {
            NotifyPropertyChanged(nameof(Number));
        }

        #region INotifyPropertyChanged 接口
        protected void NotifyPropertyChanged(string propertyName)
        {
            if (PropertyChanged != null)
            {
                PropertyChanged.Invoke(this, new PropertyChangedEventArgs(propertyName));
            }
        }
        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
        #endregion
    }


    public class ScanPosCell
    {
        public DateTime dt = DateTime.MinValue;
        public int pos;//位于膜的位置,不是机架
        public double thk;//两层的厚度
                         //由pos转换!!
        public double angle1;//上层 位于膜泡的角度 0~360°
        public double angle2;//下层 位于膜泡的角度 0~360°
        public Misc.DIRECTION direction;//只有一整副数据都是同一个方向，才能解方程

        public double rotateAngle;//0~180° 可以认为是夹扁后膜的变形
        public ScanPosCell Clone()
        {
            ScanPosCell scanpos = new ScanPosCell();
            scanpos.dt = dt;
            scanpos.pos = pos;
            scanpos.thk = thk;
            scanpos.angle1 = angle1;
            scanpos.angle2 = angle2;
            scanpos.direction = direction;
            scanpos.rotateAngle = rotateAngle;
            return scanpos;
        }
    }

    public class EquationCell
    {
        public Dictionary<int, int> boltPower = new Dictionary<int, int>();//key=boltindex, value=power
        public Dictionary<int, int> heatRotatePower = new Dictionary<int, int>();//key=boltindex, value=power

        public double thk = 0;
        public int mainBolt;//主分区号
        public void Add(int boltindex1, int boltindex2, double thk)
        {
            if (boltPower.ContainsKey(boltindex1))
            {
                boltPower[boltindex1]++;
            }
            else
            {
                boltPower.Add(boltindex1, 1);
            }

            if (boltPower.ContainsKey(boltindex2))
            {
                boltPower[boltindex2]++;
            }
            else
            {
                boltPower.Add(boltindex2, 1);
            }
            this.thk += thk;
        }

        public override string ToString()
        {
            string str = "";
            foreach (var b in boltPower)
            {
                str += "[" + b.Key.ToString() + "," + b.Value.ToString() + "] ";
            }
            return str;
        }
        public double[] GetPower(int nbolts)
        {
            double[] power = new double[nbolts];
            for (int i = 0; i < power.Count(); i++)
                power[i] = 0;

            foreach (var kv in boltPower)
            {
                power[kv.Key] = kv.Value;
            }
            return power;
        }

        public double GetAvg()
        {
            int cnt = 0;
            for (int i = 0; i < boltPower.Count(); i++)
            {
                cnt += boltPower.Values.ElementAt(i);
            }
            if (cnt > 0)
                return thk / cnt;
            else
                return double.NaN;
        }
    }
    public class ScanInfoCell : INotifyPropertyChanged
    {

        /// <summary>
        /// 已经解完方程
        /// </summary>
        public bool HasCast { get; set; }


        #region 数据
        public enum STATE
        {
            /// <summary>
            /// 获取角度出错
            /// </summary>
            Err_GetAngle,
            /// <summary>
            /// 解方程出错
            /// </summary>
            Err_Solve,
            /// <summary>
            /// 解方程可能出错
            /// </summary>
            ERR_Solve_Maybe,
            /// <summary>
            /// 没问题
            /// </summary>
            OK
        }
        public STATE State { get; set; } = STATE.OK;

        /// <summary>
        /// 扫描时间
        /// </summary>
        public DateTime StartTime { get; set; } = DateTime.MinValue;

        /// <summary>
        /// 旋转架旋转的方向，当同一次扫描中，有两个方向，Direction= Fix；
        /// </summary>
        public Misc.DIRECTION Direction { get; set; } = DIRECTION.FIX;


        /// <summary>
        /// 当前在观察
        /// </summary>
        public bool IsFocus { get; set; }



        /// <summary>
        /// 当前在观察
        /// </summary>
        public bool IsFocus2 { get; set; }

        /// <summary>
        /// 原始数据(时间，位置，总厚度)
        /// </summary>
        public List<ScanPosCell> frame = new List<ScanPosCell>();
        /// <summary>
        /// 方程列表
        /// </summary>
        public List<EquationCell> equationList = new List<EquationCell>();


        /// <summary>
        /// 下面解方程得到的一幅数据对应的数据，与 StartTime 不一样
        /// </summary>
        public DateTime ThicksDT { get; set; } = DateTime.MinValue;

        /// <summary>
        /// thicks 与 方程列表 的相关性
        /// </summary>
        public double R = -1;
        /// <summary>
        /// 一幅数据
        /// </summary>
        public double[] thks;

        /// <summary>
        /// 分区数
        /// </summary>
        public int nbolts;

        /// <summary>
        /// 复位区号
        /// </summary>
        public int orgboltno;

        /// <summary>
        /// 厚度均值
        /// </summary>
        public double Avg { get; set; }
        #endregion

        #region 分析观察
        /// <summary>
        /// 解方程 用的scaninfo
        /// </summary>
        public List<int> solveMember = new List<int>();
        /// <summary>
        /// 每个分区出现次数， 上下分区各不相同
        /// </summary>
        public int[] power;

        #endregion

        public ScanInfoCell(int nbolts, int orgboltno)
        {
            this.nbolts = nbolts;
            this.orgboltno = orgboltno;
            thks = new double[nbolts];
            power = new int[nbolts];
            for (int i = 0; i < nbolts; i++)
            {
                thks[i] = double.NaN;
            }
        }

        int GetBoltIndexFromAngle(double a)
        {
            int boltno1st = 1;
            int nbolts = thks.Count();
            int boltindex = (int)(a / 360 * nbolts);

            boltindex += orgboltno - boltno1st;

            while (boltindex >= nbolts)
                boltindex -= nbolts;

            while (boltindex < 0)
                boltindex += nbolts;

            return boltindex;
        }

        /// <summary>
        /// 完成了一些方程，返回true
        /// </summary>
        /// <param name="scanpos_idx"></param>
        /// <returns></returns>
        public bool AddEquation(int scanpos_idx, double sensor_angle)
        {

            ScanPosCell scanpos = frame[scanpos_idx];


            EquationCell equation = new EquationCell();
            equationList.Add(equation);


            //TOD0
            equation.Add(
                GetBoltIndexFromAngle(scanpos.angle1),
                GetBoltIndexFromAngle(scanpos.angle2),
                scanpos.thk);

            for (int i = 1; i < sensor_angle / 2; i++)
            {
                equation.Add(
                    GetBoltIndexFromAngle(scanpos.angle1 + i),
                    GetBoltIndexFromAngle(scanpos.angle2 + i),
                    scanpos.thk);

                equation.Add(
                    GetBoltIndexFromAngle(scanpos.angle1 - i),
                    GetBoltIndexFromAngle(scanpos.angle2 - i),
                    scanpos.thk);
            }
            return true;
        }

        #region INotifyPropertyChanged 接口
        protected void NotifyPropertyChanged(string propertyName)
        {
            if (PropertyChanged != null)
            {
                PropertyChanged.Invoke(this, new PropertyChangedEventArgs(propertyName));
            }
        }
        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
        #endregion
    }
}