【C#】C#学习之OpenCv实现模版匹配案例

已于 2025-04-03 18:58:35 修改
阅读量321 收藏 3
点赞数 6
分类专栏： C# OpenCV 文章标签： c# opencv 模版匹配
于 2025-04-03 18:57:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_43626218/article/details/146987123
版权

【摘要】

本文描述了如何使用C#基于OpenCvSharpe实现模版匹配功能，其中实现了下功能：
1、图像加载；
2、模版加载、绘制、保存功能；
3、模版匹配功能。
【文末附上项目地址】

【环境运行】

操作系统：Windows 11
编程软件：Visual Studio 2022
其他相关：.Net Framework 4.8.0

一、预览

运行效果

在这里插入图片描述

二、项目代码

（一）主窗体代码

主窗体只需添加几个按钮:图像选择、模版选择、模版绘制、模版保存、模版匹配。并添加图像控件、模版控件。添加几句代码即可。

MainForm

using CustomControls;
using System;
namespace CS学习之OpenCv实现模版匹配项目
{
    public partial class MainForm : WinFormBase
    {
        MainViewModel viewModel;
        public MainForm()
        {
            InitializeComponent();
            this.CenterToParent();
            viewModel = new MainViewModel();
        }
        private void btn_ImageSelected_Click(object sender, System.EventArgs e)
        {
            uc_Canvas.Image = viewModel.LoadSource();
        }
        private void btn_TemplateSelected_Click(object sender, System.EventArgs e)
        {
            viewModel.TemplateImage = viewModel.LoadTemplate();
            uc_Template.Image = viewModel.TemplateImage;
        }
        private void btn_Drawing_Click(object sender, System.EventArgs e)
        {
            viewModel.TemplateImage = uc_Canvas.CropSelectedRegion();
            uc_Template.Image = viewModel.TemplateImage;
        }
        private void btn_Matching_Click(object sender, System.EventArgs e)
        {
            viewModel.MatchWithScores();
            uc_Canvas.Image = viewModel.ResultImage;
        }
        private void btn_TemlateSave_Click(object sender, System.EventArgs e)
        {
            uc_Template.Image?.Save($"{Environment.CurrentDirectory}\\template.png");
        }
    }
}

（一）模版匹配相关类

MainViewModel

