C# WinForm中在PictureBox绘制可编辑移动的多Bounding Box问题

我来帮你一步步解决这些问题——你的核心问题在于没有正确管理 Bounding Box 的集合，误用了CreateGraphics导致绘制叠加，以及缺少选中、编辑的状态跟踪逻辑。下面是针对每个问题的解决思路和完整代码实现：

问题1：绘制时同一位置生成多个叠加框 #

原因：你用pBoxCenter.CreateGraphics()直接绘制，每次MouseMove都会在原有内容上叠加新框，而且这种临时绘制的内容在控件刷新（比如窗口最小化恢复）后会丢失。正确做法是利用WinForm的Paint事件统一绘制所有内容，每次重绘时清空画布再重新渲染所有框。

问题2：无法绘制多个Bounding Box #

原因：你只用单个mRect变量存储框，没有用集合维护所有已绘制的框。需要用List<Rectangle>来保存所有创建的 Bounding Box，每次绘制完成后将临时框添加到集合中。

问题3：实现Bounding Box的编辑（移动、调整大小、删除） #

需要跟踪三个核心状态：

• 当前选中的框索引
• 鼠标按下时的偏移量（用于移动/调整大小）
• 当前选中的调整控制点（比如四个角、四条边）

在MouseMove时根据不同状态处理移动或调整逻辑，同时在Paint事件中绘制选中框的控制点，方便用户操作。

完整代码实现 #

首先替换你原有的变量和事件逻辑，以下是完整的Form代码示例：

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Windows.Forms;

namespace YourWinFormProject
{
    public partial class YourForm : Form
    {
        // 存储所有已创建的Bounding Box
        private List<Rectangle> _boundingBoxes = new List<Rectangle>();
        // 绘制新框时的临时矩形
        private Rectangle? _tempRectangle;
        // 当前选中的框索引（-1表示无选中）
        private int _selectedBoxIndex = -1;
        // 调整大小的控制点类型
        private enum ResizeHandle { None, TopLeft, TopRight, BottomLeft, BottomRight, Left, Top, Right, Bottom }
        private ResizeHandle _currentResizeHandle = ResizeHandle.None;
        // 鼠标按下时相对于选中框左上角的偏移量
        private Point _mouseOffset;

        public YourForm()
        {
            InitializeComponent();
            // 注册必要的事件
            pBoxCenter.Paint += PBoxCenter_Paint;
            pBoxCenter.MouseDown += pBoxCenter_MouseDown;
            pBoxCenter.MouseMove += pBoxCenter_MouseMove;
            pBoxCenter.MouseUp += pBoxCenter_MouseUp;
            // 允许PictureBox接收键盘事件（用于删除选中框）
            pBoxCenter.KeyPreview = true;
            pBoxCenter.KeyDown += PBoxCenter_KeyDown;
        }

        // 核心绘制逻辑：统一在Paint事件中渲染所有内容
        private void PBoxCenter_Paint(object sender, PaintEventArgs e)
        {
            var g = e.Graphics;
            // 绘制所有已保存的Bounding Box
            using (var pen = new Pen(Color.White, 2))
            {
                foreach (var rect in _boundingBoxes)
                {
                    g.DrawRectangle(pen, rect);
                }
            }

            // 绘制正在创建的临时框（浅蓝色区分）
            if (_tempRectangle.HasValue)
            {
                using (var pen = new Pen(Color.LightBlue, 2))
                {
                    g.DrawRectangle(pen, _tempRectangle.Value);
                }
            }

            // 绘制选中框的调整控制点（红色小方块）
            if (_selectedBoxIndex != -1)
            {
                var selectedRect = _boundingBoxes[_selectedBoxIndex];
                using (var brush = new SolidBrush(Color.Red))
                {
                    // 四个角控制点
                    g.FillRectangle(brush, new Rectangle(selectedRect.Left - 3, selectedRect.Top - 3, 6, 6));
                    g.FillRectangle(brush, new Rectangle(selectedRect.Right - 3, selectedRect.Top - 3, 6, 6));
                    g.FillRectangle(brush, new Rectangle(selectedRect.Left - 3, selectedRect.Bottom - 3, 6, 6));
                    g.FillRectangle(brush, new Rectangle(selectedRect.Right - 3, selectedRect.Bottom - 3, 6, 6));
                    // 四条边控制点（可选，方便单独调整边）
                    g.FillRectangle(brush, new Rectangle(selectedRect.Left - 3, selectedRect.Top + selectedRect.Height / 2 - 3, 6, 6));
                    g.FillRectangle(brush, new Rectangle(selectedRect.Right - 3, selectedRect.Top + selectedRect.Height / 2 - 3, 6, 6));
                    g.FillRectangle(brush, new Rectangle(selectedRect.Left + selectedRect.Width / 2 - 3, selectedRect.Top - 3, 6, 6));
                    g.FillRectangle(brush, new Rectangle(selectedRect.Left + selectedRect.Width / 2 - 3, selectedRect.Bottom - 3, 6, 6));
                }
            }
        }

