SDC C-Project CF Review 프로그램
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
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
#pragma once
 
#define SHAREDMEMNAME_BASICINFO _T("DIT.GLASSRAWSYSTEM.SHAREDMEM.BASICINFO")
#define SHAREDMEMNAME_GLASSDATA    _T("DIT.GLASRAWSYSTEM.SHAREDMEM.GLASSDATA")
#define MUTEX_RAWMESSENGER        _T("MUTEX_RAWMESSENGER_IPC")
 
#define COMMAND_MAXCOUNT 8
 
#define RAWMESSENGER_MAXCAMNUM 30
#define RAWMESSENGER_MAXSCANNUM 20
#define RAWMESSENGER_MAXHLINUM 8
#define RAW_CODE_MAX 10
 
#define MAX_ZONE_NUM 16
 
namespace ditRaw
{
    enum ReviewPlanType
    {
        RPT_Review = 0,
        RPT_User,
        RTP_WSI,
        RTP_PlanMeasure,
        RTP_Reflow,
        RTP_WsiReflow,
        RTP_UserWsi,
        RPT_AOICustom = 1000,
    };
};
enum emAOIProcStep
{
    APS_None = 0,
 
    //AOI
    APS_GlassLoading, 
    APS_InspectEnd,
    //Review
    APS_CustomReviewRead,
    APS_ReviewStart,
    APS_ReviewEnd,
 
    RPS_StepNum
};
 
struct _grmGlassData
{
    void clear()
    {
        memset(this, 0, sizeof(_grmGlassData));
    }
 
    //Glass Á¤º¸
    char m_strFileName[64];
    char m_strPath[256];
 
    int m_nCellNum;
    int m_nDefectNum;
 
    int m_nOriginDirection;                //{ GD_LeftTop = 0, GD_RightTop = 1, GD_LeftBottom = 10, GD_RightBottom = 11 };
    int m_nConerCutDirection;
    int    m_nScanCoordinateY;                //¿©±â°¡ 0À̸é ÀϹÝ, 1À̸é Scan¹æÇâÀÌ yÃà(Áï scan¹æÇâÀÌ ´ÜÃà, offline ¼³ºñ °°Àº)
 
    int m_nGlassSizeWidth;
    int m_nGlassSizeHeight;
    /* <KYH 211129 : #3796 ADD Start> */
    int            m_nDefectNumJudgeND;
    /* <KYH 211129 : #3796 ADD End> */
    //DUMY DATA
    int            Dumy_int[9];
 
    //¼³ºñÁ¤º¸
    char m_strLine[32];
    char m_strEquipType[32];            
    char m_strEquipID[32];                
    char m_strStepID[32];            
    char m_strOperID[32];                
 
    CTime    m_tmGlassLoading;            //3. START_TIME
    CTime    m_tmInspectionStart;            //3. START_TIME
    CTime    m_tmInspectionEND;            //4. END_TIME
    CTime    m_tmReviewLoading;
    CTime    m_tmReviewEnd;
 
    //±âº» ¹°·ùÁ¤º¸
    char m_strGlassID[32];                //Glass ID
    char m_strPPID[32];                    
    char m_strEPPID[32];                
    char m_strLotID[32];                //LOT_ID
    char m_strSLotID[32];                //SLOT_ID
    char m_strRecipeName[32];            //RECIPE_NAME                                
    char m_strGlassJudge[32];            //GLASS_JUDGE
    char m_strGlassCode[32];            //Grade or Code
    char m_strProductID[16];            //4. PRODUCT_ID
 
    //VCR
    int m_nVcrResultCode;
    char m_strVCRResult[32];
    char m_strVCRGlassID[32];
 
 
    //°áÇÔ °¹¼ö °ü¸® º¯¼ö
    int            m_nDefectNumSizeSmall;
    int            m_nDefectNumSizeMid;
    int            m_nDefectNumSizeLarge;
    int            m_nDefectNumSizeHuge;
    int            m_nDefectNumSizeUltra;
 
    int            m_nDefectNumLocActive;
    int            m_nDefectNumLocPad;
    int            m_nDefectNumLocCrack;
    int            m_nDefectNumLocBM;
 
    int            m_nDefectNumTypeTB;
    int            m_nDefectNumTypeTW;
    int            m_nDefectNumTypeRB;
    int            m_nDefectNumTypeRW;
    int            m_nDefectNumTypeMD;
    int            m_nDefectNumTypeCD;
    int            m_nDefectNumTypeMC;
    /* <LJC 20220422 : #3957 ADD Start> */
    int            m_nDefectCode[RAW_CODE_MAX];
    /* <LJC 20220422 : #3957 ADD End> */
 
