522 lines
22 KiB
C#
522 lines
22 KiB
C#
using Aurora.Api;
|
|
using VisionCommon;
|
|
using VisionAligner;
|
|
using VisionCalibrator;
|
|
using VisionSequence.Pattern;
|
|
using VisionSequence.Camera;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
|
|
namespace VisionSequence.Aligner {
|
|
/// <summary>
|
|
/// C1_F1_SPN_AN 얼라인 시퀀스 파라미터
|
|
/// </summary>
|
|
public class AlignSeqParams_C1_F1_SPN_AN : SeqParamsBase {
|
|
/// <summary>얼라인 키 정보</summary>
|
|
public AlignInfo AlignInfo { get; set; }
|
|
/// <summary>얼라인 레퍼런스 위치</summary>
|
|
public Dictionary<int, StaticPoint> ReferenceResults { get; set; }
|
|
/// <summary>얼라인 레퍼런스 정보</summary>
|
|
public RefDistParam RefDistParam { get; set; }
|
|
/// <summary>그랩 이미지 (Optional)</summary>
|
|
public object GrabImage { get; set; }
|
|
/// <summary>메인 화면 타입</summary>
|
|
public eDisplayType DisplayType { get; set; }
|
|
|
|
/// <summary>
|
|
/// C1_F1_SPN_AN 얼라인 시퀀스 파라미터를 얻어온다.
|
|
/// </summary>
|
|
/// <param name="alignInfo">얼라인 키 정보</param>
|
|
/// <param name="referenceResults">얼라인 레퍼런스 위치</param>
|
|
/// <param name="grabImage">그랩 이미지 (Optional)</param>
|
|
/// <param name="refDistParam">센터로부터 각 패턴의 정위치까지 떨어진 거리 파라미터</param>
|
|
/// <param name="displayType">메인 화면 타입</param>
|
|
/// <param name="seqMode">시퀀스 모드</param>
|
|
public AlignSeqParams_C1_F1_SPN_AN(
|
|
AlignInfo alignInfo,
|
|
Dictionary<int, StaticPoint> referenceResults,
|
|
RefDistParam refDistParam,
|
|
object grabImage = null,
|
|
eDisplayType displayType = eDisplayType.Main_1,
|
|
eSeqMode seqMode = eSeqMode.Auto) : base(seqMode) {
|
|
|
|
this.AlignInfo = alignInfo;
|
|
this.ReferenceResults = referenceResults;
|
|
this.RefDistParam = refDistParam;
|
|
this.GrabImage = grabImage;
|
|
this.DisplayType = displayType;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// CAM 1대 / FOV 1개 / 패턴 1개 / 얼라인 N개 / 1 Point Align N개 / MeasurePattern to (Center + Target Offset)
|
|
/// </summary>
|
|
public class AlignSeq_C1_F1_SPN_AN : SubSeqBase {
|
|
private readonly Logger LOG = new Logger(typeof(AlignSeq_C1_F1_SPN_AN).Name);
|
|
|
|
private AlignSeqParams_C1_F1_SPN_AN _Params;
|
|
private FovInfo _FovInfo;
|
|
private AlignRecipe _AlignRecipe;
|
|
private SubSysInfo _SubSysInfo;
|
|
private PatternAgentBase _PatternAgent;
|
|
private VisionAligner.Aligner _Aligner;
|
|
private Calibrator _Calibrator;
|
|
private CameraAgentBase _CameraAgent;
|
|
private ICameraDisplay _CameraDisplay;
|
|
|
|
private CsvManager _CsvManager = new CsvManager();
|
|
private ImageManager _ImageManager = new ImageManager();
|
|
|
|
private Dictionary<int, PatternResult> _MeasurePatternResults = new Dictionary<int, PatternResult>();
|
|
private Dictionary<int, BaseResult> _MeasureResults = new Dictionary<int, BaseResult>();
|
|
private Dictionary<int, AlignResult> _AlignResults = new Dictionary<int, AlignResult>();
|
|
private List<int> _PatternIndex = new List<int>();
|
|
|
|
private string _SeqName;
|
|
private int _FindNumber = 0;
|
|
|
|
#region Sequence Id
|
|
private const string SEQ_ID_INIT = "INIT";
|
|
private const string SEQ_ID_CLEAR = "CLEAR";
|
|
|
|
private const string SEQ_ID_SET_FIXTURE = "SET_FIXTURE";
|
|
|
|
private const string SEQ_ID_FIND = "FIND";
|
|
private const string SEQ_ID_CHECK_FOUND = "CHECK_FOUND";
|
|
private const string SEQ_ID_ALIGN = "ALIGN";
|
|
private const string SEQ_ID_ALIGN_EXIT = "ALIGN_EXIT";
|
|
|
|
private const string SEQ_ID_UPDATE_UI = "UPDATE_UI";
|
|
private const string SEQ_ID_SEQ_COMPLETE = "SEQ_COMPLETE";
|
|
#endregion
|
|
|
|
/// <summary>
|
|
/// 생성자
|
|
/// </summary>
|
|
public AlignSeq_C1_F1_SPN_AN() {
|
|
}
|
|
|
|
private void SetActions(SequenceBuilder sb) {
|
|
var grabSeqBuilder = SubSeqManager.CreateSubSeqBuilder(new GrabSeq(), typeof(GrabSeq).Name);
|
|
|
|
sb.AddAction(SEQ_ID_INIT, Init);
|
|
sb.AddAction(SEQ_ID_CLEAR, Clear);
|
|
|
|
sb.AddAction(SEQ_ID_SET_FIXTURE, SetFixture);
|
|
|
|
sb.AddAction(SEQ_ID_FIND, Find);
|
|
sb.AddDecision(SEQ_ID_CHECK_FOUND, CheckFound);
|
|
sb.AddAction(SEQ_ID_ALIGN, Align);
|
|
sb.AddAction(SEQ_ID_ALIGN_EXIT, AlignExit);
|
|
|
|
sb.AddAction(SEQ_ID_UPDATE_UI, UpdateUI);
|
|
sb.AddAction(SEQ_ID_SEQ_COMPLETE, SeqComplete);
|
|
}
|
|
|
|
public override SequenceBuilder Builder(string seqName) {
|
|
_SeqName = seqName;
|
|
|
|
SequenceBuilder sb = new SequenceBuilder(1000);
|
|
SetActions(sb);
|
|
sb.OnStopped(OnStopped);
|
|
sb.OnForceError(OnForceError);
|
|
|
|
sb.Flows(
|
|
sb.Init
|
|
> sb[SEQ_ID_INIT]
|
|
> sb[SEQ_ID_CLEAR]
|
|
|
|
> sb[SEQ_ID_SET_FIXTURE]
|
|
|
|
> sb[SEQ_ID_FIND]
|
|
> sb[SEQ_ID_CHECK_FOUND]
|
|
> sb[SEQ_ID_ALIGN]
|
|
> sb[SEQ_ID_ALIGN_EXIT]
|
|
|
|
> sb[SEQ_ID_UPDATE_UI]
|
|
> sb[SEQ_ID_SEQ_COMPLETE]
|
|
);
|
|
sb.Flows(
|
|
sb[SEQ_ID_CHECK_FOUND] // Measure NG
|
|
> sb[SEQ_ID_ALIGN_EXIT]
|
|
);
|
|
sb.Flows(
|
|
sb[SEQ_ID_SEQ_COMPLETE]
|
|
> sb.Final
|
|
);
|
|
|
|
#if SEQ_DRAW
|
|
sb.Draw($"{GetType().Name}.pdf");
|
|
#endif
|
|
|
|
return sb;
|
|
}
|
|
|
|
private SequenceActionResult Init(
|
|
SequenceContext context,
|
|
string id,
|
|
SequenceActionResult param) {
|
|
|
|
if (param.Param != null) {
|
|
_Params = param.Param as AlignSeqParams_C1_F1_SPN_AN;
|
|
}
|
|
else {
|
|
LOG.E($"Param is null.");
|
|
return null;
|
|
}
|
|
|
|
_AlignRecipe = VisionRecipeManager.GetAlignRecipe(_Params.AlignInfo);
|
|
_SubSysInfo = VisionRecipeManager.GetSubSysInfo(_Params.AlignInfo.UnitId, _Params.AlignInfo.SubSysId);
|
|
_FovInfo = VisionRecipeManager.GetFovInfo(_SubSysInfo, eFovId.Fov1);
|
|
_PatternAgent = FovPatternAgentManager.GetAgent(_SubSysInfo);
|
|
_Aligner = AlignAgentManager.GetAlignAgent(_Params.AlignInfo);
|
|
_Calibrator = CalibratorManager.GetCalibrator(_FovInfo);
|
|
_CameraAgent = CameraAgentManager.GetCameraAgent(_FovInfo);
|
|
_CameraDisplay = CameraDisplayManager.GetDisplay(_FovInfo, _Params.DisplayType);
|
|
_VisionLog = new Logger(_SubSysInfo.SubSysName, VisionKeys.LogKey);
|
|
|
|
if (!InitProcData()) {
|
|
return SequenceAction.Error();
|
|
}
|
|
|
|
return SequenceAction.Ok();
|
|
}
|
|
|
|
private bool InitProcData() {
|
|
var procPatternInfo = VisionRecipeManager.GetProcPatternInfo(_FovInfo, _AlignRecipe.AlignId.ToString(), eProcPatternId.ProcPattern1);
|
|
|
|
//PatternInfo 에서 FindNumber를 가져온다.
|
|
var patternInfo = GetPatternInfo(_Params.AlignInfo, _FovInfo, procPatternInfo);
|
|
_FindNumber = _PatternAgent.GetFindNumber(patternInfo);
|
|
|
|
//PatternInfo의 FindNumber와 RefDist의 수가 다른 경우 AlignSeq를 멈춘다.
|
|
if (_FindNumber != _Params.RefDistParam.RefDists.Count) {
|
|
return false;
|
|
}
|
|
|
|
for (int patternPosIdx = 0; patternPosIdx < _Params.RefDistParam.RefDists.Count; patternPosIdx++) {
|
|
if (!_MeasurePatternResults.ContainsKey(patternPosIdx)) {
|
|
_MeasurePatternResults.Add(patternPosIdx, null);
|
|
}
|
|
else {
|
|
_MeasurePatternResults[patternPosIdx] = null;
|
|
}
|
|
|
|
if (!_AlignResults.ContainsKey(patternPosIdx)) {
|
|
_AlignResults.Add(patternPosIdx, null);
|
|
}
|
|
else {
|
|
_AlignResults[patternPosIdx] = null;
|
|
}
|
|
|
|
if (!_MeasureResults.ContainsKey(patternPosIdx)) {
|
|
_MeasureResults.Add(patternPosIdx, null);
|
|
}
|
|
else {
|
|
_MeasureResults[patternPosIdx] = null;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
private SequenceActionResult Clear(
|
|
SequenceContext context,
|
|
string id,
|
|
SequenceActionResult param) {
|
|
|
|
return SequenceAction.Ok();
|
|
}
|
|
|
|
private SequenceActionResult SetFixture(
|
|
SequenceContext context,
|
|
string id,
|
|
SequenceActionResult param) {
|
|
|
|
var procPatternInfo = VisionRecipeManager.GetProcPatternInfo(_FovInfo, _AlignRecipe.AlignId.ToString(), eProcPatternId.ProcPattern1);
|
|
|
|
var patternInfo = GetPatternInfo(_Params.AlignInfo, _FovInfo, procPatternInfo);
|
|
|
|
PatternIndex fixturePatternIndex = null;
|
|
if (patternInfo.FixtureSetting.Enabled) {
|
|
fixturePatternIndex = FixtureSetting.GetFixturePatternIndex(patternInfo.GetPatternIndex(), patternInfo.FixtureSetting.Pattern1);
|
|
}
|
|
|
|
PatternResult fixturePatternResult = null;
|
|
if (fixturePatternIndex != null) {
|
|
var fixturePatternInfo = _PatternAgent.GetPatternInfo(fixturePatternIndex);
|
|
fixturePatternResult = _PatternAgent.Find(fixturePatternInfo, _Params.GrabImage, _CameraDisplay);
|
|
GrabFindSeqUtil.TransformCoord(_Calibrator, _CameraAgent.GetImageSize(), ref fixturePatternResult);
|
|
_PatternAgent.Draw(fixturePatternInfo, fixturePatternResult, _CameraDisplay, isFixturePattern: true);
|
|
}
|
|
|
|
return SequenceAction.Ok(fixturePatternResult);
|
|
}
|
|
|
|
private SequenceActionResult Find(
|
|
SequenceContext context,
|
|
string id,
|
|
SequenceActionResult param) {
|
|
|
|
ProcPatternInfo procPatternInfo = null;
|
|
procPatternInfo = VisionRecipeManager.GetProcPatternInfo(_FovInfo, _AlignRecipe.AlignId.ToString(), eProcPatternId.ProcPattern1);
|
|
|
|
var patternInfo = GetPatternInfo(_Params.AlignInfo, _FovInfo, procPatternInfo);
|
|
PatternResult patternResult = null;
|
|
|
|
if (patternInfo.FixtureSetting.Enabled) {
|
|
var fixturePatternResult = param.Param as PatternResult;
|
|
var fixtureResult = fixturePatternResult.MoreInfo as FixtureResult;
|
|
patternResult = _PatternAgent.Find(patternInfo, _Params.GrabImage, _CameraDisplay, fixtureResult);
|
|
GrabFindSeqUtil.TransformCoord(_Calibrator, _CameraAgent.GetImageSize(), ref patternResult);
|
|
_PatternAgent.Draw(patternInfo, patternResult, _CameraDisplay);
|
|
}
|
|
else {
|
|
patternResult = _PatternAgent.Find(patternInfo, _Params.GrabImage, _CameraDisplay);
|
|
GrabFindSeqUtil.TransformCoord(_Calibrator, _CameraAgent.GetImageSize(), ref patternResult);
|
|
_PatternAgent.Draw(patternInfo, patternResult, _CameraDisplay, isFixturePattern: false);
|
|
}
|
|
|
|
patternResult.PatternName = patternInfo.PatternName;
|
|
patternResult.PatternType = patternInfo.PatternType;
|
|
patternResult.FovId = _FovInfo.FovId;
|
|
|
|
return SequenceAction.Ok(patternResult);
|
|
}
|
|
|
|
private string CheckFound(
|
|
SequenceContext context,
|
|
string id,
|
|
ICollection<string> branches,
|
|
SequenceActionResult param) {
|
|
|
|
var patternResult = param.Param as PatternResult;
|
|
SetMeasurePatterResults(id, patternResult);
|
|
|
|
if (patternResult.Status == eFoundStatus.FoundOK || patternResult.Status == eFoundStatus.ForceOK) {
|
|
return SEQ_ID_ALIGN;
|
|
}
|
|
else {
|
|
// Mark NG
|
|
var alignResult = new AlignResult() {
|
|
Status = AlignStatus.NOT_FOUND,
|
|
Delta = new AlignDelta(),
|
|
AlignAlgorithm = _AlignRecipe.ProcParams.AlignAlgorithm,
|
|
};
|
|
|
|
for (int i = 0; i < _Params.RefDistParam.RefDists.Count; i++) {
|
|
alignResult.AlignName = $"Align{i}";
|
|
_AlignResults[i] = alignResult;
|
|
}
|
|
|
|
return SEQ_ID_ALIGN_EXIT;
|
|
}
|
|
}
|
|
|
|
private void SetMeasurePatterResults(string id, PatternResult patternResult) {
|
|
if (id == SEQ_ID_CHECK_FOUND) {
|
|
var fovRecipe = VisionRecipeManager.GetFovRecipe(_FovInfo);
|
|
List<StaticPoint> refDists = new List<StaticPoint>();
|
|
for (int i = 0; i < _Params.RefDistParam.RefDists.Count; i++) {
|
|
//refDist와 FovCenter 사이의 거리를 저장하여 FovCenter가 원점이 아닐 경우에도 계산이 되도록 한다.
|
|
var refPoint = new StaticPoint(_Params.RefDistParam.RefDists[i].DistX, _Params.RefDistParam.RefDists[i].DistY) + fovRecipe.CalFovRecipe.FovCenter;
|
|
refDists.Add(new StaticPoint(refPoint.X, refPoint.Y));
|
|
}
|
|
List<StaticPoint> patternPoints = new List<StaticPoint>();
|
|
var baseResults = patternResult.Results.ToList();
|
|
foreach (var result in baseResults) {
|
|
StaticPoint staticResult = result.MaterialPosition;
|
|
patternPoints.Add(staticResult);
|
|
}
|
|
_PatternIndex = PatternUtil.GetNearestPointIndex(patternPoints, refDists, _Params.RefDistParam.DistanceTolerance);
|
|
|
|
//Pattern의 Index가 나온 경우 Index에 맞게 PatternResult를 MeasurePatternResults에 저장한다.
|
|
for (int i = 0; i < _PatternIndex.Count; i++) {
|
|
if (_PatternIndex[i] != -1) {
|
|
_MeasureResults[_PatternIndex[i]] = baseResults[i];
|
|
|
|
List<BaseResult> newResults = new List<BaseResult>();
|
|
newResults.Add(baseResults[i]);
|
|
|
|
PatternResult newPatternResult = new PatternResult() {
|
|
PatternIndex = patternResult.PatternIndex.Clone() as PatternIndex,
|
|
PatternType = patternResult.PatternType,
|
|
PatternName = patternResult.PatternName,
|
|
Status = patternResult.Status,
|
|
Results = newResults,
|
|
FindRoi = patternResult.FindRoi.Clone() as ROI,
|
|
TactTimeInMilliSec = patternResult.TactTimeInMilliSec,
|
|
MoreInfo = patternResult.MoreInfo,
|
|
FovId = patternResult.FovId,
|
|
};
|
|
|
|
_MeasurePatternResults[_PatternIndex[i]] = newPatternResult;
|
|
}
|
|
}
|
|
|
|
//Pattern의 Index가 나오지 않은 경우 해당 Index의 패턴을 NotFound 상태로 저장한다.
|
|
for (int i = 0; i < _Params.RefDistParam.RefDists.Count; i++) {
|
|
if (_MeasurePatternResults[i] == null) {
|
|
BaseResult baseResult = new BaseResult() {
|
|
ImagePosition = new ImagePoint(),
|
|
MaterialPosition = new StaticPoint(),
|
|
Angle = new Angle(),
|
|
};
|
|
List<BaseResult> newResults = new List<BaseResult>();
|
|
newResults.Add(baseResult);
|
|
_MeasurePatternResults[i] = new PatternResult() {
|
|
PatternIndex = patternResult.PatternIndex.Clone() as PatternIndex,
|
|
PatternType = patternResult.PatternType,
|
|
PatternName = patternResult.PatternName,
|
|
Status = eFoundStatus.NotFound,
|
|
Results = newResults,
|
|
FindRoi = patternResult.FindRoi.Clone() as ROI,
|
|
TactTimeInMilliSec = 0,
|
|
MoreInfo = patternResult.MoreInfo,
|
|
FovId = patternResult.FovId,
|
|
};
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private SequenceActionResult Align(
|
|
SequenceContext context,
|
|
string id,
|
|
SequenceActionResult param) {
|
|
|
|
for (int i = 0; i < _Params.RefDistParam.RefDists.Count; i++) {
|
|
if (_MeasureResults[i] == null) {
|
|
var alignResult = new AlignResult() {
|
|
Status = AlignStatus.NOT_FOUND,
|
|
Delta = new AlignDelta(),
|
|
AlignAlgorithm = _AlignRecipe.ProcParams.AlignAlgorithm,
|
|
};
|
|
alignResult.AlignName = $"Align{(i)}";
|
|
_AlignResults[i] = alignResult;
|
|
|
|
BaseResult baseResult = new BaseResult() {
|
|
ImagePosition = new ImagePoint(),
|
|
MaterialPosition = new StaticPoint(),
|
|
Angle = new Angle(),
|
|
};
|
|
_MeasureResults[i] = baseResult;
|
|
}
|
|
else {
|
|
var baseResult = _MeasureResults[i];
|
|
var meaPoint = baseResult.MaterialPosition;
|
|
var refPoint = _Params.ReferenceResults[0];
|
|
var meaAngle = baseResult.Angle;
|
|
var flipY = (int)_Calibrator.GetFlipY();
|
|
var alignResult = _Aligner.Align(meaPoint, refPoint, meaAngle, flipY);
|
|
|
|
if (alignResult == null) {
|
|
LOG.FuncE("alignResult is null.");
|
|
return SequenceAction.Error();
|
|
}
|
|
|
|
alignResult.AlignCnt = i;
|
|
alignResult.DisplayType = _Params.DisplayType;
|
|
alignResult.AlignName = $"Align{(i)}";
|
|
alignResult.AlignAlgorithm = _AlignRecipe.ProcParams.AlignAlgorithm;
|
|
_AlignResults[i] = alignResult;
|
|
}
|
|
}
|
|
return SequenceAction.Ok();
|
|
}
|
|
|
|
private SequenceActionResult AlignExit(
|
|
SequenceContext context,
|
|
string id,
|
|
SequenceActionResult param) {
|
|
|
|
// 얼라인 정상 종료, 혹은 패턴 NotFound시 지나가는 노드
|
|
|
|
return SequenceAction.Ok();
|
|
}
|
|
|
|
private SequenceActionResult UpdateUI(
|
|
SequenceContext context,
|
|
string id,
|
|
SequenceActionResult param) {
|
|
|
|
SortProcData();
|
|
UpdateProcData();
|
|
PrintVisionLog();
|
|
|
|
return SequenceAction.Ok();
|
|
}
|
|
|
|
private void SortProcData() {
|
|
// 패턴 위치 인덱스를 기준으로 패턴 및 얼라인 결과 오름차순 정렬
|
|
_MeasurePatternResults = _MeasurePatternResults.OrderBy(item => item.Key).ToDictionary(x => x.Key, x => x.Value);
|
|
_MeasureResults = _MeasureResults.OrderBy(item => item.Key).ToDictionary(x => x.Key, x => x.Value);
|
|
_AlignResults = _AlignResults.OrderBy(item => item.Key).ToDictionary(x => x.Key, x => x.Value);
|
|
}
|
|
|
|
private void UpdateProcData() {
|
|
Dictionary<int, PatternResult> cloneMeasurePatternResults = _MeasurePatternResults.ToDictionary(x => x.Key, x => x.Value?.Clone());
|
|
|
|
// 얼라인 탭에 패턴 및 얼라인 로그 기록
|
|
VisionEnv.AuroraEnv.EventPublisher.Publish(
|
|
new EventMessage(_FovInfo.GetKey(), VisionEventId.UPDATE_PATTERN_RESULTS, cloneMeasurePatternResults));
|
|
|
|
Dictionary<int, AlignResult> cloneAlignResults = _AlignResults.ToDictionary(x => x.Key, x => x.Value?.Clone());
|
|
Dictionary<int, BaseResult> cloneMeasureResults = _MeasureResults.ToDictionary(x => x.Key, x => x.Value?.Clone());
|
|
|
|
var subSysInfo = _Params.AlignInfo.ToSubSysInfo();
|
|
var alignResultsParam = new AlignResultsParam(cloneMeasureResults, cloneAlignResults);
|
|
VisionEnv.AuroraEnv.EventPublisher.Publish(
|
|
new EventMessage(subSysInfo.GetKey(), VisionEventId.UPDATE_ALIGN_RESULTS, alignResultsParam));
|
|
}
|
|
|
|
private void PrintVisionLog() {
|
|
foreach (var itemPairs in _AlignResults) {
|
|
var alignResult = itemPairs.Value;
|
|
PrintVisionLog(alignResult);
|
|
}
|
|
}
|
|
|
|
private SequenceActionResult SeqComplete(
|
|
SequenceContext context,
|
|
string id,
|
|
SequenceActionResult param) {
|
|
|
|
SetPatternResults();
|
|
|
|
return SequenceAction.Ok(_AlignResults);
|
|
}
|
|
|
|
private void SetPatternResults() {
|
|
foreach (var itemPair in _AlignResults) {
|
|
int patternPosIdx = itemPair.Key;
|
|
AlignResult alignResult = itemPair.Value;
|
|
|
|
if (_MeasurePatternResults.ContainsKey(patternPosIdx)) {
|
|
if (!alignResult.PatternResults.ContainsKey(_FovInfo)) {
|
|
alignResult.PatternResults.Add(_FovInfo, _MeasurePatternResults[patternPosIdx]);
|
|
}
|
|
else {
|
|
alignResult.PatternResults[_FovInfo] = _MeasurePatternResults[patternPosIdx];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void OnStopped(
|
|
SequenceContext context) {
|
|
LOG.I($"{context.SequenceId} - STOP Handler");
|
|
HandleAbnormalFinish(context);
|
|
}
|
|
|
|
void OnForceError(
|
|
SequenceContext context, string id) {
|
|
LOG.E($"{context.SequenceId} - FORCE ERROR Handler");
|
|
HandleAbnormalFinish(context);
|
|
}
|
|
|
|
void HandleAbnormalFinish(
|
|
SequenceContext context) {
|
|
}
|
|
}
|
|
} |