using HalconDotNet;
|
using LB_VisionControls;
|
using LB_VisionProcesses.Alogrithms;
|
using LB_VisionProcesses.Alogrithms.Halcon;
|
using Newtonsoft.Json;
|
using Newtonsoft.Json.Serialization;
|
using SharpCompress.Common;
|
using System;
|
using System.Collections.Concurrent;
|
using System.Collections.Generic;
|
using System.Diagnostics;
|
using System.Linq;
|
using System.Text;
|
using System.Text.RegularExpressions;
|
using System.Threading.Tasks;
|
|
namespace LB_VisionProcesses.Processes
|
{
|
public class RecordTool : BaseProcess
|
{
|
public RecordTool()
|
{
|
strProcessClass = "LB_VisionProcesses.Processes.RecordTool";
|
strProcessName = "创建绘制工具";
|
}
|
|
ConcurrentBag<UserRecord> dicRecords = new ConcurrentBag<UserRecord>();
|
public override bool Run()
|
{
|
#region 初始化变量
|
DateTime StartTime = DateTime.Now;
|
|
InitRunParams();
|
HOperatorSet.GenEmptyObj(out HObject EmptyObj);
|
OutputImage = EmptyObj;
|
#endregion
|
|
try
|
{
|
//if (InputImage == null)
|
//{
|
// Msg = "输入图片为空";
|
// Result = false;
|
// return Result;
|
//}
|
|
//if (!(InputImage is HObject))
|
//{
|
// Msg = "输入图片格式不为HObject";
|
// Result = false;
|
// return Result;
|
//}
|
|
#region 裁剪区域
|
//object DomainImage = null;
|
//if (!ReduceDomainImage(InputImage, ref DomainImage))
|
//{
|
// Msg = "裁剪区域失败";
|
// Result = false;
|
// return Result;
|
//}
|
#endregion
|
|
#region 算子逻辑
|
Record = new MsgRecord();
|
|
foreach (var recordObj in dicRecords)
|
{
|
if (recordObj is UserRecord record)
|
{
|
string Msg = "";
|
if (!record.MsgMap.Contains('{') || !record.MsgMap.Contains('}'))
|
Msg = record.MsgMap;
|
else
|
{
|
Msg = record.MsgMap;
|
|
// 使用正则表达式匹配所有 {key} 格式的内容
|
Msg = Regex.Replace(Msg, @"\{([^}]+)\}", match =>
|
{
|
string key = match.Groups[1].Value; // 获取花括号内的内容
|
if (Params.Inputs.ContainsKey(key))
|
{
|
object value = Params.Inputs[key];
|
if (value == null) return "";
|
|
// 尝试解析为数值类型
|
if (double.TryParse(value.ToString(), out double num))
|
return num.ToString("F4");
|
|
return value?.ToString();
|
}
|
return match.Value; // 如果找不到键，保留原文本
|
});
|
}
|
|
bool Result = false;
|
if (!record.ResultMap.StartsWith("{") || !record.ResultMap.EndsWith("}"))
|
Result = Convert.ToBoolean(record.ResultMap);
|
else
|
{
|
string Map = record.ResultMap;
|
Map = Map.Replace("{", "");
|
Map = Map.Replace("}", "");
|
if (Params.Inputs.ContainsKey(Map) && Params.Inputs[Map] is bool res)
|
Result = res;
|
}
|
|
ROI Obj = new ROI();
|
if (record.ShapeMap.StartsWith("{") && record.ShapeMap.EndsWith("}"))
|
{
|
string Map = record.ShapeMap;
|
Map = Map.Replace("{", "");
|
Map = Map.Replace("}", "");
|
if (Params.Inputs.ContainsKey(Map) && Params.Inputs[Map] is ROI roi)
|
Obj = roi;
|
}
|
|
double X = 0;
|
if (!record.XMap.StartsWith("{") || !record.XMap.EndsWith("}"))
|
X = Convert.ToDouble(record.XMap);
|
else
|
{
|
string Map = record.ResultMap;
|
Map = Map.Replace("{", "");
|
Map = Map.Replace("}", "");
|
if (Params.Inputs.ContainsKey(Map) && Params.Inputs[Map] is double val)
|
X = val;
|
}
|
|
double Y = 0;
|
if (!record.YMap.StartsWith("{") || !record.YMap.EndsWith("}"))
|
Y = Convert.ToDouble(record.YMap);
|
else
|
{
|
string Map = record.ResultMap;
|
Map = Map.Replace("{", "");
|
Map = Map.Replace("}", "");
|
if (Params.Inputs.ContainsKey(Map) && Params.Inputs[Map] is double val)
|
Y = val;
|
}
|
HPoint Pose = new HPoint(X, Y);
|
|
((MsgRecord)Record).AddXld(Msg, Pose.Row, Pose.Column, Obj.GetXld(), Result);
|
}
|
}
|
|
#endregion
|
|
#region 生成OutputImage给后续处理
|
try
|
{
|
//OutputImage = hoDomainImage;
|
}
|
catch (Exception ex)
|
{
|
Msg = "生成OutputImage失败,原因是:" + ex.ToString();
|
Result = false;
|
return Result;
|
}
|
#endregion
|
|
Msg = "运行成功";
|
Result = true;
|
return Result;
|
}
|
catch (Exception ex)
|
{
|
Msg = "运行失败,原因是:" + ex.ToString().TrimEnd();
|
OutputImage = null;
|
Result = false;
|
return Result;
|
}
|
finally
|
{
|
RunTime = (DateTime.Now - StartTime).TotalMilliseconds;
|
}
|
}
|
|
public ConcurrentDictionary<int, UserRecord> GetRecords()
|
{
|
ConcurrentDictionary<int, UserRecord> dicRecords = new ConcurrentDictionary<int, UserRecord>();
|
|
int index = 1;
|
foreach (var userRecord in this.dicRecords)
|
{
|
dicRecords.TryAdd(index, userRecord);
|
index++;
|
}
|
return dicRecords;
|
}
|
|
public override bool Load(string fullPath)
|
{
|
try
|
{
|
// 获取不带文件名的目录路径
|
string directoryPath = Path.GetDirectoryName(fullPath);
|
strProcessName = Path.GetFileNameWithoutExtension(fullPath);
|
// 修正真实路径,工具其路径为一个文件夹,而不是一个文件
|
string FilePath = directoryPath + "\\" + strProcessName;
|
fullPath = FilePath + "\\" + strProcessName + ".json";
|
|
if (!File.Exists(fullPath))
|
{
|
Debug.WriteLine("文件不存在创建空文件");
|
Save(directoryPath);
|
return true;
|
}
|
|
string strJson = string.Empty;
|
using (StreamReader streamReader = new StreamReader(fullPath, Encoding.UTF8))
|
{
|
strJson = streamReader.ReadToEnd();
|
streamReader.Close();
|
}
|
Params = JsonConvert.DeserializeObject<ProcessParams>(strJson);
|
if (Params == null)
|
return false;
|
|
Params.FixDeserializedData();
|
|
return LoadRecords(directoryPath + $"\\{strProcessName}\\{strProcessName}.rds");
|
}
|
catch { return false; }
|
}
|
|
/// <summary>
|
/// 加载绘制流(带.json,实际路径)
|
/// </summary>
|
/// <param name="fullPath">完整路径带.json</param>
|
/// <returns></returns>
|
public bool LoadRecords(string fullPath)
|
{
|
try
|
{
|
// 获取不带文件名的目录路径
|
string directoryPath = Path.GetDirectoryName(fullPath);
|
if (!File.Exists(fullPath))
|
{
|
Debug.WriteLine("文件不存在创建空文件");
|
SaveRecords(directoryPath);
|
return true;
|
}
|
|
string strJson = string.Empty;
|
using (StreamReader streamReader = new StreamReader(fullPath, Encoding.UTF8))
|
{
|
strJson = streamReader.ReadToEnd();
|
streamReader.Close();
|
}
|
ConcurrentDictionary<int, UserRecord> dicRecords = JsonConvert.DeserializeObject<ConcurrentDictionary<int, UserRecord>>(strJson);
|
if (dicRecords == null)
|
return false;
|
|
this.dicRecords.Clear();
|
for (int i = 1; i <= dicRecords.Count; i++)
|
{
|
if (dicRecords.ContainsKey(i))
|
this.dicRecords.Add(dicRecords[i]);
|
}
|
|
return true;
|
}
|
catch { return false; }
|
}
|
|
public override bool Save(string filePath)
|
{
|
try
|
{
|
if (string.IsNullOrEmpty(filePath) || filePath.Trim() == "")
|
{
|
Debug.WriteLine("文件路径不完整");
|
return false;
|
}
|
|
// 修正真实路径,工具其路径为一个文件夹,而不是一个文件
|
filePath += ("\\" + strProcessName);
|
|
string strJson = string.Empty;
|
var settings = new JsonSerializerSettings
|
{
|
Formatting = Newtonsoft.Json.Formatting.Indented,
|
// 自定义缩进（4空格）
|
ContractResolver = new DefaultContractResolver
|
{
|
NamingStrategy = new CamelCaseNamingStrategy()
|
}
|
};
|
strJson = JsonConvert.SerializeObject(Params, settings);
|
|
//判断文件夹是否存在，防呆输入为文件名称
|
if (!Directory.Exists(filePath))
|
{
|
try
|
{
|
Directory.CreateDirectory(filePath);
|
}
|
catch (Exception)
|
{ }
|
}
|
// filePath 已经含了Name
|
File.WriteAllText(filePath + $"\\{strProcessName}.json", strJson, Encoding.UTF8);
|
|
return SaveRecords(filePath);
|
}
|
catch { return false; }
|
}
|
|
/// <summary>
|
/// 保存绘制流(不带.json,实际路径)
|
/// </summary>
|
/// <param name="filePath"></param>
|
/// <returns></returns>
|
public bool SaveRecords(string filePath)
|
{
|
try
|
{
|
if (string.IsNullOrEmpty(filePath) || filePath.Trim() == "")
|
{
|
Debug.WriteLine("文件路径不完整");
|
return false;
|
}
|
|
var dicRecords = GetRecords();
|
|
string strJson = string.Empty;
|
var settings = new JsonSerializerSettings
|
{
|
Formatting = Newtonsoft.Json.Formatting.Indented,
|
// 自定义缩进（4空格）
|
ContractResolver = new DefaultContractResolver
|
{
|
NamingStrategy = new CamelCaseNamingStrategy()
|
}
|
};
|
strJson = JsonConvert.SerializeObject(dicRecords, settings);
|
|
//判断文件夹是否存在，防呆输入为文件名称
|
if (!Directory.Exists(filePath))
|
{
|
try
|
{
|
Directory.CreateDirectory(filePath);
|
}
|
catch (Exception)
|
{ }
|
}
|
// filePath 已经含了Name
|
File.WriteAllText(filePath + $"\\{strProcessName}.rds", strJson, Encoding.UTF8);
|
|
return true;
|
}
|
catch { return false; }
|
}
|
|
public bool ClearRecord()
|
{
|
try
|
{
|
dicRecords.Clear();
|
return true;
|
}
|
catch { return false; }
|
}
|
|
public bool AddRecord(UserRecord record)
|
{
|
try
|
{
|
dicRecords.Add(record);
|
return true;
|
}
|
catch { return false; }
|
}
|
|
public bool RemoveLastRecord()
|
{
|
try
|
{
|
return dicRecords.TryTake(out _);
|
}
|
catch { return false; }
|
}
|
|
/// <summary>
|
/// 获取脚本输入
|
/// </summary>
|
/// <returns></returns>
|
public Dictionary<string, object> GetInputs()
|
{
|
try
|
{
|
Dictionary<string, object> dicInputs = new Dictionary<string, object>();
|
|
for (int i = 0; i <= Params.Inputs.Count - 1; i++)
|
{
|
bool isFindKey = Params.Inputs.GetKey(i, out string key);
|
//忽略不需要的参数
|
if (!isFindKey || key == "Scrip" || key == "OtherDllPaths")
|
continue;
|
|
dicInputs.TryAdd(key, Params.Inputs[i]);
|
}
|
|
return dicInputs;
|
}
|
catch { return new Dictionary<string, object>(); }
|
}
|
|
/// <summary>
|
/// 设置脚本输入
|
/// </summary>
|
/// <param name="dicInputs"></param>
|
/// <returns></returns>
|
public bool SetInputs(Dictionary<string, object> dicInputs)
|
{
|
try
|
{
|
//设置输入前将原先其他输入清除
|
if (!ClearInputs())
|
return false;
|
|
foreach (var kvp in dicInputs)
|
{
|
string key = kvp.Key;
|
//忽略不需要的参数
|
if (key == "Scrip" || key == "OtherDllPaths")
|
continue;
|
|
Params.Inputs.Add(key, kvp.Value);
|
}
|
return true;
|
}
|
catch { return false; }
|
}
|
|
public bool ClearInputs()
|
{
|
try
|
{
|
//设置输入前将原先其他输入清除
|
for (int i = 0; i <= Params.Inputs.Count - 1; i++)
|
{
|
bool isFindKey = Params.Inputs.GetKey(i, out string key);
|
//忽略不需要的参数
|
if (!isFindKey || key == "Scrip" || key == "OtherDllPaths")
|
continue;
|
|
Params.Inputs.Remove(i);
|
}
|
return true;
|
}
|
catch { return false; }
|
}
|
}
|
|
[Serializable]
|
public class UserRecord
|
{
|
[JsonConstructor]
|
public UserRecord() { }
|
|
//public UserRecord(HPoint Pose, string Msg, bool Result = true)
|
//{
|
// this.Pose = Pose;
|
// this.Msg = Msg;
|
// this.Result = Result;
|
//}
|
|
//public UserRecord(HPoint Pose, ROI Obj, bool Result = true, string Msg = "")
|
//{
|
// this.Pose = Pose;
|
// this.Obj = Obj;
|
// this.Result = Result;
|
// this.Msg = Msg;
|
//}
|
|
[JsonProperty]
|
public string MsgMap = "";
|
[JsonProperty]
|
public string ShapeMap = "";
|
[JsonProperty]
|
public string ResultMap = "True";
|
[JsonProperty]
|
public string XMap = "0";
|
[JsonProperty]
|
public string YMap = "0";
|
|
//public bool Result = false;
|
|
//public string Msg = "";
|
|
//public HPoint Pose = new HPoint();
|
|
//public ROI Obj = new ROI();
|
}
|
|
public class OrderedConcurrentDictionary
|
{
|
private readonly ConcurrentDictionary<int, object> _dictionary = new();
|
private readonly ConcurrentQueue<int> _keyQueue = new();
|
private int _currentMaxKey = 0;
|
private readonly object _reorderLock = new();
|
|
public int Count { get { return _dictionary.Count; } }
|
|
public bool Add(object value)
|
{
|
lock (_reorderLock)
|
{
|
int newKey = GetNextKey();
|
if (_dictionary.TryAdd(newKey, value))
|
{
|
_keyQueue.Enqueue(newKey);
|
return true;
|
}
|
}
|
return false;
|
}
|
|
public bool Remove(int key)
|
{
|
if (_dictionary.TryRemove(key, out _))
|
{
|
lock (_reorderLock)
|
{
|
// 重新排序
|
ReorderDictionary();
|
}
|
return true;
|
}
|
return false;
|
}
|
|
public bool Clear()
|
{
|
try
|
{
|
while (Count > 0)
|
Remove(Count - 1);
|
|
return true;
|
}
|
catch { return false; }
|
}
|
|
public bool TryGetValue(int key, out object value)
|
{
|
return _dictionary.TryGetValue(key, out value);
|
}
|
|
private int GetNextKey()
|
{
|
return Interlocked.Increment(ref _currentMaxKey);
|
}
|
|
private void ReorderDictionary()
|
{
|
// 获取当前所有值
|
var values = _dictionary.Values.ToArray();
|
|
// 清空字典和队列
|
_dictionary.Clear();
|
while (_keyQueue.TryDequeue(out _)) { }
|
|
// 重新添加并更新键
|
for (int i = 0; i < values.Length; i++)
|
{
|
int newKey = i + 1;
|
_dictionary.TryAdd(newKey, values[i]);
|
_keyQueue.Enqueue(newKey);
|
}
|
|
// 更新最大键值
|
_currentMaxKey = values.Length;
|
}
|
}
|
}
|