    int            m_nDefectNumJudgeOKWhite;
    int            m_nDefectNumJudgeOKBlack;
    int            m_nDefectNumJudgeNG;
    int            m_nDefectNumJudgeRW;
    int            m_nDefectNumJudgeRP;
    int            m_nDefectNumJudgeRV;
    int            m_nDefectNumJudgeTR;
    int            m_nDefectNumJudgePR;
    int            m_nDefectNumJudgePT;        //< KEJ 20231123 - #4669 ADD >
    /*< LHS 20211029 - #3783 MOD Start >*/
    int            m_nDefectNumJudgeLine;
    /*< LHS 20211029 - #3783 MOD End >*/
    int            m_nDefectNumStackTD;
    int            m_nDefectNumStackSD;
    int            m_nDefectNumStackPD;
    int            m_nDefectNumStackSP;
 
 
    //Ä«¸Þ¶ó/½ºÄµ Á¤º¸ [±èÅÂÇö 2018/12/5]
    short        m_nCameraNum;
    short        m_nScanNum;
    unsigned char m_nGrayLevelAvg[RAWMESSENGER_MAXCAMNUM*RAWMESSENGER_MAXSCANNUM*RAWMESSENGER_MAXHLINUM];        
    unsigned char m_nGrayLevelMin[RAWMESSENGER_MAXCAMNUM*RAWMESSENGER_MAXSCANNUM*RAWMESSENGER_MAXHLINUM];
    unsigned char m_nGrayLevelMax[RAWMESSENGER_MAXCAMNUM*RAWMESSENGER_MAXSCANNUM*RAWMESSENGER_MAXHLINUM];
 
    //¾ó¶óÀΠÁ¤º¸ um[±èÅÂÇö 2018/12/10]
    double    m_nAlignCcdTheta;
    double    m_nAlignCcdShitftX;
    double    m_nAlignCcdShitftY;
    double    m_nAlignPreTheta;
    double    m_nAlignPreShitftX;
    double    m_nAlignPreShitftY;
    double    m_nAlignBasicTheta;
    double    m_nAlignBasicShitftX;
    double    m_nAlignBasicShitftY;
    char    m_strAlignFirst[64];
    char    m_strAlignSecond[64];
//     char    m_strAlignPath[256];
 
    //CSOT¿ë ¹°·ù Á¤º¸ [±èÅÂÇö 2018/12/5]
    char m_strCassetteSequenceNo[16];
    char m_strOwnerCode[16];            //2. OWNER_CODE
    char m_strOwnerType[16];            //3. OWNER_TYPE
 
    char m_strProcessID[21];            //5. PROCESS_ID
    char m_strProductGroup[16];            //6. PRODUCT_GROUP
    char m_strCSTID[16];                //8. CST_ID
    char m_strPreProcessID[16];            //10.PRE_PROCESS_ID
    char m_strPreEQPID[16];                //11.PRE_EQP_ID
    char m_strPreChamerID[16];            //12.PRE_CHAMBER_ID
    char m_strPreRecipeID[32];            //13.PRE_RECIPE_ID
    char m_strGroupID[16];                //14.GROUP_ID
    char m_cAutoSampleFlag;                //15.AUTOSAMPLEFLAG
 
    // CPRJ¿ë ¹°·ù Á¤º¸
    char m_strProdType[3];
    char m_strBatchID[13];
    char m_strPairHPanelID[13];
    char m_strGlassThickNess[2];
    char m_strCompCount[2];
    char m_strGlassState[2];
    char m_strInsFlag[2];
    char m_strPanelPosition[2];
    char m_strFlowHistory[2];
    char m_strCount1[2];
    char m_strCount2[2];
    char m_StrMergeList[10][12];
    //Mura Data 0412 nwh
    char m_strMaxAvgGray[12];
    char m_strMaxPortion[12];
 
 
     //1226NWH
    char m_strReadingFlag[2]; 
    BYTE m_nUniqueID[4];
    int m_nSlot_No; 
 
    BYTE m_nGlassDataBitSignal[4];
    bool m_bJob_end;  
 
    //201217 CJH - ÂïÀº Defect Review °³¼ö
    int m_nReviewNum;
    //201221 CJH - ÆÄ½ÌÇÑ Stack °á°ú
    int m_nStackNum;
    BOOL m_bStackRead;
 
    /*< KJG 20211024 - #3487 ADD Start >*/
    int m_nRawMergeNum;
    BOOL m_bRawMergeRead;
    /*< KJG 20211024 - #3487 ADD End >*/
    //210203 CJH - CutOff ´ë»ó °áÇÔ ¼ö
    int m_nCutOffDefectNum;
    //210323 CJH - Server/Frame Shrink Á¤º¸ Ãß°¡
    char m_strShrinked[6];
    //210326 CJH - RAW ÀԷ Defect ¼ö·® »óÇÑ »ç¿ë¿©ºÎ
    BOOL m_bRawCutoff;
    //210907 KJG - EdgeCrack °Ë»ç »ç¿ë À¯¹«
    BOOL m_bEdgeCrackUse;
    BOOL m_bRawMergeUse;
    /* < KJG 20220225 - #3850 ADD Start >*/ 
    char m_strRawMergeStepID[32];
    /* < KJG 20220225 - #3850 ADD End >*/
 
    /* < KMH 20220614 : #3957 ADD Start > */
    char m_strRawDefectCode[RAW_CODE_MAX][5];    // 4±ÛÀÚ¸¸ Ç¥±â
    /* < KMH 20220614 : #3957 ADD End > */
};
struct _grmBlockData
{
    void clear()
    {
        memset(this, 0, sizeof(_grmBlockData));
    }
    char m_strBlockID[16];                //1. BLOCK_ID
    char m_cBlockJudgeAOI;                //2. BLOCK_JUDGE_AOI
    char m_cBlockJudgeATS;                //4. BLOCK_JUDGE_ATS
    char m_cBlockJudgeTEG;                //5. BLOCK_JUDGE_TEG
    int m_nGlassIdDCR;                    //22. GLASS_ID_DCR
};
struct _grmCellData
{
    void clear()
    {
        memset(this, 0, sizeof(_grmCellData));
    }
    int getTotalDefectNum(){return m_nDefectNumTypeTB+m_nDefectNumTypeTW+m_nDefectNumTypeRB+m_nDefectNumTypeRW; };
    int                        m_nCellID;                            //1. PANEL_ID
    short                    m_nModelIdx;                // ¸î ¹øÂ° ¸ðµ¨Àΰ¡?
 
