bimface 水流

lixiaojun

2024-10-31 abf1e3b3334ab47c38aa92405a11a6ec92b7847a

 WinFrmUI/HStation.WinFrmUI.Xhs.Core/03-simulation/06-simulation/XhsProjectSimulationCorePage.cs

@@ -3,7 +3,9 @@
using DevExpress.XtraRichEdit.Layout;
using DevExpress.XtraSpreadsheet.Commands;
using HStation.WinFrmUI.PhartRelation;
using System.Windows.Media.Media3D;
using Yw.Pump;
using Yw.Vmo;
using Yw.WinFrmUI.Bimface;
using Yw.WinFrmUI.Hydro;

@@ -166,7 +168,7 @@
            {
                _propertyCtrl = new XhsProjectSimulationPropertyCtrl();
                _propertyCtrl.Dock = DockStyle.Fill;
                _propertyCtrl.InitialData(() => _hydroInfo, () => GetAllCalcuResultList());
                _propertyCtrl.InitialData(() => _hydroInfo, () => GetCalcuResultList());
                _propertyCtrl.BlinkLinkParterEvent += async (code, linkCode) =>
                { //强调连接组件
                    if (string.IsNullOrEmpty(code))
@@ -254,7 +256,7 @@
            }
            _propertyCtrl?.SelectParter(_parter.Code);

            var allCalcuResultList = GetAllCalcuResultList();
            var allCalcuResultList = GetCalcuResultList();
            if (allCalcuResultList != null && allCalcuResultList.Count > 0)
            {
                var calcuResult = allCalcuResultList.Find(x => x.Code == _parter.Code);
@@ -316,7 +318,7 @@
            }
            this.controlContainerBottom.Controls.Clear();
            var matchingListCtrl = GetMatchingListCtrl();
            var input = AssetsMatchingParasHelper.Create(_hydroInfo, GetAllCalcuResultList());
            var input = AssetsMatchingParasHelper.Create(_hydroInfo, GetCalcuResultList());
            matchingListCtrl.SetBindingData(input);
            this.controlContainerBottom.Controls.Add(matchingListCtrl);
            this.docPnlBottom.Visibility = DevExpress.XtraBars.Docking.DockVisibility.Visible;
@@ -543,7 +545,7 @@
                return;
            }
            var parterListCtrl = GetParterListCtrl();
            parterListCtrl.SetBindingData(_hydroInfo, GetAllCalcuResultList());
            parterListCtrl.SetBindingData(_hydroInfo, GetCalcuResultList());
            this.controlContainerBottom.Controls.Clear();
            this.controlContainerBottom.Controls.Add(parterListCtrl);
            this.docPnlBottom.Visibility = DevExpress.XtraBars.Docking.DockVisibility.Visible;