using OpenCvSharp;
using OpenCvSharp.Extensions;
using System.Windows.Forms;
using System.Collections.ObjectModel;
using System.Drawing;
using Point = OpenCvSharp.Point;
using System.Linq;
using System.IO;
public class MainViewModel
{
    private Mat _srcMat;        //原图Mat
    private Mat _template;      //模版Mat
    private Mat _result;        //结果Mat
    private Image sourceImage = null;        //原图
    private Image templateImage = null;      //模版图
    private Image resultImage = null;        //结果图：匹配结果
    private Image resultJethouImage = null;  //结果图：热图
    public Image SourceImage
    {
        get => sourceImage;
        set => sourceImage = value;
    }
    public Image TemplateImage
    {
        get => templateImage;
        set
        {
            templateImage = value;
            _template = ImageToMat(value);
        }
    }
    public Image ResultImage
    {
        get => resultImage;
        set => resultImage = value;
    }
    public Image ResultJethouImage
    {
        get => resultJethouImage;
        set => resultJethouImage = value;
    }
    public Mat Template { get => _template; set => _template = value; }
    private int MatchingMethodIndex = 0;    //匹配方法索引
                                            //匹配方法集合
    private ObservableCollection<string> MatchingMethods = new ObservableCollection<string>();
    public MainViewModel()
    {
        InitializeMatchMethods();
    }
    /// <summary>
    /// 初始化匹配方法
    /// </summary>
    private void InitializeMatchMethods()
    {
        MatchingMethods.Add("平方差匹配法 (SqDiff)");
        MatchingMethods.Add("归一化平方差匹配法 (SqDiffNormed)");
        MatchingMethods.Add("相关匹配法 (CCorr)");
        MatchingMethods.Add("归一化相关匹配法 (CCorrNormed)");
        MatchingMethods.Add("系数匹配法 (CCoeff)");
        MatchingMethods.Add("归一化系数匹配法 (CCoeffNormed)");
        // 默认选择归一化系数匹配法
        MatchingMethodIndex = MatchingMethods.Count - 1;
    }
    /// <summary>
    /// 加载图像
    /// </summary>
    public Image LoadSource()
    {
        using (var openFileDialog = new OpenFileDialog())
        {
            openFileDialog.Filter = "Image Files|*.jpg;*.jpeg;*.png;*.bmp";
            if (openFileDialog.ShowDialog() == DialogResult.OK)
            {
                _srcMat = new Mat(openFileDialog.FileName, ImreadModes.Color);
                if (!_srcMat.Empty())
                {
                    return BitmapConverter.ToBitmap(_srcMat);
                }
            }
        }
        return null;
    }
    /// <summary>
    /// 加载模版
    /// </summary>
    public Image LoadTemplate()
    {
        using (var openFileDialog = new OpenFileDialog())
        {
            openFileDialog.Filter = "Image Files|*.jpg;*.jpeg;*.png;*.bmp";
            if (openFileDialog.ShowDialog() == DialogResult.OK)
            {
                Template = new Mat(openFileDialog.FileName, ImreadModes.Color);
                if (!Template.Empty())
                {
                    return BitmapConverter.ToBitmap(Template);
                }
            }
        }
        return null;
    }
    /// <summary>
    /// 匹配
    /// </summary>
    public void MatchWithScores()
    {
        if (_srcMat == null || _srcMat.Empty() || Template == null || Template.Empty())
        {
            MessageBox.Show("请先加载源图像和模板图像");
            return;
        }
        TemplateMatchModes method = (TemplateMatchModes)MatchingMethodIndex;
        using (Mat result = new Mat())
        using (Mat displayImage = _srcMat.Clone())
        using (Mat graySrc = new Mat())
        using (Mat grayTemplate = new Mat())
        {
            // 转换为灰度图像
            Cv2.CvtColor(_srcMat, graySrc, ColorConversionCodes.BGR2GRAY);
            Cv2.CvtColor(Template, grayTemplate, ColorConversionCodes.BGR2GRAY);
            // 执行模板匹配
            Cv2.MatchTemplate(graySrc, grayTemplate, result, method);
            // 获取匹配分数
            double minVal, maxVal;
            Point minLoc, maxLoc;
            Cv2.MinMaxLoc(result, out minVal, out maxVal, out minLoc, out maxLoc);
            // 确定最佳匹配位置和分数
            Point matchLoc;
            double bestScore;
            bool isSqDiff = method == TemplateMatchModes.SqDiff || method == TemplateMatchModes.SqDiffNormed;
            matchLoc = isSqDiff ? minLoc : maxLoc;
            bestScore = isSqDiff ? minVal : maxVal;
            // 计算结果的统计信息
            Scalar mean, stdDev;
            Cv2.MeanStdDev(result, out mean, out stdDev);
            // 绘制匹配结果
            Rect matchRect = new Rect(matchLoc, new OpenCvSharp.Size(Template.Width, Template.Height));
            Cv2.Rectangle(displayImage, matchRect, Scalar.Green, 2);
            Point center = new Point(matchLoc.X + Template.Width / 2, matchLoc.Y + Template.Height / 2);
            DrawCrosshair(displayImage, center, Scalar.Green, 1, 1);
            // 显示所有参数信息
            string infoText = $"Method: {method}\n" +
                              $"Score: {bestScore:F4}\n" +
                              $"Position: ({center.X}, {center.Y})\n" +
                              $"Mean: {mean.Val0:F4}\n" +
                              $"StdDev: {stdDev.Val0:F4}";
            // 在图像上绘制多行文本
            string[] lines = infoText.Split('\n');
            for (int i = 0; i < lines.Length; i++)
            {
                Cv2.PutText(displayImage, lines[i],
                           new Point(10, 30 + i * 25),
                           HersheyFonts.HersheySimplex, 0.7, Scalar.Red, 1);
            }
            ResultImage = BitmapConverter.ToBitmap(displayImage);
            // 保存匹配结果热图
            using (Mat resultDisplay = new Mat())
            {
                Cv2.Normalize(result, resultDisplay, 0, 255, NormTypes.MinMax);
                resultDisplay.ConvertTo(resultDisplay, MatType.CV_8UC1);
                Cv2.ApplyColorMap(resultDisplay, resultDisplay, ColormapTypes.Jet);
                // 在热图上也显示分数
                Cv2.PutText(resultDisplay, $"Best: {bestScore:F4}",
                           new Point(10, 30),
                           HersheyFonts.HersheySimplex, 0.7, Scalar.White, 1);
                ResultJethouImage = BitmapConverter.ToBitmap(resultDisplay);
            }
        }
    }
    public Mat ImageToMat(Image image)
    {
        if (image == null) return null;
        // 将Image转换为Bitmap
        using (var bitmap = new Bitmap(image))
        using (var ms = new MemoryStream())
        {
            // 将Bitmap保存到MemoryStream
            bitmap.Save(ms, System.Drawing.Imaging.ImageFormat.Bmp);
            ms.Position = 0;
            // 从MemoryStream创建Mat
            return Cv2.ImDecode(ms.ToArray(), ImreadModes.Color);
        }
    }
    /// <summary>
    /// 绘制十字准心
    /// </summary>
    /// <param name="image">图像矩阵</param>
    /// <param name="center">中心点</param>
    /// <param name="color">颜色</param>
    /// <param name="size">大小</param>
    /// <param name="thickness">线宽</param>
    private void DrawCrosshair(Mat image, Point center, Scalar color, int size, int thickness)
    {
        // 水平线
        Cv2.Line(image,
                 new Point(center.X - size, center.Y),
                 new Point(center.X + size, center.Y),
                 color, thickness);
        // 垂直线
        Cv2.Line(image,
                 new Point(center.X, center.Y - size),
                 new Point(center.X, center.Y + size),
                 color, thickness);
    }
}

（三）模版显示控件

该类实现了图像显示功能，支持图像缩放、拖动、还原，用来显示模版图像。

UCImageZoomControl

namespace UControls
{
    public partial class UCImageZoomControl : UserControl
    {
        private Image _image;                           //图像
        private float _zoomFactor = 1.0f;               //缩放因子
        private const float ZoomIncrement = 0.1f;       //缩放增量
        private const float MinZoom = -5.0f;            //最小缩放
        private const float MaxZoom = 20.0f;            //最大缩放
        private const float PixelGridThreshold = 8.0f;  // 显示像素格的缩放阈值

        private Point _lastLocation;                    //最后位置
        private bool _isDragging = false;               //是否拖拽
        private PointF _imagePosition = PointF.Empty;   //图像位置
        private bool _showPixelGrid = false;            //显示像素格
        [Description("获取或设置控件显示的图像")]
        [Category("UserDefine")]
        public Image Image
        {
            get => _image;
            set
            {
                _image = value;
                _zoomFactor = 1.0f;
                _imagePosition = PointF.Empty;
                CenterImage();
                Invalidate();
            }
        }
        public float ZoomFactor => _zoomFactor;
        public bool ShowPixelGrid { get; set; } = true; // 是否启用像素格显示

        public UCImageZoomControl()
        {
            InitializeComponent();
            this.DoubleBuffered = true;
            this.BackColor = Color.LightGray;
            this.BorderStyle = BorderStyle.FixedSingle;
            this.MouseDown += Control_MouseDown;
            this.MouseMove += Control_MouseMove;
            this.MouseUp += Control_MouseUp;
            this.MouseWheel += Control_MouseWheel;
            this.MouseDoubleClick += Control_MouseDoubleClick;
        }