    char                    m_strCellName[32];
    int                        m_rectCellLeft;
    int                        m_rectCellTop;
    int                        m_rectCellRight;
    int                        m_rectCellBottom;
 
    int/*Judgement*/        m_nJudgement;
    int                        m_nJudgeFlag;
    int                        m_nJudgeGlade;
 
 
    //°áÇÔ °¹¼ö °ü¸® º¯¼ö
    int            m_nDefectNumSizeSmall;
    int            m_nDefectNumSizeMid;
    int            m_nDefectNumSizeLarge;
    int            m_nDefectNumSizeHuge;
    int            m_nDefectNumSizeUltra;
 
    int            m_nDefectNumLocActive;
    int            m_nDefectNumLocPad;
    int            m_nDefectNumLocCrack;
    int            m_nDefectNumLocBM;
 
    int            m_nDefectNumTypeTB;
    int            m_nDefectNumTypeTW;
    int            m_nDefectNumTypeRB;
    int            m_nDefectNumTypeRW;
    int            m_nDefectNumTypeMD;
    int            m_nDefectNumTypeCD;
    int            m_nDefectNumTypeMC;
    /* <KYH 211129 : #3796 ADD Start> */
    int            m_nDefectNumJudgeND;
    /* <KYH 211129 : #3796 ADD End> */
    /* <LJC 20220422 : #3957 ADD Start> */
    int            m_nDefectCode[RAW_CODE_MAX];
    /* <LJC 20220422 : #3957 ADD End> */
    //DUMY DATA
    int            Dumy_int[9];
 
    //Mura Data nwh 0404 
    char        m_strProImage[32];
    char        m_strAvgGray_0[12];
    char        m_strPortion_0[12];
    //kyh Mura Data Ãß°¡ 0622
    char        m_strCorner_Gray_0[12];
    char        m_strAvgAmp_0[12];
    char        m_strFFTVar_0[12];
    char        m_strFFTVah_0[12];
    char        m_strFFTVaq_0[12];
    char        m_strFFTPK_0[12];
 
    char        m_strAvgGray_1[12];
    char        m_strPortion_1[12];
    //kyh Mura Data Ãß°¡ 0622
    char        m_strCorner_Gray_1[12];
    char        m_strAvgAmp_1[12];
    char        m_strFFTVar_1[12];
    char        m_strFFTVah_1[12];
    char        m_strFFTVaq_1[12];
    char        m_strFFTPK_1[12];
 
    char        m_strAvgGray_2[12];
    char        m_strPortion_2[12];
    //kyh Mura Data Ãß°¡ 0622
    char        m_strCorner_Gray_2[12];
    char        m_strAvgAmp_2[12];
    char        m_strFFTVar_2[12];
    char        m_strFFTVah_2[12];
    char        m_strFFTVaq_2[12];
    char        m_strFFTPK_2[12];
 
    char        m_strAvgGray_3[12];
    char        m_strPortion_3[12];
    //kyh Mura Data Ãß°¡ 0622
    char        m_strCorner_Gray_3[12];
    char        m_strAvgAmp_3[12];
    char        m_strFFTVar_3[12];
    char        m_strFFTVah_3[12];
    char        m_strFFTVaq_3[12];
    char        m_strFFTPK_3[12];
 
    int            m_nDefectNumJudgeOKWhite;
    int            m_nDefectNumJudgeOKBlack;
    int            m_nDefectNumJudgeNG;
    int            m_nDefectNumJudgeRW;
    int            m_nDefectNumJudgeRP;
    int            m_nDefectNumJudgeRV;
    int            m_nDefectNumJudgeTR;
    int            m_nDefectNumJudgePR;
    int            m_nDefectNumJudgePT;        //< KEJ 20231123 - #4669 ADD >
    /*< LHS 20211029 - #3783 MOD Start >*/
    int            m_nDefectNumJudgeLine;
    /*< LHS 20211029 - #3783 MOD End >*/
    int            m_nReflowResult[8];            // 0: Reflow X 1: Reflow OK 2: Reflow NG
 
    // FilteringµÈ Stackº° ¼ö
    int            m_nDefectTDCount;
    int            m_nDefectSDCount;
    int            m_nDefectPDCount;
    int            m_nDefectSPCount;
 
    // Gate/Data ÃÑ °¹¼ö
    int            m_nGateNum;
    int            m_nDataNum;
 
    // 210129 CJH - Cell Origin ¹æÇâ
    int            m_nCellXDir;
    int            m_nCellYDir;
};
 
struct _grmDefectReviewData
{
    void clear()
    {
        memset(this, 0, sizeof(_grmDefectReviewData));
    }
 
