MvvmScaffoldFrame48.DLL/CameraTools/HikCamera.cs

@@ -37,6 +37,9 @@ namespace MvvmScaffoldFrame48.DLL.CameraTools
 
         #region 构造函数
         
+        /// <summary>
+        /// 相机构造函数 不加载相机
+        /// </summary>
         public HikCamera()
         {
             if (_device != null && _device.IsConnected)

MvvmScaffoldFrame48.DLL/ConfigTools/XMLReadWrite.cs

@@ -34,6 +34,30 @@ namespace MvvmScaffoldFrame48.DLL.ConfigTools
             }
         }
 
+        /// <summary>
+        /// 序列化对象为XML字符串
+        /// </summary>
+        /// <typeparam name="T">对象类型</typeparam>
+        /// <param name="data">要序列化的对象</param>
+        /// <returns>XML字符串</returns>
+        /// <exception cref="InvalidOperationException"></exception>
+        public static string SerializeToString<T>(T data)
+        {
+            try
+            {
+                var serializer = new XmlSerializer(typeof(T));
+                using (var writer = new StringWriter())
+                {
+                    serializer.Serialize(writer, data);
+                    return writer.ToString();
+                }
+            }
+            catch (Exception ex)
+            {
+                throw new InvalidOperationException("XML serialization to string failed", ex);
+            }
+        }
+
         /// <summary>
         /// 从XML文件反序列化对象
         /// </summary>
@@ -56,5 +80,28 @@ namespace MvvmScaffoldFrame48.DLL.ConfigTools
                 throw new InvalidOperationException("XML deserialization failed", ex);
             }
         }
+
+        /// <summary>
+        /// 从XML字符串反序列化对象
+        /// </summary>
+        /// <typeparam name="T">对象类型</typeparam>
+        /// <param name="xmlString">XML字符串</param>
+        /// <returns>反序列化的对象</returns>
+        /// <exception cref="InvalidOperationException"></exception>
+        public static T DeserializeFromString<T>(string xmlString)
+        {
+            try
+            {
+                var serializer = new XmlSerializer(typeof(T));
+                using (var reader = new StringReader(xmlString))
+                {
+                    return (T)serializer.Deserialize(reader);
+                }
+            }
+            catch (Exception ex)
+            {
+                throw new InvalidOperationException("XML deserialization from string failed", ex);
+            }
+        }
     }
 }

MvvmScaffoldFrame48.DLL/MvvmScaffoldFrame48.Dll.csproj

@@ -114,6 +114,7 @@
     <Compile Include="ThreadManager\CameraGroup.cs" />
     <Compile Include="ThreadManager\CommunicationThread.cs" />
     <Compile Include="ThreadManager\IImageProcessingAlgorithmHikVision.cs" />
+    <Compile Include="ThreadManager\ImageProcessingAlgorithmHikVisionFactory.cs" />
     <Compile Include="ThreadManager\ProcessingAlgorithm.cs" />
     <Compile Include="ThreadManager\ThreadManager.cs" />
     <Compile Include="UserManager.cs" />

MvvmScaffoldFrame48.DLL/ThreadManager/CameraGroup.cs

@@ -1,11 +1,10 @@
-using MvCameraControl;
+// CameraGroup.cs 相机组线程管理类，控制相机采集和识别的线程运行，开放有算法的接口
+using MvCameraControl;
 using MvvmScaffoldFrame48.DLL.CameraTools;
 using MvvmScaffoldFrame48.Model.ResultModel;
