~zhengyabo/SemanticSegmentationVer.git

			@@ -4,6 +4,7 @@
			using LB_VisionProcesses.Cameras;
			using Sunny.UI.Win32;
			using System;
			using System.Collections.Concurrent;
			using System.Collections.Generic;
			using System.Drawing;
			using System.Drawing.Imaging;
			@@ -533,14 +534,23 @@

			private void CreateAndFireBitmap()
			{
			Bitmap bmp = null;
			BitmapData bmpData = null;

			try
			{
			int width = _currentBitmapWidth;
			int height = _currentLineCount; // 使用实际采集到的行数
			int height = _currentLineCount;

			if (width <= 0 \|\| height <= 0 \|\| _rawPixelBuffer == null) return;
			// 基础合法性校验
			if (width <= 0 \|\| height <= 0 \|\| _rawPixelBuffer == null \|\| _rawPixelBuffer.Length < width * height)
			{
			AsyncLogHelper.Warn($"LBCamera[{SN}]: 图像参数无效，跳过生成");
			return;
			}

			Bitmap bmp = new Bitmap(width, height, PixelFormat.Format8bppIndexed);
			// 1. 创建8位灰度位图
			bmp = new Bitmap(width, height, PixelFormat.Format8bppIndexed);

			// 设置灰度调色板
			ColorPalette palette = bmp.Palette;
			@@ -550,9 +560,8 @@
			}
			bmp.Palette = palette;

			// 拷贝数据
			BitmapData bmpData = bmp.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.WriteOnly, PixelFormat.Format8bppIndexed);

			// 2. 高效内存拷贝（支持Stride对齐，整行复制）
			bmpData = bmp.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.WriteOnly, PixelFormat.Format8bppIndexed);
			// 注意：Bitmap Stride 可能不等于 Width，需要逐行拷贝
			int stride = bmpData.Stride;
			IntPtr ptr = bmpData.Scan0;
			@@ -567,36 +576,33 @@
			}

			bmp.UnlockBits(bmpData);
			bmpData = null; // 标记已解锁

			_frameCount++;
			AsyncLogHelper.Info($"LBCamera[{SN}]: Frame {_frameCount} generated ({width}x{height})");
			//空值校验：转换失败则直接返回
			if (bmp == null)
			AsyncLogHelper.Info($"LBCamera[{SN}]: 生成第 {_frameCount} 帧 ({width}x{height})");

			// 3. 获取/创建线程安全队列
			var queue = CollectedImages.GetOrAdd(SN, new ConcurrentQueue<Bitmap>());

			// 4. 队列限流，防止内存溢出
			if (queue.Count >= MAX_QUEUE_CAPACITY)
			{
			AsyncLogHelper.Warn(SN + "帧转换为Bitmap失败，跳过处理");
			return;
			if (queue.TryDequeue(out Bitmap old))
			{
			old.Dispose(); // 丢弃最旧帧，释放内存
			AsyncLogHelper.Warn($"LBCamera[{SN}]: 队列已满，自动丢弃最旧帧");
			}
			// 线程安全地将Bitmap添加到CollectedImages字典
			lock (_collectedImagesLock)
			{
			// 确保当前相机SN对应的列表存在
			if (!CollectedImages.ContainsKey(SN))
			{
			CollectedImages[SN] = new List<Bitmap>();
			}
			CollectedImages[SN].Add(bmp);
			AsyncLogHelper.Info(SN + $"图像已加入缓存，当前缓存数量：{CollectedImages[SN].Count}");
			}

			// 处理CollectedImages中的图像：遍历消费列表第一个元素直到为空
			ProcessCollectedImages();
			//// 异步触发事件，避免阻塞SDK回调线程
			// 5. 入队
			queue.Enqueue(bmp);
			AsyncLogHelper.Info($"LBCamera[{SN}]: 图像入队，当前队列：{queue.Count}");

			// 6. 启动队列（单例，避免多线程重复）
			StartConsumeQueue();
			//Task.Factory.StartNew(() =>
			//{
			// try
			// {
			// ImageGrabbed?.Invoke(this, new LBCameraEventArgs(SN, bmp, true));
			// CallBackImg = (Bitmap)bmp.Clone();
			// CallBackImg = (Bitmap)bitmap.Clone();
			// if (CallBackImg == null)
			// {
			// return;
			@@ -606,102 +612,83 @@
			// if (mode == TriggerMode.On && source != TriggerSource.Software)
			// TriggerRunMessageReceived?.Invoke(SN, source.ToString()); // 触发运行事件
			// }
			// bmp.Dispose();
			// }
			// catch (Exception ex)
			// {
			// AsyncLogHelper.Error($"LBCamera: Event Invoke error - {ex.Message}");
			// bmp.Dispose(); // 异常时释放资源
			// }
			// bitmap.Dispose();
			//});
			}
			catch (Exception ex)
			{
			AsyncLogHelper.Error($"LBCamera: CreateBitmap error - {ex.Message}");
			AsyncLogHelper.Error($"LBCamera[{SN}]: 创建图像失败 - {ex.Message}", ex);
			}
			finally
			{
			// 强制资源释放，绝对杜绝泄漏
			if (bmpData != null)
			{
			try { bmp?.UnlockBits(bmpData); } catch { }
			}
			// 注意：bmp 已入队，不能在这里释放，由调用者释放
			}
			}

			/// <summary>
			/// 启动队列（保证单线程）
			/// </summary>
			private void StartConsumeQueue()
			{
			// 使用轻量级判断，避免重复启动消费任务
			if (CollectedImages.TryGetValue(SN, out var queue) && !queue.IsEmpty)
			{
			Task.Factory.StartNew(ProcessImageQueue, TaskCreationOptions.LongRunning);
			}
			}

			/// <summary>
			/// 处理CollectedImages中的缓存图像
			/// 核心逻辑：遍历取第一个图像 -> 赋值给CallBackImg -> 触发事件 -> 释放并移除
			/// </summary>
			private void ProcessCollectedImages()
			{
			Task.Factory.StartNew(() =>
			{
			// 加锁保证线程安全，防止多线程同时操作列表
			lock (_collectedImagesLock)
			{
			// 校验当前相机的图像列表是否存在且有数据
			if (!CollectedImages.ContainsKey(SN) \|\| CollectedImages[SN].Count == 0)
			{
			AsyncLogHelper.Info(SN + "当前无缓存图像，跳过处理");
			return;
			}
			// 循环处理：直到列表为空
			while (CollectedImages[SN].Count > 0)
			private void ProcessImageQueue()
			{
			try
			{
			// 1 取列表第一个索引的图像赋值给CallBackImg
			Bitmap firstBitmap = CollectedImages[SN][0];
			ImageGrabbed?.Invoke(this, new LBCameraEventArgs(SN, firstBitmap, true));
			CallBackImg = (Bitmap)firstBitmap.Clone(); // 克隆避免原对象被释放后引用失效
			if (!CollectedImages.TryGetValue(SN, out var queue) \|\| queue.IsEmpty)
			return;

			// 2 获取触发模式并判断是否触发运行事件
			// 短锁：仅出队，不阻塞生产
			while (queue.TryDequeue(out Bitmap bitmap))
			{
			using (bitmap) // 自动释放：using 是最安全的方式
			{
			try
			{
			// 关键：事件传递克隆对象，绝对安全，不传递原资源
			using (Bitmap clone = (Bitmap)bitmap.Clone())
			{
			// 触发图像事件
			ImageGrabbed?.Invoke(this, new LBCameraEventArgs(SN, clone, true));
			}

			// 触发模式判断
			if (GetTriggerMode(out TriggerMode mode, out TriggerSource source))
			{
			// 硬触发模式下触发运行事件
			if (mode == TriggerMode.On && source != TriggerSource.Software)
			{
			AsyncLogHelper.Info(SN + $"触发硬触发事件，触发源：{source}");
			TriggerRunMessageReceived?.Invoke(SN, source.ToString());
			AsyncLogHelper.Info($"LBCamera[{SN}]: 硬触发事件 - {source}");
			}
			}
			else
			{
			AsyncLogHelper.Warn(SN + "获取触发模式失败，跳过事件触发");
			}

			// 3 释放第一个图像资源并从列表移除
			// 先释放Bitmap内存，再移除列表元素
			firstBitmap.Dispose();
			CollectedImages[SN].RemoveAt(0);
			AsyncLogHelper.Info(SN + $"已消费缓存图像，剩余缓存数量：{CollectedImages[SN].Count}");
			}
			catch (Exception ex)
			{
			AsyncLogHelper.Error(SN + $"处理缓存图像异常：{ex.Message}", ex);
			// 单个图像处理失败时，移除该图像避免阻塞后续处理
			if (CollectedImages[SN].Count > 0)
			AsyncLogHelper.Error($"LBCamera[{SN}]: 处理单帧图像异常 - {ex.Message}", ex);
			continue; // 单帧异常，继续处理下一帧
			}
			}
			}
			}
			catch (Exception ex)
			{
			try
			{
			CollectedImages[SN][0]?.Dispose(); // 尝试释放
			CollectedImages[SN].RemoveAt(0);
			AsyncLogHelper.Error($"LBCamera[{SN}]: 消费队列异常 - {ex.Message}", ex);
			}
			catch (Exception innerEx)
			{
			AsyncLogHelper.Error(SN + $"清理异常图像失败：{innerEx.Message}", innerEx);
			}
			}
			// 单个图像处理失败不终止循环，继续处理下一个
			// 4. 所有图像处理完成后，清空CallBackImg
			if (CallBackImg != null)
			{
			CallBackImg.Dispose();
			CallBackImg = null;
			}
			continue;
			}
			// 4. 所有图像处理完成后，清空CallBackImg
			if (CallBackImg != null)
			{
			CallBackImg.Dispose();
			CallBackImg = null;
			}
			}
			}
			});
			}