    //////////////////////////////////////////////////////////////////////////
    //¿©±â¼­ ºÎÅÍ ¸®ºä ¿µ¿ª [±èÅÂÇö 2019/1/19]
    ditRaw::ReviewPlanType            m_nPlanType    ;    
    int            m_nResultCode;  //0:None, 1:Success
    int            m_nShotIndex; //¸®ºä ÂïÀº ¼ø¹ø [±èÅÂÇö 2018/12/5]
    int            m_nModuleIndex;
    int            m_nMagnificIndex;
    float        m_fManification;
    float        m_fManificResoultion;
    char        m_strRevImageName[256];
    char        m_strRevImagePath[256];
 
    //////////////////////////////////////////////////////////////////////////
    // Measure ¿µ¿ª
    int            m_nMeasure_Index;
    int            m_nMeasure_ResultCode; //0:None, 1:Success
    float        m_fMesure_ResultData[8];    // 0:Type, 1:ShiftX, 2:ShiftY
 
    //////////////////////////////////////////////////////////////////////////
    // WSI¿µ¿ª
    int            m_nWsi_ResultCode; //0:None, 1:Success
    int            m_nWsi_Type;                                    // ÇÔ¸ô / µ¹±â
    float        m_fWsi_ResultData[8];            // 0:Type, 1:Height(um), 2:Width
    char        m_strWsi_2DImageFilename[256];
    char        m_strWsi_3DImageFilename[256]; 
    int            m_nWsiReflowPositionIndex;                    // WsiReflowPositionIndex
    int            m_nWsi_pReflowResultData[8];
    double        m_dWsi_DamDistance;
 
    double        m_dWsiMmMotorX;                                // WSI ¸ðÅÍ ÁÂÇ¥ 20180223 HJH
    double        m_dWsiMmMotorY;
    float        m_fWsiManification;                            // WSI ¹èÀ²
 
    //////////////////////////////////////////////////////////////////////////
    // Reflow ¿µ¿ª    
    int            m_nReflow_Index;
    int            m_nReflow_ResultCode; //0:None, // °ËÃâÇÑ LineÀÇ °³¼ö. 3 ¹Ì¸¸ : DAM2 Reflow ÆÇÁ¤, 4~5 : DAM1 Reflow ÆÇÁ¤, 6 : no Reflow ÆÇÁ¤ / -1 : image not loaded, -2 : roi setting error, -3 : roi length error, -5 : select wrong side
    float        m_fReflow_LinePosData[8];    
    int            m_nReflow_Side;
    int            m_nReflow_InspectionMode;
};
 
struct _grmDefectData
{
    void clear()
    {
        memset(this, 0, sizeof(_grmDefectData));
    }
 
    short            m_nDefectID;
    short            m_nCameraID;
    short            m_nScanIdx;
    //short            m_nDefectIdx;                // Ä«¸Þ¶ó¿¡¼­ÀÇ °áÇÔ À妽º
    int                m_nDefectIdx;                // Ä«¸Þ¶ó¿¡¼­ÀÇ °áÇÔ À妽º 201207 CJH - ÀÚ¸´ ¼ö ³Ñħ. intÇüÀ¸·Î º¯°æ
 
    int                m_nPixelConv;                // pixel ´ÜÀ§ ÁÂÇ¥
    int                m_nPixelScan;                // pixel ´ÜÀ§ ÁÂÇ¥
 
    /* < KMH 20220707 : #4230 MOD Start > */
    // ¹üÀ§ ¹þ¾î³ª¼­ À½¼ö·Î Ç¥±âµÇ¸é D_Col Fail
    //short                            m_nPixelSize;                // °áÇÔÅ©±â        ---------------------------------PS
    int                    m_nPixelSize;                // °áÇÔÅ©±â        ---------------------------------PS
    /* < KMH 20220707 : #4230 MOD End > */
    short/*SERVER_DefectType*/        m_DefectType;                // °áÇԠŸÀÔ    ---------------------------------DT
    short/*SERVER_DefectSubType*/    m_DefectSubType;            // °áÇÔÀÇ ÆÇÁ¤»óÅÂ.
    short/*SERVER_DefectBDType*/    m_DefectBDType;                // °áÇԠŸÀÔ - Bright, Dark, Both
 
    short            m_sPixelWidth;                // Çȼ¿´ÜÀ§ °áÇÔ ³Êºñ
    short            m_sPixelHeight;                // Çȼ¿´ÜÀ§ °áÇÔ ³ôÀÌ
    short            m_nLevelSrcMin;                // °áÇÔ ¹à±â Min    -----------------------------SN
    short            m_nLevelSrcMax;                // °áÇÔ ¹à±â Max    -----------------------------SX
    short            m_nLevelSrcAvg;                // °áÇÔ ¹à±â Avg    -----------------------------SA
    short            m_nLevelRefMin;                // ºñ±³´ë»ó ¹à±â Min    -------------------------RN
    short            m_nLevelRefMax;                // ºñ±³´ë»ó ¹à±â Max    -------------------------RX
    short            m_nLevelRefAvg;                // ºñ±³´ë»ó ¹à±â Avg    -------------------------RA
    short            m_nLevelDiffMin;            // ºñ±³Â÷ Min    ---------------------------------DN
    short            m_nLevelDiffMax;            // ºñ±³Â÷ Max    ---------------------------------DX
    short            m_nLevelDiffAvg;            // ºñ±³Â÷ Avg    ---------------------------------DA
 
