mrDarker
2025-08-22 f8ad0695ff2431cb90640be52b523d6434bdbf83
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
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
#pragma once
 
#include "Config.h"
#include "cv.h"
#include "highgui.h"
#include "opencv.hpp"
#include "core.hpp"
#include <vector>
#include <algorithm>//20140528
#include "HardwareSettings.h"
 
#define MAX_STRING_LENGTH            1024
#define MAX_MARKER_COUNT            3
 
typedef struct tagJUDGEEDGE
{
    BOOL bError;            //俊矾 咯何..
    int  nRefernce;            //  扁霖     
    int  nTolPlus;            // +倾侩坷瞒
    int  nTolMinus;            // -倾侩坷瞒
    int  nSlant;            //荤急 
}JUDGEEDGE, *PJUDGEEDGE;
 
typedef struct tagUserDefectArea
{
    int x;
    int y;
    int area_width;
    int area_height;
    int defect_threshold;
    int defect_dilation;
    int defect_width;
    int defect_height;
 
    void clear(void)
    {
        x = 0;
        y = 0;
        area_width = 0;
        area_height = 0;
        defect_threshold = 0;
        defect_dilation = 0;
        defect_width = 0;
        defect_height = 0;
    }
 
    tagUserDefectArea(void)
    {
        clear();
    }
}ST_USER_DEFECT_AREA;
 
typedef struct tagEXECPTION_AREA
{
    int        nAreaType;
    CRect    rc;            // 康开 困摹 (Mark 盔痢)    
    SIZE    szErrSize;  // 捞 康开俊辑 利侩瞪 Size    
    int        nAppDefect; // 利侩瞪 Defect 辆幅
    int        nDetectLimitedArea;    // 荤侩磊 汲沥 ROI 荤侩 蜡公
 
    void Init()
    {
        nAreaType  = 0;
        nAppDefect = 0;
        nDetectLimitedArea = 0;
        rc = CRect(0,0,0,0);
        szErrSize.cx = 0;
        szErrSize.cy = 0;        
    };
 
    void CopyData(tagEXECPTION_AREA *pExp)
    {
        nAreaType = pExp->nAreaType;
        rc = pExp->rc;
        szErrSize = pExp->szErrSize;
        nAppDefect = pExp->nAppDefect;
        nDetectLimitedArea = pExp->nDetectLimitedArea;    
    }
 
}EXECPTION_AREA;
 
typedef std::vector<EXECPTION_AREA*>  EXCEPTION_AREA_LIST;
typedef EXCEPTION_AREA_LIST::iterator itEXCEPTION_AREA_LIST;
typedef std::vector<ST_USER_DEFECT_AREA> USER_DEFECT_AREA_LIST;
typedef std::vector<ST_USER_DEFECT_AREA>::iterator itUSER_DEFECT_AREA_LIST;
 
typedef struct stLinkList
{
    CString m_strUpperName;
    CString m_strStepName;
    CString m_strInsName;
 
public:
    stLinkList()
    {
        reset();
    }
    void reset()
    {
        m_strUpperName = _T("");
        m_strStepName = _T("");
        m_strInsName = _T("");        
    }
} LinkList, *pLinkList;
typedef std::vector<LinkList*>                VectorLinkList;
typedef std::vector<LinkList*>::iterator    VectorLinkListIt;
 
class CRECIPE_INFO_PARM
{    
public:
    CRECIPE_INFO_PARM();
    virtual ~CRECIPE_INFO_PARM(void);
 
public:
    BOOL        ReadRecipe(CConfig *pFile);
    BOOL        WriteRecipe(CConfig *pFile);
 
public:
    void        Reset();
    void        SetRecipeName(CString strRecipe);
    void        SetRecipeFileName(CString strFile);
 
