Kyungshin-Welder/AuroraVision/CogPattern/Blob/Blob.cs

/*
  * Copyright (c) 2025 LG Electronics Inc.
   * SPDX-License-Identifier: LicenseRef-LGE-Proprietary
   */
using Aurora.Api;
using CogCommon;
using VisionCommon;
using Hermes;
using Cognex.VisionPro;
using Cognex.VisionPro.Blob;
using System;
using System.IO;
using System.Drawing;
using VisionCommonUI;

namespace CogPattern {
    /// <summary>
    /// 패턴 Blob
    /// </summary>
    public class Blob : PatternBase, IPatternFinder, IDisposable {
        /// <summary>
        /// 패턴 파일 확장자
        /// </summary>
        public string FILE_EXT_PATTERN { get; set; } = "_Blob.vpp";
        private BlobParamExt _paramExt = null;

        private Logger _logger;
        private PatternInfo _patternInfo;
        private CogBlobTool _CogBlobTool;

        /// <summary>
        /// 생성자
        /// </summary>
        /// <param name="patternInfo">패턴 정보</param>
        public Blob(PatternInfo patternInfo) {
            _patternInfo = patternInfo;
            _logger = new Logger(
                $"Blob_{patternInfo.GetPatternIndex()}");
            InitContext();
        }

        private void InitContext() {
            if (E1.OK != Load()) {
                Create();
            }
        }

        /// <summary>
        /// 패턴 경로 가져오기
        /// </summary>
        /// <returns>패턴 경로</returns>
        public string GetPatternFilePath(string patternName = PatternConstants.FILE_NAME_PATTERN) {
            return Path.Combine(new string[] {
                PatternConstants.GetSubPatternDirPath(_patternInfo),
                patternName + FILE_EXT_PATTERN
            });
        }

        /// <summary>
        /// 패턴 불러오기
        /// </summary>
        /// <returns>성공 유무</returns>
        public int Load() {
            var patternFilePath = GetPatternFilePath();

            if (!File.Exists(patternFilePath)) {
                _logger.I($"Pattern File does NOT exist : {patternFilePath}");
                return E2.NOT_FOUND;
            }

            CogBlob.FreeTool(_CogBlobTool);
            _CogBlobTool = CogBlob.LoadTool(patternFilePath);
            _paramExt = LoadParamExt();

            return E1.OK;
        }

        /// <summary>
        /// 패턴 저장
        /// </summary>
        /// <returns>성공 유무</returns>
        public int Save() {
            var patternFilePath = GetPatternFilePath();
            var patternDirPath = Path.GetDirectoryName(patternFilePath);
            if (!Directory.Exists(patternDirPath)) {
                Directory.CreateDirectory(patternDirPath);
            }

            SaveParamExt(_paramExt);
            return CogBlob.SaveTool(_CogBlobTool, patternFilePath);
        }

        /// <summary>
        /// 패턴 생성
        /// </summary>
        /// <returns>성공 유무</returns>
        public int Create() {
            CogBlob.FreeTool(_CogBlobTool);
            _CogBlobTool = CogBlob.CreateTool();
            _paramExt = LoadParamExt();

            return E1.OK;
        }

        /// <summary>
        /// 패턴 제거
        /// </summary>
        /// <returns>성공 유무</returns>
        public int Remove() {
            CogBlob.FreeTool(_CogBlobTool);

            var patternFilePath = GetPatternFilePath();
            var patternDirPath = Path.GetDirectoryName(patternFilePath);
            if (Directory.Exists(patternDirPath)) {
                Directory.Delete(patternDirPath, recursive: true);
            }

            return E1.OK;
        }

        /// <summary>
        /// 패턴 찾기 영역 가져오기
        /// </summary>
        /// <returns>패턴 찾기 영역</returns>
        public ROI GetFindROI() {
            return CogBlob.GetFindROI(_CogBlobTool);
        }