    int                m_nDefectRScale;            // Çȼ¿´ÜÀ§ °áÇÔ ³ôÀÌ    -------------------------RS
    short            m_sThreshold;                // °áÇÔÀ» °ËÃâÇÒ ¶§ÀÇ Threshold
    short            m_sThresholdAvg;            // °áÇÔÀ» °ËÃâÇÒ ¶§ÀÇ Threshold AVG
    short            m_sDefectPeak;                // °áÇÔÀÇ Peak.
    short            m_sDefectLevel;                // (DiffAvg - Th) BOE 8G ¿äû»çÇ×
 
    int                m_nPixelGlassStart;            // Glass ½ÃÀÛ Çȼ¿
    short            m_sDefectLoc;
 
    short            m_sZoneClassPixelCount[16];
    short            m_sZonePixelCount[16];    // Zoneº° °áÇÔ Pixel ¼ö
    short            m_sZoneValueMin[16];    // Zoneº° °áÇÔ Min
    short            m_sZoneValueMax[16];    // Zoneº° °áÇÔ Max
    short            m_sZoneValueAvg[16];    // Zoneº° °áÇÔ Avg
    short            m_sZonePixelPercent[16];    // --------------------------------------Z0~ZF
 
    //210127 CJH - Zoneº° Source Gray ÀÔ·Â
    short            m_sZoneValueSrcMin[16];    // Zoneº° Source Min
    short            m_sZoneValueSrcMax[16];    // Zoneº° Source Max
    short            m_sZoneValueSrcAvg[16]; // Zoneº° Source Avg
 
    int                m_nUMOriginX;                // um´ÜÀ§ xÁÂÇ¥ (¿øÁ¡±âÁØ)
    int                m_nUMOriginY;                // um´ÜÀ§ yÁ¶Ç¥ (¿øÁ¡±âÁØ)
    int                m_nUMCenterAlignX;            // um´ÜÀ§ XÁÂÇ¥ (Glass Center ±âÁØ, ¾ó¶óÀκ¸Á¤ ÈÄ)
    int                m_nUMCenterAlignY;            // um´ÜÀ§ YÁÂÇ¥ (Glass Center ±âÁØ, ¾ó¶óÀκ¸Á¤ ÈÄ)
    int                m_nUMCenterX;                // um´ÜÀ§ XÁÂÇ¥ (Glass Center ±âÁØ, ¾ó¶óÀκ¸Á¤ Àü)
    int                m_nUMCenterY;                // um´ÜÀ§ YÁÂÇ¥ (Glass Center ±âÁØ, ¾ó¶óÀκ¸Á¤ Àü)
    int                m_nUMSizeX;                    // um´ÜÀ§ X Å©±â    -----------------------------UX
    int                m_nUMSizeY;                    // um´ÜÀ§ Y Å©±â    -----------------------------UY
    int                m_nUMSize;                    // um´ÜÀ§ Å©±â.
    CRect            m_RectUM;                    // µðÆå ¼¾ÅÍ ±âÁØ »ç°¢Çü.
 
    short/*SERVER_DefectSizeType*/    m_DefectSizeType;            // °áÇÔ Å©±â Á¾·ùenum SERVER_DefectSizeType        { SizeType_Unknown = 0, SizeType_Small, SizeType_Mid, SizeType_Large, SizeType_Huge, SizeType_Ultra };
    short/*SERVER_DefectPeakType*/    m_DefectPeakType;            // PeakÀÇ Á¾·ù.
    short/*Judgement*/                m_DefectJudgement;            // °áÇÔ ÆÇÁ¤.
    BOOL                    m_bDefectCutoff;            // ÄÆ ¿ÀÇÁ µðÆå(TRUE= Cutoff, FALSE)
    short/*MAP16_DefectClass*/        m_DefectClass;                // BOE Defect Class 16µîºÐ ±¸ºÐ
    int                m_nPadRegionIdx;            // PAD ¿µ¿ª À妽º
 
    int                m_nUMCellX;                    // ¼¿ ¿øÁ¡ ±âÁØ x ÁÂÇ¥
    int                m_nUMCellY;                    // ¼¿ ¿øÁ¡ ±âÁØ y ÁÂÇ¥
    short            m_nModelIdx;                // ¸î ¹øÂ° ¸ðµ¨Àΰ¡?
    short            m_nCellIdx;                    // ¸î¹øÂ° ¼¿Àΰ¡?
    char            m_strCellName[32];            // ¼¿ À̸§                            /* < KMH 20220609 : #4183 ADD  > */
    short            m_nCellGate;                // ¼¿º° Gate¶óÀÎ(¾ó¶óÀΠº¸Á¤ Àü)
    short            m_nCellData;                // ¼¿º° Data¶óÀÎ(¾ó¶óÀΠº¸Á¤ Àü)
    short            m_nCellGateAlign;            // ¼¿º° Gate¶óÀÎ(¾ó¶óÀΠº¸Á¤ ÈÄ)
    short            m_nCellDataAlign;            // ¼¿º° Data¶óÀÎ(¾ó¶óÀΠº¸Á¤ ÈÄ)
 
