private void ApplySettingValue(bool _IsDisplay = true)
        {
            if (!AlgoInitFlag)
            {
                return;
            }

            CogLeadResult _CogLeadResult  = new CogLeadResult();
            CogLeadAlgo   _CogLeadAlgoRcp = new CogLeadAlgo();

            _CogLeadAlgoRcp.ThresholdMin = Convert.ToInt32(graLabelThresholdValue.Text);
            _CogLeadAlgoRcp.BlobAreaMin  = Convert.ToDouble(textBoxBlobAreaMin.Text);
            _CogLeadAlgoRcp.BlobAreaMax  = Convert.ToDouble(textBoxBlobAreaMax.Text);
            _CogLeadAlgoRcp.WidthMin     = Convert.ToDouble(textBoxWidthSizeMin.Text);
            _CogLeadAlgoRcp.WidthMax     = Convert.ToDouble(textBoxWidthSizeMax.Text);
            _CogLeadAlgoRcp.HeightMin    = Convert.ToDouble(textBoxHeightSizeMin.Text);
            _CogLeadAlgoRcp.HeightMax    = Convert.ToDouble(textBoxHeightSizeMax.Text);
            _CogLeadAlgoRcp.ForeGround   = Convert.ToInt32(graLabelForeground.Text);

            var _ApplyLeadInspValueEvent = ApplyLeadInspValueEvent;

            if (_ApplyLeadInspValueEvent != null)
            {
                _ApplyLeadInspValueEvent(_CogLeadAlgoRcp, ref _CogLeadResult, _IsDisplay);
            }

            LeadPitchAverage = _CogLeadResult.LeadPitchAvg;
            LeadAngleAverage = _CogLeadResult.LeadAngleAvg;
            LeadCount        = _CogLeadResult.LeadCount;
        }
Esempio n. 2
0
        public InspectionLead()
        {
            BlobProc    = new CogBlob();
            BlobResults = new CogBlobResults();
            BlobResult  = new CogBlobResult();
            InspResults = new CogLeadResult();

            BlobProc.SegmentationParams.Mode               = CogBlobSegmentationModeConstants.HardFixedThreshold;
            BlobProc.SegmentationParams.Polarity           = CogBlobSegmentationPolarityConstants.LightBlobs;
            BlobProc.SegmentationParams.HardFixedThreshold = 100;
            BlobProc.ConnectivityMode      = CogBlobConnectivityModeConstants.GreyScale;
            BlobProc.ConnectivityCleanup   = CogBlobConnectivityCleanupConstants.Fill;
            BlobProc.ConnectivityMinPixels = 10;
        }