+using MvvmScaffoldFrame48.Model.StorageModel.SystemConfig;
 using System;
 using System.Collections.Concurrent;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -17,39 +16,34 @@ namespace MvvmScaffoldFrame48.DLL.ThreadManager
     /// </summary>
     public class CameraGroup
     {
+        #region 变量与实例
+        //相机线程的休眠时间，默认为0，即不休眠。在采集节拍没有那么高时，增加此值降低性能消耗
+        private int CameraSleepTime = 0;
+        //相机
         public HikCamera Camera { get; set; }
+        //相机ID
         public int CameraId { get; set; }
+        //是否运行中
         public bool IsRunning { get; set; }
-        public CancellationTokenSource CancellationTokenSource { get; set; }
+        //相机处理线程
         public Task CameraTask { get; set; }
+        //图像处理线程
         public Task ProcessingTask { get; set; }
+        //图像队列
         public ConcurrentQueue<IImage> ImageQueue { get; set; }
+        //信号量
         public SemaphoreSlim QueueSemaphore { get; set; }
-
+        //取消令牌
+        public CancellationTokenSource CancellationTokenSource { get; set; }
         // 图像处理算法（接口方式）
         public IImageProcessingAlgorithmHikVision ImageProcessor { get; set; }
-
         // 结果发送事件，当图像处理完成时触发
         public event EventHandler<CameraProcessEventArgsResultModel> ProcessResultAvailable;
+        // 相机配置
+        public CameraProcessConfigModel Configuration { get; set; }
+        #endregion
 
-        /// <summary>
-        /// 发送处理结果到通信线程的方法
-        /// 多个线程可以共用此方法
-        /// </summary>
-        /// <param name="resultData">处理结果数据</param>
-        public void SendProcessResult(object resultData)
-        {
-            var eventArgs = new CameraProcessEventArgsResultModel
-            {
-                CameraId = this.CameraId,
-                ResultData = resultData,
-                Timestamp = DateTime.Now
-            };
-
-            // 触发事件，通知订阅者有新的处理结果
-            ProcessResultAvailable?.Invoke(this, eventArgs);
-        }
-
+        #region 公共方法
         /// <summary>
         /// 启动相机组（包括采集和处理线程）
         /// </summary>
@@ -60,7 +54,7 @@ namespace MvvmScaffoldFrame48.DLL.ThreadManager
                 Console.WriteLine($"相机 {CameraId} 未初始化");
                 return;
             }
-            if(Camera.Device == null)
+            if (Camera.Device == null)
             {
                 Console.WriteLine($"相机 {CameraId} 未初始化");
             }
@@ -72,6 +66,9 @@ namespace MvvmScaffoldFrame48.DLL.ThreadManager
             if (IsRunning)
                 return;
 
+            // 根据配置加载算法
+            LoadAlgorithmFromConfiguration();
+
             Camera.StartReceiveFuntion();
 
             // 重置取消令牌
@@ -120,10 +117,134 @@ namespace MvvmScaffoldFrame48.DLL.ThreadManager
             Console.WriteLine($"相机组 {CameraId} 已停止");
         }
 
+        /// <summary>
+        /// 更新算法参数
+        /// </summary>
+        /// <param name="parameters">新参数</param>
+        public void UpdateAlgorithmParameters(object parameters)
+        {
+            if (ImageProcessor != null && parameters != null)
+            {
+                string parametersjson = ImageProcessor.GetSaveJson();
+                ImageProcessor.Configure(parametersjson);
+
+                // 更新配置
+                if (Configuration != null)
+                {
+                    Configuration.AlgorithmParameters = parametersjson;
+                }
+
+                Console.WriteLine($"相机 {CameraId} 算法参数已更新");
+            }
+        }
+        #endregion
+
+        #region 私有方法
+        /// <summary>
+        /// 设置图像处理算法
+        /// </summary>
+        /// <param name="algorithmName">算法名称</param>
+        private void SetProcessingAlgorithm(string algorithmName, string parameters = null)
+        {
+            if (string.IsNullOrEmpty(algorithmName))
+            {
+                ImageProcessor = null;
+                return;
+            }
+
+            try
+            {
+                // 根据算法名称创建实例（这里可以使用简单的工厂方法或反射）
+                ImageProcessor = ImageProcessingAlgorithmHikVisionFactory.CreateAlgorithm(algorithmName);
+
+                // 配置参数
+                if (parameters != null &&  ImageProcessor != null)
+                {
+                    ImageProcessor.Configure(parameters);
+                }
+
+                Console.WriteLine($"相机 {CameraId} 成功设置算法: {algorithmName}");
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"相机 {CameraId} 设置算法 {algorithmName} 失败: {ex.Message}");
+            }
+        }
+
+        /// <summary>
+        /// 根据配置动态加载算法
+        /// </summary>
+        private void LoadAlgorithmFromConfiguration()
+        {
+            if (Configuration != null && !string.IsNullOrEmpty(Configuration.ProcessingAlgorithmName))
+            {
+                SetProcessingAlgorithm(Configuration.ProcessingAlgorithmName, Configuration.AlgorithmParameters);
+            }
+            else
+            {
+                // 使用默认算法（无参数）
+                SetProcessingAlgorithm("Default");
+            }
+        }
+
+        /// <summary>
+        /// 发送处理结果到通信线程的方法
+        /// 多个线程可以共用此方法
+        /// </summary>
+        /// <param name="resultData">处理结果数据</param>
+        private void SendProcessResult(object resultData)
+        {
+            var eventArgs = new CameraProcessEventArgsResultModel
+            {
+                CameraId = this.CameraId,
+                ResultData = resultData,
+                Timestamp = DateTime.Now
+            };
+
+            // 触发事件，通知订阅者有新的处理结果
+            ProcessResultAvailable?.Invoke(this, eventArgs);
+        }
+
+        /// <summary>
+        /// 图像处理实现
+        /// </summary>
+        private void ProcessImage(IImage imageData, int cameraId)
+        {
+            object resultData = null;
+
+            try
+            {
+                // 优先使用接口方式的算法
+                if (ImageProcessor != null)
+                {
+                    resultData = ImageProcessor.ProcessImage(imageData, cameraId);
+                }
+                // 如果都没有设置，则使用默认处理
+                else
+                {
+                    Console.WriteLine($"相机 {CameraId} 未加载算法");
+                    // 默认处理逻辑
+                }
+
+                // 发送处理结果
+                SendProcessResult(resultData);
+
+                // 输出处理结果
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"相机 {CameraId} 图像处理错误: {ex.Message}");
+
+                // 发送错误结果
+            }
+        }
+        #endregion
+
+        #region 线程主体方法
         /// <summary>
         /// 相机采集循环
         /// </summary>