    int                m_nUMShotX;                    // ¼¦ ±âÁØ XÁÂÇ¥
    int                m_nUMShotY;                    // ¼¦ ±âÁØ YÁÂÇ¥
    short            m_nMaskDefectIdx;            // ÇÑ Glass¿¡¼­ ¹ß°ßµÈ ¸¶½ºÅ©°áÇÔ ¹­À½ÀÇ À妽º.
    short            m_nShotIdx;                    // ³ë±¤¼¦ ¹øÈ£
    short            m_nMatchShotCount;            // µ¿ÀÏÇÑ ¸¶½ºÅ© °áÇÔÀÇ ¼ö.
    short            m_nMatchMaxSize;            // µ¿ÀÏÇÑ ¸¶½ºÅ© Áß °¡Àå Å« °áÇÔÀÇ Å©±â.
 
    short            m_nRepeatCount;                // ¿¬¼Ó°áÇԹ߰ßÀ§ÇÑ µ¿ÀÏÁÂÇ¥ ¹Ýº¹¼ö
    short            m_nMaskRepeatCount;
    int                m_StackInfo;                // Stack Flag
    BOOL            m_bRealStack;                // Stack ¸ÓÁö¿¡ ÀÇÇÑ TD(TRUE) ÀÎÁö, ÇÊÅ͸µ¿¡ ÀÇÇÑ TD(FALSE)±¸ºÐÇÒ ¼ö ÀÖ´Ù.
    short            m_nStackStepCount;            // Stack ¼ö
    short            m_nStackColorIdx;            // Color¸¦ ¼±ÅÃÇϴ À妽º.
    //CString            m_strStackStep[CFDEFECT_STACKCOUNT];            // Stack Step.
/* < KMH 20220712 : #4230 MOD Start > */
    //    char            m_strStackFirst[60];            // Stack Step. //201221 CJH - ÃÖ´ë »çÀÌÁî 60bytes
    char            m_strStackFirst[400];            // Stack Step. // 400 bytes È®Àå¿äû : SDC Ã¤½Â¼®P
/* < KMH 20220712 : #4230 MOD End > */
    char            m_strUnitID[16];                // À¯´Ö¾ÆÀ̵ð
 
    int                m_ClassificationType;                // enum ClassificationType            { ClassType_None= 0, ClassType_PI_Over= 1, ClassType_PI_Under= 2, ClassType_TFE_Circle= 3, ClassType_Bubble, ClassType_Scratch, ClassType_Particle}; Classification Type, PI³ª TFEµî Ãß°¡ ºÐ·ù  ¾Ë°í¸®Áò Àû¿ë °á°ú.
    int                m_nAtomWidth;                // TFE ÇÙ ³Êºñ
    int                m_nAtomHeight;                // TFE ÇÙ ³ôÀÌ
    short/*ReKind*/            m_DefectKind;                // °áÇÔ Á¾·ù
 
    char            m_strDefectCode[32];            // Defect Code
    BOOL            m_bMergeState;                // Merge Status
    char            m_strAoiImageName[256];            // Defect Image Name(CCD Image)
    int                m_nDefectMerge;        // ÇöÀç µðÆåÀÇ ¸ÓÁö ¿©ºÎ
 
 
    int                m_nPixelSizeOrigin;
    int                m_nScratchRatio;
    int                m_nDensity;            // ¿øÇü °áÇÔ ±¸ºÐÀ» À§ÇÑ ¹Ðµµ [2017.8.2 bhs]
 
    char            m_strDefectName[16];
    char            m_strDefectType[16];
 
    double            m_dScanResolution;
    double            m_dConvResolution;
 
    int                m_nAngle;                    // °¢µµ
    int                m_nMajor;                    // ÀåÃà ±æÀÌ(Long)
    int                m_nMinor;                    // ´ÜÃà ±æÀÌ(Short)
    int                m_nCompact;                    // Blob ÀåÃàÀ» Áö¸§À¸·Î Çϴ ¿øÀÇ ³ÐÀ̿͠Blob ³ÐÀÌÀÇ ºñÀ²
    int                m_nThickness;                // Blob ³ÐÀ̿͠ÀåÃàÀÇ ºñÀ² (Area / Major)
    
    short            m_nHliLevelIdx;                // ¸î ¹øÂ° ·¹º§(ä³Î)Àΰ¡?
    int                m_nHliLayers;                // ÇØ´ç°áÇÔ¿¡ Æ÷ÇԵȠ·¹À̾î bitó¸®
 
    BOOL            m_bShrinked;                //210323 CJH - Frame Shrink Á¤º¸ Ãß°¡
 
    char            m_strAoiImagePath[255];
    char            m_strReviewImagePath[255];
 
    int                m_nAlignRectLeft;
    int                m_nAlignRectTop;
    int                m_nAlignRectBottom;
    int                m_nAlignRectRight;
    /*< LHS 20211029 - #3783 MOD Start >*/
    char            m_strLNDefectCode[12];
    short/*LineDefectType*/ m_LineDefectType;
    /*< LHS 20211029 - #3783 MOD End >*/
 
    _grmDefectReviewData m_ReviewDefect;
};
 
 
enum emGlassRawCommand
{
    grcNone = 0,
 
    //AOI Sequence
    grcSequenceGlassLoading = 1,
    grcSequenceInspectEnd = 2,
    //Review Sequence
    grcSequenceReviewStart = 3,
    grcSequenceReviewEnd = 4,
 
    grcSequenceCustomReviewDataRead = 10,
 
    grcWriteRaw = 101,
    grcReadRaw = 102,
 
