python export.py --weights yolov5s.pt --include onnx

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Linq;
using Microsoft.ML.OnnxRuntime;
using Microsoft.ML.OnnxRuntime.Tensors;

namespace YoloV5OnnxRuntime
{
    class Program
    {
        // 檢測(cè)類別名稱
        private static readonly string[] classNames = new[] {
            "person", "bicycle", "car", "motorcycle", "airplane", "bus", "train", "truck", "boat", "traffic light",
            "fire hydrant", "stop sign", "parking meter", "bench", "bird", "cat", "dog", "horse", "sheep", "cow",
            "elephant", "bear", "zebra", "giraffe", "backpack", "umbrella", "handbag", "tie", "suitcase", "frisbee",
            "skis", "snowboard", "sports ball", "kite", "baseball bat", "baseball glove", "skateboard", "surfboard",
            "tennis racket", "bottle", "wine glass", "cup", "fork", "knife", "spoon", "bowl", "banana", "apple",
            "sandwich", "orange", "broccoli", "carrot", "hot dog", "pizza", "donut", "cake", "chair", "couch",
            "potted plant", "bed", "dining table", "toilet", "tv", "laptop", "mouse", "remote", "keyboard", "cell phone",
            "microwave", "oven", "toaster", "sink", "refrigerator", "book", "clock", "vase", "scissors", "teddy bear",
            "hair drier", "toothbrush"
        };

        static void Main(string[] args)
        {
            // 模型路徑和輸入圖像路徑
            string modelPath = "yolov5s.onnx";
            string imagePath = "test.jpg";
            
            // 加載模型
            using var session = new InferenceSession(modelPath);
            
            // 加載并預(yù)處理圖像
            var (inputTensor, originalWidth, originalHeight) = LoadImage(imagePath);
            
            // 準(zhǔn)備輸入?yún)?shù)
            var inputs = new List<NamedOnnxValue> { NamedOnnxValue.CreateFromTensor("images", inputTensor) };
            
            // 運(yùn)行模型推理
            using var results = session.Run(inputs);
            
            // 處理輸出結(jié)果
            var outputTensor = results.First().AsTensor<float>();
            var predictions = ProcessOutput(outputTensor, originalWidth, originalHeight);
            
            // 繪制檢測(cè)結(jié)果
            DrawPredictions(imagePath, predictions, "output.jpg");
            
            Console.WriteLine("檢測(cè)完成，結(jié)果已保存至 output.jpg");
        }

        // 加載并預(yù)處理圖像
        private static (DenseTensor<float> tensor, int width, int height) LoadImage(string imagePath)
        {
            using var image = Image.FromFile(imagePath);
            int originalWidth = image.Width;
            int originalHeight = image.Height;
            
            // 調(diào)整圖像大小為模型輸入尺寸（通常為640x640）
            var resizedImage = ResizeImage(image, 640, 640);
            
            // 圖像轉(zhuǎn)張量
            var tensor = new DenseTensor<float>(new[] { 1, 3, 640, 640 });
            var mean = new[] { 0.0f, 0.0f, 0.0f }; // 均值
            var std = new[] { 1.0f, 1.0f, 1.0f };  // 標(biāo)準(zhǔn)差
            
            using (var bitmap = new Bitmap(resizedImage))
            {
                for (int y = 0; y < bitmap.Height; y++)
                {
                    for (int x = 0; x < bitmap.Width; x++)
                    {
                        var pixel = bitmap.GetPixel(x, y);
                        
                        // 注意：圖像通道順序?yàn)锽GR（OpenCV默認(rèn)），而模型可能需要RGB
                        tensor[0, 0, y, x] = (pixel.R / 255.0f - mean[0]) / std[0];
                        tensor[0, 1, y, x] = (pixel.G / 255.0f - mean[1]) / std[1];
                        tensor[0, 2, y, x] = (pixel.B / 255.0f - mean[2]) / std[2];
                    }
                }
            }
            
            return (tensor, originalWidth, originalHeight);
        }

        // 調(diào)整圖像大小
        private static Image ResizeImage(Image image, int width, int height)
        {
            var destRect = new Rectangle(0, 0, width, height);
            var destImage = new Bitmap(width, height);
            
            destImage.SetResolution(image.HorizontalResolution, image.VerticalResolution);
            
            using (var graphics = Graphics.FromImage(destImage))
            {
                graphics.CompositingMode = System.Drawing.Drawing2D.CompositingMode.SourceCopy;
                graphics.CompositingQuality = System.Drawing.Drawing2D.CompositingQuality.HighQuality;
                graphics.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
                graphics.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
                graphics.PixelOffsetMode = System.Drawing.Drawing2D.PixelOffsetMode.HighQuality;
                
                using (var wrapMode = new System.Drawing.Imaging.ImageAttributes())
                {
                    wrapMode.SetWrapMode(System.Drawing.Drawing2D.WrapMode.TileFlipXY);
                    graphics.DrawImage(image, destRect, 0, 0, image.Width, image.Height, GraphicsUnit.Pixel, wrapMode);
                }
            }
            
            return destImage;
        }