        /// <summary>
        /// 重写：重设大小方法
        /// </summary>
        protected override void OnResize(EventArgs e)
        {
            base.OnResize(e);
            if (_image != null)
            {
                int scaledWidth = (int)(_image.Width * _zoomFactor);
                int scaledHeight = (int)(_image.Height * _zoomFactor);
                if (scaledWidth <= this.ClientSize.Width && scaledHeight <= this.ClientSize.Height)
                {
                    CenterImage();
                }
            }
        }
        /// <summary>
        /// 重写：绘制方法
        /// </summary>
        protected override void OnPaint(PaintEventArgs e)
        {
            base.OnPaint(e);
            if (_image == null) return;
            // 计算缩放后的图像尺寸
            int scaledWidth = (int)(_image.Width * _zoomFactor);
            int scaledHeight = (int)(_image.Height * _zoomFactor);

            // 计算绘制位置
            Rectangle destRect;
            if (_imagePosition == PointF.Empty)
            {
                int x = (this.ClientSize.Width - scaledWidth) / 2;
                int y = (this.ClientSize.Height - scaledHeight) / 2;
                destRect = new Rectangle(x, y, scaledWidth, scaledHeight);
            }
            else
            {
                destRect = new Rectangle(
                    (int)_imagePosition.X, (int)_imagePosition.Y,
                            scaledWidth, scaledHeight);
            }
            // 绘制图像：保持像素清晰|像素对齐精度
            e.Graphics.InterpolationMode = InterpolationMode.NearestNeighbor;
            e.Graphics.PixelOffsetMode = PixelOffsetMode.Half;
            e.Graphics.DrawImage(_image, destRect);
            // 绘制像素边界
            if (_zoomFactor >= PixelGridThreshold && ShowPixelGrid)
            {
                DrawPixelGrid(e.Graphics, destRect);
            }
        }
        /// <summary>
        /// 绘制像素网格
        /// </summary>
        private void DrawPixelGrid(Graphics g, Rectangle destRect)
        {
            // 保存原始绘图状态
            var originalSmoothingMode = g.SmoothingMode;
            var originalTransform = g.Transform;
            g.SmoothingMode = SmoothingMode.None;
            using (var gridPen = new Pen(Color.FromArgb(100, Color.Black), 1))
            {
                // 计算每个像素的宽度和高度
                float pixelWidth = _zoomFactor;
                float pixelHeight = _zoomFactor;
                // 绘制垂直线
                for (int x = 0; x <= _image.Width; x++)
                {
                    float lineX = destRect.Left + x * pixelWidth;
                    g.DrawLine(gridPen, lineX, destRect.Top, lineX, destRect.Bottom);
                }
                // 绘制水平线
                for (int y = 0; y <= _image.Height; y++)
                {
                    float lineY = destRect.Top + y * pixelHeight;
                    g.DrawLine(gridPen, destRect.Left, lineY, destRect.Right, lineY);
                }
            }
            // 恢复原始绘图状态
            g.SmoothingMode = originalSmoothingMode;
            g.Transform = originalTransform;
        }
        /// <summary>
        /// 设置中心位于图像
        /// </summary>
        private void CenterImage()
        {
            if (_image == null) return;
            int scaledWidth = (int)(_image.Width * _zoomFactor);
            int scaledHeight = (int)(_image.Height * _zoomFactor);
            _imagePosition = new PointF(
                (this.ClientSize.Width - scaledWidth) / 2f,
                (this.ClientSize.Height - scaledHeight) / 2f);
            Invalidate();   //重绘
        }
        #region 缩放功能
        public void ZoomIn()
        {
            Zoom(ZoomIncrement);
        }
        public void ZoomOut()
        {
            Zoom(-ZoomIncrement);
        }
        public void ResetZoom()
        {
            _zoomFactor = 1.0f;
            CenterImage();
        }
        private void Zoom(float factor)
        {
            if (_image == null) return;
            Point mousePos = this.PointToClient(MousePosition);
            float mouseXRelative = (mousePos.X - _imagePosition.X) / (_image.Width * _zoomFactor);
            float mouseYRelative = (mousePos.Y - _imagePosition.Y) / (_image.Height * _zoomFactor);
            float newZoom = _zoomFactor + factor;
            newZoom = Math.Max(MinZoom, Math.Min(MaxZoom, newZoom));
            if (Math.Abs(newZoom - _zoomFactor) > 0.01f)
            {
                _zoomFactor = newZoom;
                int newWidth = (int)(_image.Width * _zoomFactor);
                int newHeight = (int)(_image.Height * _zoomFactor);

                _imagePosition = new PointF(
                    mousePos.X - mouseXRelative * newWidth,
                    mousePos.Y - mouseYRelative * newHeight);

                if (newWidth <= this.ClientSize.Width && newHeight <= this.ClientSize.Height)
                {
                    CenterImage();
                }
                Invalidate();
            }
        }
        #endregion

        #region 鼠标事件处理
        private void Control_MouseWheel(object sender, MouseEventArgs e)
        {
            if (e.Delta > 0) ZoomIn();
            else if (e.Delta < 0) ZoomOut();
        }
        private void Control_MouseDown(object sender, MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Left && _image != null)
            {
                _lastLocation = e.Location;
                _isDragging = true;
                this.Cursor = Cursors.Hand;
            }
        }
        private void Control_MouseMove(object sender, MouseEventArgs e)
        {
            if (_isDragging && _image != null)
            {
                int deltaX = e.X - _lastLocation.X;
                int deltaY = e.Y - _lastLocation.Y;

                _imagePosition.X += deltaX;
                _imagePosition.Y += deltaY;

                _lastLocation = e.Location;
                Invalidate();
            }
        }
        private void Control_MouseUp(object sender, MouseEventArgs e)
        {
            _isDragging = false;
            this.Cursor = Cursors.Default;
        }
        private void Control_MouseDoubleClick(object sender, MouseEventArgs e)
        {
            ResetZoom();
        }
        #endregion
    }
}