-        private void CameraCaptureLoop(CancellationToken token)
+        private async void CameraCaptureLoop(CancellationToken token)
         {
             //int frameCount = 0;
             try
@@ -131,7 +252,7 @@ namespace MvvmScaffoldFrame48.DLL.ThreadManager
                 while (!token.IsCancellationRequested)
                 {
                     // 模拟相机图像采集（无休眠，持续采集）
-                    if(Camera.GetOnceImage(out IFrameOut imageData))
+                    if (Camera.GetOnceImage(out IFrameOut imageData))
                     {
                         // 将图像放入队列
                         ImageQueue.Enqueue(imageData.Image.Clone() as IImage);
@@ -140,6 +261,7 @@ namespace MvvmScaffoldFrame48.DLL.ThreadManager
                         imageData.Dispose();
                     }
                     // 这里不添加休眠，保持最大帧率采集
+                    await Task.Delay(CameraSleepTime);
                 }
             }
             catch (OperationCanceledException)
@@ -188,46 +310,6 @@ namespace MvvmScaffoldFrame48.DLL.ThreadManager
                 Console.WriteLine($"相机 {CameraId} 处理异常: {ex.Message}");
             }
         }
-
-        /// <summary>
-        /// 图像处理实现
-        /// </summary>
-        private void ProcessImage(IImage imageData,int cameraId)
-        {
-            object resultData = null;
-
-            try
-            {
-                // 优先使用接口方式的算法
-                if (ImageProcessor != null)
-                {
-                    resultData = ImageProcessor.ProcessImage(imageData,cameraId);
-                }
-                // 如果都没有设置，则使用默认处理
-                else
-                {
-                    // 默认处理逻辑
-                }
-
-                // 发送处理结果
-                SendProcessResult(resultData);
-
-                // 输出处理结果
-                //Console.WriteLine($"相机 {CameraId} 处理时间 {DateTime.Now.ToString("g")}");
-            }
-            catch (Exception ex)
-            {
-                Console.WriteLine($"相机 {CameraId} 图像处理错误: {ex.Message}");
-
-                // 发送错误结果
-                //var errorResult = new ProcessResultData
-                //{
-                //    Result = $"Error_Camera{CameraId}_Frame{imageData.FrameNumber}_{ex.Message}",
-                //    ProcessingTime = DateTime.Now
-                //};
-
-                //SendProcessResult(errorResult);
-            }
-        }
+        #endregion
     }
 }

MvvmScaffoldFrame48.DLL/ThreadManager/CommunicationThread.cs