    void        SetRecipeFileNameBackUp(CString strFile);
    CString        GetRecipeName();
    CString        GetRecipeFileName();
 
 
public:
    TCHAR        m_strRecipeName[MAX_STRING_LENGTH];                    // 饭矫乔 捞抚.    
    TCHAR        m_strRecipeFileName[MAX_STRING_LENGTH];                // 饭乔矫 颇老疙    
    TCHAR        m_strRecipeFileNameBackUp[MAX_STRING_LENGTH];        // 饭乔矫 颇老疙    
    int            m_nSoftRevision;
 
    CString        m_strComment;                                        // Comment
    double        m_dOneScanTime_sec;                                    // Scan Time
};
 
class CRECIPE_INFO_COFG
{
public:
    CRECIPE_INFO_COFG() { Reset(); };
    virtual ~CRECIPE_INFO_COFG(void) {};
 
public:
    void        Reset();
    BOOL        LoadRecipeConfigFile(CString strRecipe);
    BOOL        SaveRecipeConfigFile(CString strRecipe);
 
public:
    BOOL m_bUse;
};
 
//park
enum LIGHT_CONTROL_METHOD{LIGHT_CONTROL_METHOD_AUTO=0,LIGHT_CONTROL_METHOD_MANUAL,LIGHT_CONTROL_METHOD_NONE};
 
#define        LIGHT_CONTROL_COUNT            2
#define        LIGHT_CONTROL_CH_COUNT        8
 
class CLIGHT_PARM
{    
public:
    CLIGHT_PARM();
    virtual ~CLIGHT_PARM(void);
 
public:
    BOOL        ReadRecipe(CConfig *pFile);
    BOOL        WriteRecipe(CConfig *pFile);
    BOOL        WriteRecipe(std::vector<std::pair<CString, CString>>* pParamList);
 
public:
    void        Reset();
    CString        GetFileString(void *pValue);
 
public:
    BOOL        m_bLightControl;            
    int            m_nContValue[LIGHT_CONTROL_COUNT][LIGHT_CONTROL_CH_COUNT];
 
    void        SetContValue(int nIdx, int nCh, int nContValue);        
};
 
class CSIDE_INSPECTT_PARM
{    
public:
    CSIDE_INSPECTT_PARM()                    {Reset();};
    virtual ~CSIDE_INSPECTT_PARM(void)        {};
 
    void Reset();
    BOOL ReadRecipe(CConfig *pFile, int nSideIdx, eSideInsType eInsType);
    BOOL WriteRecipe(CConfig *pFile, int nSideIdx, eSideInsType eInsType);
 
public:
    BOOL            m_bUseInspect;
    int                m_nInspect_Method;            // 0 : Gray, 1 : Pitch, 2 : Gray + Pitch
    int                m_nInspect_Range_um;
    int                m_nInspect_SideLine_Offset_um;
    int                m_nMin_Threshold;
    int                m_nMax_Threshold;
    int                m_nDiff_Threshold;
    int                m_nDiff_Pitch;
    BOOL            m_bSide_Filter;
    int                m_nSide_Filter_um;
    int                m_nMinSize_Filter_pxl;
    int                m_nMinSize_Filter_X_um;
    int                m_nMinSize_Filter_Y_um;
    int                m_nDefect_Size_Dilation;    // - : Erosion, + : Dilation
 
 
    // First, Second, Third
    int                m_nJudge_Size_Min_X_um[3];
    int                m_nJudge_Size_Min_Y_um[3];
    int                m_nJudge_Size_Min_OR_AND[3];    // 0 : No Use, 1 : OR, 2 : AND
};
 
class CNOTCH_PARM
{    
public:
    CNOTCH_PARM()                            {Reset();};
    virtual ~CNOTCH_PARM(void)                {};
 
    void Reset();
    BOOL ReadRecipe(CConfig *pFile, int nSideIdx, int nNotchIdx);
    BOOL WriteRecipe(CConfig *pFile, int nSideIdx, int nNotchIdx);
 
public:
    int       m_nGlassStartLine_pxl;    // Notch 殿废 且 锭 Glass Start Line..
    CPoint m_ptTopMarkPos;            // Notch 殿废 且 锭 Top Align Mark..
    CPoint m_ptBotMarkPos;            // Notch 殿废 且 锭 Bot Align Mark..
 