    grcWriteBin = 201,
    grcReadBin = 202,
 
    grcReviewWriteBIn = 301,
 
    grcGlassRawCommand
};
 
 
struct _grmDitCommand
{
    struct _grmCommand
    {
        int nCommand;
        char strParam[256];
        short nResult; 
    };
    short m_nCommandIdxWrite;
    short m_nCommandIdxRead;
    _grmCommand m_nCommandBuffer[COMMAND_MAXCOUNT]; 
};
 
struct _grmDitMemInfo
{
    //°øÀ¯ ¸Þ¸ð¸® »ý¼ºÇÒ °ø°£ °áÁ¤ [±èÅÂÇö 2018/11/12]
    size_t m_nGlassRawDataSize;
    int m_nGlassMaxDataNum;
    int m_nBlockMaxDataNum;
    int m_nCellMaxDataNum;
    int m_nDefectMaxDataNum;
    int m_nStackMaxDataNum;
    /*< KJG 20211024 - #3487 ADD Start >*/
    int m_nRawMergeMaxDataNum;
    /*< KJG 20211024 - #3487 ADD End >*/
 
    //Char ±âÁØ ÀÚ·á°¡ Àִ ½ÃÀÛ À§Ä¡ [±èÅÂÇö 2018/11/12]
    int m_nGlassDataPoint;
    int m_nBlockDataPoint;
    int m_nCellDataPoint;
    int m_nDefectDataPoint;
    int m_nStackDataPoint;
    /*< KJG 20211024 - #3487 ADD Start >*/
    int m_nRawMergeDataPoint;
    /*< KJG 20211024 - #3487 ADD End >*/
 
    int m_nSizeOfGlassData;
    int m_nSizeOfBlockData;
    int m_nSizeOfCellData;
    int m_nSizeOfDefectData;
    int m_nSizeOfStackData;
    /*< KJG 20211024 - #3487 ADD Start >*/
    int m_nSizeOfRawMergeData;
    /*< KJG 20211024 - #3487 ADD End >*/
};
struct _grmDitGlassRawInfo : public _grmDitMemInfo, public _grmDitCommand
{
    size_t m_nGlassLoadingCount;
    emAOIProcStep m_ClientProcStep; //AOI, Review°¡ º¸³½ ¸í·É
    emAOIProcStep m_ServerProcStep; //GlassRaw Messenger(Server)°¡ Ã³¸® ¿Ï·á ÇÑ ¸í·É
};
 
class CgrmGlassRawData
{
public:
    CgrmGlassRawData()
    {
        m_pGlassRawData = NULL;
        m_bRefAlloc = FALSE;
    };
 
    ~CgrmGlassRawData()
    {
        clear();
    };
 