@@ -1,4 +1,5 @@
-using MvvmScaffoldFrame48.Model.ResultModel;
+//
+using MvvmScaffoldFrame48.Model.ResultModel;
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
@@ -15,6 +16,7 @@ namespace MvvmScaffoldFrame48.DLL.ThreadManager
     /// </summary>
     public class CommunicationThread
     {
+        #region 变量与实例
         public bool IsRunning { get; private set; }
         public CancellationTokenSource CancellationTokenSource { get; private set; }
         public Task CommunicationTask { get; private set; }
@@ -22,6 +24,9 @@ namespace MvvmScaffoldFrame48.DLL.ThreadManager
         // 待发送数据队列
         private readonly ConcurrentQueue<CameraProcessEventArgsResultModel> _dataQueue = new ConcurrentQueue<CameraProcessEventArgsResultModel>();
         private readonly SemaphoreSlim _queueSemaphore = new SemaphoreSlim(0);
+        #endregion
+
+        #region 公共方法
 
         /// <summary>
         /// 发送数据到通信设备
@@ -73,7 +78,9 @@ namespace MvvmScaffoldFrame48.DLL.ThreadManager
             IsRunning = false;
             Console.WriteLine("通信线程已停止");
         }
+        #endregion
 
+        #region 私有方法
         private async void CommunicationLoop(CancellationToken token)
         {
             try
@@ -109,5 +116,6 @@ namespace MvvmScaffoldFrame48.DLL.ThreadManager
             // 实现具体通信逻辑
             Console.WriteLine($"通信线程发送数据: 相机{data.CameraId}, 时间{data.Timestamp}");
         }
+        #endregion
     }
 }

MvvmScaffoldFrame48.DLL/ThreadManager/IImageProcessingAlgorithmHikVision.cs

@@ -1,4 +1,6 @@
-using MvCameraControl;
+// IImageProcessingAlgorithmHikVision.cs 创建于 2023/05/09 14:07:09
+// 算法接口，用于处理图像数据，可以继承此接口来实现新的算法，
+using MvCameraControl;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -20,5 +22,19 @@ namespace MvvmScaffoldFrame48.DLL.ThreadManager
         /// 获取算法名称
         /// </summary>
         string AlgorithmName { get; }
+
+        /// <summary>
+        /// 配置算法参数
+        /// </summary>
+        /// <param name="parameters">参数字典</param>
+        void Configure(string parameters);
+
+        /// <summary>
+        /// 获取当前算法参数
+        /// </summary>
+        /// <returns>参数字典</returns>
+        Object GetParameters();
+
+        string GetSaveJson();
     }
 }

MvvmScaffoldFrame48.DLL/ThreadManager/ImageProcessingAlgorithmHikVisionFactory.cs