        // 處理模型輸出
        private static List<Prediction> ProcessOutput(Tensor<float> output, int originalWidth, int originalHeight)
        {
            const float confidenceThreshold = 0.5f;
            const float nmsThreshold = 0.4f;
            
            var predictions = new List<Prediction>();
            
            // 解析模型輸出
            for (int i = 0; i < output.Length / 85; i++)
            {
                float confidence = output[0, i, 4];
                
                if (confidence >= confidenceThreshold)
                {
                    // 找到概率最高的類別
                    int classId = 0;
                    float maxClassProbs = 0;
                    
                    for (int c = 0; c < 80; c++)
                    {
                        float classProbs = output[0, i, 5 + c];
                        if (classProbs > maxClassProbs)
                        {
                            maxClassProbs = classProbs;
                            classId = c;
                        }
                    }
                    
                    float score = confidence * maxClassProbs;
                    
                    if (score >= confidenceThreshold)
                    {
                        // 獲取邊界框坐標(biāo)
                        float cx = output[0, i, 0];
                        float cy = output[0, i, 1];
                        float w = output[0, i, 2];
                        float h = output[0, i, 3];
                        
                        // 轉(zhuǎn)換為左上角和右下角坐標(biāo)
                        float x1 = (cx - w / 2) / 640.0f * originalWidth;
                        float y1 = (cy - h / 2) / 640.0f * originalHeight;
                        float x2 = (cx + w / 2) / 640.0f * originalWidth;
                        float y2 = (cy + h / 2) / 640.0f * originalHeight;
                        
                        predictions.Add(new Prediction
                        {
                            ClassId = classId,
                            Score = score,
                            BBox = new RectangleF(x1, y1, x2 - x1, y2 - y1)
                        });
                    }
                }
            }
            
            // 非極大值抑制
            return NonMaxSuppression(predictions, nmsThreshold);
        }

        // 非極大值抑制
        private static List<Prediction> NonMaxSuppression(List<Prediction> predictions, float threshold)
        {
            var result = new List<Prediction>();
            
            // 按置信度降序排序
            predictions = predictions.OrderByDescending(p => p.Score).ToList();
            
            while (predictions.Count > 0)
            {
                var best = predictions[0];
                result.Add(best);
                predictions.RemoveAt(0);
                
                // 移除重疊度高的邊界框
                predictions = predictions.Where(p => IoU(best.BBox, p.BBox) < threshold).ToList();
            }
            
            return result;
        }

        // 計(jì)算交并比
        private static float IoU(RectangleF a, RectangleF b)
        {
            float areaA = a.Width * a.Height;
            if (areaA <= 0) return 0;
            
            float areaB = b.Width * b.Height;
            if (areaB <= 0) return 0;
            
            float minX = Math.Max(a.Left, b.Left);
            float minY = Math.Max(a.Top, b.Top);
            float maxX = Math.Min(a.Right, b.Right);
            float maxY = Math.Min(a.Bottom, b.Bottom);
            
            float intersectionWidth = maxX - minX;
            float intersectionHeight = maxY - minY;
            
            if (intersectionWidth <= 0 || intersectionHeight <= 0)
                return 0;
                
            float intersectionArea = intersectionWidth * intersectionHeight;
            return intersectionArea / (areaA + areaB - intersectionArea);
        }

        // 繪制預(yù)測(cè)結(jié)果
        private static void DrawPredictions(string inputImagePath, List<Prediction> predictions, string outputImagePath)
        {
            using var image = Image.FromFile(inputImagePath);
            using var graphics = Graphics.FromImage(image);
            
            // 設(shè)置繪圖質(zhì)量
            graphics.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;
            graphics.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
            graphics.PixelOffsetMode = System.Drawing.Drawing2D.PixelOffsetMode.HighQuality;
            
            // 繪制邊界框和標(biāo)簽
            foreach (var prediction in predictions)
            {
                var bbox = prediction.BBox;
                var label = $"{classNames[prediction.ClassId]}: {prediction.Score:F2}";
                
                // 繪制邊界框
                using var pen = new Pen(Color.FromArgb(255, 255, 0, 0), 2);
                graphics.DrawRectangle(pen, bbox.X, bbox.Y, bbox.Width, bbox.Height);
                
                // 繪制標(biāo)簽背景
                using var font = new Font("Arial", 10, FontStyle.Bold);
                using var brush = new SolidBrush(Color.FromArgb(255, 255, 0, 0));
                using var textBrush = new SolidBrush(Color.White);
                
                var textSize = graphics.MeasureString(label, font);
                var textBackground = new RectangleF(bbox.X, bbox.Y - textSize.Height, textSize.Width, textSize.Height);
                
                graphics.FillRectangle(brush, textBackground);
                graphics.DrawString(label, font, textBrush, bbox.X, bbox.Y - textSize.Height);
            }
            
            // 保存結(jié)果圖像
            image.Save(outputImagePath, ImageFormat.Jpeg);
        }
    }