（四）图像显示及模版创建控件、

该类实现了图像显示功能，支持缩放、拖动、还原以及ROI区域绘制、拖动等，用于显示原图。

UCPictrueBox

namespace UControls
{
    public partial class UCPictrueBox : UserControl
    {
        #region 字段|属性
        private Image _image;                           //图像
        private float _zoomFactor = 1.0f;               //缩放因子
        private const float ZoomIncrement = 0.1f;       //缩放增益
        private const float MinZoom = 0.01f;            //最小缩放
        private const float MaxZoom = 20.0f;            //最大缩放
        private const float PixelGridThreshold = 8.0f;  //像素格阈值

        private Point _lastLocation;                    //最后位置
        private bool _isDragging = false;               //是否拖拽    
        private PointF _imagePosition = PointF.Empty;   //图像位置
        private bool _showPixelGrid = false;            //是否显示像素格

        // 矩形截取字段
        private Rectangle _selectionRect = Rectangle.Empty; //选择区域
        private Point _selectionStart;                      //选择起始点
        private bool _isSelecting = false;                  //是否选择
        private bool _isMovingSelection = false;            //是否移动选择
        private Point _moveStartPoint;                      //移动起始点

        // 选择框样式
        private readonly Pen _selectionPen = new Pen(Color.Red, 2);
        private readonly Brush _selectionBackBrush = new SolidBrush(Color.FromArgb(50, 0, 0, 255));

        // 原有属性保持不变
        [Description("获取或设置控件显示的图像")]
        [Category("UserDefine")]
        public Image Image
        {
            get => _image;
            set
            {
                _image = value;
                _zoomFactor = 1.0f;
                _imagePosition = PointF.Empty;
                _selectionRect = Rectangle.Empty; // 清除选择区域
                CenterImage();
                Invalidate();
            }
        }
        public float ZoomFactor => _zoomFactor;
        public bool ShowPixelGrid { get; set; } = true;

        // 新增属性
        [Description("获取当前选择区域")]
        [Category("UserDefine")]
        public Rectangle SelectionRect => _selectionRect;

        [Description("获取或设置是否启用矩形选择功能")]
        [Category("UserDefine")]
        public bool EnableSelection { get; set; } = true;
        #endregion

        public UCPictrueBox()
        {
            InitializeComponent();
            Initalize();
        }
        private void Initalize()
        {
            this.DoubleBuffered = true;
            this.BackColor = Color.LightGray;
            this.BorderStyle = BorderStyle.FixedSingle;

            this.MouseDown += Control_MouseDown;
            this.MouseMove += Control_MouseMove;
            this.MouseUp += Control_MouseUp;
            this.MouseWheel += Control_MouseWheel;
            this.MouseDoubleClick += Control_MouseDoubleClick;
        }

        #region 控件、图像绘制
        /// <summary>
        /// 重写重设大小方法
        /// </summary>
        protected override void OnResize(EventArgs e)
        {
            base.OnResize(e);
            if (_image != null)
            {
                int scaledWidth = (int)(_image.Width * _zoomFactor);
                int scaledHeight = (int)(_image.Height * _zoomFactor);
                if (scaledWidth <= this.ClientSize.Width && scaledHeight <= this.ClientSize.Height)
                {
                    CenterImage();
                }
            }
        }
        /// <summary>
        /// 重写绘制方法
        /// </summary>
        protected override void OnPaint(PaintEventArgs e)
        {
            base.OnPaint(e);
            if (_image == null) return;

            // 计算缩放后的图像尺寸
            int scaledWidth = (int)(_image.Width * _zoomFactor);
            int scaledHeight = (int)(_image.Height * _zoomFactor);

            // 计算绘制位置
            Rectangle destRect;
            if (_imagePosition == PointF.Empty)
            {
                int x = (this.ClientSize.Width - scaledWidth) / 2;
                int y = (this.ClientSize.Height - scaledHeight) / 2;
                destRect = new Rectangle(x, y, scaledWidth, scaledHeight);
            }
            else
            {
                destRect = new Rectangle(
                    (int)_imagePosition.X, (int)_imagePosition.Y,
                    scaledWidth, scaledHeight);
            }

            // 绘制图像
            e.Graphics.InterpolationMode = InterpolationMode.NearestNeighbor;
            e.Graphics.PixelOffsetMode = PixelOffsetMode.Half;
            e.Graphics.DrawImage(_image, destRect);

            // 绘制选择区域（如果存在）
            if (!_selectionRect.IsEmpty)
            {
                // 将选择区域转换为显示坐标
                Rectangle displaySelection = ConvertToDisplayRect(_selectionRect, destRect);

                // 绘制半透明背景
                e.Graphics.FillRectangle(_selectionBackBrush, displaySelection);

                // 绘制边框
                e.Graphics.DrawRectangle(_selectionPen, displaySelection);

                // 绘制调整手柄
                DrawSelectionHandles(e.Graphics, displaySelection);
            }

            // 绘制像素格
            if (_zoomFactor >= PixelGridThreshold && ShowPixelGrid)
            {
                DrawPixelGrid(e.Graphics, destRect);
            }
        }
        /// <summary>
        /// 绘制像素网格
        /// </summary>
        private void DrawPixelGrid(Graphics g, Rectangle destRect)
        {
            // 保存原始绘图状态
            var originalSmoothingMode = g.SmoothingMode;
            var originalTransform = g.Transform;
            // 设置绘图参数
            g.SmoothingMode = SmoothingMode.None;
            using (var gridPen = new Pen(Color.FromArgb(100, Color.Black), 1))
            {
                // 计算每个像素的宽度和高度
                float pixelWidth = _zoomFactor;
                float pixelHeight = _zoomFactor;
                // 绘制垂直线
                for (int x = 0; x <= _image.Width; x++)
                {
                    float lineX = destRect.Left + x * pixelWidth;
                    g.DrawLine(gridPen, lineX, destRect.Top, lineX, destRect.Bottom);
                }
                // 绘制水平线
                for (int y = 0; y <= _image.Height; y++)
                {
                    float lineY = destRect.Top + y * pixelHeight;
                    g.DrawLine(gridPen, destRect.Left, lineY, destRect.Right, lineY);
                }
            }
            // 恢复原始绘图状态
            g.SmoothingMode = originalSmoothingMode;
            g.Transform = originalTransform;
        }
        private void CenterImage()
        {
            if (_image == null) return;
            int scaledWidth = (int)(_image.Width * _zoomFactor);
            int scaledHeight = (int)(_image.Height * _zoomFactor);
            _imagePosition = new PointF(
                (this.ClientSize.Width - scaledWidth) / 2f,
                (this.ClientSize.Height - scaledHeight) / 2f);
            Invalidate();   //重绘
        }
        #endregion