@@ -0,0 +1,80 @@
+// ImageProcessingAlgorithmFactory.cs 识别算法工厂，用于注册算法实现
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace MvvmScaffoldFrame48.DLL.ThreadManager
+{
+    public static class ImageProcessingAlgorithmHikVisionFactory
+    {
+        #region 变量与实例
+        // 存储所有算法实现类型的字典
+        private static readonly Dictionary<string, Type> _algorithmTypes = new Dictionary<string, Type>();
+        #endregion
+
+        #region 构造方法
+        /// <summary>
+        /// 静态构造函数，在类加载时注册所有可用的算法实现
+        /// </summary>
+        static ImageProcessingAlgorithmHikVisionFactory()
+        {
+            // 注册所有可用的算法实现
+            RegisterAlgorithm<ProcessingAlgorithm>("ProcessingAlgorithm");
+            // 可以继续注册更多算法...
+        }
+        #endregion
+
+        #region 私有方法
+        /// <summary>
+        /// 注册算法实现
+        /// </summary>
+        /// <typeparam name="T">算法实现类型</typeparam>
+        /// <param name="algorithmName">算法名称</param>
+        private static void RegisterAlgorithm<T>(string algorithmName) where T : IImageProcessingAlgorithmHikVision, new()
+        {
+            _algorithmTypes[algorithmName] = typeof(T);
+        }
+        #endregion
+
+        #region 公有方法
+        /// <summary>
+        /// 根据算法名称创建算法实例
+        /// </summary>
+        /// <param name="algorithmName">算法名称</param>
+        /// <returns>算法实例</returns>
+        public static IImageProcessingAlgorithmHikVision CreateAlgorithm(string algorithmName)
+        {
+            if (_algorithmTypes.ContainsKey(algorithmName))
+            {
+                return (IImageProcessingAlgorithmHikVision)Activator.CreateInstance(_algorithmTypes[algorithmName]);
+            }
+            else
+            {
+                Console.WriteLine($"未找到名为 '{algorithmName}' 的算法实现");
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// 获取所有已注册的算法名称
+        /// </summary>
+        /// <returns>算法名称列表</returns>
+        public static List<string> GetAvailableAlgorithms()
+        {
+            return _algorithmTypes.Keys.ToList();
+        }
+
+        /// <summary>
+        /// 检查算法是否存在
+        /// </summary>
+        /// <param name="algorithmName">算法名称</param>
+        /// <returns>是否存在</returns>
+        public static bool AlgorithmExists(string algorithmName)
+        {
+            return _algorithmTypes.ContainsKey(algorithmName);
+        }
+        #endregion
+    }
+}

MvvmScaffoldFrame48.DLL/ThreadManager/ProcessingAlgorithm.cs

@@ -1,5 +1,8 @@
-using MvCameraControl;
+//实现线程算法示例
+using MvCameraControl;
+using MvvmScaffoldFrame48.DLL.ConfigTools;
 using MvvmScaffoldFrame48.Model.ResultModel;
+using MvvmScaffoldFrame48.Model.StorageModel.ProcessingConfig;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -11,10 +14,29 @@ namespace MvvmScaffoldFrame48.DLL.ThreadManager
 {
     public class ProcessingAlgorithm : IImageProcessingAlgorithmHikVision
     {
+        #region 变量与实例
+        //参数:阈值
+        private double _threshold = 128.0;
+        //参数:最小面积
+        private int _minArea = 100;
+        //参数:是否启用滤波
+        private bool _enableFiltering = true;
+        //参数:滤波类型
+        private string _filterType = "Gaussian";
+        //算法名称
         public string AlgorithmName => "ProcessingAlgorithm";
+        #endregion
 
-        public object ProcessImage(IImage imageData,int cameraId)
+        #region 私有方法
+        #endregion
+
+        #region 公开方法
+        public object ProcessImage(IImage imageData, int cameraId)
         {
+            // 使用当前参数进行图像处理
+            Console.WriteLine($"AlgorithmA 处理图像: 阈值={_threshold}, 最小面积={_minArea}");
+
+
             // 模拟算法A的处理逻辑
             Thread.Sleep(1); // 模拟处理时间
             Console.WriteLine("相机执行了一次识别");
@@ -26,5 +48,40 @@ namespace MvvmScaffoldFrame48.DLL.ThreadManager
                 Timestamp = DateTime.Now
             };
         }
+
+        public void Configure(string parameters)
+        {
+            var parameter = XMLReadWrite.DeserializeFromString<ProcessingAlgorithmConfigModel>(parameters);
+            if(parameter != null)
+            {
+                _threshold = parameter.Threshold;
+                _minArea = parameter.MinArea;
+                _enableFiltering = parameter.EnableFiltering;
+                _filterType = parameter.FilterType;
+            }
+        }
+
+        public object GetParameters()
+        {
+            return new ProcessingAlgorithmConfigModel
+            {
+                Threshold = _threshold,
+                MinArea = _minArea,
+                EnableFiltering = _enableFiltering,
+                FilterType = _filterType
+            };
+        }
+
+        public string GetSaveJson()
+        {
+            return XMLReadWrite.SerializeToString(new ProcessingAlgorithmConfigModel
+            {
+                Threshold = _threshold,
+                MinArea = _minArea,
+                EnableFiltering = _enableFiltering,
+                FilterType = _filterType
+            });
+        }
+        #endregion
     }
 }

MvvmScaffoldFrame48.DLL/ThreadManager/ThreadManager.cs

@@ -1,35 +1,79 @@
-using MvCameraControl;
+// 线程管理中心，负责线程的管理，如线程的初始化，启动，停止，包括识别线程的算法加载
+using MvCameraControl;
 using MvvmScaffoldFrame48.DLL.CameraTools;
+using MvvmScaffoldFrame48.DLL.ConfigTools;
 using MvvmScaffoldFrame48.Model.ResultModel;
+using MvvmScaffoldFrame48.Model.StorageModel.ProcessingConfig;
+using MvvmScaffoldFrame48.Model.StorageModel.SystemConfig;
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
+using System.IO;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using System.Windows.Media.Media3D;
 
 namespace MvvmScaffoldFrame48.DLL.ThreadManager
 {
     public class ThreadManager
     {
+        #region 变量与实例
+        //相机组
         private readonly CameraGroup[] _cameraGroups = new CameraGroup[1];
+        // 通信线程
         private readonly CommunicationThread _communicationThread;
+        // 相机配置参数
+        private List<CameraProcessConfigModel> _cameraConfigurations;
+        #endregion
 
+        #region 构造函数
+        /// <summary>
+        /// 构造函数
+        /// </summary>
         public ThreadManager()
         {
+            // 加载相机配置
+            LoadCameraConfigurations();
+
+            // 获取相机列表
             HikVision.GetCameraList(out List<IDeviceInfo> cameraInfoList);
+
             // 初始化四个相机组
             for (int i = 0; i < _cameraGroups.Count(); i++)
             {
-                _cameraGroups[i] = new CameraGroup
+                // 加载对应相机位的配置参数
+                var CheckConfig = _cameraConfigurations.Where(c => c.CameraId == i);
+                if(CheckConfig.Count() == 0) 
                 {
-                    CameraId = i,
-                    ImageQueue = new ConcurrentQueue<IImage>(),
-                    QueueSemaphore = new SemaphoreSlim(0),
-                    Camera = new HikCamera(cameraInfoList[i])
-                };
-
-                _cameraGroups[i].ImageProcessor = new ProcessingAlgorithm();
+                    _cameraGroups[i] = null;
+                    continue; 
+                }
+                var cameraConfig = CheckConfig.FirstOrDefault();
+                // 获取参数对应的相机
+                HikVision.GetCamera(out IDeviceInfo cameraInfo, cameraConfig.CameraSN);
+                if (cameraInfo == null)
+                {
+                    _cameraGroups[i] = new CameraGroup
+                    {
+                        CameraId = i,
+                        ImageQueue = new ConcurrentQueue<IImage>(),
+                        QueueSemaphore = new SemaphoreSlim(0),
+                        Camera = new HikCamera(),
+                        Configuration = cameraConfig
+                    };
+                }
+                else 
+                {
+                    _cameraGroups[i] = new CameraGroup
+                    {
+                        CameraId = i,
+                        ImageQueue = new ConcurrentQueue<IImage>(),
+                        QueueSemaphore = new SemaphoreSlim(0),
+                        Camera = new HikCamera(cameraInfo),
+                        Configuration = cameraConfig
+                    };
+                }
                 // 订阅处理结果事件
                 _cameraGroups[i].ProcessResultAvailable += OnProcessResultAvailable;
             }
@@ -37,17 +81,45 @@ namespace MvvmScaffoldFrame48.DLL.ThreadManager
             // 初始化通信和显示线程
             _communicationThread = new CommunicationThread();
         }
+        #endregion
+
+        #region 公共方法
 
         /// <summary>
-        /// 处理相机处理结果
+        /// 动态更改相机算法
         /// </summary>
-        private void OnProcessResultAvailable(object sender, CameraProcessEventArgsResultModel e)
+        public void ChangeCameraAlgorithm(int cameraId, string algorithmName)
         {
-            // 将处理结果发送到通信线程
-            _communicationThread.SendData(e);
+            if (cameraId >= 0 && cameraId < _cameraGroups.Count())
+            {
+                // 相机组未初始化
+                if (_cameraGroups == null)
+                {
+                    Console.WriteLine($"相机组{cameraId}未初始化");
+                    return;
+                }
+                // 更新配置
+                var config = _cameraConfigurations.FirstOrDefault(c => c.CameraId == cameraId);
+                if (config != null)
+                {
+                    config.ProcessingAlgorithmName = algorithmName;
+                }
 
-            // 可以在这里添加其他处理逻辑，如更新显示等
-            Console.WriteLine($"收到相机{e.CameraId}的处理结果");
+                // 如果相机正在运行，需要重启以应用新算法
+                bool wasRunning = _cameraGroups[cameraId].IsRunning;
+                if (wasRunning)
+                {
+                    _cameraGroups[cameraId].Stop();
+                    Thread.Sleep(100); // 等待线程完全停止
+                }
+
+                // 更新相机组配置并重新启动
+                _cameraGroups[cameraId].Configuration = config;
+                if (wasRunning)
+                {
+                    _cameraGroups[cameraId].Start();
+                }
+            }
         }
 
         /// <summary>
@@ -117,12 +189,90 @@ namespace MvvmScaffoldFrame48.DLL.ThreadManager
         /// </summary>
         public bool IsCameraGroupRunning(int cameraId)
         {
-            return cameraId >= 0 && cameraId < 4 && _cameraGroups[cameraId].IsRunning;
+            return cameraId >= 0 && cameraId < _cameraGroups.Count() && _cameraGroups[cameraId].IsRunning;
+        }
+
+        /// <summary>
+        /// 为每个相机创建配置
+        /// </summary>
+        private CameraProcessConfigModel CreateCameraConfiguration(int cameraId,string ProcessingAlgorithm)
+        {
+            var config = new CameraProcessConfigModel
+            {
+                CameraId = cameraId,
+                CameraSN = "00E31768761",
+                IsEnabled = true
+            };
+
+            switch (ProcessingAlgorithm)
+            {
+                case "ProcessingAlgorithm":
+                    config.ProcessingAlgorithmName = "ProcessingAlgorithm";
+                    config.AlgorithmParameters = XMLReadWrite.SerializeToString(new ProcessingAlgorithmConfigModel()
+                    {
+                        Threshold = 0.5,
+                        MinArea = 100,
+                        EnableFiltering = true,
+                        FilterType = "FilterType"
+                    });
+                    break;
+            }
+
+            return config;
+        }
+
+        /// <summary>
+        /// 动态更新相机算法参数
+        /// </summary>
+        public void UpdateCameraParameters(int cameraId, object newParameters)
+        {
+            if (cameraId >= 0 && cameraId < _cameraGroups.Count())
+            {
+                _cameraGroups[cameraId].UpdateAlgorithmParameters(newParameters);
+            }
         }
 
         /// <summary>
         /// 获取通信线程运行状态
         /// </summary>
         public bool IsCommunicationRunning => _communicationThread.IsRunning;
+        #endregion
+
+        #region 私有方法
+        /// <summary>
+        /// 加载相机配置
+        /// </summary>
+        private void LoadCameraConfigurations()
+        {
+            // 这里可以从XML文件、数据库或其他配置源加载配置
+            if (File.Exists("TestConfig.xml"))
+            {
+                _cameraConfigurations = XMLReadWrite.DeserializeFromXml<List<CameraProcessConfigModel>>("TestConfig.xml");
+            }
+            else
+            {
+                _cameraConfigurations = new List<CameraProcessConfigModel>()
+                {
+                    CreateCameraConfiguration(0, "ProcessingAlgorithm"),
+                };
+            }
+
+            //XMLReadWrite.SerializeToXml(_cameraConfigurations, "TestConfig.xml");
+        }
+
+        /// <summary>
+        /// 处理相机处理结果
+        /// </summary>
+        private void OnProcessResultAvailable(object sender, CameraProcessEventArgsResultModel e)
+        {
+            // 将处理结果发送到通信线程
+            _communicationThread.SendData(e);
+
+            // 可以在这里添加其他处理逻辑，如更新显示等
+            Console.WriteLine($"收到相机{e.CameraId}的处理结果");
+        }
+
+
+        #endregion
     }
 }