        /// <summary>
        /// 패턴 찾기 영역 지정하기
        /// </summary>
        /// <param name="findRoi">패턴 찾기 영역</param>
        /// <returns>성공 유무</returns>
        public int SetFindROI(ROI findRoi) {
            if (ROI.IsNullOrEmpty(findRoi)) {
                return E1.GENERIC;
            }

            CogBlob.SetFindROI(_CogBlobTool, findRoi);
            return E1.OK;
        }

        /// <summary>
        /// 패턴 파라미터 가져오기
        /// </summary>
        /// <returns>패턴 파라미터</returns>
        public IRunParam GetRunParam() {
            return new BlobRunParam() {
                BlobParamExt = _paramExt.Clone() as BlobParamExt,
                ForegroundColor = GetForegroundColor(_CogBlobTool),
                FindROI = CogBlob.GetFindROI(_CogBlobTool)
            };
        }

        /// <summary>
        /// 타겟 컬러 가져오기
        /// </summary>
        /// <param name="cogBlobTool">Tool</param>
        /// <returns>기본 컬러</returns>
        private eForegroundColor GetForegroundColor(CogBlobTool cogBlobTool) {
            if (cogBlobTool.RunParams.SegmentationParams.Polarity == CogBlobSegmentationPolarityConstants.LightBlobs) {
                return eForegroundColor.White;
            }
            else {
                return eForegroundColor.Black;
            }
        }

        /// <summary>
        /// 패턴 파라미터 설정
        /// </summary>
        /// <param name="runParam">패턴 파라미터</param>
        /// <returns>성공 유무</returns>
        public int SetRunParam(IRunParam runParam) {
            _paramExt = ((BlobRunParam)runParam).BlobParamExt.Clone() as BlobParamExt;
            return CogBlob.SetRunParam(_CogBlobTool, runParam);
        }

        /// <summary>
        /// 패턴 찾기
        /// </summary>
        /// <param name="image">이미지</param>
        /// <returns>패턴 결과</returns>
        public PatternResult Find(object image) {
            var findRoi = CogBlob.GetFindROI(_CogBlobTool);
            return Find((ICogImage)image, findRoi);
        }

        /// <summary>
        /// 패턴 찾기
        /// </summary>
        /// <param name="image">이미지</param>
        /// <param name="findRoi">패턴 찾기 영역</param>
        /// <returns>패턴 결과</returns>
        public PatternResult Find(object image, ROI findRoi) {
            return CogBlob.Find(_CogBlobTool, (ICogImage)image, findRoi, _paramExt);
        }

        public PatternResult GetNotFoundPatternResult() {
            return CogBlob.GetNotFoundPatternResult();
        }

        /// <summary>
        /// 패턴 Tool 가져오기
        /// </summary>
        /// <returns>패턴 Tool</returns>
        public object GetTool() {
            return _CogBlobTool;
        }

        /// <summary>
        /// 패턴 결과 그리기
        /// </summary>
        /// <param name="patternResult">패턴 결과</param>
        /// <param name="cameraDisplay">카메라 디스플레이</param>
        /// <param name="isFixturePattern">픽스쳐 패턴 여부</param>
        public void Draw(
            PatternResult patternResult, ICameraDisplay cameraDisplay, bool isFixturePattern = false) {
            CogBlob.Draw(patternResult, cameraDisplay as ICogCameraDisplay);
        }

        /// <summary>
        /// 패턴 미리보기 가져오기
        /// </summary>
        /// <returns>패턴 미리보기</returns>
        public Bitmap GetThumbnail() {
            return ThumbnailImage.Blob();
        }

        #region IDisposible
        /// <summary>
        /// 자원 회수
        /// </summary>
        public void Dispose() {
            CogBlob.FreeTool(_CogBlobTool);
        }
        #endregion

        #region Blob Specific
        internal BlobParamExt LoadParamExt() {
            return BlobParamExt.Load(PatternConstants.GetSubPatternDirPath(_patternInfo));
        }

        internal int SaveParamExt(BlobParamExt blobParamExt) {
            return BlobParamExt.Save(
                PatternConstants.GetSubPatternDirPath(_patternInfo),
                blobParamExt);
        }
        #endregion
    }
}