Esempio n. 3
0
        private void ApplyLeadInspValueFunction(CogLeadAlgo _CogLeadAlgo, ref CogLeadResult _CogLeadResult, bool _IsDisplay = true)
        {
            if (eTeachStep.ALGO_SET != CurrentTeachStep)
            {
                MessageBox.Show("Not select \"Algorithm Set\" button"); return;
            }
            if (_IsDisplay)
            {
                AlgorithmAreaDisplayRefresh();
            }

            bool _Result = InspLeadProcess.Run(InspectionImage, AlgoRegionRectangle, _CogLeadAlgo, ref _CogLeadResult);

            #region Result Display
            if (_IsDisplay)
            {
                for (int iLoopCount = 0; iLoopCount < _CogLeadResult.BlobCount; ++iLoopCount)
                {
                    //Blob Boundary
                    CogRectangleAffine _BlobRectAffine = new CogRectangleAffine();
                    _BlobRectAffine.SetCenterLengthsRotationSkew(_CogLeadResult.BlobCenterX[iLoopCount], _CogLeadResult.BlobCenterY[iLoopCount], _CogLeadResult.PrincipalWidth[iLoopCount], _CogLeadResult.PrincipalHeight[iLoopCount], _CogLeadResult.Angle[iLoopCount], 0);
                    kpTeachDisplay.DrawStaticShape(_BlobRectAffine, "BlobRectAffine" + (iLoopCount + 1), CogColorConstants.Green);
                    kpTeachDisplay.DrawBlobResult(_CogLeadResult.ResultGraphic[iLoopCount], "BlobRectGra" + (iLoopCount + 1));

                    CogLineSegment _CenterLine = new CogLineSegment();
                    kpTeachDisplay.DrawStaticLine(_CogLeadResult.BlobCenterX[iLoopCount], _CogLeadResult.BlobCenterY[iLoopCount], _CogLeadResult.PrincipalWidth[iLoopCount] / 2 + 20, _CogLeadResult.Angle[iLoopCount], 2, "CenterLine+_" + (iLoopCount + 1), CogColorConstants.Cyan);
                    kpTeachDisplay.DrawStaticLine(_CogLeadResult.BlobCenterX[iLoopCount], _CogLeadResult.BlobCenterY[iLoopCount], _CogLeadResult.PrincipalWidth[iLoopCount] / 2 + 20, (Math.PI) + _CogLeadResult.Angle[iLoopCount], 2, "CenterLine-_" + (iLoopCount + 1), CogColorConstants.Cyan);

                    CogPointMarker _PitchPoint = new CogPointMarker();
                    _PitchPoint.SetCenterRotationSize(_CogLeadResult.LeadPitchTopX[iLoopCount], _CogLeadResult.LeadPitchTopY[iLoopCount], 0, 1);
                    kpTeachDisplay.DrawStaticShape(_PitchPoint, "PointStart" + (iLoopCount + 1), CogColorConstants.Yellow, 2);
                    _PitchPoint.SetCenterRotationSize(_CogLeadResult.LeadPitchBottomX[iLoopCount], _CogLeadResult.LeadPitchBottomY[iLoopCount], 0, 1);
                    kpTeachDisplay.DrawStaticShape(_PitchPoint, "PointEnd" + (iLoopCount + 1), CogColorConstants.Orange, 2);
                }
            }
            #endregion Result Display

            #region Pitch Average 측정
            try
            {
                double[] _LeadPitchX = new double[_CogLeadResult.BlobCount];
                Array.Copy(_CogLeadResult.LeadPitchTopX, _LeadPitchX, _CogLeadResult.BlobCount);
                Array.Sort(_LeadPitchX);

                double[] _LeadPitches = new double[_CogLeadResult.BlobCount - 1];
                for (int iLoopCount = 0; iLoopCount < _CogLeadResult.BlobCount - 1; ++iLoopCount)
                {
                    _LeadPitches[iLoopCount] = _LeadPitchX[iLoopCount + 1] - _LeadPitchX[iLoopCount];
                }

                Array.Sort(_LeadPitches);
                double _Gab = _LeadPitches[4];
                int    _Index = 1;
                double _PitchSum = _LeadPitches[4], _PitchArray = 0;
                for (int iLoopCount = 5; iLoopCount < _CogLeadResult.BlobCount - 1; ++iLoopCount)
                {
                    if (_Gab + 20 < _LeadPitches[iLoopCount])
                    {
                        break;
                    }
                    _PitchSum += _LeadPitches[iLoopCount];
                    _Index++;
                }

                _PitchArray = _PitchSum / _Index;
                _CogLeadResult.LeadPitchAvg = _PitchArray;
            }

            catch
            {
                _CogLeadResult.LeadPitchAvg = 0;
                CLogManager.AddInspectionLog(CLogManager.LOG_TYPE.ERR, "ApplyLeadInspValueFunction Exception", CLogManager.LOG_LEVEL.LOW);
            }
            #endregion Pitch Average 측정

            #region Lead Angle Average 측정
            try
            {
                double[] _LeadAngles = new double[_CogLeadResult.BlobCount];
                Array.Copy(_CogLeadResult.Angle, _LeadAngles, _CogLeadResult.BlobCount);
                Array.Sort(_LeadAngles);

                int    _Index = 0;
                double _AngleSum = 0, _AngleAvg = 0;
                for (int iLoopCount = 5; iLoopCount < _CogLeadResult.BlobCount - 5; ++iLoopCount)
                {
                    _AngleSum += _CogLeadResult.Angle[iLoopCount];
                    _Index++;
                }
                _AngleAvg = _AngleSum / _Index;
                _CogLeadResult.LeadAngleAvg = _AngleAvg;
            }

            catch
            {
                _CogLeadResult.LeadAngleAvg = 0;
                CLogManager.AddInspectionLog(CLogManager.LOG_TYPE.ERR, "ApplyLeadInspValueFunction Exception", CLogManager.LOG_LEVEL.LOW);
            }
            #endregion Lead Angle Average 측정
        }
