C#调用YOLOv3算法dll动态链接库（YOLO算法落地）

最新推荐文章于 2024-06-27 23:05:24 发布
最新推荐文章于 2024-06-27 23:05:24 发布
阅读量6.4k 收藏 55
点赞数 12
文章标签： c# 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42136882/article/details/107730456
版权

C#调用YOLOv3算法dll动态链接库

前段时间在搞一个软件，目标是实现细胞计数的功能，当时我细胞计数的算法用到的是YOLOv3目标检测算法，所以就涉及到怎么实现模型落地的问题。当时有个同学在帮老师做项目，他比较懂，我于是向他寻求帮助，但是…可能涉及到了商业机密吧，于是我就自己研究。
我看了很多博客，感觉讲的也不是很到位，或者说没有给出一些干货，今天我来给大家带点干货，当然我是用**C#**调用的YOLOv3动态链接库，如果有需要的小伙伴就拿去吧。

yolov3编译成动态库

大家按照这个链接去GitHub下载YOLOv3的源码：https://github.com/AlexeyAB/darknet?tdsourcetag=s_pcqq_aiomsg.我是按照这个教程做的：https://zhuanlan.zhihu.com/p/97605980，这个教程还是很详细的，我就不讲了。

C#调用YOLOv3动态链接库

我已经将软件打包到GitHub上了：https://github.com/NameZth/AICounter-master.git，由于YOLOv3的权重文件和配置文件太大就没有上传，所以需要小伙伴自己训练一下模型. 当然我也是参考别人做的：https://github.com/RaminAbbaszadi/YoloWrapper-WPF，下面是文件的分布：
在这里插入图片描述在***DeepLearningWrapper***这个文件中调用的YOLOv3的动态链接库：

using System;
using System.IO;
using System.Text;
using System.Linq;
using DeepLearning.Base;
using System.Collections.Generic;
using System.Runtime.InteropServices;

namespace DeepLearning
{
    public class DeepLearningWrapper : IDisposable
    {
        #region Const

        public const int MAX_OBJECTS_NUMBER = 1000;
        private const string DEEP_LEARNING_LIBRARY_DLL_CPU_VERSION = @"\x64\yolo_cpp_dll.dll";
        private const string DEEP_LEARNING_LIBRARY_DLL_GPU_VERSION = @"\x64\yolo_cpp_gpu.dll";

        #endregion

        #region Fields

        private static Dictionary<int, string> m_ObjectType = new Dictionary<int, string>();
        private static NetConfigaration m_NetConf;

        #endregion

        #region Initilizing

        public DeepLearningWrapper()
        {
        }

        #endregion

        #region DllImport Cpu

        [DllImport(DEEP_LEARNING_LIBRARY_DLL_CPU_VERSION, EntryPoint = "init")]
        public static extern int InitializeNetInCpu(string configrationFilenamr, string weightFileanme, int gpu);

        [DllImport(DEEP_LEARNING_LIBRARY_DLL_CPU_VERSION, EntryPoint = "detect_image")]
        internal static extern int DetectImageInCpu(string filename, ref BoundingBoxContainer container);

        [DllImport(DEEP_LEARNING_LIBRARY_DLL_CPU_VERSION, EntryPoint = "detect_mat")]
        internal static extern int DetectImageInCpu(IntPtr pArray, int nSize, ref BoundingBoxContainer container);

        [DllImport(DEEP_LEARNING_LIBRARY_DLL_CPU_VERSION, EntryPoint = "dispose")]
        internal static extern int DisposeNetInCpu();

        #endregion

        #region DllImport Gpu

        [DllImport(DEEP_LEARNING_LIBRARY_DLL_GPU_VERSION, EntryPoint = "init")]
        internal static extern int InitializeNetInGpu(string configurationFilename, string weightsFilename, int gpu);

        [DllImport(DEEP_LEARNING_LIBRARY_DLL_GPU_VERSION, EntryPoint = "detect_image")]
        internal static extern int DetectImageInGpu(string filename, ref BoundingBoxContainer container);

        [DllImport(DEEP_LEARNING_LIBRARY_DLL_GPU_VERSION, EntryPoint = "detect_mat")]
        internal static extern int DetectImageInGpu(IntPtr pArray, int nSize, ref BoundingBoxContainer container);

        [DllImport(DEEP_LEARNING_LIBRARY_DLL_GPU_VERSION, EntryPoint = "dispose")]
        internal static extern int DisposeNetInGpu();

