C3032
3 天以前 ebcc1d53f14112363bbf539bcaf0202aadcdc9d7
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
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
using System;
using System.Collections.Generic;
using System.Linq;
 
namespace LB_VisionProcesses.Processes
{
    /// <summary>
    /// 轮胎判定规则
    /// </summary>
    public enum TyreJudgeRule
    {
        /// <summary>
        /// 任一NG则整胎NG
        /// </summary>
        AnyNG,
 
        /// <summary>
        /// 全部OK才整胎OK
        /// </summary>
        AllOK,
 
        /// <summary>
        /// 多数表决(超过半数OK则OK)
        /// </summary>
        MajorityVote
    }
 
    /// <summary>
    /// 轮胎计数结果
    /// </summary>
    public class TyreCountResult
    {
        /// <summary>
        /// 是否完成一个轮胎
        /// </summary>
        public bool IsTyreComplete { get; set; }
 
        /// <summary>
        /// 轮胎ID
        /// </summary>
        public int TyreID { get; set; }
 
        /// <summary>
        /// 轮胎整体结果
        /// </summary>
        public bool TyreResult { get; set; }
 
        /// <summary>
        /// 各图像结果列表
        /// </summary>
        public List<bool> ImageResults { get; set; } = new List<bool>();
 
        /// <summary>
        /// 当前图像序号(1~n)
        /// </summary>
        public int CurrentImageIndex { get; set; }
 
        /// <summary>
        /// 消息
        /// </summary>
        public string Message { get; set; }
    }
 
    /// <summary>
    /// 轮胎统计器 - 用于管理轮胎级别的计数和统计
    /// </summary>
    public class TyreStatistics
    {
        #region 配置参数
 
        /// <summary>
        /// 每张轮胎所需图像数(默认8张)
        /// </summary>
        public int ImagesPerTyre { get; set; } = 8;
 
        /// <summary>
        /// 判定规则
        /// </summary>
        public TyreJudgeRule JudgeRule { get; set; } = TyreJudgeRule.AnyNG;
 
        #endregion
 
        #region 统计数据
 
        /// <summary>
        /// 轮胎总数
        /// </summary>
        public int TyreTotal => TyreOK + TyreNG;
 
        /// <summary>
        /// 轮胎OK计数
        /// </summary>
        public int TyreOK { get; set; }
 
        /// <summary>
        /// 轮胎NG计数
        /// </summary>
        public int TyreNG { get; set; }
 
        /// <summary>
        /// 当前轮胎ID(从1开始)
        /// </summary>
        public int CurrentTyreID { get; set; } = 1;
 
        /// <summary>
        /// 当前轮胎的图像序号(0~ImagesPerTyre-1)
        /// </summary>
        public int CurrentImageIndex { get; set; } = 0;
 
        /// <summary>
        /// 当前轮胎的各图像结果
        /// </summary>
        public List<bool> CurrentTyreResults { get; set; } = new List<bool>();
 
        /// <summary>
        /// 当前轮胎的各图像SN
        /// </summary>
        public List<string> CurrentTyreImageSNs { get; set; } = new List<string>();
 
        /// <summary>
        /// 轮胎良品率
        /// </summary>
        public double TyreRateOK => TyreTotal > 0 ? (TyreOK / (double)TyreTotal) * 100 : 0;
 
        #endregion
 
        #region 构造方法
 
        public TyreStatistics() { }
 
        public TyreStatistics(int imagesPerTyre, TyreJudgeRule judgeRule = TyreJudgeRule.AnyNG)
        {
            ImagesPerTyre = imagesPerTyre;
            JudgeRule = judgeRule;
        }
 
        #endregion
 
        #region 核心方法
 
        /// <summary>
        /// 添加图像检测结果
        /// </summary>
        /// <param name="isOK">图像检测结果</param>
        /// <param name="imageSN">图像序列号(可选)</param>
        /// <returns>轮胎计数结果</returns>
        public TyreCountResult AddImageResult(bool isOK, string imageSN = null)
        {
            // 添加到当前轮胎结果列表
            CurrentTyreResults.Add(isOK);
            CurrentTyreImageSNs.Add(imageSN);
            CurrentImageIndex++;
 
            var result = new TyreCountResult
            {
                CurrentImageIndex = CurrentImageIndex,
                IsTyreComplete = false,
                Message = $"当前轮胎第 {CurrentImageIndex}/{ImagesPerTyre} 张图像"
            };
 
            // 检查是否完成一个轮胎
            if (CurrentImageIndex >= ImagesPerTyre)
            {
                // 计算轮胎整体结果
                bool tyreResult = CalculateTyreResult();
 
                // 更新统计
                if (tyreResult)
                    TyreOK++;
                else
                    TyreNG++;
 
                // 构建完成结果
                result.IsTyreComplete = true;
                result.TyreID = CurrentTyreID;
                result.TyreResult = tyreResult;
                result.ImageResults = new List<bool>(CurrentTyreResults);
                result.Message = $"完成轮胎 #{CurrentTyreID},结果: {(tyreResult ? "OK" : "NG")}";
 
                // 重置当前轮胎数据
                ResetCurrentTyre();
            }
 
            return result;
        }
 
        /// <summary>
        /// 计算轮胎整体结果
        /// </summary>
        private bool CalculateTyreResult()
        {
            if (CurrentTyreResults.Count == 0)
                return true;
 
            switch (JudgeRule)
            {
                case TyreJudgeRule.AnyNG:
                    // n张中任一NG则整胎NG
                    return !CurrentTyreResults.Any(r => !r);
 
                case TyreJudgeRule.AllOK:
                    // 全部OK才整胎OK(与AnyNG相同)
                    return CurrentTyreResults.All(r => r);
 
                case TyreJudgeRule.MajorityVote:
                    // 多数表决:超过半数OK则OK
                    int okCount = CurrentTyreResults.Count(r => r);
                    return okCount > (CurrentTyreResults.Count / 2.0);
 
                default:
                    return !CurrentTyreResults.Any(r => !r);
            }
        }
 
        /// <summary>
        /// 重置当前轮胎数据
        /// </summary>
        private void ResetCurrentTyre()
        {
            CurrentTyreID++;
            CurrentImageIndex = 0;
            CurrentTyreResults.Clear();
            CurrentTyreImageSNs.Clear();
        }
 
        /// <summary>
        /// 重置所有统计
        /// </summary>
        public void Reset()
        {
            TyreOK = 0;
            TyreNG = 0;
            CurrentTyreID = 1;
            ResetCurrentTyre();
        }
 
        /// <summary>
        /// 清空当前轮胎(用于异常情况)
        /// </summary>
        public void ClearCurrentTyre()
        {
            ResetCurrentTyre();
        }
 
        /// <summary>
        /// 获取当前进度信息
        /// </summary>
        public string GetProgressInfo()
        {
            if (ImagesPerTyre <= 1)
                return $"轮胎 #{CurrentTyreID} (3D模式)";
 
            return $"轮胎 #{CurrentTyreID} - 第 {CurrentImageIndex}/{ImagesPerTyre} 张";
        }
 
        /// <summary>
        /// 获取统计信息字符串
        /// </summary>
        public string GetStatisticsInfo()
        {
            return $"轮胎总数: {TyreTotal}, OK: {TyreOK}, NG: {TyreNG}, 良品率: {TyreRateOK:F2}%";
        }
 
        #endregion
    }
}