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
using HalconDotNet;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.Drawing.Imaging;
using System.Threading;
 
namespace LB_VisionProcesses.Cameras
{
    public abstract class BaseCamera : ICamera
    {
        protected BaseCamera() { }
 
        #region Parm
        /// <summary>
        /// 相机SN号
        /// </summary>
        public string SN { get; set; } = string.Empty;
 
        /// <summary>
        /// 相机名称
        /// </summary>
        public string CameraName { get; set; } = string.Empty;
 
        /// <summary>
        /// 相机硬触发获取图像触发对应的检测流程
        /// </summary>
        public Action<string, string> TriggerRunMessageReceived;
        public CameraBrand Brand { get; set; } = CameraBrand.UNSUPPORTED;
 
        public bool isGrabbing = false;
 
        //public EventHandler<CameraEventArgs> ImageGrabbed = delegate { };
 
        private EventHandler<CameraEventArgs> _imageGrabbed;
        public EventHandler<CameraEventArgs> ImageGrabbed
        {
            get => _imageGrabbed;
            set
            {
                Debug.WriteLine($"ImageGrabbed 被设置,新值: {value?.Method}");
                Debug.WriteLine($"调用堆栈: {Environment.StackTrace}");
                _imageGrabbed = value;
            }
        }
 
        protected static Bitmap CallBackImg { get; set; }
 
        private Dictionary<string, List<Bitmap>> _collectedImages;
        public Dictionary<string, List<Bitmap>> CollectedImages
        {
            get => _collectedImages;
            set
            {
                _collectedImages = value;
            }
        }
 
        public Bitmap Bitmap;
        #endregion
 
        #region  operate
 
        public virtual void Dispose()
        {
            try
            {
                CloseDevice();
            }
            catch { }
        }
        public abstract bool CloseDevice();
 
        public abstract List<string> GetListEnum();
 
        public abstract bool InitDevice(string SN, object Handle = null);
 
        public abstract bool StartWith_SoftTriggerModel();
 
        public abstract bool StartWith_HardTriggerModel(TriggerSource hardtriggeritem = TriggerSource.Line0);
 
        /// <summary>
        /// 等待软/硬触发获取图像
        /// </summary>
        /// <param name="bitmap"></param>
        /// <param name="outtime"></param>
        /// <returns></returns>
        public abstract bool GetImage(out Bitmap bitmap, int outtime = 3000);
        /// <summary>
        /// 软触发获取图像
        /// </summary>
        /// <param name="bitmap"></param>
        /// <param name="outtime"></param>
        /// <returns></returns>
        public abstract bool GetImageWithSoftTrigger(out Bitmap bitmap, int outtime = 3000);
 
        /// <summary>
        /// 软触发
        /// </summary>
        /// <returns></returns>
        public abstract bool SoftTrigger();
 
        public void Bitmap2HObject(Bitmap bmp, out HObject image)
        {
            try
            {
                if (bmp == null)
                {
                    image = null;
                    return;
                }
                BitmapData srcBmpData;
                switch (bmp.PixelFormat)
                {
                    case PixelFormat.Format24bppRgb:
                        srcBmpData = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
                        HOperatorSet.GenImageInterleaved(out image, srcBmpData.Scan0, "bgr", bmp.Width, bmp.Height, 0, "byte", 0, 0, 0, 0, -1, 0);
                        bmp.UnlockBits(srcBmpData);
                        break;
                    default:
                        srcBmpData = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadOnly, PixelFormat.Format8bppIndexed);
 
                        HOperatorSet.GenImage1(out image, "byte", bmp.Width, bmp.Height, srcBmpData.Scan0);
                        bmp.UnlockBits(srcBmpData);
                        break;
                }
            }
            catch (Exception ex)
            {
                image = null;
            }
        }
 
        #endregion
 
        #region SettingConfig
        public abstract void SetCamConfig(CameraConfig config);
        public abstract void GetCamConfig(out CameraConfig config);
 
        /// <summary>
        /// 设置触发模式及触发源
        /// </summary>
        /// <param name="mode"></param>
        /// <param name="triggerEnum"></param>
        /// <returns></returns>
        public abstract bool SetTriggerMode(TriggerMode mode, TriggerSource triggerEnum = TriggerSource.Line0);
 
        public abstract bool GetTriggerMode(out TriggerMode mode, out TriggerSource source);
 
        public abstract bool SetExpouseTime(double value);
 
        public abstract bool GetExpouseTime(out double value);
 
        public abstract bool SetTriggerPolarity(TriggerPolarity polarity);
 
        public abstract bool GetTriggerPolarity(out TriggerPolarity polarity);
 
        /// <summary>
        /// 设置触发滤波时间 (us)
        /// </summary>
        /// <param name="flitertime"></param>
        /// <returns></returns>
        public abstract bool SetTriggerFliter(double flitertime);
 
        /// <summary>
        /// 获取触发参数时间 (us)
        /// </summary>
        /// <param name="flitertime"></param>
        /// <returns></returns>
        public abstract bool GetTriggerFliter(out double flitertime);
 
        public abstract bool SetTriggerDelay(double delay);
 
        public abstract bool GetTriggerDelay(out double delay);
 
        public abstract bool SetGain(double gain);
 
        public abstract bool GetGain(out double gain);
 
        public abstract bool SetLineMode(IOLines line, LineMode mode);
 
        public abstract bool SetLineStatus(IOLines line, LineStatus linestatus);
 
        public abstract bool GetLineStatus(IOLines line, out LineStatus lineStatus);
 
        public abstract bool AutoBalanceWhite();
 
        #endregion
 
        #region  protected abstract
        /// <summary>
        /// 开始采图(默认单次采集)
        /// </summary>
        /// <returns></returns>
        public abstract bool StartGrabbing();
 
        /// <summary>
        /// 单次采集模式(适用于线扫相机)
        /// </summary>
        /// <returns></returns>
        public virtual bool StartSingleGrab()
        {
            // 默认实现:普通相机不支持单次采集,直接返回false
            // 线扫相机需要重写此方法
            return false;
        }
 
        /// <summary>
        /// 连续采集模式
        /// </summary>
        /// <returns></returns>
        public abstract bool StartContinuousGrab();
 
        /// <summary>
        /// 停止采图
        /// </summary>
        /// <returns></returns>
        public abstract bool StopGrabbing();
        #endregion
    }
}