MvvmScaffoldFrame48.MODEL/MvvmScaffoldFrame48.Model.csproj

@@ -68,9 +68,11 @@
     <Compile Include="StorageModel\HikVisionCamera\CameraInfoModel.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="StorageModel\ImageAlgorithm\BoundingRectangleMdoel.cs" />
+    <Compile Include="StorageModel\ProcessingConfig\ProcessingAlgorithmConfigModel.cs" />
     <Compile Include="StorageModel\ImageAlgorithm\CPUDeepObjectDetectUseModel.cs" />
     <Compile Include="StorageModel\SystemAlarm\AlarmMessModel.cs" />
     <Compile Include="StorageModel\SystemAlarm\AlarmTypes.cs" />
+    <Compile Include="StorageModel\SystemConfig\AllCameraProcessConfigModel.cs" />
     <Compile Include="StorageModel\SystemTools\SystemMessageConfigModel.cs" />
     <Compile Include="UserModel.cs" />
   </ItemGroup>

MvvmScaffoldFrame48.MODEL/StorageModel/AlgorithmConfig/ProcessingAlgorithmParameterConfig.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace MvvmScaffoldFrame48.Model.StorageModel.AlgorithmConfig
+{
+    public class ProcessingAlgorithmParameterConfig
+    {
+        public double _threshold {get; set;}
+        //参数:最小面积
+        public int _minArea { get; set; }
+        //参数:是否启用滤波
+        public bool _enableFiltering {get; set;}
+        //参数:滤波类型
+        public string _filterType {get;set;}
+    }
+}