@@ -948,7 +950,7 @@
            {
                return;
            }
            var allCalcuResultList = GetAllCalcuResultList();
            var allCalcuResultList = GetCalcuResultList();
            var vmList = new List<XhsSinglePumpViewModel>();
            foreach (var pump in _hydroInfo.Pumps)
            {
@@ -1034,13 +1036,13 @@
        #region 前提条件

        //显示计算前提条件窗体
        private async void ShowCalcuPrefixDlg()
        private void ShowCalcuPrefixDlg()
        {
            if (_hydroInfo == null)
            {
                return;
            }
            var dlg = new SetHydroCalcuPrefixDlg();
            var dlg = new HStation.WinFrmUI.SetHydroCalcuPrefixDlg1();
            dlg.SetBindingData(_hydroInfo);
            dlg.HydroViewEvent += async (parter) =>
            {
@@ -1067,11 +1069,17 @@
                    return;
                }

                WaitFormHelper.ShowWaitForm(this, "正在计算分析中，请稍候...");

                await Task.Delay(5000);

                var netWork = Yw.Hydro.ParseHelper.ToNetwork(_hydroInfo);
                _calcuResult = netWork.Calcu();

                WaitFormHelper.HideWaitForm();
                if (_calcuResult.Succeed)
                {
                    GetAllCalcuResultList(false);
                    GetCalcuResultList(false);
                    await _bimfaceCtrl?.SetLogicCalcuCustomLabels(_calcuResult);
                    TipFormHelper.ShowSucceed("计算成功！");
                }
@@ -1136,7 +1144,7 @@

        //获取计算结果
        //true 使用缓存，false 不使用缓存
        private List<HydroCalcuResult> GetAllCalcuResultList(bool isCache = true)
        private List<HydroCalcuResult> GetCalcuResultList(bool isCache = true)
        {
            if (_hydroInfo == null)
            {
@@ -1376,7 +1384,7 @@
        private List<HydroMarkSetViewModel> _allMarkList = null;

        //显示标注窗体
        private async void ShowMarkDlg()
        private void ShowMarkDlg()
        {
            if (_hydroInfo == null)
            {
@@ -1432,17 +1440,13 @@
                }
            }
            var dlg = new SetHydroMarkDlg();
            dlg.InitialData(() => _hydroInfo);
            dlg.SetBindingData(_allMarkList);
            dlg.SetBindingData(_hydroInfo, _allMarkList);
            dlg.ReloadDataEvent += async (allResultList) =>
            {
                var leadLabels = allResultList?.Select(x => new LogicMarkLeadLabel(x.Code, x.Text)).ToList();
                var leadLabels = allResultList?.Select(x => new LogicMarkLeadLabel(x.Code, x.Text, 100000)).ToList();
                await _bimfaceCtrl?.SetLogicMarkLeadLabels(leadLabels);
            };
            if (dlg.ShowDialog() != DialogResult.OK)
            {
                await _bimfaceCtrl?.ClearLogicMarkLeadLabels();
            }
            dlg.ShowDialog();
        }

        //设置标注
@@ -1455,30 +1459,85 @@

        #region 颜色分级

        //颜色分级应用列表
        private List<HydroGradingApplyViewModel> _allGradingApplyList = null;
        //颜色分级编码列表
        private List<string> _allGradingCodeList = null;
        #region 颜色配置

        //设置颜色分级
        private void SetGrading()
        //所有分级列表
        private List<HydroGradingVmo> _allGradingList = null;

        //获取分级列表
        private async Task<List<HydroGradingVmo>> GetGradingList()
        {
            if (_hydroInfo == null)
            {
                return default;
            }
            if (_allGradingList == null)
            {
                _allGradingList = await BLLFactory<Yw.BLL.HydroGrading>.Instance.GetByModelID(_hydroInfo.ID);
                if (_allGradingList == null || _allGradingList.Count < 1)
                {
                    var config = Yw.Settings.HydroParasHelper.Hydro.Grading;
                    if (config != null && config.Items != null && config.Items.Count > 0)
                    {
                        _allGradingList = new List<HydroGradingVmo>();
                        config.Items.ForEach(x =>
                        {
                            var vmo = new HydroGradingVmo()
                            {
                                ModelID = _hydroInfo.ID,
                                Catalog = x.Catalog,
                                PropName = x.PropName,
                                SetValue = x.SetValue,
                                MinValue = x.MinValue,
                                MaxValue = x.MaxValue,
                                Color = x.Color,
                                SortCode = config.Items.IndexOf(x)
                            };
                            _allGradingList.Add(vmo);
                        });
                    }
                }
            }
            return _allGradingList;
        }

        //显示配置颜色分级窗体
        private async void ShowSetGradingDlg()
        {
            if (_hydroInfo == null)
            {
                return;
            }
            var dlg = new SetHydroGradingModelDlg();
            dlg.SetBindingData(_hydroInfo.ID);
            var allGradingList = await GetGradingList();
            var dlg = new SetHydroGradingTreeDlg();
            dlg.SetBindingData(_hydroInfo, allGradingList);
            dlg.ReloadDataEvent += (list) =>
            {
                _allGradingList = list;
            };
            dlg.ApplyDataEvent += () =>
            {
                ShowApplyGradingDlg();
            };
            dlg.ShowDialog();
        }

        //应用颜色分级
        private async void ApplyGrading()
        //配置颜色分级
        private void barBtnGradingSet_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            if (_hydroInfo == null)
            {
                return;
            }
            ShowSetGradingDlg();
        }

        #endregion

        #region 应用分级

        //颜色分级应用列表
        private List<HydroGradingApplyViewModel> _allGradingApplyList = null;

        //获取颜色分级应用列表
        private List<HydroGradingApplyViewModel> GetGradingApplyList()
        {
            if (_allGradingApplyList == null)
            {
                _allGradingApplyList = new List<HydroGradingApplyViewModel>();
@@ -1489,7 +1548,7 @@
                    {
                        Code = Yw.Hydro.ParterCatalog.Pump,
                        Name = Yw.WinFrmUI.HydroParterCatalogHelper.GetCatalogName(Yw.Hydro.ParterCatalog.Pump),
                        PropName = string.Empty
                        PropName = Yw.Hydro.ParterProp.LinkStatus
                    });
                }
                if (_hydroInfo.Valves != null && _hydroInfo.Valves.Count > 0)
@@ -1498,7 +1557,7 @@
                    {
                        Code = Yw.Hydro.ParterCatalog.Valve,
                        Name = Yw.WinFrmUI.HydroParterCatalogHelper.GetCatalogName(Yw.Hydro.ParterCatalog.Valve),
                        PropName = string.Empty
                        PropName = Yw.Hydro.ParterProp.LinkStatus
                    });
                }
                if (_hydroInfo.Pipes != null && _hydroInfo.Pipes.Count > 0)