    BOOL   m_bNotch_Use;
    CRect  m_rtNotch_Area_pxl;
 
    int       m_nGrind_Threshold;
    int       m_nGlass_Threshold;
    int       m_nSmooth_Filter;
    int       m_nReferece_Line_Threshold;
    int       m_nNotchCenter_Offset_pxl;
 
    BOOL   m_bNotch_Inspect_Defect_Use;
    int       m_nNotch_Inspect_Defect_Threshold;
    int       m_nNotch_Inspect_Defect_Offset;
    int       m_nNotch_Inspect_Defect_dilate;
    int       m_nNotch_Inspect_Defect_Min_X_um;
    int       m_nNotch_Inspect_Defect_Min_Y_um;
    int       m_nNotch_Inspect_Defect_Judge_X_um;
    int       m_nNotch_Inspect_Defect_Judge_Y_um;
    int       m_nNotch_Inspect_Defect_Judge_And;
 
    BOOL   m_bNotch_Dimension_Use[MAX_SIDE_NOTCH_MEASURE_COUNT];
    double m_dNotch_Dimension_STD_mm[MAX_SIDE_NOTCH_MEASURE_COUNT];
    double m_dNotch_Dimension_Diff_MIN_mm[MAX_SIDE_NOTCH_MEASURE_COUNT];
    double m_dNotch_Dimension_Diff_MAX_mm[MAX_SIDE_NOTCH_MEASURE_COUNT];
 
    BOOL   m_bNotch_Chamfer_Use[MAX_SIDE_NOTCH_MEASURE_COUNT];
    double m_dNotch_Chamfer_STD_mm[MAX_SIDE_NOTCH_MEASURE_COUNT];
    double m_dNotch_Chamfer_Diff_MIN_mm[MAX_SIDE_NOTCH_MEASURE_COUNT];
    double m_dNotch_Chamfer_Diff_MAX_mm[MAX_SIDE_NOTCH_MEASURE_COUNT];
 
    // Notch Circle
    int       m_nNotch_Circle_Count;
    BOOL   m_bNotch_Circle_Use[MAX_SIDE_NOTCH_CIRCLE_COUNT];
    CPoint m_ptNotch_Circle_TopMarkPos[MAX_SIDE_NOTCH_CIRCLE_COUNT];            // Notch Circle 殿废 且 锭 Top Align Mark..
    CPoint m_ptNotch_Circle_BotMarkPos[MAX_SIDE_NOTCH_CIRCLE_COUNT];            // Notch Circle 殿废 且 锭 Bot Align Mark..
    CRect  m_rtNotch_Circle_Area_pxl[MAX_SIDE_NOTCH_CIRCLE_COUNT];
    double m_dNotch_Circle_Spec_Radius_um[MAX_SIDE_NOTCH_CIRCLE_COUNT];
    double m_dNotch_Circle_Spec_Radius_Min_um[MAX_SIDE_NOTCH_CIRCLE_COUNT];
    double m_dNotch_Circle_Spec_Radius_Max_um[MAX_SIDE_NOTCH_CIRCLE_COUNT];
};
 
class CEXCEPTION_AREA_PARM
{    
public:
    CEXCEPTION_AREA_PARM()                    {Reset();};
    virtual ~CEXCEPTION_AREA_PARM(void)        {};
 
    void Reset();
    BOOL ReadRecipe(CConfig *pFile, int nSideIdx, int nExceptionIdx);
    BOOL WriteRecipe(CConfig *pFile, int nSideIdx, int nExceptionIdx);
 
public:
    CPoint m_ptTopMarkPos;
    CPoint m_ptBotMarkPos;
 
    CRect m_rtExceptionArea;
 