    void clear()
    {
        if(m_bRefAlloc) { m_pGlassRawData = NULL; return;}
 
        if(m_pGlassRawData)
        {
            delete [] m_pGlassRawData;
            m_pGlassRawData = NULL;
        }
    };
    BOOL ImportGlassRaw(_grmDitMemInfo* pInfo, char* pData, bool bRefAlloc = false)
    {
        if(pInfo == NULL) return FALSE;
 
        if(m_pGlassRawData && pInfo->m_nGlassRawDataSize != m_MemInfo.m_nGlassRawDataSize) clear(); 
 
        if(m_pGlassRawData == NULL) m_pGlassRawData = new char[ pInfo->m_nGlassRawDataSize ];
 
        m_MemInfo = *pInfo;
 
        m_nGlassRawDataSize = pInfo->m_nGlassRawDataSize;
 
        m_nGlassMaxDataNum  = pInfo->m_nGlassMaxDataNum ;
        m_nBlockMaxDataNum    = pInfo->m_nBlockMaxDataNum    ;
        m_nCellMaxDataNum   = pInfo->m_nCellMaxDataNum  ;
        m_nDefectMaxDataNum = pInfo->m_nDefectMaxDataNum;
        m_nStackMaxDataNum    = pInfo->m_nStackMaxDataNum    ;
 
        m_nGlassDataPoint   = pInfo->m_nGlassDataPoint  ;
        m_nBlockDataPoint    = pInfo->m_nBlockDataPoint    ;
        m_nCellDataPoint    = pInfo->m_nCellDataPoint   ;
        m_nDefectDataPoint  = pInfo->m_nDefectDataPoint ;
        m_nStackDataPoint   = pInfo->m_nStackDataPoint    ;
 
        m_nSizeOfGlassData  = pInfo->m_nSizeOfGlassData ;
        m_nSizeOfBlockData    = pInfo->m_nBlockDataPoint    ;
        m_nSizeOfCellData   = pInfo->m_nSizeOfCellData  ;
        m_nSizeOfDefectData = pInfo->m_nSizeOfDefectData;
        m_nSizeOfStackData  = pInfo->m_nSizeOfStackData    ;
 
        if(bRefAlloc)
        {
            m_pGlassRawData = pData;
        }
        else
        {
            if(pData)
            {
                memcpy(m_pGlassRawData, pData, sizeof(char)*pInfo->m_nGlassRawDataSize);
            }
            else
            {
                memset(m_pGlassRawData, 0, sizeof(char)*pInfo->m_nGlassRawDataSize );
            }
        }
 
 
        m_pGlassData  = (_grmGlassData*)&m_pGlassRawData[pInfo->m_nGlassDataPoint];
        m_pBlockData        = (_grmBlockData*)&m_pGlassRawData[pInfo->m_nBlockDataPoint];
        m_pCellData   = (_grmCellData*)&m_pGlassRawData[pInfo->m_nCellDataPoint];
        m_pDefectData = (_grmDefectData*)&m_pGlassRawData[pInfo->m_nDefectDataPoint];
        m_pStackData = (_grmDefectData*)&m_pGlassRawData[pInfo->m_nStackDataPoint];
 
        m_bRefAlloc = bRefAlloc;
        return TRUE;
    };
    BOOL ExportGlassRaw(_grmDitMemInfo* pInfo, char* pData)
    {
        if(pInfo == NULL || pData == NULL) return FALSE;
 
        if(1) //new type //¸Þ¸ð¸® ÃÑ °ø°£ Å©±â¿¡ »ó°ü¾øÀÌ 
        {
            //if(pInfo->m_nGlassRawDataSize != m_MemInfo.m_nGlassRawDataSize) return FALSE;
 
            if(pInfo->m_nSizeOfGlassData  !=  m_MemInfo.m_nSizeOfGlassData)  return FALSE;
            if(pInfo->m_nSizeOfBlockData  !=  m_MemInfo.m_nSizeOfBlockData)  return FALSE;
            if(pInfo->m_nSizeOfCellData   !=  m_MemInfo.m_nSizeOfCellData)   return FALSE;
            if(pInfo->m_nSizeOfDefectData !=  m_MemInfo.m_nSizeOfDefectData) return FALSE;
            if(pInfo->m_nSizeOfStackData  !=  m_MemInfo.m_nSizeOfStackData)     return FALSE;
 
            if(pInfo->m_nCellMaxDataNum < m_pGlassData->m_nCellNum) return FALSE;
            if(pInfo->m_nDefectMaxDataNum < m_pGlassData->m_nDefectNum) return FALSE;
            if(pInfo->m_nStackMaxDataNum < m_pGlassData->m_nDefectNum) return FALSE;
 
            memcpy(&pData[pInfo->m_nGlassDataPoint], m_pGlassData,     pInfo->m_nSizeOfGlassData* 1);
            memcpy(&pData[pInfo->m_nBlockDataPoint], m_pBlockData,     pInfo->m_nSizeOfBlockData* 1);
            memcpy(&pData[pInfo->m_nCellDataPoint], m_pCellData,     pInfo->m_nSizeOfCellData*m_pGlassData->m_nCellNum);
            memcpy(&pData[pInfo->m_nDefectDataPoint], m_pDefectData, pInfo->m_nSizeOfDefectData*m_pGlassData->m_nDefectNum);
            memcpy(&pData[pInfo->m_nStackDataPoint], m_pStackData, pInfo->m_nSizeOfStackData*m_pGlassData->m_nDefectNum);
        }
        else //if() //type old 
        {
            if(pInfo->m_nGlassRawDataSize != m_MemInfo.m_nGlassRawDataSize) return FALSE;
 
            if(pInfo->m_nSizeOfGlassData  !=  m_MemInfo.m_nSizeOfGlassData)  return FALSE;
            if(pInfo->m_nSizeOfBlockData  !=  m_MemInfo.m_nSizeOfBlockData)  return FALSE;
            if(pInfo->m_nSizeOfCellData   !=  m_MemInfo.m_nSizeOfCellData)   return FALSE;
            if(pInfo->m_nSizeOfDefectData !=  m_MemInfo.m_nSizeOfDefectData) return FALSE;
 
            memcpy(pData, m_pGlassRawData, sizeof(char)*pInfo->m_nGlassRawDataSize);
        }
 
 
        return TRUE;
    };
 
    _grmGlassData*    GetGlassData(){return m_pGlassData;};
    _grmBlockData*    GetBlockData(int nIndex){return &m_pBlockData[nIndex];};
    _grmCellData*    GetCellData(int nIndex){return &m_pCellData[nIndex];};
    _grmDefectData*    GetDefectData(int nIndex){return &m_pDefectData[nIndex];};
    _grmDitMemInfo* GetMemInfo(){return &m_MemInfo;};
    _grmDefectData* GetStackData(int nIndex) { return &m_pStackData[nIndex]; };
protected:
    _grmDitMemInfo  m_MemInfo;
    char* m_pGlassRawData;
 
    _grmGlassData*  m_pGlassData;
    _grmBlockData*    m_pBlockData;
    _grmCellData*   m_pCellData;
    _grmDefectData* m_pDefectData;
    _grmDefectData*    m_pStackData;
 
    size_t m_nGlassRawDataSize;
 
    int m_nGlassMaxDataNum;
    int m_nBlockMaxDataNum;
    int m_nCellMaxDataNum;
    int m_nDefectMaxDataNum;
    int m_nStackMaxDataNum;
 
    int m_nGlassDataPoint;
    int m_nBlockDataPoint;
    int m_nCellDataPoint;
    int m_nDefectDataPoint;
    int m_nStackDataPoint;
 
    int m_nSizeOfGlassData;
    int m_nSizeOfBlockData;
    int m_nSizeOfCellData;
    int m_nSizeOfDefectData;
    int m_nSizeOfStackData;
 
private:
    bool m_bRefAlloc;
};