MvvmScaffoldFrame48.MODEL/StorageModel/ProcessingConfig/ProcessingAlgorithmConfigModel.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace MvvmScaffoldFrame48.Model.StorageModel.ProcessingConfig
+{
+    public class ProcessingAlgorithmConfigModel
+    {
+        //参数:阈值
+        public double Threshold { get; set; }
+        //参数:最小面积
+        public int MinArea { get; set;}
+        //参数:是否启用滤波
+        public bool EnableFiltering {get; set;}
+        //参数:滤波类型
+        public string FilterType { get; set;}
+    }
+}

MvvmScaffoldFrame48.MODEL/StorageModel/SystemConfig/AllCameraProcessConfigModel.cs

@@ -0,0 +1,53 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Xml.Linq;
+
+namespace MvvmScaffoldFrame48.Model.StorageModel.SystemConfig
+{
+    // <summary>
+    /// 单个相机处理配置
+    /// </summary>
+    public class CameraProcessConfigModel
+    {
+        /// <summary>
+        /// 相机ID
+        /// </summary>
+        public int CameraId { get; set; }
+
+        /// <summary>
+        /// 相机序列号
+        /// </summary>
+        public string CameraSN { get; set; }
+
+        /// <summary>
+        /// 使用的图像处理算法名称
+        /// </summary>
+        public string ProcessingAlgorithmName { get; set; }
+
+        /// <summary>
+        /// 算法参数
+        /// </summary>
+        //public Dictionary<string, object> AlgorithmParameters { get; set; }
+        public string AlgorithmParameters { get; set; }
+
+        /// <summary>
+        /// 相机参数
+        /// </summary>
+        //public Dictionary<string, object> CameraParameters { get; set; }
+        public string CameraParameters { get; set; }
+
+        /// <summary>
+        /// 是否启用
+        /// </summary>
+        public bool IsEnabled { get; set; }
+
+        //public CameraProcessConfigModel()
+        //{
+            //AlgorithmParameters = new Dictionary<string, object>();
+            //CameraParameters = new Dictionary<string, object>();
+        //}
+    }
+}