        [DllImport(DEEP_LEARNING_LIBRARY_DLL_GPU_VERSION, EntryPoint = "get_device_count")]
        internal static extern int GetDeviceCount();

        [DllImport(DEEP_LEARNING_LIBRARY_DLL_GPU_VERSION, EntryPoint = "get_device_name")]
        internal static extern int GetDeviceName(int gpu, StringBuilder deviceName);

        #endregion

        #region Dispose

        public void Dispose()
        {
            switch (DetectionHardware)
            {
                case DetectionHardwares.CPU:
                    DisposeNetInCpu();
                    break;
                case DetectionHardwares.GPU:
                    DisposeNetInGpu();
                    break;
            }
        }

        #endregion

        #region Wrapper

        public void InitilizeDeepLearningNetwork(int gpu = 0)
        {
            if (m_NetConf == null)
                m_NetConf = new NetConfigaration();

            HardwareReport = new HardwareReports();

            DetectionHardware = DetectionHardwares.CPU;
            if (HardwareReport.IsCudaExists && HardwareReport.IsCudnnExists)
                DetectionHardware = DetectionHardwares.GPU;

            switch (DetectionHardware)
            {
                case DetectionHardwares.CPU:
                    InitializeNetInCpu(m_NetConf.ConfigFile, m_NetConf.Weightfile, 0);
                    break;
                case DetectionHardwares.GPU:
                    var deviceCount = GetDeviceCount();
                    if (gpu > (deviceCount - 1))
                        throw new IndexOutOfRangeException("Graphic device index is out of range");
                    var deviceName = new StringBuilder();
                    GetDeviceName(gpu, deviceName);
                    HardwareReport.GraphicDeviceName = deviceName.ToString();
                    InitializeNetInGpu(m_NetConf.ConfigFile, m_NetConf.Weightfile, gpu);
                    break;
                default:
                    break;
            }

            var lines = File.ReadAllLines(m_NetConf.NamesFile);
            for (var i = 0; i < lines.Length; i++)
                m_ObjectType.Add(i, lines[i]);
        }


        public IEnumerable<DetectedItemInfo> Detect(string imageFilePath)
        {
            if (!File.Exists(imageFilePath))
                throw new FileNotFoundException("Cannot find the file", imageFilePath);

            var container = new BoundingBoxContainer();
            var count = 0;
            switch (DetectionHardware)
            {
                case DetectionHardwares.CPU:
                    count = DetectImageInCpu(imageFilePath, ref container);
                    break;
                case DetectionHardwares.GPU:
                    count = DetectImageInGpu(imageFilePath, ref container);
                    break;
            }

            return Convert(container);
        }

        public IEnumerable<DetectedItemInfo> Detect(byte[] imageData)
        {
            var container = new BoundingBoxContainer();

            var size = Marshal.SizeOf(imageData[0]) * imageData.Length;
            var pnt = Marshal.AllocHGlobal(size);

            try
            {
                // Copy the array to unmanaged memory.
                Marshal.Copy(imageData, 0, pnt, imageData.Length);
                var count = 0;
                switch (DetectionHardware)
                {
                    case DetectionHardwares.CPU:
                        count = DetectImageInCpu(pnt, imageData.Length, ref container);
                        break;
                    case DetectionHardwares.GPU:
                        count = DetectImageInGpu(pnt, imageData.Length, ref container);
                        break;
                }
            }
            catch (Exception exception)
            {
                return null;
            }
            finally
            {
                // Free the unmanaged memory.
                Marshal.FreeHGlobal(pnt);
            }

            return Convert(container);
        }

        #endregion

        #region Utilities

        private IEnumerable<DetectedItemInfo> Convert(BoundingBoxContainer container)
        {
            var netItems = new List<DetectedItemInfo>();
            foreach (var item in container.candidates.Where(o => o.height > 0 || o.width > 0))
            {
                var objectType = m_ObjectType[(int)item.obj_id];
                var netItem = new DetectedItemInfo() { X = (int)item.leftTopX, Y = (int)item.leftTopY, Height = (int)item.height, Width = (int)item.width, Confidence = item.prob, Type = objectType };
                netItems.Add(netItem);
            }

            return netItems;
        }

        #endregion

        #region Properties

        public DetectionHardwares DetectionHardware = DetectionHardwares.Unknown;
        public HardwareReports HardwareReport { get; private set; }

        #endregion
    }
}

然后就是在其他软件中类的定义：
***BoundingBox***文件：