    // 預(yù)測(cè)結(jié)果類
    public class Prediction
    {
        public int ClassId { get; set; }
        public float Score { get; set; }
        public RectangleF BBox { get; set; }
    }
}

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Linq;
using Microsoft.ML;
using Microsoft.ML.Data;
using Microsoft.ML.OnnxTransformer;
using Microsoft.ML.Trainers;

namespace YoloV5MLNet
{
    class Program
    {
        // 檢測(cè)類別名稱（同上）
        private static readonly string[] classNames = new[] { ... }; // 同上，省略
        
        static void Main(string[] args)
        {
            string modelPath = "yolov5s.onnx";
            string imagePath = "test.jpg";
            
            // 創(chuàng)建MLContext
            var mlContext = new MLContext();
            
            // 定義模型輸入輸出架構(gòu)
            var data = new List<ImageInputData> { new ImageInputData { ImagePath = imagePath } };
            var dataView = mlContext.Data.LoadFromEnumerable(data);
            
            // 定義數(shù)據(jù)轉(zhuǎn)換管道
            var pipeline = mlContext.Transforms.LoadImages(outputColumnName: "image", imageFolder: "", inputColumnName: nameof(ImageInputData.ImagePath))
                .Append(mlContext.Transforms.ResizeImages(outputColumnName: "image", imageWidth: 640, imageHeight: 640, inputColumnName: "image"))
                .Append(mlContext.Transforms.ExtractPixels(outputColumnName: "images", inputColumnName: "image", interleavePixelColors: true, offsetImage: 0))
                .Append(mlContext.Transforms.ApplyOnnxModel(
                    shapeDictionary: new Dictionary<string, int[]>()
                    {
                        { "images", new[] { 1, 3, 640, 640 } },
                        { "output", new[] { 1, 25200, 85 } }
                    },
                    inputColumnNames: new[] { "images" },
                    outputColumnNames: new[] { "output" },
                    modelFile: modelPath));
            
            // 訓(xùn)練管道（這里只是為了創(chuàng)建預(yù)測(cè)引擎）
            var model = pipeline.Fit(dataView);
            
            // 創(chuàng)建預(yù)測(cè)引擎
            var predictor = mlContext.Model.CreatePredictionEngine<ImageInputData, ImagePrediction>(model);
            
            // 進(jìn)行預(yù)測(cè)
            var prediction = predictor.Predict(new ImageInputData { ImagePath = imagePath });
            
            // 處理輸出結(jié)果
            var originalImage = Image.FromFile(imagePath);
            var predictions = ProcessOutput(prediction.Output, originalImage.Width, originalImage.Height);
            
            // 繪制檢測(cè)結(jié)果
            DrawPredictions(imagePath, predictions, "output.jpg");
            
            Console.WriteLine("檢測(cè)完成，結(jié)果已保存至 output.jpg");
        }

        // 圖像處理和結(jié)果解析方法（與ONNX Runtime版本相同）
        private static List<Prediction> ProcessOutput(float[] output, int originalWidth, int originalHeight)
        {
            // 與ONNX Runtime版本中的ProcessOutput方法相同
            // ...
        }

        // 非極大值抑制和IoU計(jì)算方法（同上）
        private static List<Prediction> NonMaxSuppression(List<Prediction> predictions, float threshold)
        {
            // ...
        }
        
        private static float IoU(RectangleF a, RectangleF b)
        {
            // ...
        }

        // 繪制預(yù)測(cè)結(jié)果（同上）
        private static void DrawPredictions(string inputImagePath, List<Prediction> predictions, string outputImagePath)
        {
            // ...
        }
    }

    // 數(shù)據(jù)模型類
    public class ImageInputData
    {
        [LoadColumn(0)]
        public string ImagePath { get; set; }
    }

    public class ImagePrediction
    {
        [ColumnName("output")]
        public float[] Output { get; set; }
    }

    // 預(yù)測(cè)結(jié)果類（同上）
    public class Prediction
    {
        public int ClassId { get; set; }
        public float Score { get; set; }
        public RectangleF BBox { get; set; }
    }
}