        #region 缩放功能
        public void ZoomIn()
        {
            Zoom(ZoomIncrement);
        }
        public void ZoomOut()
        {
            Zoom(-ZoomIncrement);
        }
        public void ResetZoom()
        {
            _zoomFactor = 1.0f;
            CenterImage();
        }
        private void Zoom(float factor)
        {
            if (_image == null) return;
            Point mousePos = this.PointToClient(MousePosition);
            float mouseXRelative = (mousePos.X - _imagePosition.X) / (_image.Width * _zoomFactor);
            float mouseYRelative = (mousePos.Y - _imagePosition.Y) / (_image.Height * _zoomFactor);
            float newZoom = _zoomFactor + factor;
            newZoom = Math.Max(MinZoom, Math.Min(MaxZoom, newZoom));
            if (Math.Abs(newZoom - _zoomFactor) > 0.01f)
            {
                _zoomFactor = newZoom;
                int newWidth = (int)(_image.Width * _zoomFactor);
                int newHeight = (int)(_image.Height * _zoomFactor);

                _imagePosition = new PointF(
                    mousePos.X - mouseXRelative * newWidth,
                    mousePos.Y - mouseYRelative * newHeight);

                if (newWidth <= this.ClientSize.Width && newHeight <= this.ClientSize.Height)
                {
                    CenterImage();
                }
                Invalidate();
            }
        }
        #endregion