    int m_nFilterType;        // 0 : No Use, 1 : Intersection, 2 : Fully
 
    int m_nFilterSizeX;
    int m_nFilterSizeY;
    BOOL m_bFilterAnd;
};
 
class CUSER_DEFECT_AREA_PARM
{    
public:
    CUSER_DEFECT_AREA_PARM()                    {Reset();};
    virtual ~CUSER_DEFECT_AREA_PARM(void)        {};
 
    void Reset();
    BOOL ReadRecipe(CConfig *pFile, int nSideIdx, int nUserDefectAreaIdx);
    BOOL WriteRecipe(CConfig *pFile, int nSideIdx, int nUserDefectAreaIdx);
 
public:
    CPoint    m_ptTopMarkPos;
    CPoint    m_ptBotMarkPos;
 
    CRect    m_rtUserDefectArea;
 
    BOOL    m_bUseInspect;
    int        m_nInspect_Method;            // 0 : Gray, 1 : Y Pitch, 2 : X Pitch
    int        m_nMin_Threshold;
    int        m_nMax_Threshold;
    int        m_nDiff_Threshold;
    int        m_nDiff_Pitch;
    int        m_nMinSize_Filter_pxl;
 
    int        m_nJudge_Size_Min_X_um;
    int        m_nJudge_Size_Min_Y_um;
    int        m_nJudge_Size_Min_OR_AND;    // 0 : No Use, 1 : OR, 2 : AND
};
 
class CSIDE_PARM
{    
public:
    CSIDE_PARM();
    virtual ~CSIDE_PARM(void);
 
public:
    void            Reset();
    BOOL            ReadRecipe(CConfig *pFile, int nSideIdx);
    BOOL            WriteRecipe(CConfig *pFile, int nSideIdx);
 
public:    
    int                m_nSidePanelSize_um;        // Scan 搁狼 技肺 规氢 农扁
    int                m_nFindStartEndLine_X_pxl;    // Start/End Find Pos X
    int                m_nFindStartEndLine_Threshold;
    int                m_nSideLineThreshold;
    int                m_nChamferLineThreshold;
 
    // Top Corner Size
    int                m_nTopCornerShape;            // 0 : None, 1 : CCut, 2 : RCut
    BOOL            m_bTopCornerFindDefect;
    BOOL            m_bTopCornerMeasureSize;
    int                m_nTopCornerEdgeFilterSize;
    int                m_nTopCornerEdgeThreshold;
    int                m_nTopCornerSizeX_um;
    int                m_nTopCornerSizeY_um;
    BOOL            m_bTopCornerDimension_Use[MAX_CORNER_DIMENSION_MEASURE_COUNT];
    double            m_dTopCornerDimensionSpec_mm_Std[MAX_CORNER_DIMENSION_MEASURE_COUNT];
    double            m_dTopCornerDimensionSpec_mm_Min[MAX_CORNER_DIMENSION_MEASURE_COUNT];
    double            m_dTopCornerDimensionSpec_mm_Max[MAX_CORNER_DIMENSION_MEASURE_COUNT];
    BOOL            m_bTopCornerChamfer_Use[MAX_CORNER_DIMENSION_MEASURE_COUNT];
    double            m_dTopCornerChamfer_Spec_mm_Std[MAX_CORNER_DIMENSION_MEASURE_COUNT];
    double            m_dTopCornerChamfer_Spec_mm_Min[MAX_CORNER_DIMENSION_MEASURE_COUNT];
    double            m_dTopCornerChamfer_Spec_mm_Max[MAX_CORNER_DIMENSION_MEASURE_COUNT];
 