        private void pBoxCenter_MouseDown(object sender, MouseEventArgs e)
        {
            // 先检查是否点击了调整控制点
            _currentResizeHandle = CheckResizeHandle(e.Location);
            if (_currentResizeHandle != ResizeHandle.None)
            {
                _mouseOffset = new Point(e.X - _boundingBoxes[_selectedBoxIndex].Left, e.Y - _boundingBoxes[_selectedBoxIndex].Top);
                pBoxCenter.Cursor = GetResizeCursor(_currentResizeHandle);
                return;
            }

            // 检查是否点击了已有的Bounding Box
            _selectedBoxIndex = CheckBoxHit(e.Location);
            if (_selectedBoxIndex != -1)
            {
                _mouseOffset = new Point(e.X - _boundingBoxes[_selectedBoxIndex].Left, e.Y - _boundingBoxes[_selectedBoxIndex].Top);
                pBoxCenter.Cursor = Cursors.SizeAll;
                return;
            }

            // 否则开始绘制新框
            _tempRectangle = new Rectangle(e.X, e.Y, 0, 0);
            pBoxCenter.Cursor = Cursors.Cross;
        }

        private void pBoxCenter_MouseMove(object sender, MouseEventArgs e)
        {
            if (e.Button != MouseButtons.Left) return;

            // 正在绘制新框
            if (_tempRectangle.HasValue)
            {
                var tempRect = _tempRectangle.Value;
                tempRect.Width = e.X - tempRect.X;
                tempRect.Height = e.Y - tempRect.Y;
                // 确保宽高为正，自动调整左上角坐标
                if (tempRect.Width < 0)
                {
                    tempRect.X += tempRect.Width;
                    tempRect.Width = -tempRect.Width;
                }
                if (tempRect.Height < 0)
                {
                    tempRect.Y += tempRect.Height;
                    tempRect.Height = -tempRect.Height;
                }
                _tempRectangle = tempRect;
                pBoxCenter.Invalidate(); // 触发Paint事件重绘
                return;
            }

            // 编辑已选中的框
            if (_selectedBoxIndex != -1)
            {
                if (_currentResizeHandle != ResizeHandle.None)
                {
                    ResizeSelectedBox(e.Location);
                }
                else
                {
                    MoveSelectedBox(e.Location);
                }
                pBoxCenter.Invalidate();
            }
        }

        private void pBoxCenter_MouseUp(object sender, MouseEventArgs e)
        {
            // 完成新框绘制，添加到集合
            if (_tempRectangle.HasValue)
            {
                if (_tempRectangle.Value.Width > 0 && _tempRectangle.Value.Height > 0)
                {
                    _boundingBoxes.Add(_tempRectangle.Value);
                }
                _tempRectangle = null;
                pBoxCenter.Invalidate();
            }
            // 重置编辑状态
            _currentResizeHandle = ResizeHandle.None;
            pBoxCenter.Cursor = Cursors.Default;
        }