        #region 鼠标事件处理
        private void Control_MouseDown(object sender, MouseEventArgs e)
        {
            if (_image == null) return;

            // 计算图像显示区域:缩放宽度、缩放高度
            int scaledWidth = (int)(_image.Width * _zoomFactor);
            int scaledHeight = (int)(_image.Height * _zoomFactor);
            //目标矩形
            Rectangle destRect;
            if (_imagePosition == PointF.Empty)
            {
                destRect = new Rectangle(
                    (this.ClientSize.Width - scaledWidth) / 2,
                    (this.ClientSize.Height - scaledHeight) / 2,
                    scaledWidth, scaledHeight);
            }
            else
            {
                destRect = new Rectangle(
                    (int)_imagePosition.X, (int)_imagePosition.Y,
                    scaledWidth, scaledHeight);
            }
            // 检查是否在图像区域内
            if (!destRect.Contains(e.Location)) return;

            if (EnableSelection)
            {
                // 检查是否点击了选择区域
                if (!_selectionRect.IsEmpty)
                {
                    Rectangle displaySelection = ConvertToDisplayRect(_selectionRect, destRect);

                    // 检查是否点击了调整手柄
                    if (IsOnSelectionHandle(e.Location, displaySelection))
                    {
                        _isSelecting = true;
                        _selectionStart = e.Location;
                        return;
                    }
                    // 检查是否点击了选择区域内部
                    if (displaySelection.Contains(e.Location))
                    {
                        _isMovingSelection = true;
                        _moveStartPoint = e.Location;
                        this.Cursor = Cursors.SizeAll;
                        return;
                    }
                }
                // 开始新的选择
                _isSelecting = true;
                _selectionStart = e.Location;

                // 转换坐标为图像坐标
                Point imagePoint = ConvertToImagePoint(e.Location, destRect);
                _selectionRect = new Rectangle(imagePoint.X, imagePoint.Y, 0, 0);
            }
            else
            {
                // 原有拖拽图像逻辑
                if (e.Button == MouseButtons.Left && _image != null)
                {
                    _lastLocation = e.Location;
                    _isDragging = true;
                    this.Cursor = Cursors.Hand;
                }
            }
            Invalidate();
        }
        private void Control_MouseMove(object sender, MouseEventArgs e)
        {
            if (_image == null) return;

            // 计算图像显示区域
            int scaledWidth = (int)(_image.Width * _zoomFactor);
            int scaledHeight = (int)(_image.Height * _zoomFactor);
            Rectangle destRect = _imagePosition == PointF.Empty
                ? new Rectangle(
                    (this.ClientSize.Width - scaledWidth) / 2,
                    (this.ClientSize.Height - scaledHeight) / 2,
                    scaledWidth, scaledHeight)
                : new Rectangle(
                    (int)_imagePosition.X, (int)_imagePosition.Y,
                    scaledWidth, scaledHeight);

            if (_isSelecting && EnableSelection)
            {
                // 更新选择区域
                Point imageStart = ConvertToImagePoint(_selectionStart, destRect);
                Point imageEnd = ConvertToImagePoint(e.Location, destRect);

                int x = Math.Min(imageStart.X, imageEnd.X);
                int y = Math.Min(imageStart.Y, imageEnd.Y);
                int width = Math.Abs(imageEnd.X - imageStart.X);
                int height = Math.Abs(imageEnd.Y - imageStart.Y);

                // 限制在图像范围内
                x = Math.Max(0, Math.Min(x, _image.Width - 1));
                y = Math.Max(0, Math.Min(y, _image.Height - 1));
                width = Math.Min(width, _image.Width - x);
                height = Math.Min(height, _image.Height - y);

                _selectionRect = new Rectangle(x, y, width, height);

                Invalidate();
            }
            else if (_isMovingSelection && EnableSelection)
            {
                // 移动选择区域
                int dx = e.X - _moveStartPoint.X;
                int dy = e.Y - _moveStartPoint.Y;

                Rectangle displaySelection = ConvertToDisplayRect(_selectionRect, destRect);
                displaySelection.X += dx;
                displaySelection.Y += dy;

                // 转换回图像坐标
                _selectionRect = ConvertToImageRect(displaySelection, destRect);

                // 限制在图像范围内
                _selectionRect.X = Math.Max(0, Math.Min(_selectionRect.X, _image.Width - _selectionRect.Width));
                _selectionRect.Y = Math.Max(0, Math.Min(_selectionRect.Y, _image.Height - _selectionRect.Height));

                _moveStartPoint = e.Location;
                Invalidate();
            }
            else if (EnableSelection && !_selectionRect.IsEmpty)
            {
                // 检查鼠标是否在选择区域或手柄上
                Rectangle displaySelection = ConvertToDisplayRect(_selectionRect, destRect);

                if (IsOnSelectionHandle(e.Location, displaySelection))
                {
                    this.Cursor = Cursors.SizeNWSE; // 根据实际手柄位置可以调整光标
                }
                else if (displaySelection.Contains(e.Location))
                {
                    this.Cursor = Cursors.SizeAll;
                }
                else
                {
                    this.Cursor = Cursors.Default;
                }
            }
            else
            {
                // 原有拖拽图像逻辑
                if (_isDragging && _image != null)
                {
                    int deltaX = e.X - _lastLocation.X;
                    int deltaY = e.Y - _lastLocation.Y;

                    _imagePosition.X += deltaX;
                    _imagePosition.Y += deltaY;

                    _lastLocation = e.Location;
                    Invalidate();
                }
            }
        }
        private void Control_MouseUp(object sender, MouseEventArgs e)
        {
            _isDragging = false;
            _isSelecting = false;
            _isMovingSelection = false;
            this.Cursor = Cursors.Default;
        }
        private void Control_MouseWheel(object sender, MouseEventArgs e)
        {
            if (e.Delta > 0) ZoomIn();
            else if (e.Delta < 0) ZoomOut();
        }
        private void Control_MouseDoubleClick(object sender, MouseEventArgs e)
        {
            ResetZoom();
        }
        #endregion

        #region 图像转换判定
        /// <summary>
        /// 新增方法：将图像坐标转换为显示坐标
        /// </summary>
        private Rectangle ConvertToDisplayRect(Rectangle imageRect, Rectangle displayImageRect)
        {
            float scaleX = (float)displayImageRect.Width / _image.Width;
            float scaleY = (float)displayImageRect.Height / _image.Height;
            return new Rectangle(
                displayImageRect.X + (int)(imageRect.X * scaleX),
                displayImageRect.Y + (int)(imageRect.Y * scaleY),
                (int)(imageRect.Width * scaleX),
                (int)(imageRect.Height * scaleY));
        }

        /// <summary>
        /// 新增方法：将显示坐标转换为图像坐标
        /// </summary>
        private Rectangle ConvertToImageRect(Rectangle displayRect, Rectangle displayImageRect)
        {
            float scaleX = (float)_image.Width / displayImageRect.Width;
            float scaleY = (float)_image.Height / displayImageRect.Height;

            return new Rectangle(
                (int)((displayRect.X - displayImageRect.X) * scaleX),
                (int)((displayRect.Y - displayImageRect.Y) * scaleY),
                (int)(displayRect.Width * scaleX),
                (int)(displayRect.Height * scaleY));
        }

        /// <summary>
        /// 新增方法：绘制选择手柄
        /// </summary>
        private void DrawSelectionHandles(Graphics g, Rectangle rect)
        {
            int handleSize = 8;
            // 四个角的手柄
            g.FillRectangle(Brushes.White, rect.Left - handleSize / 2, rect.Top - handleSize / 2, handleSize, handleSize);
            g.FillRectangle(Brushes.White, rect.Right - handleSize / 2, rect.Top - handleSize / 2, handleSize, handleSize);
            g.FillRectangle(Brushes.White, rect.Left - handleSize / 2, rect.Bottom - handleSize / 2, handleSize, handleSize);
            g.FillRectangle(Brushes.White, rect.Right - handleSize / 2, rect.Bottom - handleSize / 2, handleSize, handleSize);
        }

        /// <summary>
        /// 新增方法：检查是否点击了选择手柄
        /// </summary>
        private bool IsOnSelectionHandle(Point point, Rectangle selectionRect)
        {
            int handleSize = 8;
            // 检查四个角
            return IsPointInHandle(point, selectionRect.Left, selectionRect.Top, handleSize) ||
                   IsPointInHandle(point, selectionRect.Right, selectionRect.Top, handleSize) ||
                   IsPointInHandle(point, selectionRect.Left, selectionRect.Bottom, handleSize) ||
                   IsPointInHandle(point, selectionRect.Right, selectionRect.Bottom, handleSize);
        }