using System;

namespace DeepLearning
{
    internal struct BoundingBox
    {
        #region Fields

        internal UInt32 leftTopX, leftTopY, width, height;
        internal float prob;
        internal UInt32 obj_id;
        internal UInt32 track_id;
        internal UInt32 frames_counter;
        
        #endregion
    }
}

***BoundingBoxContainer***文件：

using System.Runtime.InteropServices;

namespace DeepLearning
{
    [StructLayout(LayoutKind.Sequential)]
    internal struct BoundingBoxContainer
    {
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = DeepLearningWrapper.MAX_OBJECTS_NUMBER)]
        internal BoundingBox[] candidates;
    }
}

***DetectedItemInfo***文件：

namespace DeepLearning
{
    public class DetectedItemInfo
    {
        #region Properties

        public string Type { get; set; }
        public double Confidence { get; set; }
        public int X { get; set; }
        public int Y { get; set; }
        public int Width { get; set; }
        public int Height { get; set; }

        #endregion

        #region Utilities

        public bool Compare(DetectedItemInfo newItem)
        {
            bool result = false;
            if (newItem != null)
            {
                if (newItem.Type == this.Type && newItem.Confidence == this.Confidence &&
                    newItem.X == this.X && newItem.Y == this.Y && newItem.Width == this.Width &&
                    newItem.Height == this.Height)
                {
                    result = true;
                }
            }
            return result;
        }

        #endregion
    }
}
HardwareReports文件：
using System;
using System.IO;

namespace DeepLearning
{
    public class HardwareReports
    {
        #region Initilizing

        public HardwareReports()
        {
            Init();
        }

        private void Init()
        {
            if (File.Exists(@"x64\cudnn64_7.dll"))
               IsCudnnExists = true;

            var envirormentVariables = Environment.GetEnvironmentVariables(EnvironmentVariableTarget.Machine);
            if (envirormentVariables.Contains("CUDA_PATH"))
                IsCudaExists = true;

        }

        #endregion

        #region Properties

        public bool IsCudaExists { get; set; }
        public bool IsCudnnExists { get; set; }
        public string GraphicDeviceName { get; set; }

        #endregion
    }
}

NetConfigaration文件：

namespace DeepLearning
{
    public class NetConfigaration
    {
        #region Const

        private const string CONFIG_FILE_PATH = @"Assets\Aalskidhytd.cfg";
        private const string WEIGHT_FILE_PATH = @"Assets\Aalskidhytd.weights";
        private const string NAMES_FILE_PATH  = @"Assets\Aalskidhytd.names";

        #endregion

        #region Initilizing

        public NetConfigaration()
        {
            Init();
        }

        private void Init()
        {
            ConfigFile = CONFIG_FILE_PATH;
            Weightfile = WEIGHT_FILE_PATH;
            NamesFile  = NAMES_FILE_PATH;
        }

        #endregion

        #region Properties

        public string ConfigFile { get; set; }
        public string Weightfile { get; set; }
        public string NamesFile { get; set; }

        #endregion
    }
}

软件界面展示（检测的精度不是很高）：
在这里插入图片描述

努力奔跑的TH
关注
  • 12
    点赞
  • 踩
  • 55
    收藏
    觉得还不错? 一键收藏
  • 29
    评论