        // 删除选中的框（按Delete键）
        private void PBoxCenter_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Delete && _selectedBoxIndex != -1)
            {
                _boundingBoxes.RemoveAt(_selectedBoxIndex);
                _selectedBoxIndex = -1;
                pBoxCenter.Invalidate();
            }
        }

        // 辅助方法：检查是否点击了调整控制点
        private ResizeHandle CheckResizeHandle(Point location)
        {
            if (_selectedBoxIndex == -1) return ResizeHandle.None;
            var rect = _boundingBoxes[_selectedBoxIndex];

            if (new Rectangle(rect.Left - 3, rect.Top - 3, 6, 6).Contains(location)) return ResizeHandle.TopLeft;
            if (new Rectangle(rect.Right - 3, rect.Top - 3, 6, 6).Contains(location)) return ResizeHandle.TopRight;
            if (new Rectangle(rect.Left - 3, rect.Bottom - 3, 6, 6).Contains(location)) return ResizeHandle.BottomLeft;
            if (new Rectangle(rect.Right - 3, rect.Bottom - 3, 6, 6).Contains(location)) return ResizeHandle.BottomRight;

            if (new Rectangle(rect.Left - 3, rect.Top + rect.Height / 2 - 3, 6, 6).Contains(location)) return ResizeHandle.Left;
            if (new Rectangle(rect.Right - 3, rect.Top + rect.Height / 2 - 3, 6, 6).Contains(location)) return ResizeHandle.Right;
            if (new Rectangle(rect.Left + rect.Width / 2 - 3, rect.Top - 3, 6, 6).Contains(location)) return ResizeHandle.Top;
            if (new Rectangle(rect.Left + rect.Width / 2 - 3, rect.Bottom - 3, 6, 6).Contains(location)) return ResizeHandle.Bottom;

            return ResizeHandle.None;
        }

        // 辅助方法：获取对应调整控制点的光标
        private Cursor GetResizeCursor(ResizeHandle handle)
        {
            return handle switch
            {
                ResizeHandle.TopLeft or ResizeHandle.BottomRight => Cursors.SizeNWSE,
                ResizeHandle.TopRight or ResizeHandle.BottomLeft => Cursors.SizeNESW,
                ResizeHandle.Left or ResizeHandle.Right => Cursors.SizeWE,
                ResizeHandle.Top or ResizeHandle.Bottom => Cursors.SizeNS,
                _ => Cursors.Default
            };
        }

        // 辅助方法：检查是否点击了某个Bounding Box
        private int CheckBoxHit(Point location)
        {
            // 倒序检查，确保最上层的框优先被选中
            for (int i = _boundingBoxes.Count - 1; i >= 0; i--)
            {
                if (_boundingBoxes[i].Contains(location))
                {
                    return i;
                }
            }
            return -1;
        }

        // 移动选中的框
        private void MoveSelectedBox(Point mouseLocation)
        {
            var rect = _boundingBoxes[_selectedBoxIndex];
            rect.Location = new Point(mouseLocation.X - _mouseOffset.X, mouseLocation.Y - _mouseOffset.Y);
            // 确保框不会超出PictureBox边界（可选）
            rect.X = Math.Max(0, rect.X);
            rect.Y = Math.Max(0, rect.Y);
            rect.X = Math.Min(pBoxCenter.Width - rect.Width, rect.X);
            rect.Y = Math.Min(pBoxCenter.Height - rect.Height, rect.Y);
            _boundingBoxes[_selectedBoxIndex] = rect;
        }

        // 调整选中框的大小
        private void ResizeSelectedBox(Point mouseLocation)
        {
            var rect = _boundingBoxes[_selectedBoxIndex];
            switch (_currentResizeHandle)
            {
                case ResizeHandle.TopLeft:
                    rect.Width = rect.Right - mouseLocation.X;
                    rect.Height = rect.Bottom - mouseLocation.Y;
                    rect.Location = mouseLocation;
                    break;
                case ResizeHandle.TopRight:
                    rect.Width = mouseLocation.X - rect.Left;
                    rect.Height = rect.Bottom - mouseLocation.Y;
                    rect.Y = mouseLocation.Y;
                    break;
                case ResizeHandle.BottomLeft:
                    rect.Width = rect.Right - mouseLocation.X;
                    rect.Height = mouseLocation.Y - rect.Top;
                    rect.X = mouseLocation.X;
                    break;
                case ResizeHandle.BottomRight:
                    rect.Width = mouseLocation.X - rect.Left;
                    rect.Height = mouseLocation.Y - rect.Top;
                    break;
                case ResizeHandle.Left:
                    rect.Width = rect.Right - mouseLocation.X;
                    rect.X = mouseLocation.X;
                    break;
                case ResizeHandle.Right:
                    rect.Width = mouseLocation.X - rect.Left;
                    break;
                case ResizeHandle.Top:
                    rect.Height = rect.Bottom - mouseLocation.Y;
                    rect.Y = mouseLocation.Y;
                    break;
                case ResizeHandle.Bottom:
                    rect.Height = mouseLocation.Y - rect.Top;
                    break;
            }
            // 确保框的最小尺寸（避免缩成0）
            rect.Width = Math.Max(10, rect.Width);
            rect.Height = Math.Max(10, rect.Height);
            // 确保框不会超出PictureBox边界
            rect.X = Math.Max(0, rect.X);
            rect.Y = Math.Max(0, rect.Y);
            rect.X = Math.Min(pBoxCenter.Width - rect.Width, rect.X);
            rect.Y = Math.Min(pBoxCenter.Height - rect.Height, rect.Y);
            _boundingBoxes[_selectedBoxIndex] = rect;
        }
    }
}

功能说明 #

替换代码后，你将获得以下完整功能：

1. 绘制多个框：拖拽鼠标可创建单个或多个Bounding Box，不会出现叠加问题
2. 移动框：点击选中框后拖拽鼠标即可移动
3. 调整大小：点击框的红色控制点（角或边），拖拽即可调整对应方向的尺寸
4. 删除框：选中框后按Delete键即可删除

内容的提问来源于stack exchange，提问作者Edison