        /// <summary>
        /// 点是否在手上
        /// </summary>
        private bool IsPointInHandle(Point point, int handleX, int handleY, int size)
        {
            return point.X >= handleX - size / 2 && point.X <= handleX + size / 2
                && point.Y >= handleY - size / 2 && point.Y <= handleY + size / 2;
        }
        /// <summary>
        /// 新增方法：将显示坐标转换为图像坐标
        /// </summary>
        private Point ConvertToImagePoint(Point displayPoint, Rectangle displayImageRect)
        {
            float scaleX = (float)_image.Width / displayImageRect.Width;
            float scaleY = (float)_image.Height / displayImageRect.Height;

            return new Point(
                (int)((displayPoint.X - displayImageRect.X) * scaleX),
                (int)((displayPoint.Y - displayImageRect.Y) * scaleY));
        }

        /// <summary>
        /// 新增方法：截取选择区域
        /// </summary>
        public Image CropSelectedRegion()
        {
            if (_image == null || _selectionRect.IsEmpty) return null;
            Bitmap croppedImage = new Bitmap(_selectionRect.Width, _selectionRect.Height);
            using (Graphics g = Graphics.FromImage(croppedImage))
            {
                g.InterpolationMode = InterpolationMode.HighQualityBicubic;
                g.PixelOffsetMode = PixelOffsetMode.HighQuality;
                g.SmoothingMode = SmoothingMode.HighQuality;
                g.DrawImage(_image,
                    new Rectangle(0, 0, croppedImage.Width, croppedImage.Height),
                    _selectionRect, GraphicsUnit.Pixel);
            }

            return croppedImage;
        }

        /// <summary>
        /// 新增方法：清除选择区域
        /// </summary>
        public void ClearSelection()
        {
            _selectionRect = Rectangle.Empty;
            Invalidate();
        }
        #endregion
    }
}

三、总结

本文使用C#结合OpenCV实现基本的模版匹配功能。通过自定义图像显示控件显示原图，使用OpenCvSharp库实现模版匹配功能。通过该案例既能学习到如何自定义控件、又能学习图像匹配相关的知识，应该是个不错的项目。

项目地址：https://gitee.com/incodenotes/cshape-demos

最后

如果你觉得这篇文章对你有帮助，不妨点个赞再走呗！

如有疑问，欢迎留言讨论！

也可以加入微信公众号 [编程笔记in] ，一起交流学习！

在这里插入图片描述

