513 lines
22 KiB
C#
513 lines
22 KiB
C#
using MilCommon;
|
|
using VisionCommon;
|
|
using Matrox.MatroxImagingLibrary;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using Hermes;
|
|
using System.IO;
|
|
using Newtonsoft.Json;
|
|
using System.Linq;
|
|
using System.Windows;
|
|
|
|
namespace MilPattern {
|
|
public class MilPatternAgent : PatternAgentBase {
|
|
/// <summary>
|
|
/// MIL 패턴 에이전트
|
|
/// </summary>
|
|
public MilPatternAgent(
|
|
FovInfo fovInfo) : base(fovInfo) {
|
|
|
|
LoadPatterns();
|
|
SetObservable();
|
|
}
|
|
|
|
private void SetObservable() {
|
|
var observable = VisionEventId.GetRecipeActivatedObservable();
|
|
observable.Subscribe(_ => LoadPatterns());
|
|
}
|
|
|
|
public override Dictionary<PatternInfo, IPatternFinder> GetPatterns() {
|
|
return _patterns;
|
|
}
|
|
|
|
#region Main Patterns
|
|
public override List<PatternInfo> GetMainPatterns(SubSysInfo subSysInfo, eFovId fovId) {
|
|
var fovIdxPrefix = PatternIndex.GetPrefix(subSysInfo.UnitId, subSysInfo.SubSysId, fovId);
|
|
return GetMainPatterns(fovIdxPrefix);
|
|
}
|
|
|
|
public override List<PatternInfo> GetMainPatterns(FovInfo fovInfo) {
|
|
var fovIdxPrefix = PatternIndex.GetPrefix(fovInfo.UnitId, fovInfo.SubSysId, fovInfo.FovId);
|
|
return GetMainPatterns(fovIdxPrefix);
|
|
}
|
|
#endregion
|
|
|
|
public override PatternInfo GetPatternInfo(FovInfo fovInfo, int patternId) {
|
|
return GetPatternInfo(
|
|
new PatternIndex(fovInfo.UnitId, fovInfo.SubSysId, fovInfo.FovId, patternId));
|
|
}
|
|
|
|
public override string GetPatternInfoPath() {
|
|
if (VisionSettingManager.VisionSetting.UseCamPattern) {
|
|
return VisionEnv.VisionRootDataPath;
|
|
}
|
|
else {
|
|
return PatternConstants.GetCurrentRecipeFilePath();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 패턴 가져오기
|
|
/// </summary>
|
|
/// <returns>패턴</returns>
|
|
public override int LoadPatterns() {
|
|
if (!MilEnvironment.Instance.HasValidLicense()) {
|
|
_logger.I("No MIL license");
|
|
return E1.GENERIC;
|
|
}
|
|
|
|
if (E1.OK != ClearPatterns(_patterns)) {
|
|
return E1.GENERIC;
|
|
}
|
|
if (E1.OK != LoadPatterns(_patterns)) {
|
|
return E1.GENERIC;
|
|
}
|
|
|
|
return E1.OK;
|
|
}
|
|
|
|
public override int CopyPattern(PatternIndex sourcePatternIndex, PatternIndex dstPatternIndex) {
|
|
// 1. Copy
|
|
string curRecipePath = GetPatternInfoPath();
|
|
string sourcePatternPath = Path.Combine(new string[] {
|
|
curRecipePath,
|
|
PatternConstants.DIR_NAME_PATTERN,
|
|
sourcePatternIndex.GetSubPatternDirectoryPath()
|
|
});
|
|
string dstPatternPath = Path.Combine(new string[] {
|
|
curRecipePath,
|
|
PatternConstants.DIR_NAME_PATTERN,
|
|
dstPatternIndex.GetSubPatternDirectoryPath()
|
|
});
|
|
|
|
// 2. Remove old dst pattern
|
|
if (E1.OK != Remove(dstPatternIndex)) {
|
|
_logger.FuncE($"Remove error");
|
|
return E1.GENERIC;
|
|
}
|
|
|
|
// 3. Copy pattern files
|
|
if (E1.OK != CopyPatternFiles(sourcePatternPath, dstPatternPath)) {
|
|
_logger.FuncE($"CopyPatternFiles error");
|
|
return E1.GENERIC;
|
|
}
|
|
|
|
// 4. Reload copied pattern files
|
|
var patternInfoFilePath = Path.Combine(dstPatternPath, PatternConstants.FILE_NAME_PATTERN_INFO);
|
|
if (!File.Exists(patternInfoFilePath)) {
|
|
_logger.FuncE($"patternInfoFilePath does NOT exist : {patternInfoFilePath}");
|
|
return E1.GENERIC;
|
|
}
|
|
|
|
var sourcePatternInfo = GetPatternInfo(sourcePatternIndex);
|
|
var dstPatternInfo = LoadPatternInfoFromFile(patternInfoFilePath);
|
|
dstPatternInfo.MilSystemId = sourcePatternInfo.MilSystemId;
|
|
dstPatternInfo.PatternIndex = dstPatternIndex.Clone() as PatternIndex;
|
|
|
|
return ReloadPattern(dstPatternInfo);
|
|
}
|
|
|
|
public override object GetTool(PatternInfo patternInfo) {
|
|
throw new NotImplementedException(); // 미사용
|
|
}
|
|
|
|
#region Find for Sequence
|
|
public override PatternResult FindPattern(
|
|
PatternInfo patternInfo, object image, ICameraDisplay cameraDisplay, FixtureResult fixtureResult) {
|
|
|
|
var findImage = (MIL_ID)image;
|
|
var patternResult = new PatternResult();
|
|
var pattern = _patterns[patternInfo];
|
|
|
|
if (((PatternBase)pattern).IsDirty()) {
|
|
((PatternBase)pattern).CleanDirty();
|
|
pattern.Load();
|
|
}
|
|
|
|
ROI fixtureRoi = GetFixtureROI(patternInfo, fixtureResult);
|
|
patternResult.FindRoi = fixtureRoi.Clone() as ROI;
|
|
|
|
if (!patternInfo.IsActivated) {
|
|
_logger.I($"{patternInfo} : NOT activated");
|
|
patternResult = pattern.GetNotFoundPatternResult();
|
|
}
|
|
else {
|
|
if (patternInfo.PreProcParam.Enabled()) {
|
|
MIL_ID preProcImage = MIL.M_NULL;
|
|
try {
|
|
preProcImage = ImgPreProcessor.GetPreProcessedImage(findImage, patternInfo.PreProcParam);
|
|
patternResult = Find(patternInfo, preProcImage, fixtureRoi);
|
|
CopyImageToDisplay(cameraDisplay as IMilCameraDisplay, preProcImage);
|
|
}
|
|
catch (Exception e) {
|
|
_logger.I($"{e.Message}");
|
|
}
|
|
finally {
|
|
MilEnvironment.FreeImage(preProcImage);
|
|
}
|
|
}
|
|
else {
|
|
patternResult = Find(patternInfo, findImage, fixtureRoi);
|
|
}
|
|
}
|
|
|
|
if (patternResult.Status == eFoundStatus.FoundOK) {
|
|
foreach (var reuslt in patternResult.Results) {
|
|
_logger.I($"{patternInfo} : {patternResult.Status} : {reuslt}");
|
|
}
|
|
}
|
|
else {
|
|
_logger.I($"{patternInfo} : {patternResult.Status}");
|
|
}
|
|
|
|
SetPatternParams(patternInfo, patternResult);
|
|
|
|
if (patternResult.PatternType == ePatternType.LineFinder) {
|
|
SetLineCenterPoint(patternResult, patternInfo, cameraDisplay);
|
|
}
|
|
|
|
return patternResult;
|
|
}
|
|
|
|
private void CopyImageToDisplay(IMilCameraDisplay milCameraDisplay, MIL_ID preProcImage) {
|
|
var displayImage = milCameraDisplay.GetImage();
|
|
if (MilEnvironment.ImageSizeEquals(preProcImage, displayImage)) {
|
|
MilEnvironment.CopyImage(preProcImage, displayImage);
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region TestFind for Pattern Registration
|
|
public override PatternResult FindPattern(PatternInfo patternInfo, object image, ROI findRoi = null) {
|
|
var findImage = (MIL_ID)image;
|
|
var patternResult = new PatternResult() {
|
|
PatternIndex = patternInfo.GetPatternIndex().Clone() as PatternIndex,
|
|
};
|
|
|
|
if (_patterns.ContainsKey(patternInfo)) {
|
|
if (patternInfo.IsActivated) {
|
|
var pattern = _patterns[patternInfo];
|
|
if (findRoi == null) {
|
|
patternResult = pattern.Find(findImage);
|
|
}
|
|
else {
|
|
patternResult = pattern.Find(findImage, findRoi);
|
|
}
|
|
|
|
patternResult.FindRoi = (findRoi != null) ? findRoi : GetFindROI(patternInfo);
|
|
}
|
|
else {
|
|
_logger.I($"Pattern is not activated.");
|
|
}
|
|
}
|
|
else {
|
|
_logger.I($"Pattern does not exist.");
|
|
}
|
|
#if TEST_DEBUG
|
|
Logger.W("TEST", $"[TEST] FindROI LEFTTOP : {patternResult.FindRoi.LeftTop.ToString()}, {patternResult.FindRoi.Center.ToString()}");
|
|
Logger.W("TEST", $"[TEST] FindROI WH : ({patternResult.FindRoi.Width}, {patternResult.FindRoi.Height}),({patternResult.FindRoi.Width/2}, {patternResult.FindRoi.Height/2})");
|
|
Logger.E("TEST", $"[TEST] Result : {patternResult.Results.FirstOrDefault()?.ImagePosition.X:F8}, {patternResult.Results.FirstOrDefault()?.ImagePosition.Y:F8}");
|
|
if(patternResult.Results.Count() >0 && patternResult.Results.FirstOrDefault() is ModelFinderResult modelFinderResult) {
|
|
Logger.E("TEST", $"[TEST] Result Score : {modelFinderResult.Score:F8}");
|
|
}
|
|
#endif
|
|
SetPatternParams(patternInfo, patternResult);
|
|
|
|
return patternResult;
|
|
}
|
|
|
|
public override PatternResult FindPatternBlock(PatternInfo patternInfo, object image, ROI findRoi = null) {
|
|
var findImage = (MIL_ID)image;
|
|
var patternResult = new PatternResult() {
|
|
PatternIndex = patternInfo.GetPatternIndex().Clone() as PatternIndex,
|
|
};
|
|
|
|
if (_patterns.ContainsKey(patternInfo)) {
|
|
if (patternInfo.IsActivated) {
|
|
var pattern = _patterns[patternInfo];
|
|
var patternBlock = pattern as IPatternBlock;
|
|
var patternBlockResults = new List<PatternResult>();
|
|
foreach (var patternId in patternBlock.GetPatternBlockIds()) {
|
|
var curPatternIndex = patternInfo.GetPatternIndex().Clone() as PatternIndex;
|
|
curPatternIndex.PatternId = patternId;
|
|
var patterBlockPatternInfo = GetPatternInfo(curPatternIndex);
|
|
var curPattern = GetPattern(patterBlockPatternInfo);
|
|
PatternResult curPatternResult;
|
|
if (findRoi == null) {
|
|
curPatternResult = curPattern.Find(findImage);
|
|
}
|
|
else {
|
|
curPatternResult = curPattern.Find(findImage, findRoi);
|
|
}
|
|
|
|
curPatternResult.FindRoi = (findRoi != null) ? findRoi : GetFindROI(patterBlockPatternInfo);
|
|
SetPatternParams(patterBlockPatternInfo, curPatternResult);
|
|
patternBlockResults.Add(curPatternResult);
|
|
}
|
|
patternResult = patternBlock.Find(patternBlockResults);
|
|
patternResult.FindRoi = (findRoi != null) ? findRoi : GetFindROI(patternInfo);
|
|
}
|
|
else {
|
|
_logger.I($"Pattern is not activated.");
|
|
}
|
|
}
|
|
else {
|
|
_logger.I($"Pattern does not exist.");
|
|
}
|
|
|
|
SetPatternParams(patternInfo, patternResult);
|
|
|
|
return patternResult;
|
|
}
|
|
#endregion
|
|
|
|
public override void Draw(
|
|
PatternInfo patternInfo, PatternResult patternResult, ICameraDisplay cameraDisplay, bool isFixturePattern = false) {
|
|
// Draw 택타임이 길어 비동기식으로 변경함.
|
|
Application.Current.Dispatcher.BeginInvoke(
|
|
new Action(() => {
|
|
if (_patterns.ContainsKey(patternInfo)) {
|
|
var milCameraDisplay = cameraDisplay as IMilCameraDisplay;
|
|
IPatternFinder pattern;
|
|
if (patternResult.Status != eFoundStatus.NotFound &&
|
|
patternResult.PatternIndex != null) {
|
|
pattern = GetPattern(patternResult.PatternIndex);
|
|
}
|
|
else {
|
|
pattern = _patterns[patternInfo];
|
|
}
|
|
|
|
if (PatternConstants.IsPatternBlock(patternInfo.PatternType)) {
|
|
DrawPatternBlockResult(pattern, patternResult, milCameraDisplay, isFixturePattern);
|
|
}
|
|
else {
|
|
DrawPatternResult(pattern, patternResult, milCameraDisplay, isFixturePattern);
|
|
}
|
|
}
|
|
}));
|
|
}
|
|
|
|
private void DrawPatternResult(
|
|
IPatternFinder pattern, PatternResult patternResult, IMilCameraDisplay milCameraDisplay, bool isFixturePattern) {
|
|
DrawFindROI(patternResult, milCameraDisplay, isFixturePattern);
|
|
pattern.Draw(patternResult, milCameraDisplay, isFixturePattern);
|
|
}
|
|
|
|
private void DrawPatternBlockResult(
|
|
IPatternFinder pattern, PatternResult patternResult, IMilCameraDisplay milCameraDisplay, bool isFixturePattern) {
|
|
foreach (var patternBlockResult in patternResult.Results) {
|
|
PatternResult line1PatternResult = null;
|
|
PatternResult line2PatternResult = null;
|
|
|
|
if (patternBlockResult.GetType() == typeof(LineIntersectionResult)) {
|
|
var intersectionResult = patternBlockResult as LineIntersectionResult;
|
|
line1PatternResult = intersectionResult.Line1PatternResult;
|
|
line2PatternResult = intersectionResult.Line2PatternResult;
|
|
}
|
|
else if (patternBlockResult.GetType() == typeof(CaliperResult)) {
|
|
var caliperResult = patternBlockResult as CaliperResult;
|
|
line1PatternResult = caliperResult.PatternResultFirst;
|
|
line2PatternResult = caliperResult.PatternResultSecond;
|
|
}
|
|
|
|
DrawFindROI(line1PatternResult, milCameraDisplay, isFixturePattern);
|
|
DrawFindROI(line2PatternResult, milCameraDisplay, isFixturePattern);
|
|
pattern.Draw(patternResult, milCameraDisplay, isFixturePattern);
|
|
}
|
|
}
|
|
|
|
private void DrawFindROI(
|
|
PatternResult patternResult, IMilCameraDisplay milCameraDisplay, bool isFixturePattern) {
|
|
MIL_INT color = MIL.M_NULL;
|
|
if (patternResult == null) {
|
|
return;
|
|
}
|
|
if (patternResult.PatternType == ePatternType.Brightness && patternResult.Status == eFoundStatus.FoundOK) {
|
|
color = ColorConverter.ConvertColor(eColor.Magenta);
|
|
}
|
|
else if (patternResult.PatternType == ePatternType.MultiLineFinder) {
|
|
foreach (LineFinderResult lineFinderResult in patternResult.Results) {
|
|
color = GraphicColors.GetFindRoiColor(lineFinderResult.Status, isFixturePattern);
|
|
milCameraDisplay.AddPatternResultFindRoi(color, lineFinderResult.FindRoi);
|
|
}
|
|
return;
|
|
}
|
|
else if (patternResult.PatternType == ePatternType.MultiOcr) {
|
|
foreach (OcrResult ocrResult in patternResult.Results) {
|
|
color = GraphicColors.GetFindRoiColor(ocrResult.Status, isFixturePattern);
|
|
milCameraDisplay.AddPatternResultFindRoi(color, ocrResult.FindRoi);
|
|
}
|
|
return;
|
|
}
|
|
else {
|
|
color = GraphicColors.GetFindRoiColor(patternResult.Status, isFixturePattern);
|
|
}
|
|
milCameraDisplay.AddPatternResultFindRoi(color, patternResult.FindRoi);
|
|
}
|
|
|
|
public override IPatternFinder CreatePattern(PatternInfo patternInfo) {
|
|
switch (patternInfo.PatternType) {
|
|
case ePatternType.ImageModelFinder:
|
|
return new ImageModelFinder(patternInfo);
|
|
case ePatternType.ShapeModelFinder:
|
|
return new ShapeModelFinder(patternInfo);
|
|
case ePatternType.PatternMatching:
|
|
return new PatternMatching(patternInfo);
|
|
case ePatternType.LineFinder:
|
|
case ePatternType.MultiLineFinder:
|
|
return new LineFinder(patternInfo);
|
|
case ePatternType.Caliper:
|
|
return new Caliper(patternInfo);
|
|
case ePatternType.EdgeFinder:
|
|
return new EdgeFinder(patternInfo);
|
|
case ePatternType.Blob:
|
|
return new Blob(patternInfo);
|
|
case ePatternType.Code:
|
|
return new Code(patternInfo);
|
|
case ePatternType.Ocr:
|
|
case ePatternType.MultiOcr:
|
|
return new OcrFinder(patternInfo);
|
|
case ePatternType.Brightness:
|
|
return new Brightness(patternInfo);
|
|
case ePatternType.LineIntersection:
|
|
return new LineIntersection(patternInfo);
|
|
case ePatternType.LineWidth:
|
|
return new LineWidth(patternInfo);
|
|
case ePatternType.MachinePattern_A:
|
|
case ePatternType.MachinePattern_B:
|
|
case ePatternType.MachinePattern_C:
|
|
return EquipAdapter.Instance.MachinePatternManager.GetPattern(patternInfo);
|
|
}
|
|
|
|
_logger.E($"No matching of PatternType : {patternInfo.PatternType}");
|
|
return null;
|
|
}
|
|
|
|
public override List<PatternInfo> GetPatternInfoListFromFiles(string curRecipePath) {
|
|
var patternInfoList = new List<PatternInfo>();
|
|
var camRecipe = VisionRecipeManager.GetCamRecipe(_fovInfo);
|
|
var patternCount = 0;
|
|
if (VisionSettingManager.VisionSetting.UseCamPattern) {
|
|
patternCount = PatternConstants.CAM_PATTERN_COUNT;
|
|
}
|
|
else {
|
|
patternCount = PatternConstants.FOV_PATTERN_COUNT;
|
|
}
|
|
|
|
for (int patternId = 0; patternId < patternCount; patternId++) {
|
|
string patternDirPath;
|
|
if (VisionSettingManager.VisionSetting.UseCamPattern) {
|
|
patternDirPath = Path.Combine(
|
|
curRecipePath,
|
|
PatternConstants.DIR_NAME_PATTERN,
|
|
((int)_camId).ToString(),
|
|
patternId.ToString());
|
|
}
|
|
else {
|
|
patternDirPath = Path.Combine(
|
|
curRecipePath,
|
|
PatternConstants.DIR_NAME_PATTERN,
|
|
((int)_fovInfo.UnitId).ToString(),
|
|
((int)_fovInfo.SubSysId).ToString(),
|
|
((int)_fovInfo.FovId).ToString(),
|
|
patternId.ToString());
|
|
}
|
|
|
|
if (Directory.Exists(patternDirPath)) {
|
|
var patternDirPathList = Directory.GetDirectories(patternDirPath, "??", SearchOption.TopDirectoryOnly);
|
|
|
|
foreach (var subPatternDirPath in patternDirPathList) {
|
|
if (Directory.Exists(subPatternDirPath)) {
|
|
var patternInfoFilePath = Path.Combine(subPatternDirPath, PatternConstants.FILE_NAME_PATTERN_INFO);
|
|
|
|
if (File.Exists(patternInfoFilePath)) {
|
|
var patternInfo = LoadPatternInfoFromFile(patternInfoFilePath);
|
|
patternInfo.MilSystemId = GetMilSystemId(camRecipe.CamId);
|
|
patternInfo.PatternIndex = new PatternIndex(
|
|
_fovInfo.UnitId, _fovInfo.SubSysId, _fovInfo.FovName, _fovInfo.FovId,
|
|
patternId, Convert.ToInt32(Path.GetFileName(subPatternDirPath)));
|
|
patternInfoList.Add(patternInfo);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return patternInfoList;
|
|
}
|
|
|
|
private PatternInfo LoadPatternInfoFromFile(string filePath) {
|
|
return JsonConvert.DeserializeObject(
|
|
File.ReadAllText(filePath), typeof(PatternInfo)) as PatternInfo;
|
|
}
|
|
|
|
public override int GetMilSystemId(eCamId camId) {
|
|
var camConfig = VisionEnv.AuroraEnv.DeviceManager.GetDeviceConfig(camId.ToString()) as CamConfig;
|
|
if (camConfig != null) {
|
|
return (int)MilEnvironment.Instance.GetSystem(camConfig.CamConnConfig.BoardType, camConfig.CamConnConfig.BoardSlotPos);
|
|
}
|
|
else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
private Dictionary<T, U> SortDictionary<T, U>(Dictionary<T, U> dict) {
|
|
return dict.OrderBy(item => item.Key).ToDictionary(x => x.Key, x => x.Value);
|
|
}
|
|
|
|
public override int GetFindNumber(PatternInfo patternInfo) {
|
|
if (patternInfo.PatternType == ePatternType.ImageModelFinder) {
|
|
ImageModelFinder imageModelFinder = new ImageModelFinder(patternInfo);
|
|
return (imageModelFinder.GetFindNumber());
|
|
}
|
|
else if (patternInfo.PatternType == ePatternType.ShapeModelFinder) {
|
|
ShapeModelFinder shapeModelFinder = new ShapeModelFinder(patternInfo);
|
|
return (shapeModelFinder.GetFindNumber());
|
|
}
|
|
else if (patternInfo.PatternType == ePatternType.PatternMatching) {
|
|
PatternMatching patternMatching = new PatternMatching(patternInfo);
|
|
return (patternMatching.GetFindNumber());
|
|
}
|
|
else {
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
public override bool IsTrainPattern(PatternInfo patternInfo) {
|
|
var pattern = GetPattern(patternInfo);
|
|
if (pattern is IPatternTrain) {
|
|
return true;
|
|
}
|
|
else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public override bool IsDeletable(PatternInfo patternInfo, int patternIndex) {
|
|
if (patternInfo.PatternType == ePatternType.LineIntersection) {
|
|
var runparam = GetRunParam(patternInfo) as LineIntersectionRunParam;
|
|
if (runparam.PatternId1 == patternIndex || runparam.PatternId2 == patternIndex) {
|
|
return false;
|
|
}
|
|
}
|
|
else if (patternInfo.PatternType == ePatternType.LineWidth) {
|
|
var runparam = GetRunParam(patternInfo) as LineWidthRunParam;
|
|
if (runparam.PatternId1 == patternIndex || runparam.PatternId2 == patternIndex) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
}
|