    int                m_nTopCornerIns_StartOffset;
    int                m_nTopCornerIns_Range;
    int                m_nTopCornerIns_Thres_Min;
    int                m_nTopCornerIns_Thres_Max;
    int                m_nTopCornerIns_Min_Size;
    int                m_nTopCornerIns_Defect_Size_Dilation;
    int                m_nTopCorner_Measure_Judge_Std_um_X;
    int                m_nTopCorner_Measure_Judge_Min_um_X;
    int                m_nTopCorner_Measure_Judge_Max_um_X;
    int                m_nTopCorner_Measure_Judge_Std_um_Y;
    int                m_nTopCorner_Measure_Judge_Min_um_Y;
    int                m_nTopCorner_Measure_Judge_Max_um_Y;
    int                m_nTopCorner_Measure_Judge_OR_AND;
    int                m_nTopCorner_Judge_Size_Min_X_um;
    int                m_nTopCorner_Judge_Size_Min_Y_um;
    int                m_nTopCorner_Judge_Size_Min_OR_AND;    // 0 : No Use, 1 : OR, 2 : AND
 
    // Bottom Corner Size
    int                m_nBottomCornerShape;        // 0 : CCut, 1 : RCut
    BOOL            m_bBottomCornerFindDefect;
    BOOL            m_bBottomCornerMeasureSize;
    int                m_nBottomCornerEdgeFilterSize;
    int                m_nBottomCornerEdgeThreshold;
    int                m_nBottomCornerSizeX_um;
    int                m_nBottomCornerSizeY_um;
    BOOL            m_bBottomCornerDimension_Use[MAX_CORNER_DIMENSION_MEASURE_COUNT];
    double            m_dBottomCornerDimensionSpec_mm_Std[MAX_CORNER_DIMENSION_MEASURE_COUNT];
    double            m_dBottomCornerDimensionSpec_mm_Min[MAX_CORNER_DIMENSION_MEASURE_COUNT];
    double            m_dBottomCornerDimensionSpec_mm_Max[MAX_CORNER_DIMENSION_MEASURE_COUNT];
    BOOL            m_bBottomCornerChamfer_Use[MAX_CORNER_DIMENSION_MEASURE_COUNT];
    double            m_dBottomCornerChamfer_Spec_mm_Std[MAX_CORNER_DIMENSION_MEASURE_COUNT];
    double            m_dBottomCornerChamfer_Spec_mm_Min[MAX_CORNER_DIMENSION_MEASURE_COUNT];
    double            m_dBottomCornerChamfer_Spec_mm_Max[MAX_CORNER_DIMENSION_MEASURE_COUNT];
 
    int                m_nBottomCornerIns_StartOffset;
    int                m_nBottomCornerIns_Range;
    int                m_nBottomCornerIns_Thres_Min;
    int                m_nBottomCornerIns_Thres_Max;
    int                m_nBottomCornerIns_Min_Size;
    int                m_nBottomCornerIns_Defect_Size_Dilation;
    int                m_nBottomCorner_Measure_Judge_Std_um_X;
    int                m_nBottomCorner_Measure_Judge_Min_um_X;
    int                m_nBottomCorner_Measure_Judge_Max_um_X;
    int                m_nBottomCorner_Measure_Judge_Std_um_Y;
    int                m_nBottomCorner_Measure_Judge_Min_um_Y;
    int                m_nBottomCorner_Measure_Judge_Max_um_Y;
    int                m_nBottomCorner_Measure_Judge_OR_AND;
    int                m_nBottomCorner_Judge_Size_Min_X_um;
    int                m_nBottomCorner_Judge_Size_Min_Y_um;
    int                m_nBottomCorner_Judge_Size_Min_OR_AND;    // 0 : No Use, 1 : OR, 2 : AND
 
    // Top Mark
    BOOL            m_bTopMark_Use;
    int                m_nTopMarkToEdgeY_um;
    int                m_nTopMarkToEdgeX_um;
    double            m_dTopMarkTemplateMatchingRate;
    int                m_nTopMarkType;                        // 0 : Black Mark, 1 : White Mark, 2 : Image Matching
 