Esempio n. 4
0
        public bool Run(CogImage8Grey _SrcImage, CogRectangle _InspRegion, CogLeadAlgo _CogLeadAlgo, ref CogLeadResult _CogLeadResult, double _ReferX = -1, double _ReferY = -1)
        {
            bool _Result = true;

            SetHardFixedThreshold(_CogLeadAlgo.ThresholdMin);
            SetConnectivityMinimum((int)_CogLeadAlgo.BlobAreaMin);
            SetPolarity(Convert.ToBoolean(_CogLeadAlgo.ForeGround));

            if (true == Inspection(_SrcImage, _InspRegion))
            {
                GetResult(true);
            }

            if (GetResults().BlobCount > 0)
            {
                _CogLeadResult           = GetResults();
                _CogLeadResult.LeadCount = _CogLeadResult.BlobCount;

                #region Lead Pitch Point Get
                for (int iLoopCount = 0; iLoopCount < _CogLeadResult.BlobCount; ++iLoopCount)
                {
                    #region Lead Bent Check
                    double _Angle = _CogLeadResult.Angle[iLoopCount] * 180 / Math.PI;
                    if (_Angle > 0)
                    {
                        _Angle = 90 - (_CogLeadResult.Angle[iLoopCount] * 180 / Math.PI);
                    }
                    else
                    {
                        _Angle = -(90 + (_CogLeadResult.Angle[iLoopCount] * 180 / Math.PI));
                    }

                    _CogLeadResult.IsLeadBentGood[iLoopCount] = true;
                    if (_CogLeadAlgo.IsLeadBentInspection)
                    {
                        if ((_Angle > _CogLeadAlgo.LeadBentMax) || (_Angle < -_CogLeadAlgo.LeadBentMin))
                        {
                            _CogLeadResult.IsLeadBentGood[iLoopCount] = false;
                            _CogLeadResult.IsGood &= _CogLeadResult.IsLeadBentGood[iLoopCount];
                        }
                    }
                    #endregion Lead Bent Check

                    #region Pitch Point 구하기
                    if (_CogLeadResult.Angle[iLoopCount] > 0)
                    {
                        CogLineSegment _CenterLine = new CogLineSegment();
                        _CenterLine.SetStartLengthRotation(_CogLeadResult.BlobCenterX[iLoopCount], _CogLeadResult.BlobCenterY[iLoopCount], _CogLeadResult.PrincipalWidth[iLoopCount] / 2, (Math.PI) + _CogLeadResult.Angle[iLoopCount]);
                        _CogLeadResult.LeadPitchTopX[iLoopCount] = _CenterLine.EndX;
                        _CogLeadResult.LeadPitchTopY[iLoopCount] = _CenterLine.EndY;

                        _CenterLine.SetStartLengthRotation(_CogLeadResult.BlobCenterX[iLoopCount], _CogLeadResult.BlobCenterY[iLoopCount], _CogLeadResult.PrincipalWidth[iLoopCount] / 2, _CogLeadResult.Angle[iLoopCount]);
                        _CogLeadResult.LeadPitchBottomX[iLoopCount] = _CenterLine.EndX;
                        _CogLeadResult.LeadPitchBottomY[iLoopCount] = _CenterLine.EndY;
                    }

                    else
                    {
                        CogLineSegment _CenterLine = new CogLineSegment();
                        _CenterLine.SetStartLengthRotation(_CogLeadResult.BlobCenterX[iLoopCount], _CogLeadResult.BlobCenterY[iLoopCount], _CogLeadResult.PrincipalWidth[iLoopCount] / 2, _CogLeadResult.Angle[iLoopCount]);
                        _CogLeadResult.LeadPitchTopX[iLoopCount] = _CenterLine.EndX;
                        _CogLeadResult.LeadPitchTopY[iLoopCount] = _CenterLine.EndY;

                        _CenterLine.SetStartLengthRotation(_CogLeadResult.BlobCenterX[iLoopCount], _CogLeadResult.BlobCenterY[iLoopCount], _CogLeadResult.PrincipalWidth[iLoopCount] / 2, (Math.PI) + _CogLeadResult.Angle[iLoopCount]);
                        _CogLeadResult.LeadPitchBottomX[iLoopCount] = _CenterLine.EndX;
                        _CogLeadResult.LeadPitchBottomY[iLoopCount] = _CenterLine.EndY;
                    }
                    #endregion Pitch Point 구하기

                    #region Length 구하기
                    if (_ReferY != -1 && _ReferY != -1)
                    {
                        _CogLeadResult.LeadLength[iLoopCount]       = Math.Abs(_ReferY - _CogLeadResult.LeadPitchTopY[iLoopCount]);
                        _CogLeadResult.LeadLengthStartX[iLoopCount] = _CogLeadResult.LeadPitchTopX[iLoopCount];
                        _CogLeadResult.LeadLengthStartY[iLoopCount] = _ReferY;
                    }
                    #endregion Length 구하기
                }
                #endregion Lead Pitch Point Get

                #region Lead Length Get
                #endregion Lead Length Get

                _CogLeadResult.IsGood &= true;
            }

            else
            {
                _CogLeadResult.IsGood = false;
            }

            return(_Result);
        }