Alturos.Yolo：C＃Yolo暗网包装器（实时对象检测）
02-05
阿尔特罗斯·尤洛 最新的C＃实时对象检测系统（Visual Studio）。 该项目具有CPU和GPU支持，使用GPU可以更快地进行检测。 该项目的主要目标是易于使用yolo，该软件包可在nuget上使用，您只需安装两个软件包即可开始检测。 在后台，我们使用Windows Yolo版本的 。 将图像路径或字节数组发送到并接收检测到的对象的位置。 我们的项目旨在将对象类型和-position返回为可处理数据。 该库支持 NuGet 通过快速安装Alturos.Yolo PM> install-package Alturos.Yolo (C# wrapper and C++ dlls 28MB
yolov3 dll c# 调用
03-13
yolov3 源码编译dll ，c#调用 ，权重现在不能共享， 自己网上寻找。
深度学习实践：使用 YOLOv3-Tiny 进行验证码识别（C# 实现）
最新发布
asfdsgdf的博客
06-27 675
在这篇文章中，我们将使用 C# 实现基于 YOLOv3-Tiny 的验证码识别任务。我们编写了 data.py 脚本生成训练数据配置文件，并将标注文件转换为 darknet 可识别的格式。在 darknet 文件夹中会生成一个名为 predictions.jpg 的文件，这是我们验证出来的结果文件。Alturos.Yolo：用于在 C# 中使用 YOLO 模型的库 GitHub - Alturos.Yolo。我们将使用 GPU 进行训练。我们将使用 Alturos.Yolo 库来进行图像处理和目标检测。
C# yolov3 调用程序.zip
11-13
c# 调用yolov3 的程序，实现目标识别 c# 调用yolov3 的程序，实现目标识别 c# 调用yolov3 的程序，实现目标识别c# 调用yolov3 的程序，实现目标识别
C#基于OpenCV实现的加载Darknet的YOLO模型
12-19
C#基于OpenCV实现的加载Darknet的YOLO模型的源代码，是个小项目。
C#调用yolov3 目标检测
网络架构
11-13 1214
代码地址 编译好的下载 qq群686070107 主函数调用 using System; using Models; using ObjectDetectionGui.Views; using DeepLearning; namespace ObjectDetectionGui { public class Detect { static void Main(string[] args) { WrapperModel model =
C#基于yolov3的行人检测
dotNET跨平台
06-15 1077
using System; using System.Collections.Generic; using System.Drawing; using System.IO; using S...
yolov5_tensorrt_dll c++动态链接库接口
09-06
本文将详细介绍如何将YOLOv5模型与TensorRT结合，通过C++实现动态链接库接口，以便于其他如C#、Java等语言调用。 首先，我们需要了解YOLOv5模型。YOLO（You Only Look Once）是一种基于卷积神经网络的目标检测框架...
yolov7-tiny的c# 调用，vs2022使用opencvsharp推理
07-10
在本文中，我们将深入探讨如何在C#环境中利用OpenCVSharp库调用Yolov7-tiny模型进行对象检测。Yolov7-tiny是一种轻量级的深度学习模型，适用于实时目标检测任务，尤其适合资源有限的环境，如嵌入式系统或PC端应用。...
采用C#语言对 YOLOv4 目标检测算法封装，将模型在实际应用系统中落地，实现模型在线远程调用。.zip
01-15
软件开发设计：应用软件开发、系统软件开发、移动应用开发、网站开发C++、Java、python、web、C#等语言的项目开发与学习资料 硬件与设备：单片机、EDA、proteus、RTOS、包括计算机硬件、服务器、网络设备、存储设备...
c# 通过emgucv调用gpu推理yolov7和yolov7-tiny，darknet版本。
09-19
在本文中，我们将深入探讨如何使用C#编程语言结合EmguCV库来调用GPU进行Yolov7和Yolov7-tiny的物体检测。这两个模型是基于Darknet框架训练的，它们在实时物体检测任务中表现出色，尤其是Yolov7-tiny，它在保持相对较...
vs2015下使用动态链接库调用YOLOv3
03-07
从零开始在win10+vs2015上运行YOLOv3,记得在x64 debug下运行，相关文件需要另外准备，压缩包内的截图里面有完整路径。参考博文：https://blog.csdn.net/qq_22199831/article/details/104713533
C#使用YOLOv5进行人体检测
04-29
C#使用YOLOv5进行人体检测
c++调用yolov3训练模型.zip
11-15
c++接口调用yolov3训练好的模型，只要将yolov3训练后的权重和c++文件放在一个文件夹下即可，具体看里面路径设置。
C# Opencvsharp+yolov3 目标识别.rar
04-17
现在网上很少关于C#目标检测的例子，要么质量不高，需要用Py 本例子基于开源代码，改成了WINFORM应用
C#语言对 YOLOv4 目标检测算法封装
03-26
借鉴大神代码 写了个dome采用C#语言对 YOLOv4 目标检测算法封装，将模型在实际应用系统中落地，实现模型在线远程调用 。希望对大家有所帮助
C#yolo8/yolo9实现分类、检测、分割、关键点、obb旋转框 全兼容,全网最强调用框架
BW_SOFTWARE的博客
11-15 2047
C#使用OnnxRuntime和OpenCvSharp实现的分类、检测、分割、动作。超高速推理，并且自动识别版本和类型，3行代码即可调用
C#通过Process调用python 并实现YOLO目标检测
我专门写BUG
03-11 1116
C#通过Process调用python 并实现YOLO目标检测
c# yolov3 yolov4 yolo tiny
weixin_51330616的博客
10-24 741
效果很棒
评论 29
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值