MvvmScaffoldFrame48.MODEL/StorageModel/SystemConfig/CameraProcessConfigModel.cs

@@ -0,0 +1,47 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Xml.Linq;
+
+namespace MvvmScaffoldFrame48.Model.StorageModel.SystemConfig
+{
+    // <summary>
+    /// 单个相机处理配置
+    /// </summary>
+    public class CameraProcessConfigModel
+    {
+        /// <summary>
+        /// 相机ID
+        /// </summary>
+        public int CameraId { get; set; }
+
+        /// <summary>
+        /// 相机序列号
+        /// </summary>
+        public string CameraSN { get; set; }
+
+        /// <summary>
+        /// 使用的图像处理算法名称
+        /// </summary>
+        public string ProcessingAlgorithmName { get; set; }
+
+        /// <summary>
+        /// 算法参数
+        /// </summary>
+        //public Dictionary<string, object> AlgorithmParameters { get; set; }
+        public string AlgorithmParameters { get; set; } = "{}";
+
+        /// <summary>
+        /// 相机参数
+        /// </summary>
+        //public Dictionary<string, object> CameraParameters { get; set; }
+        public string CameraParameters { get; set; } = "{}";
+
+        /// <summary>
+        /// 是否启用
+        /// </summary>
+        public bool IsEnabled { get; set; }
+    }
+}