duheng
10 天以前 4de480ec624d3b79ca690dc906e10cd2fbdc9be7
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
 
namespace IStation.WinFrmUI.Curve
{
    public partial class FeatCurveByEditDlg : DevExpress.XtraBars.Ribbon.RibbonForm
    {
        public FeatCurveByEditDlg()
        {
            InitializeComponent();
        }
 
        private void FeatCurveByEditDlg_Load(object sender, EventArgs e)
        {
 
        }
        public void SetCurveExpr(string curveExprQH, string curveExprQE, string curveExprQP)
        {
            if (string.IsNullOrEmpty(curveExprQH))
                return;
 
            List<Model.CurvePoint> pointInfoQE = null, pointInfoQP = null;
 
            Model.eCurveFitType fit_type_qh = Model.eCurveFitType.CubicCurve;
            Model.eCurveFitType fit_type_qe = Model.eCurveFitType.CubicCurve;
            Model.eCurveFitType fit_type_qp = Model.eCurveFitType.CubicCurve;
 
            var CurveExprQH = new Model.CurveExpress(curveExprQH);
            var pointInfoQH = Model.FitCurveHelper.GetFitPoints(CurveExprQH, 12);
            fit_type_qh = CurveExprQH.FitType;
 
            if (!string.IsNullOrEmpty(curveExprQE))
            {
 
                var CurveExprQE = new Model.CurveExpress(curveExprQE);
                pointInfoQE = Model.FitCurveHelper.GetFitPoints(CurveExprQE, 12);
                fit_type_qe = CurveExprQE.FitType;
            }
 
            if (!string.IsNullOrEmpty(curveExprQP))
            {
                var CurveExprQP = new Model.CurveExpress(curveExprQP);
                pointInfoQP = Model.FitCurveHelper.GetFitPoints(CurveExprQP, 12);
                fit_type_qp = CurveExprQP.FitType;
            }
             
            featCurveByEditCtrl1.SetFeatPoint(pointInfoQH, pointInfoQE, pointInfoQP, fit_type_qh, fit_type_qe, fit_type_qp);
        }
 
        public void SetCurveInfo(
    Model.CurveExpress curveQH,
    Model.CurveExpress curveQE,
    Model.CurveExpress curveQP)
        {
            if (curveQH == null)
                return;
             
 
            var pointInfoQH = Model.FitCurveHelper.GetFitPoints(curveQH, 12);
            var pointInfoQE = Model.FitCurveHelper.GetFitPoints(curveQE, 12);
            var pointInfoQP = Model.FitCurveHelper.GetFitPoints(curveQP, 12);
 
 
            featCurveByEditCtrl1.SetFeatPoint(pointInfoQH, pointInfoQE, pointInfoQP, curveQH.FitType,
              curveQE == null ? Model.eCurveFitType.CubicCurve : curveQE.FitType,
              curveQP == null ? Model.eCurveFitType.CubicCurve : curveQP.FitType); ;
        }
 
        public void SetFeatPoint(
    List<Model.CurvePoint> pointInfoQH,
    List<Model.CurvePoint> pointInfoQE,
    List<Model.CurvePoint> pointInfoQP,
    Model.eCurveFitType fit_type_qh,
    Model.eCurveFitType fit_type_qe,
    Model.eCurveFitType fit_type_qp)
        {
            featCurveByEditCtrl1.SetFeatPoint(pointInfoQH, pointInfoQE, pointInfoQP, fit_type_qh, fit_type_qe, fit_type_qp);
        }
 
        public void SetLxpCoordinateParas(Model.CurveCoordinateParas coord)
        {
            this.featCurveByEditCtrl1.SetLxpCoordinateParas(coord);
        }
 
        public bool GetFeatPoint(
out List<Model.CurvePoint> pointInfoQH,
out List<Model.CurvePoint> pointInfoQE,
out List<Model.CurvePoint> pointInfoQP)
        {
            return featCurveByEditCtrl1.GetPointListInfo(out pointInfoQH, out pointInfoQE, out pointInfoQP);
        }
 
        public Model.CurveCoordinateParas GetLxpCoordinateParas()
        {
            return this.featCurveByEditCtrl1.GetLxpCoordinateParas();
        }
 
        private void bbi保存修改_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            this.DialogResult = DialogResult.OK;
            this.Close();
        }
 
        private void bbi取消保存_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            this.DialogResult = DialogResult.Cancel;
            this.Close();
        }
 
        private void bbi修改坐标_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            featCurveByEditCtrl1.SetCoordinateByDialog();
        }
 
        private void bbi最大流量对齐_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            DialogResult result = MessageBox.Show("请问是否对齐最大流量值", "询问",
System.Windows.Forms.MessageBoxButtons.YesNo,
System.Windows.Forms.MessageBoxIcon.Warning);
            if (result != DialogResult.Yes)
            {
                return;
            }
 
            //  IStation.Model.FeatCurveExpressGroup curve = new Model.FeatCurveExpressGroup(curve_entity.CurveInfo);
 
            //                var max_q = curve.CurveQH.RangeMax;
 
            //                if (curve.CurveQE != null)
            //                {
            //                    max_q = Math.Max(curve.CurveQE.RangeMax, max_q);
            //                }
 
            //                if (curve.CurveQP != null)
            //                {
            //                    max_q = Math.Max(curve.CurveQP.RangeMax, max_q);
            //                }
 
 
 
            //                if (curve.CurveQH != null)
            //                {
            //                    curve.CurveQH.RangeMax = max_q;
            //                }
            //                if (curve.CurveQP != null)
            //                {
            //                    curve.CurveQP.RangeMax = max_q;
            //                }
            //                if (curve.CurveQE != null)
            //                {
            //                    curve.CurveQE.RangeMax = max_q;
            //                }
            //                curve_entity.CurveInfo = curve.ToDsString();
 
 
 
 
        }
 
    }
}