using LB_VisionProcesses;
|
using System;
|
using System.Diagnostics;
|
using System.Reflection;
|
using System.Reflection.Emit;
|
using System.Text.Json.Nodes;
|
using System.Threading;
|
using static System.Windows.Forms.VisualStyles.VisualStyleElement.TreeView;
|
|
namespace LB_VisionFlowNode
|
{
|
/// <summary>
|
/// 插件节点方法信息
|
/// </summary>
|
public class PluginNodeMethodInfo
|
{
|
public string DisplayName { get; set; }
|
public string FullTypeName { get; set; }
|
public string Category { get; set; }
|
public string Group { get; set; }
|
public string Description { get; set; }
|
}
|
public abstract class IFlowContext
|
{
|
public readonly Dictionary<string, MethodInfo> _nodeMethods
|
= new Dictionary<string, MethodInfo>();
|
|
public readonly Dictionary<string, List<MethodInfo>> _groupedMethods
|
= new Dictionary<string, List<MethodInfo>>();
|
|
public readonly Dictionary<string, Func<FlowNode, bool>> _nodeDelegates
|
= new Dictionary<string, Func<FlowNode, bool>>();
|
|
// 自动生成的插件节点方法信息
|
public readonly Dictionary<string, PluginNodeMethodInfo> _pluginNodeMethods
|
= new Dictionary<string, PluginNodeMethodInfo>();
|
|
// 动态方法的包装（用于模拟MethodInfo）
|
private readonly Dictionary<string, DynamicMethodWrapper> _dynamicMethodWrappers
|
= new Dictionary<string, DynamicMethodWrapper>();
|
|
// 是否已自动生成插件节点
|
private bool _pluginNodesGenerated = false;
|
|
// 动态方法包装类
|
public class DynamicMethodWrapper
|
{
|
public string DisplayName { get; set; }
|
public string Category { get; set; }
|
public string Group { get; set; }
|
public string Description { get; set; }
|
public Func<FlowNode, bool> Execute { get; set; }
|
// 模拟MethodInfo的必要属性
|
public string Name => DisplayName;
|
}
|
|
public void InitializeMethods()
|
{
|
// 1. 先处理自身的Node特性方法
|
var methods = GetType().GetMethods(BindingFlags.Public | BindingFlags.Instance);
|
foreach (var method in methods)
|
{
|
var nodeAttr = method.GetCustomAttribute<NodeAttribute>();
|
if (nodeAttr != null)
|
{
|
// 使用描述作为键值
|
_nodeMethods[nodeAttr.Description] = method;
|
|
// 按组分类
|
if (!_groupedMethods.ContainsKey(nodeAttr.Group))
|
{
|
_groupedMethods[nodeAttr.Group] = new List<MethodInfo>();
|
}
|
_groupedMethods[nodeAttr.Group].Add(method);
|
}
|
}
|
|
// 2. 自动为IProcess工具生成动态节点方法
|
GeneratePluginNodeMethods();
|
}
|
|
/// <summary>
|
/// 自动为IProcess工具生成节点方法（核心方法）
|
/// </summary>
|
private void GeneratePluginNodeMethods()
|
{
|
if (_pluginNodesGenerated)
|
return;
|
try
|
{
|
// 确保IProcess的插件管理器已初始化
|
if (IProcess.dicProcesses == null || IProcess.dicProcesses.Count == 0)
|
{
|
var _ = IProcess.dicProcesses; // 触发初始化
|
}
|
// 清空现有的插件节点方法
|
_pluginNodeMethods.Clear();
|
_dynamicMethodWrappers.Clear();
|
// 遍历所有IProcess工具
|
foreach (var processKvp in IProcess.dicProcesses)
|
{
|
string toolName = processKvp.Key;
|
string className = processKvp.Value;
|
// 获取工具的分类
|
string category = GetCategoryForTool(toolName);
|
string group = GetGroupForCategory(category); // 根据分类确定组
|
string description = $"{toolName}";
|
|
// 创建插件节点方法信息
|
var pluginNode = new PluginNodeMethodInfo
|
{
|
DisplayName = toolName,
|
FullTypeName = className,
|
Category = category,
|
Group = group,
|
Description = description
|
};
|
_pluginNodeMethods[toolName] = pluginNode;
|
|
// 创建动态执行委托
|
Func<FlowNode, bool> executeDelegate = (node) =>
|
{
|
try
|
{
|
// 创建IProcess实例
|
IProcess process = IProcess.CreateProcess(toolName);
|
if (process == null)
|
{
|
Debug.WriteLine($"无法创建工具实例: {toolName}");
|
node.Result = false;
|
return false;
|
}
|
|
// 初始化运行参数
|
process.InitRunParams();
|
|
// 执行工具的Run方法
|
bool runResult = process.Run();
|
|
// 设置节点结果
|
node.Result = runResult;
|
node.BranchIndex = "0"; // 默认分支
|
|
// 释放资源
|
process.Dispose();
|
|
Debug.WriteLine($"插件工具 {toolName} 执行完成，结果: {runResult}");
|
return runResult;
|
}
|
catch (Exception ex)
|
{
|
Debug.WriteLine($"插件工具 {toolName} 执行失败: {ex.Message}");
|
node.Result = false;
|
return false;
|
}
|
};
|
|
// 创建动态方法包装
|
var dynamicMethod = new DynamicMethodWrapper
|
{
|
DisplayName = toolName,
|
Category = category,
|
Group = group,
|
Description = description,
|
Execute = executeDelegate
|
};
|
_dynamicMethodWrappers[description] = dynamicMethod;
|
|
// ********** 关键：将动态方法添加到_nodeMethods和_groupedMethods **********
|
// 方式：生成动态MethodInfo（使用Emit），或者模拟（这里用Emit生成真实的MethodInfo）
|
MethodInfo dynamicMethodInfo = CreateDynamicMethod(toolName, group, description);
|
|
// 添加到_nodeMethods（键是description）
|
_nodeMethods[description] = dynamicMethodInfo;
|
|
// 添加到_groupedMethods
|
if (!_groupedMethods.ContainsKey(group))
|
{
|
_groupedMethods[group] = new List<MethodInfo>();
|
}
|
_groupedMethods[group].Add(dynamicMethodInfo);
|
|
// 添加到_nodeDelegates
|
_nodeDelegates[description] = executeDelegate;
|
|
Debug.WriteLine($"自动生成插件节点: {toolName} (分类: {category}, 组: {group})");
|
}
|
|
_pluginNodesGenerated = true;
|
}
|
catch (Exception ex)
|
{
|
Debug.WriteLine($"自动生成插件节点方法失败: {ex.Message}");
|
}
|
}
|
|
/// <summary>
|
/// 使用Reflection.Emit生成动态MethodInfo，模拟Node特性方法
|
/// </summary>
|
/// <param name="toolName">工具名称</param>
|
/// <param name="group">组名</param>
|
/// <param name="description">描述</param>
|
/// <returns>动态生成的MethodInfo</returns>
|
private MethodInfo CreateDynamicMethod(string toolName, string group, string description)
|
{
|
// 1. 定义动态方法的参数和返回类型
|
Type flowNodeType = typeof(FlowNode);
|
DynamicMethod dynamicMethod = new DynamicMethod(
|
toolName, // 方法名
|
typeof(void), // 返回类型（和原有Node方法一致）
|
new[] { typeof(FlowNode) }, // 参数类型
|
GetType(), // 所属类型
|
true); // 跳过JIT可见性检查
|
|
// 2. 生成IL代码，调用动态委托
|
ILGenerator il = dynamicMethod.GetILGenerator();
|
// 加载参数（FlowNode）
|
il.Emit(OpCodes.Ldarg_1); // 注意：实例方法的第一个参数是this（Ldarg_0），这里动态方法是静态的，所以Ldarg_0是FlowNode
|
// 调用委托（这里简化，直接设置Result为true）
|
il.Emit(OpCodes.Ldflda, flowNodeType.GetProperty("Result").GetSetMethod());
|
il.Emit(OpCodes.Ldc_I4_1);
|
il.Emit(OpCodes.Callvirt, flowNodeType.GetProperty("Result").GetSetMethod());
|
// 设置BranchIndex
|
il.Emit(OpCodes.Ldarg_1);
|
il.Emit(OpCodes.Ldflda, flowNodeType.GetProperty("BranchIndex").GetSetMethod());
|
il.Emit(OpCodes.Ldstr, "0");
|
il.Emit(OpCodes.Callvirt, flowNodeType.GetProperty("BranchIndex").GetSetMethod());
|
// 返回
|
il.Emit(OpCodes.Ret);
|
|
// 3. 将DynamicMethod包装为MethodInfo（DynamicMethod继承自MethodInfo）
|
return dynamicMethod;
|
}
|
|
/// <summary>
|
/// 根据工具名称推断分类（完善逻辑）
|
/// </summary>
|
private string GetCategoryForTool(string toolName)
|
{
|
if (string.IsNullOrWhiteSpace(toolName))
|
return "未分类";
|
|
toolName = toolName.ToLower();
|
|
if (toolName.Contains("相机") || toolName.Contains("取图"))
|
return "相机工具";
|
else if (toolName.Contains("通讯") || toolName.Contains("command"))
|
return "通讯工具";
|
else if (toolName.Contains("opencvsharp"))
|
return "OpencvSharp算法";
|
else if (toolName.Contains("halcon"))
|
return "Halcon算法";
|
else if (toolName.Contains("yolo") || toolName.Contains("tensorrt") ||
|
toolName.Contains("ocr") || toolName.Contains("deeplearning") || toolName.Contains("大模型"))
|
return "深度学习";
|
else if (toolName.Contains("图像处理") || toolName.Contains("点云") ||
|
toolName.Contains("线线交点"))
|
return "图像处理工具";
|
else if (toolName.Contains("测试") || toolName.Contains("检查") ||
|
toolName.Contains("端口") || toolName.Contains("屏幕") ||
|
toolName.Contains("工序") || toolName.Contains("转产"))
|
return "自定义工具";
|
else if (toolName.Contains("脚本") || toolName.Contains("分支") ||
|
toolName.Contains("延时") || toolName.Contains("绘制"))
|
return "工具";
|
else if (toolName.Contains("固定跟随") || toolName.Contains("fixture"))
|
return "工具";
|
else
|
return "插件工具";
|
}
|
|
/// <summary>
|
/// 根据分类确定组名
|
/// </summary>
|
private string GetGroupForCategory(string category)
|
{
|
switch (category)
|
{
|
case "通讯工具":
|
return "Basic";
|
case "算法":
|
return "Basic";
|
case "深度学习":
|
return "Basic";
|
case "图像处理工具":
|
return "Basic";
|
case "自定义工具":
|
return "Basic";
|
case "工具":
|
return "Basic";
|
default:
|
return "Plugin";
|
}
|
}
|
|
public void InitializeDelegates()
|
{
|
// 1. 处理自身的Node方法
|
foreach (var kvp in _nodeMethods)
|
{
|
var method = kvp.Value;
|
var parameters = method.GetParameters();
|
|
//如果是动态方法（DynamicMethod），跳过（已经在GeneratePluginNodeMethods中添加了委托）
|
if (method is DynamicMethod)
|
{
|
// 从动态方法包装中获取对应的委托
|
if (_dynamicMethodWrappers.TryGetValue(kvp.Key, out var wrapper))
|
{
|
// 直接使用包装中的Execute委托
|
_nodeDelegates[kvp.Key] = wrapper.Execute;
|
}
|
else
|
{
|
// 如果没有找到包装，创建一个默认的执行委托
|
_nodeDelegates[kvp.Key] = (node) =>
|
{
|
Debug.WriteLine($"执行动态方法: {kvp.Key}");
|
node.Result = true;
|
node.BranchIndex = "0";
|
return true;
|
};
|
}
|
continue;
|
}
|
|
if (parameters.Length == 0)
|
{
|
var action = (Action)Delegate.CreateDelegate(typeof(Action), this, method);
|
_nodeDelegates[kvp.Key] = (node) => { action(); return node.Result; };
|
}
|
else if (parameters.Length == 1 && parameters[0].ParameterType == typeof(FlowNode))
|
{
|
var action = (Action<FlowNode>)Delegate.CreateDelegate(typeof(Action<FlowNode>), this, method);
|
_nodeDelegates[kvp.Key] = (node) => { action(node); return node.Result; };
|
}
|
}
|
|
// 2. 确保动态方法的委托已添加（GeneratePluginNodeMethods中已处理）
|
}
|
|
public virtual bool ExecuteNode(FlowNode node)
|
{
|
if (string.IsNullOrEmpty(node.Description))
|
return false;
|
|
// 优先检查动态委托
|
if (_nodeDelegates.TryGetValue(node.Description, out var nodeDelegate))
|
{
|
try
|
{
|
return nodeDelegate(node);
|
}
|
catch (Exception ex)
|
{
|
Debug.WriteLine($"执行节点失败: {ex.Message}");
|
return false;
|
}
|
}
|
|
// 兼容原有逻辑
|
return false;
|
}
|
|
public Dictionary<string, MethodInfo> GetAvailableNodes()
|
{
|
return _nodeMethods.ToDictionary(
|
kvp => kvp.Key,
|
kvp => kvp.Value
|
);
|
}
|
|
// 获取按组分组的可用节点（包含动态生成的插件节点）
|
public Dictionary<string, List<ToolStripMenuItem>> GetGroupedMenuItems(EventHandler clickHandler)
|
{
|
var groupedMenuItems = new Dictionary<string, List<ToolStripMenuItem>>();
|
|
foreach (var group in _groupedMethods)
|
{
|
var menuItems = new List<ToolStripMenuItem>();
|
|
foreach (var method in group.Value)
|
{
|
string menuText;
|
string toolTip;
|
|
// 判断是静态方法还是动态方法
|
if (method is DynamicMethod dynamicMethod)
|
{
|
// 动态方法（插件工具）
|
var pluginNode = _pluginNodeMethods.Values.FirstOrDefault(p => p.DisplayName == dynamicMethod.Name);
|
menuText = pluginNode?.DisplayName ?? dynamicMethod.Name;
|
toolTip = pluginNode?.Description ?? $"动态工具: {dynamicMethod.Name}";
|
}
|
else
|
{
|
// 静态方法（原有Node特性方法）
|
var nodeAttr = method.GetCustomAttribute<NodeAttribute>();
|
menuText = nodeAttr?.Name ?? method.Name;
|
toolTip = nodeAttr?.Description ?? method.Name;
|
}
|
|
var menuItem = new ToolStripMenuItem
|
{
|
Text = menuText,
|
Tag = menuText, // 存储描述作为标识
|
ToolTipText = toolTip
|
};
|
|
if (clickHandler != null)
|
{
|
menuItem.Click += clickHandler;
|
}
|
|
menuItems.Add(menuItem);
|
}
|
|
groupedMenuItems[group.Key] = menuItems;
|
}
|
|
return groupedMenuItems;
|
}
|
|
// 获取按类别分组的菜单项（包含动态生成的插件节点）
|
public Dictionary<string, List<ToolStripMenuItem>> GetCategorizedMenuItems(EventHandler clickHandler)
|
{
|
var categorizedMethods = new Dictionary<string, List<MethodInfo>>();
|
|
// 1. 处理原有Node方法
|
foreach (var method in _nodeMethods.Values.Where(m => !(m is DynamicMethod)))
|
{
|
var nodeAttr = method.GetCustomAttribute<NodeAttribute>();
|
if (nodeAttr == null) continue;
|
|
if (!categorizedMethods.ContainsKey(nodeAttr.Category))
|
{
|
categorizedMethods[nodeAttr.Category] = new List<MethodInfo>();
|
}
|
categorizedMethods[nodeAttr.Category].Add(method);
|
}
|
|
// 2. 处理动态插件方法
|
foreach (var pluginNode in _pluginNodeMethods.Values)
|
{
|
if (!categorizedMethods.ContainsKey(pluginNode.Category))
|
{
|
categorizedMethods[pluginNode.Category] = new List<MethodInfo>();
|
}
|
|
// 找到对应的动态MethodInfo
|
var dynamicMethod = _nodeMethods.Values
|
.OfType<DynamicMethod>()
|
.FirstOrDefault(m => m.Name == pluginNode.DisplayName);
|
|
if (dynamicMethod != null)
|
{
|
categorizedMethods[pluginNode.Category].Add(dynamicMethod);
|
}
|
}
|
|
// 生成菜单项
|
var categorizedMenuItems = new Dictionary<string, List<ToolStripMenuItem>>();
|
foreach (var category in categorizedMethods)
|
{
|
var menuItems = new List<ToolStripMenuItem>();
|
|
foreach (var method in category.Value)
|
{
|
string menuText;
|
string toolTip;
|
|
if (method is DynamicMethod dynamicMethod)
|
{
|
var pluginNode = _pluginNodeMethods.Values.FirstOrDefault(p => p.DisplayName == dynamicMethod.Name);
|
menuText = pluginNode?.DisplayName ?? dynamicMethod.Name;
|
toolTip = pluginNode?.Description ?? $"动态工具: {dynamicMethod.Name}";
|
}
|
else
|
{
|
var nodeAttr = method.GetCustomAttribute<NodeAttribute>();
|
menuText = nodeAttr?.Name ?? method.Name;
|
toolTip = $"{nodeAttr?.Group} - {nodeAttr?.Description}";
|
}
|
|
var menuItem = new ToolStripMenuItem
|
{
|
Text = menuText,
|
Tag = menuText,
|
ToolTipText = toolTip
|
};
|
|
if (clickHandler != null)
|
{
|
menuItem.Click += clickHandler;
|
}
|
|
menuItems.Add(menuItem);
|
}
|
|
categorizedMenuItems[category.Key] = menuItems;
|
}
|
|
return categorizedMenuItems;
|
}
|
|
// 原有Node方法
|
[Node("开始", "控制", "Logic", "开始")]
|
public virtual void 开始(FlowNode node) { node.Result = true; }
|
|
[Node("结束", "控制", "Logic", "结束")]
|
public virtual void 结束(FlowNode node) { node.Result = true; }
|
|
[Node("分支", "控制", "Logic", "分支")]
|
public virtual void 分支(FlowNode node) { node.Result = true; }
|
|
[Node("多分支", "控制", "Logic", "多分支")]
|
public virtual void 多分支(FlowNode node) { node.Result = true; }
|
|
[Node("并行分支开始", "控制", "Logic", "并行分支开始")]
|
public virtual void 并行分支开始(FlowNode node)
|
{
|
string ProcessName = node.Text;
|
node.BranchIndex = "-1";
|
try
|
{
|
for (int i = 0; i < node.BranchNodes.Count; i++)
|
{
|
if (i == 0)
|
node.BranchIndex = "0;";
|
else
|
node.BranchIndex += $"{i.ToString()};";
|
}
|
node.Result = true;
|
}
|
catch { node.Result = false; }
|
}
|
|
[Node("并行分支结束", "控制", "Logic", "并行分支结束")]
|
public virtual void 并行分支结束(FlowNode node) { node.Result = true; }
|
}
|
|
public class FlowContext : IFlowContext
|
{
|
/// <summary>
|
/// 运行标记
|
/// </summary>
|
public bool bRuning = false;
|
|
/// <summary>
|
/// 运行完成
|
/// </summary>
|
public bool bCompleted = true;
|
|
/// <summary>
|
/// 运行结果
|
/// </summary>
|
public bool Result = false;
|
|
/// <summary>
|
/// 运行消息
|
/// </summary>
|
public string Msg = string.Empty;
|
|
/// <summary>
|
/// 运行时间
|
/// </summary>
|
public double RunTime = 0;
|
|
/// <summary>
|
/// 开始时间
|
/// </summary>
|
public DateTime StartTime = DateTime.Now;
|
|
public FlowContext()
|
{
|
InitializeMethods();
|
InitializeDelegates();
|
}
|
|
// 统一的动态节点执行辅助方法（可选）
|
private void RunNodeAsync(FlowNode node)
|
{
|
// 调用基类的ExecuteNode
|
node.Result = ExecuteNode(node);
|
if (node.Result)
|
{
|
Debug.WriteLine($"{node.Text} 运行完成");
|
}
|
else
|
{
|
Msg += $"[{node.Text}] 运行失败";
|
Result = false;
|
}
|
}
|
|
// 重写原有Node方法，添加业务逻辑
|
[Node("开始", "控制", "Logic", "开始")]
|
public override void 开始(FlowNode node)
|
{
|
StartTime = DateTime.Now;
|
RunTime = 0;
|
|
Result = true;
|
bRuning = true;
|
bCompleted = false;
|
Msg = string.Empty;
|
node.Result = true;
|
}
|
|
[Node("结束", "控制", "Logic", "结束")]
|
public override void 结束(FlowNode node)
|
{
|
bRuning = false;
|
bCompleted = true;
|
|
if (Result)
|
Msg = "运行成功";
|
|
RunTime = (DateTime.Now - StartTime).TotalMilliseconds;
|
node.Result = true;
|
}
|
|
[Node("分支", "控制", "Logic", "分支")]
|
public override void 分支(FlowNode node)
|
{
|
string ProcessName = node.Text;
|
node.BranchIndex = "-1";
|
node.Result = true;
|
try
|
{
|
if (node.Break)
|
{
|
node.BranchIndex = "0";
|
node.Result = true;
|
return;
|
}
|
|
node.BranchIndex = 0.ToString();
|
Debug.WriteLine($"{ProcessName},分支{node.BranchIndex}运行完成");
|
}
|
catch (Exception ex)
|
{
|
node.Result = false;
|
Result &= false;
|
Msg = $"[{ProcessName}]运行发生意外,{ex.Message}";
|
}
|
}
|
|
[Node("多分支", "控制", "Logic", "多分支")]
|
public override void 多分支(FlowNode node)
|
{
|
string ProcessName = node.Text;
|
node.BranchIndex = "-1";
|
node.Result = true;
|
try
|
{
|
if (node.Break)
|
{
|
node.BranchIndex = "0";
|
node.Result = true;
|
return;
|
}
|
|
node.BranchIndex = 0.ToString();
|
Debug.WriteLine($"{ProcessName},分支{node.BranchIndex}运行完成");
|
}
|
catch (Exception ex)
|
{
|
node.Result = false;
|
Result &= false;
|
Msg = $"[{ProcessName}]运行发生意外,{ex.Message}";
|
}
|
}
|
|
// 保留原有测试方法（可选，也可以移除，由动态生成替代）
|
[Node("测试工具", "算法", "Basic", "测试工具")]
|
public void 测试工具(FlowNode node) { RunNodeAsync(node); }
|
}
|
|
}
|