C# WinForms 中使用 OpenCvSharp 实现模板匹配：5步轻松搞定
java专栏
01-09 738
模板匹配（Template Matching）是一种常用的图像处理技术，用于在一幅图像中寻找与给定模板最相似的局部区域。通过模板匹配，我们可以在图像中找到特定的对象或特征。
C#图像处理-OpenCVSharp学习笔记：OpenCVSharp模板匹配与应用
PixelShadeZ的博客
08-14 981
模板匹配是一种常见的图像处理技术，它可以在图像中寻找与给定模板最相似的子图像。基本思路是将模板图像在待匹配图像上滑动，计算模板图像与滑动窗口之间的相似度，找到最相似的位置。模板匹配是图像处理中常用的技术之一，它可以在图像中寻找与给定模板最相似的子图像。通过使用人脸模板与输入图像进行匹配，可以找到人脸在图像中的位置，并进一步进行后续的特征提取和比对。通过将字符模板与图像进行匹配，可以找到图像中文字的位置，并进行文字的提取和识别。只需要将模板与图像进行匹配，找到最佳匹配位置，就可以实现物体的检测和跟踪功能。
C# OpenCV机器视觉:模板匹配
xcwzj123的专栏
12-22 987
又是一个无聊周末，阿强正坐在家中，享受着他最爱的零食，突然，他的手机响了。经过这次模板匹配的冒险，阿强不仅学会了如何使用 C# 和 OpenCvSharp 进行模板匹配，还领悟到了一个深刻的道理：生活中，有时我们需要寻找和识别那些重要的瞬间，才能更好地理解我们的生活。”几分钟后，安装成功了！于是，阿强决定展开一场“寻找小猫”的冒险，利用模板匹配技术来在他的照片库中寻找更多类似的小猫照片。绘制匹配结果：最后，阿强在主图像上绘制匹配结果，心中暗想：“这下我可以自豪地告诉朋友们，我找到了更多的小猫！
C#/python opencv多模板匹配实战应用例程
一个学长的博客
01-19 2186
最近在做项目的时候为了检测某一种物品的齐套性，以及为了和写c#的软件负责人配合自己研究了一下opnencv C# 版的模板匹配，对基础的例程做了一下改进，留一份例程。因为工作性质原因不能直接放项目的实际图片我用visio简单绘制了一个图片，最终结果如下。在看代码之前滤清一下需求，目的是寻找到图像中目标的个数，这好像听起来很简单，但是实际上我们需要经过一个对模板匹配算法输出的相似度值进行一个分析的过程。
OpenCV matchTemplate 模板匹配原理及代码实现（C#）
weixin_40671962的博客
10-22 4154
该方法在进行相关匹配前，先对模板和识别区域的矩阵进行了预处理：用矩阵减去矩阵均值，这种方法解决了模板图像和识别图像亮度差异造成的影响。由计算结果逻辑可知，计算结果越大，匹配结果越好。该方法会因为图像的全局亮度改变导致计算结果改变，例如图像变亮，每个像素的灰度值都会增大，这会导致计算结果变大；T为模板图像，I为匹配图像；在匹配图像的（x,y）位置，向右x’，向下y’ 框定识别区域，计算相关性。图像完全匹配时，计算结果为0；模板与匹配图像相乘，计算结果越大，匹配结果越好；完全匹配为1，完全不匹配为-1。
OpenCv案例(八)：基于OpenCVSharp学习之模板匹配
qq_37835727的博客
12-17 7612
1：建好测试Demo C#项目中添加好OpenCVSharp安装包 如下图（图中是VS2015版本） NuGet工具给项目添加OpenCvSharp3-AnyCPU： 工具>>NuGet包管理器>>管理解决方案的NuGet程序包 2：测试Demo 首先，添加引用：using OpenCvSharp; /// <summary> /// 模板匹配 /// </summary> /// <param name="temp...
《深度学习》OpenCV轮廓检测 模版匹配 解析及实现
wx_AHao1004Y的博客
09-05 2535
模型匹配是一种通过在图像中查找和识别特定形状或物体的方法。模型匹配基于图像中的特征点，并尝试找到与预定义的模型或样本最匹配的图像区域。模型匹配（Model Fitting）是指将机器学习模型与训练数据进行拟合，使模型能够从数据中学习到最佳的参数或规律。模型匹配是机器学习中一个关键的步骤，它决定了模型的准确性和泛化能力。模型匹配的主要目标是通过调整模型的参数或超参数，使得模型能够更好地拟合训练数据，并且在未见过的数据上具有较好的预测能力。
[C#]OpenCvSharp利用MatchTemplate实现多目标匹配
FL1623863129的博客
04-04 1239
C# opencvsharp多目标模板匹配算法演示代码_哔哩哔哩_bilibili。【演示源码下载地址】
C# OpenCV机器视觉:利用CNN实现快速模板匹配
xcwzj123的专栏
01-25 2729
突然，一则新闻吸引了他的注意：某博物馆里一幅珍贵的古画离奇失踪，警方怀疑是被一伙狡猾的盗贼偷走了，现场只留下一些模糊不清的监控画面，根本无法确定盗贼的行踪。阿强越说越兴奋，仿佛自己已经成为了 CNN 的主人，带着它在图像世界里大杀四方：“比如说，我们要找一个特定的图案，CNN 就会像一个不知疲倦的寻宝者，在图像的每一个角落仔细搜寻。当它面对一张图像时，就会施展它的魔法，把图像里的各种特征都提取出来，然后和它记忆中的模板进行比对，不管是多么微小的细节，都逃不过它的法眼。“快了，快了，马上就能找到那些盗贼了！
C#学习之OpenCv实现模版匹配案例
04-03
本文描述了如何使用C#基于OpenCvSharpe实现模版匹配功能，其中实现了下功能： 1、图像加载； 2、模版加载、绘制、保存功能； 3、模版匹配功能。
C# OpenCvSharp 模板匹配.rar
11-09
在本项目"C# OpenCvSharp 模板匹配.rar"中，主要涉及的是使用C#编程语言和OpenCvSharp库进行图像处理的模板匹配技术。OpenCvSharp是OpenCV（开源计算机视觉库）的C#封装版本，它为.NET开发者提供了丰富的计算机视觉...
C#+halcon和opencv模板匹配
11-16
标题 "C#+halcon和opencv模板匹配" 涉及到的是在C#编程环境中，利用两种不同的图像处理库——Halcon与OpenCV——进行模板匹配的技术。模板匹配是一种计算机视觉技术，主要用于寻找一个图像（目标图像）在另一个大...
基于C#OpenCVSharp4的多角度（带旋转角度）模板匹配算法C#OpenCVSharp4
03-12
OpenCvSharp 是一个OpenCV的.Net wrapper，应用最新的OpenCV库开发，使用习惯比EmguCV更接近原始...使用OpenCvSharp，可用C#，VB.NET等语言实现多种流行的图像处理(image processing)与计算机视觉(computer vision)算法
C# winform opencvsharp多目标模板匹配算法演示代码.7z
04-04
博客地址：https://blog.youkuaiyun.com/FL1623863129/article/details/137368770 视频演示：https://www.bilibili.com/video/BV1Mt421n7fx/ 测试环境：vs2019,netframework4.7.2,opencvsharp4.8.0
基于 C# 开发 SQL Server 数据库应用：深入解析与实战指南
zhu1996zhu的博客
04-01 1537
本文围绕基于C#开发SQL Server数据库应用展开，详述开发环境准备，重点呈现数据库连接、查询、插入、更新及删除操作的专业代码示例，还提及可优化方向，助力开发者掌握相关技能，为用C#开发此类数据库应用提供全面实用的参考。
C# System.Text.Json 中 JsonNamingPolicy 使用详解
鲤籽鲲的博客
04-03 878
C# System.Text.Json 中 JsonNamingPolicy 使用详解
C#核心学习（七）面向对象--封装（6）C#中的拓展方法与运算符重载: 让代码更“聪明”的魔法
最新发布
m0_74212916的博客
04-03 745
核心知识点速览 ​拓展方法 ​是什么：为现有类型（包括系统类型）添加“假装的”实例方法，无需修改源码。 ​怎么用：静态类 + this 参数，例如为 int 添加 IsEven() 方法。 ​典型场景：增强工具方法、实现链式调用（如LINQ）。 ​运算符重载 ​是什么：让自定义类型支持 +、== 等运算符的语义化操作。 ​怎么用：public static operator 定义，例如实现向量相加。 ​典型场景：数学计算、集合操作、物理引擎开发。
C# System.Text.Json 中 JsonConverter 使用详解
鲤籽鲲的博客
04-03 912
C# System.Text.Json 中 JsonConverter 使用详解
C#里第一个WPF程序
大坡3D软件开发
04-03 68
WPF程序对界面进行优化，但是比WINFORMS的程序要复杂很多，并且界面UI基本上不适合拖放，所以需要比较多的时间来布局界面，随着客户对界面的需求提高，还是需要采用这样的方式来实现。产且需要开发人员编写更多的代码。即使如此，在面对诱人的界面表现，App.xaml文件中定义。从这几堆代码来看，就比较多。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

编程笔记in

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值