    // Bottom Mark
    BOOL            m_bBottomMark_Use;
    int                m_nBottomMarkToEdgeY_um;
    int                m_nBottomMarkToEdgeX_um;
    double            m_dBottomMarkTemplateMatchingRate;
    int                m_nBottomMarkType;                    // 0 : Black Mark, 1 : White Mark, 2 : Image Matching
 
    // Find Side Line
    int                m_nSideDimensionCount;
    int                m_nSideDimensionPos_TopMarkToDistance_um[MAX_SIDE_DIMENSION_MEASURE_COUNT];
    BOOL            m_bSideDimension_Use[MAX_SIDE_DIMENSION_MEASURE_COUNT];
    int             m_nSideDimensionSpec_Thres[MAX_SIDE_DIMENSION_MEASURE_COUNT];
    double            m_dSideDimensionSpec_mm_Std[MAX_SIDE_DIMENSION_MEASURE_COUNT];
    double            m_dSideDimensionSpec_mm_Min[MAX_SIDE_DIMENSION_MEASURE_COUNT];
    double            m_dSideDimensionSpec_mm_Max[MAX_SIDE_DIMENSION_MEASURE_COUNT];
    double            m_dSideDimensionSpec_mm_Off[MAX_SIDE_DIMENSION_MEASURE_COUNT];
    BOOL            m_bSideChamfer_Use[MAX_SIDE_DIMENSION_MEASURE_COUNT];
    double            m_dSideChamfer_Spec_mm_Std[MAX_SIDE_DIMENSION_MEASURE_COUNT];
    double            m_dSideChamfer_Spec_mm_Min[MAX_SIDE_DIMENSION_MEASURE_COUNT];
    double            m_dSideChamfer_Spec_mm_Max[MAX_SIDE_DIMENSION_MEASURE_COUNT];
 
    // Judge Area
    int                m_nCenterJudgeArea_StartLine_To_Start_pxl;
    int                m_nCenterJudgeArea_StartLine_To_End_pxl;
 
    // Inspect Param
    CSIDE_INSPECTT_PARM        m_InspectPrm[MAX_SIDE_INSPECT_TYPE];
 
    //pose direction
    CString                    m_strPosDirection;   
 
    // Notch
    int                        m_nNotchCount;
    CNOTCH_PARM                m_NotchPrm[MAX_SIDE_NOTCH_COUNT];
 
    // Exception
    int                        m_nExptionCount;
    CEXCEPTION_AREA_PARM    m_ExpAreaPrm[MAX_SIDE_EXCEPTION_AREA_COUNT];
 
    // User Defect
    int                        m_nUserDefectAreaCount;
    CUSER_DEFECT_AREA_PARM    m_UserDefectPrm[MAX_SIDE_USER_DEFECT_AREA_COUNT];
};
 
class CGlassRecipe
{
public:
    CGlassRecipe(void);
    virtual ~CGlassRecipe(void);
 
public:
    BOOL        ReadRecipe(CConfig *pFile);
    BOOL        WriteRecipe(CConfig *pFile);
 
    BOOL        WriteRecipeFile();    
    BOOL        WriteRecipeFileBackUp();
    BOOL        MakeRecipeFileName(CString strRecipe);    
    BOOL        MakeRecipeFileNameBackUp(CString strRecipe);
    BOOL        ReadRecipeFile();
 
    int            GetLightValue(int iCon,int iCh);
 
    CString        GetRecipeName();
    void        Reset();
 
    BOOL        Save_Image(CString strPath,IplImage *IpImg);
    BOOL        Load_Image(CString strPath,IplImage **pIpImg);
 
    BOOL        LoadRecipeConfigFile(CString strRecipe);
    BOOL        SaveRecipeConfigFile(CString strRecipe);
 
public:
    CRECIPE_INFO_COFG           m_RecieCofg;
    CRECIPE_INFO_PARM            m_RecieParm;
    CLIGHT_PARM                    m_LightParm;
    CSIDE_PARM                    m_SideParam[MAX_DIMENSION_COUNT];
    
protected:
    // CConfig                        m_RecipeFile;
};