@@ -1507,38 +1566,407 @@
                    {
                        Code = Yw.Hydro.ParterCatalog.Pipe,
                        Name = Yw.WinFrmUI.HydroParterCatalogHelper.GetCatalogName(Yw.Hydro.ParterCatalog.Pipe),
                        PropName = string.Empty
                        PropName = Yw.Hydro.ParterProp.CalcuFlow
                    });
                }
            }
            var dlg = new ApplyHydroGradingDlg();
            dlg.SetBindingData(() => _hydroInfo, _allGradingApplyList, GetAllCalcuResultList());
            dlg.ReloadDataEvent += (obj) =>
            {
                _allGradingCodeList = obj?.Select(x => x.Code).Distinct().ToList();
                var objGroupList = obj?.GroupBy(x => x.Color).ToList();
                objGroupList?.ForEach(async x =>
                {
                    await _bimfaceCtrl?.OverrideComponentsColor(x.Select(t => t.Code).Distinct().ToList(), x.Key, 1);
                });
            };
            if (dlg.ShowDialog() == DialogResult.Cancel)
            {
                await _bimfaceCtrl?.RestoreComponentsColor(_allGradingCodeList);
            }
            return _allGradingApplyList;
        }

        //设置
        private void barBtnGradingSet_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        //颜色分级应用结果列表
        private List<HydroGradingApplyResultViewModel> _allGradingApplyResultList = null;

        //获取颜色分级应用结果列表
        private async Task<List<HydroGradingApplyResultViewModel>> GetGradingApplyResultList()
        {
            SetGrading();
            if (_hydroInfo == null)
            {
                return default;
            }

            //所有分级列表
            var allGradingList = await GetGradingList();
            if (allGradingList == null || allGradingList.Count < 1)
            {
                return default;
            }

            //所有分级应用列表
            var allGradingApplyList = GetGradingApplyList();
            if (allGradingApplyList == null || allGradingApplyList.Count < 1)
            {
                return default;
            }

            var allCalcuResultList = GetCalcuResultList();

            _allGradingApplyResultList = new List<HydroGradingApplyResultViewModel>();
            allGradingApplyList.ForEach(x =>
            {
                var allCatalogGradingList = allGradingList.Where(t => t.Catalog == x.Code).ToList();
                if (allCatalogGradingList != null || allCatalogGradingList.Count > 0)
                {
                    switch (x.Code)
                    {
                        case Yw.Hydro.ParterCatalog.Pump:
                            {
                                if (_hydroInfo.Pumps != null && _hydroInfo.Pumps.Count > 0)
                                {
                                    foreach (var pump in _hydroInfo.Pumps)
                                    {
                                        switch (x.PropName)
                                        {
                                            case Yw.Hydro.ParterProp.LinkStatus:
                                                {
                                                    var gradingList = allCatalogGradingList.Where(x => x.PropName == Yw.Hydro.ParterProp.LinkStatus).OrderBy(t => t.SortCode).ToList();
                                                    if (gradingList != null && gradingList.Count > 0)
                                                    {
                                                        var grading = gradingList.Meet(pump.LinkStatus);
                                                        if (grading != null)
                                                        {
                                                            var result = new HydroGradingApplyResultViewModel()
                                                            {
                                                                Code = pump.Code,
                                                                Color = grading.Color
                                                            };
                                                            _allGradingApplyResultList.Add(result);
                                                        }
                                                    }
                                                }
                                                break;
                                            case Yw.Hydro.ParterProp.CalcuFlow:
                                                {
                                                    var gradingList = allCatalogGradingList.Where(x => x.PropName == Yw.Hydro.ParterProp.CalcuFlow).OrderBy(t => t.SortCode).ToList();
                                                    if (gradingList != null && gradingList.Count > 0)
                                                    {
                                                        var calcuResult = allCalcuResultList?.Find(t => t.Code == pump.Code);
                                                        if (calcuResult is HydroCalcuLinkResult calcuLinkResult)
                                                        {
                                                            if (calcuLinkResult.CalcuFlow.HasValue)
                                                            {
                                                                var grading = gradingList.Meet(Math.Abs(calcuLinkResult.CalcuFlow.Value));
                                                                if (grading != null)
                                                                {
                                                                    var result = new HydroGradingApplyResultViewModel()
                                                                    {
                                                                        Code = pump.Code,
                                                                        Color = grading.Color
                                                                    };
                                                                    _allGradingApplyResultList.Add(result);
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                break;
                                            case Yw.Hydro.ParterProp.CalcuVelocity:
                                                {
                                                    var gradingList = allCatalogGradingList.Where(x => x.PropName == Yw.Hydro.ParterProp.CalcuVelocity).OrderBy(t => t.SortCode).ToList();
                                                    if (gradingList != null && gradingList.Count > 0)
                                                    {
                                                        var calcuResult = allCalcuResultList?.Find(t => t.Code == pump.Code);
                                                        if (calcuResult is HydroCalcuLinkResult calcuLinkResult)
                                                        {
                                                            if (calcuLinkResult.CalcuVelocity.HasValue)
                                                            {
                                                                var grading = gradingList.Meet(Math.Abs(calcuLinkResult.CalcuVelocity.Value));
                                                                if (grading != null)
                                                                {
                                                                    var result = new HydroGradingApplyResultViewModel()
                                                                    {
                                                                        Code = pump.Code,
                                                                        Color = grading.Color
                                                                    };
                                                                    _allGradingApplyResultList.Add(result);
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                break;
                                            case Yw.Hydro.ParterProp.CalcuHeadLoss:
                                                {
                                                    var gradingList = allCatalogGradingList.Where(x => x.PropName == Yw.Hydro.ParterProp.CalcuHeadLoss).OrderBy(t => t.SortCode).ToList();
                                                    if (gradingList != null && gradingList.Count > 0)
                                                    {
                                                        var calcuResult = allCalcuResultList?.Find(t => t.Code == pump.Code);
                                                        if (calcuResult is HydroCalcuLinkResult calcuLinkResult)
                                                        {
                                                            if (calcuLinkResult.CalcuHeadLoss.HasValue)
                                                            {
                                                                var grading = gradingList.Meet(Math.Abs(calcuLinkResult.CalcuHeadLoss.Value));
                                                                if (grading != null)
                                                                {
                                                                    var result = new HydroGradingApplyResultViewModel()
                                                                    {
                                                                        Code = pump.Code,
                                                                        Color = grading.Color
                                                                    };
                                                                    _allGradingApplyResultList.Add(result);
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                break;
                                            default: break;
                                        }
                                    }
                                }
                            }
                            break;
                        case Yw.Hydro.ParterCatalog.Valve:
                            {
                                if (_hydroInfo.Valves != null && _hydroInfo.Valves.Count > 0)
                                {
                                    foreach (var valve in _hydroInfo.Valves)
                                    {
                                        switch (x.PropName)
                                        {
                                            case Yw.Hydro.ParterProp.LinkStatus:
                                                {
                                                    var gradingList = allCatalogGradingList.Where(x => x.PropName == Yw.Hydro.ParterProp.LinkStatus).OrderBy(t => t.SortCode).ToList();
                                                    if (gradingList != null && gradingList.Count > 0)
                                                    {
                                                        var grading = gradingList.Meet(valve.LinkStatus);
                                                        if (grading != null)
                                                        {
                                                            var result = new HydroGradingApplyResultViewModel()
                                                            {
                                                                Code = valve.Code,
                                                                Color = grading.Color
                                                            };
                                                            _allGradingApplyResultList.Add(result);
                                                        }
                                                    }
                                                }
                                                break;
                                            case Yw.Hydro.ParterProp.CalcuFlow:
                                                {
                                                    var gradingList = allCatalogGradingList.Where(x => x.PropName == Yw.Hydro.ParterProp.CalcuFlow).OrderBy(t => t.SortCode).ToList();
                                                    if (gradingList != null && gradingList.Count > 0)
                                                    {
                                                        var calcuResult = allCalcuResultList?.Find(t => t.Code == valve.Code);
                                                        if (calcuResult is HydroCalcuLinkResult calcuLinkResult)
                                                        {
                                                            if (calcuLinkResult.CalcuFlow.HasValue)
                                                            {
                                                                var grading = gradingList.Meet(Math.Abs(calcuLinkResult.CalcuFlow.Value));
                                                                if (grading != null)
                                                                {
                                                                    var result = new HydroGradingApplyResultViewModel()
                                                                    {
                                                                        Code = valve.Code,
                                                                        Color = grading.Color
                                                                    };
                                                                    _allGradingApplyResultList.Add(result);
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                break;
                                            case Yw.Hydro.ParterProp.CalcuVelocity:
                                                {
                                                    var gradingList = allCatalogGradingList.Where(x => x.PropName == Yw.Hydro.ParterProp.CalcuVelocity).OrderBy(t => t.SortCode).ToList();
                                                    if (gradingList != null && gradingList.Count > 0)
                                                    {
                                                        var calcuResult = allCalcuResultList?.Find(t => t.Code == valve.Code);
                                                        if (calcuResult is HydroCalcuLinkResult calcuLinkResult)
                                                        {
                                                            if (calcuLinkResult.CalcuVelocity.HasValue)
                                                            {
                                                                var grading = gradingList.Meet(Math.Abs(calcuLinkResult.CalcuVelocity.Value));
                                                                if (grading != null)
                                                                {
                                                                    var result = new HydroGradingApplyResultViewModel()
                                                                    {
                                                                        Code = valve.Code,
                                                                        Color = grading.Color
                                                                    };
                                                                    _allGradingApplyResultList.Add(result);
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                break;
                                            case Yw.Hydro.ParterProp.CalcuHeadLoss:
                                                {
                                                    var gradingList = allCatalogGradingList.Where(x => x.PropName == Yw.Hydro.ParterProp.CalcuHeadLoss).OrderBy(t => t.SortCode).ToList();
                                                    if (gradingList != null && gradingList.Count > 0)
                                                    {
                                                        var calcuResult = allCalcuResultList?.Find(t => t.Code == valve.Code);
                                                        if (calcuResult is HydroCalcuLinkResult calcuLinkResult)
                                                        {
                                                            if (calcuLinkResult.CalcuHeadLoss.HasValue)
                                                            {
                                                                var grading = gradingList.Meet(Math.Abs(calcuLinkResult.CalcuHeadLoss.Value));
                                                                if (grading != null)
                                                                {
                                                                    var result = new HydroGradingApplyResultViewModel()
                                                                    {
                                                                        Code = valve.Code,
                                                                        Color = grading.Color
                                                                    };
                                                                    _allGradingApplyResultList.Add(result);
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                break;
                                            default: break;
                                        }
                                    }
                                }
                            }
                            break;
                        case Yw.Hydro.ParterCatalog.Pipe:
                            {
                                if (_hydroInfo.Pipes != null && _hydroInfo.Pipes.Count > 0)
                                {
                                    foreach (var pipe in _hydroInfo.Pipes)
                                    {
                                        switch (x.PropName)
                                        {
                                            case Yw.Hydro.ParterProp.CalcuFlow:
                                                {
                                                    var gradingList = allCatalogGradingList.Where(x => x.PropName == Yw.Hydro.ParterProp.CalcuFlow).OrderBy(t => t.SortCode).ToList();
                                                    if (gradingList != null && gradingList.Count > 0)
                                                    {
                                                        var calcuResult = allCalcuResultList?.Find(t => t.Code == pipe.Code);
                                                        if (calcuResult is HydroCalcuLinkResult calcuLinkResult)
                                                        {
                                                            if (calcuLinkResult.CalcuFlow.HasValue)
                                                            {
                                                                var grading = gradingList.Meet(Math.Abs(calcuLinkResult.CalcuFlow.Value));
                                                                if (grading != null)
                                                                {
                                                                    var result = new HydroGradingApplyResultViewModel()
                                                                    {
                                                                        Code = pipe.Code,
                                                                        Color = grading.Color
                                                                    };
                                                                    _allGradingApplyResultList.Add(result);
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                break;
                                            case Yw.Hydro.ParterProp.CalcuVelocity:
                                                {
                                                    var gradingList = allCatalogGradingList.Where(x => x.PropName == Yw.Hydro.ParterProp.CalcuVelocity).OrderBy(t => t.SortCode).ToList();
                                                    if (gradingList != null && gradingList.Count > 0)
                                                    {
                                                        var calcuResult = allCalcuResultList?.Find(t => t.Code == pipe.Code);
                                                        if (calcuResult is HydroCalcuLinkResult calcuLinkResult)
                                                        {
                                                            if (calcuLinkResult.CalcuVelocity.HasValue)
                                                            {
                                                                var grading = gradingList.Meet(Math.Abs(calcuLinkResult.CalcuVelocity.Value));
                                                                if (grading != null)
                                                                {
                                                                    var result = new HydroGradingApplyResultViewModel()
                                                                    {
                                                                        Code = pipe.Code,
                                                                        Color = grading.Color
                                                                    };
                                                                    _allGradingApplyResultList.Add(result);
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                break;
                                            case Yw.Hydro.ParterProp.CalcuHeadLoss:
                                                {
                                                    var gradingList = allCatalogGradingList.Where(x => x.PropName == Yw.Hydro.ParterProp.CalcuHeadLoss).OrderBy(t => t.SortCode).ToList();
                                                    if (gradingList != null && gradingList.Count > 0)
                                                    {
                                                        var calcuResult = allCalcuResultList?.Find(t => t.Code == pipe.Code);
                                                        if (calcuResult is HydroCalcuLinkResult calcuLinkResult)
                                                        {
                                                            if (calcuLinkResult.CalcuHeadLoss.HasValue)
                                                            {
                                                                var grading = gradingList.Meet(Math.Abs(calcuLinkResult.CalcuHeadLoss.Value));
                                                                if (grading != null)
                                                                {
                                                                    var result = new HydroGradingApplyResultViewModel()
                                                                    {
                                                                        Code = pipe.Code,
                                                                        Color = grading.Color
                                                                    };
                                                                    _allGradingApplyResultList.Add(result);
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                break;
                                            default: break;
                                        }
                                    }
                                }
                            }
                            break;
                        default: break;
                    }
                }
            });

            return _allGradingApplyResultList;
        }

        //应用
        //颜色分级编码列表
        private List<string> _allGradingCodeList = null;

        //应用颜色分级
        private async void ApplyGrading()
        {
            if (_hydroInfo == null)
            {
                return;
            }
            var allGradingApplyResultList = await GetGradingApplyResultList();
            _allGradingCodeList = allGradingApplyResultList?.Select(x => x.Code).Distinct().ToList();
            var objGroupList = allGradingApplyResultList?.GroupBy(x => x.Color).ToList();
            objGroupList?.ForEach(async x =>
            {
                await _bimfaceCtrl?.OverrideComponentsColor(x.Select(t => t.Code).Distinct().ToList(), x.Key, 1);
            });
        }

        //显示应用颜色分级窗体
        private void ShowApplyGradingDlg()
        {
            if (_hydroInfo == null)
            {
                return;
            }
            var allGradingApplyList = GetGradingApplyList();
            if (allGradingApplyList == null || allGradingApplyList.Count < 1)
            {
                return;
            }
            var dlg = new ApplyHydroGradingDlg();
            dlg.SetBindingData(allGradingApplyList);
            dlg.ReloadDataEvent += async (obj) =>
            {
                _allGradingApplyList = obj;
                ApplyGrading();
            };
            dlg.ShowDialog();
        }

        //应用颜色分级
        private void barBtnGradingApply_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            ApplyGrading();
            ShowApplyGradingDlg();
        }

        #endregion

        #endregion

@@ -1568,5 +1996,21 @@
        }

        #endregion

        private void barButtonItem1_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            var pipes = _hydroInfo.GetAllPipes();
            var list = pipes.Select(x =>
            {
                return new Yw.WinFrmUI.Bimface.LogicFlowEffect()
                {
                    Id = x.Code,
                    Rotation = 90,
                    Direction = true,
                    Speed = 0.1d
                };
            }).ToList();
            _bimfaceCtrl?.LoadAllFlowMaterialList(list);
        }
    }
}