Merge remote-tracking branch 'resnet50_onnxruntime/master'

Resource/Models/download.sh

+#!/bin/bash
+
+# 获取当前脚本的绝对路径
+script_path=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+
+#下载链接
+model_url="https://github.com/onnx/models/blob/main/vision/classification/resnet/model/resnet50-v2-7.onnx"
+
+#使用wget下载文件并保存到当前脚本所在文件夹
+wget -P "$script_path" "$model_url"

Src/Classifier.cpp

+#include <Classifier.h>
+#include <Filesystem.h>
+#include <SimpleLog.h>
+#include <algorithm>
+#include <CommonUtility.h>
+
+namespace ortSamples
+{
+
+Classifier::Classifier()
+{
+}
+
+Classifier::~Classifier()
+{
+    configurationFile.release();
+}
+
+ErrorCode Classifier::Initialize(InitializationParameterOfClassifier initializationParameterOfClassifier)
+{
+    // 读取配置文件
+    std::string configFilePath=initializationParameterOfClassifier.configFilePath;
+    if(Exists(configFilePath)==false)
+    {
+        LOG_ERROR(stdout, "no configuration file!\n");
+        return CONFIG_FILE_NOT_EXIST;
+    }
+    if(!configurationFile.open(configFilePath, cv::FileStorage::READ))
+    {
+       LOG_ERROR(stdout, "fail to open configuration file\n");
+       return FAIL_TO_OPEN_CONFIG_FILE;
+    }
+    LOG_INFO(stdout, "succeed to open configuration file\n");
+
+    // 获取配置文件参数
+    cv::FileNode netNode = configurationFile["Classifier"];
+    std::string modelPath=(std::string)netNode["ModelPath"];
+
+    // 初始化session
+    //设置DCU
+    OrtROCMProviderOptions rocm_options;
+    rocm_options.device_id = 0;
+    sessionOptions.AppendExecutionProvider_ROCM(rocm_options);
+    sessionOptions.SetGraphOptimizationLevel(GraphOptimizationLevel::ORT_ENABLE_BASIC);
+    // sessionOptions.EnableProfiling("profile_prefix");
+
+    session = new Ort::Session(env, modelPath.c_str(), sessionOptions);
+    return SUCCESS;
+}
+
+ErrorCode Classifier::Classify(const std::vector<cv::Mat> &srcImages,std::vector<std::vector<ResultOfPrediction>> &predictions)
+{
+    if(srcImages.size()==0||srcImages[0].empty()||srcImages[0].depth()!=CV_8U)
+    {
+        LOG_ERROR(stdout, "image error!\n");
+        return IMAGE_ERROR;
+    }
+    
+    // 数据预处理
+    std::vector<cv::Mat> image;
+    for(int i =0;i<srcImages.size();++i)
+    {
+        //BGR转换为RGB
+        cv::Mat imgRGB;
+        cv::cvtColor(srcImages[i], imgRGB, cv::COLOR_BGR2RGB);
+
+        // 调整大小，使短边为256，保持长宽比
+        cv::Mat shrink;
+        float ratio = (float)256 / min(imgRGB.cols, imgRGB.rows);
+        if(imgRGB.rows > imgRGB.cols)
+        {
+            cv::resize(imgRGB, shrink, cv::Size(256, int(ratio * imgRGB.rows)), 0, 0);
+        }
+        else
+        {
+            cv::resize(imgRGB, shrink, cv::Size(int(ratio * imgRGB.cols), 256), 0, 0);
+        }
+
+        // 裁剪中心窗口为224*224
+        int start_x = shrink.cols/2 - 224/2;
+        int start_y = shrink.rows/2 - 224/2;
+        cv::Rect rect(start_x, start_y, 224, 224);
+        cv::Mat images = shrink(rect);
+        image.push_back(images);
+    }
+
+    // normalize并转换为NCHW
+    cv::Mat inputBlob;
+    Image2BlobParams image2BlobParams;
+    image2BlobParams.scalefactor=cv::Scalar(1/58.395, 1/57.12, 1/57.375);
+    image2BlobParams.mean=cv::Scalar(123.675, 116.28, 103.53);
+    image2BlobParams.swapRB=false;
+    blobFromImagesWithParams(image,inputBlob,image2BlobParams);
+
+    // 设置onnx的输入和输出名
+    std::vector<const char*> input_node_names = {"data"};
+    std::vector<const char*> output_node_names = {"resnetv24_dense0_fwd"};
+
+    // 初始化输入数据
+    std::array<int64_t, 4> inputShape{1, 3, 224, 224};
+    auto memoryInfo = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
+    std::array<float, 3 * 224 * 224> input_image{};
+    float* input_test = (float*)inputBlob.data;
+    Ort::Value inputTensor = Ort::Value::CreateTensor<float>(memoryInfo, input_test, input_image.size(), inputShape.data(), inputShape.size());
+    std::vector<Ort::Value> intput_tensors;
+    intput_tensors.push_back(std::move(inputTensor));
+    
+    // 进行推理
+    auto output_tensors = session->Run(Ort::RunOptions{nullptr}, input_node_names.data(), intput_tensors.data(), 1, output_node_names.data(), 1);
+    
+    // 解析输出结果
+    const float* pdata = output_tensors[0].GetTensorMutableData<float>();
+    int numberOfClasses = 1000 ;
+    for(int i=0;i<srcImages.size();++i)
+    {
+        int startIndex=numberOfClasses*i;
+        std::vector<float> logit;
+        for(int j=0;j<numberOfClasses;++j)
+        {
+            logit.push_back(pdata[startIndex+j]);
+        }     
+        std::vector<ResultOfPrediction> resultOfPredictions;
+        for(int j=0;j<numberOfClasses;++j)
+        {
+            ResultOfPrediction prediction;
+            prediction.label=j;
+            prediction.confidence=logit[j];
+            resultOfPredictions.push_back(prediction);
+        }
+        predictions.push_back(resultOfPredictions);
+    }
+    return SUCCESS;
+}
+}

Src/Classifier.h

+#ifndef __CLASSIFIER_H__
+#define __CLASSIFIER_H__
+
+#include <onnxruntime_cxx_api.h>
+#include <CommonDefinition.h>
+
+namespace ortSamples
+{
+class  Classifier
+{
+public:
+    Classifier();
+    
+    ~Classifier();
+
+    ErrorCode Initialize(InitializationParameterOfClassifier initializationParameterOfClassifier);
+
+    ErrorCode Classify(const std::vector<cv::Mat> &srcImages,std::vector<std::vector<ResultOfPrediction>> &predictions);
+
+private:
+    cv::FileStorage configurationFile;
+    Ort::Session *session;
+    cv::Size inputSize;
+    std::string inputName;
+    Ort::Env env = Ort::Env(ORT_LOGGING_LEVEL_ERROR, "ONNXRuntime");
+    Ort::SessionOptions sessionOptions = Ort::SessionOptions();
+};
+}
+
+#endif
+

Src/Utility/CommonDefinition.h

+// 常用定义
+
+#ifndef __COMMON_DEFINITION_H__
+#define __COMMON_DEFINITION_H__
+
+#include <opencv2/opencv.hpp>
+
+namespace ortSamples
+{
+   
+// 路径分隔符(Linux:‘/’,Windows:’\\’)
+#ifdef _WIN32
+#define  PATH_SEPARATOR '\\'
+#else
+#define  PATH_SEPARATOR '/'
+#endif
+
+#define CONFIG_FILE  "../Resource/Configuration.xml"
+
+typedef enum _ErrorCode
+{
+    SUCCESS=0,  // 0
+    MODEL_NOT_EXIST, // 模型不存在
+    CONFIG_FILE_NOT_EXIST, // 配置文件不存在
+    FAIL_TO_LOAD_MODEL, // 加载模型失败
+    FAIL_TO_OPEN_CONFIG_FILE, // 加载配置文件失败
+    IMAGE_ERROR, // 图像错误
+}ErrorCode;
+
+typedef struct _ResultOfPrediction
+{
+    float confidence;
+    int label;
+    _ResultOfPrediction():confidence(0.0f),label(0){}
+
+}ResultOfPrediction;
+
+typedef struct _InitializationParameterOfClassifier
+{
+    std::string parentPath;
+    std::string configFilePath;
+}InitializationParameterOfClassifier;
+
+}
+
+#endif
+

Src/Utility/CommonUtility.cpp

+#include <CommonUtility.h>
+
+using namespace cv;
+using namespace cv::dnn;
+
+namespace ortSamples
+{
+
+void blobFromImagesWithParams(InputArrayOfArrays images_, OutputArray blob_, const Image2BlobParams& param)
+{
+    if (images_.kind() != _InputArray::STD_VECTOR_MAT && images_.kind() != _InputArray::STD_ARRAY_MAT &&
+        images_.kind() != _InputArray::STD_VECTOR_VECTOR) {
+        String error_message = "The data is expected as vectors of vectors or vectors of matrices.";
+        CV_Error(Error::StsBadArg, error_message);
+    }
+    CV_CheckType(param.ddepth, param.ddepth == CV_32F || param.ddepth == CV_8U,
+                 "Blob depth should be CV_32F or CV_8U");
+    Size size = param.size;
+    std::vector<Mat> images;
+    images_.getMatVector(images);
+    CV_Assert(!images.empty());
+
+    int nch = images[0].channels();
+    Scalar scalefactor = param.scalefactor;
+
+    if (param.ddepth == CV_8U)
+    {
+        CV_Assert(scalefactor == Scalar::all(1.0) && "Scaling is not supported for CV_8U blob depth");
+        CV_Assert(param.mean == Scalar() && "Mean subtraction is not supported for CV_8U blob depth");
+    }
+
+    for (size_t i = 0; i < images.size(); i++)
+    {
+        Size imgSize = images[i].size();
+        if (size == Size())
+            size = imgSize;
+        if (size != imgSize)
+        {
+            if (param.paddingmode == DNN_PMODE_CROP_CENTER)
+            {
+                float resizeFactor = std::max(size.width / (float)imgSize.width,
+                                              size.height / (float)imgSize.height);
+                resize(images[i], images[i], Size(), resizeFactor, resizeFactor, INTER_LINEAR);
+                Rect crop(Point(0.5 * (images[i].cols - size.width),
+                                0.5 * (images[i].rows - size.height)),
+                          size);
+                images[i] = images[i](crop);
+            }
+            else
+            {
+                if (param.paddingmode == DNN_PMODE_LETTERBOX)
+                {
+                    float resizeFactor = std::min(size.width / (float)imgSize.width,
+                                                  size.height / (float)imgSize.height);
+                    int rh = int(imgSize.height * resizeFactor);
+                    int rw = int(imgSize.width * resizeFactor);
+                    resize(images[i], images[i], Size(rw, rh), INTER_LINEAR);
+
+                    int top = (size.height - rh)/2;
+                    int bottom = size.height - top - rh;
+                    int left = (size.width - rw)/2;
+                    int right = size.width - left - rw;
+                    copyMakeBorder(images[i], images[i], top, bottom, left, right, BORDER_CONSTANT);
+                }
+                else
+                    resize(images[i], images[i], size, 0, 0, INTER_LINEAR);
+            }
+        }
+
+        Scalar mean = param.mean;
+        if (param.swapRB)
+        {
+            std::swap(mean[0], mean[2]);
+            std::swap(scalefactor[0], scalefactor[2]);
+        }
+
+        if (images[i].depth() == CV_8U && param.ddepth == CV_32F)
+            images[i].convertTo(images[i], CV_32F);
+
+        images[i] -= mean;
+        multiply(images[i], scalefactor, images[i]);
+    }
+
+    size_t nimages = images.size();
+    Mat image0 = images[0];
+    CV_Assert(image0.dims == 2);
+
+    if (param.datalayout == DNN_LAYOUT_NCHW)
+    {
+        if (nch == 3 || nch == 4)
+        {
+            int sz[] = { (int)nimages, nch, image0.rows, image0.cols };
+            blob_.create(4, sz, param.ddepth);
+            Mat blob = blob_.getMat();
+            Mat ch[4];
+
+            for (size_t i = 0; i < nimages; i++)
+            {
+                const Mat& image = images[i];
+                CV_Assert(image.depth() == blob_.depth());
+                nch = image.channels();
+                CV_Assert(image.dims == 2 && (nch == 3 || nch == 4));
+                CV_Assert(image.size() == image0.size());
+
+                for (int j = 0; j < nch; j++)
+                    ch[j] = Mat(image.rows, image.cols, param.ddepth, blob.ptr((int)i, j));
+                if (param.swapRB)
+                    std::swap(ch[0], ch[2]);
+                split(image, ch);
+            }
+        }
+        else
+        {
+            CV_Assert(nch == 1);
+            int sz[] = { (int)nimages, 1, image0.rows, image0.cols };
+            blob_.create(4, sz, param.ddepth);
+            Mat blob = blob_.getMat();
+
+            for (size_t i = 0; i < nimages; i++)
+            {
+                const Mat& image = images[i];
+                CV_Assert(image.depth() == blob_.depth());
+                nch = image.channels();
+                CV_Assert(image.dims == 2 && (nch == 1));
+                CV_Assert(image.size() == image0.size());
+
+                image.copyTo(Mat(image.rows, image.cols, param.ddepth, blob.ptr((int)i, 0)));
+            }
+        }
+    }
+    else if (param.datalayout == DNN_LAYOUT_NHWC)
+    {
+        int sz[] = { (int)nimages, image0.rows, image0.cols, nch};
+        blob_.create(4, sz, param.ddepth);
+        Mat blob = blob_.getMat();
+        int subMatType = CV_MAKETYPE(param.ddepth, nch);
+        for (size_t i = 0; i < nimages; i++)
+        {
+            const Mat& image = images[i];
+            CV_Assert(image.depth() == blob_.depth());
+            CV_Assert(image.channels() == image0.channels());
+            CV_Assert(image.size() == image0.size());
+            if (param.swapRB)
+            {
+                Mat tmpRB;
+                cvtColor(image, tmpRB, COLOR_BGR2RGB);
+                tmpRB.copyTo(Mat(tmpRB.rows, tmpRB.cols, subMatType, blob.ptr((int)i, 0)));
+            }
+            else
+                image.copyTo(Mat(image.rows, image.cols, subMatType, blob.ptr((int)i, 0)));
+        }
+    }
+    else
+        CV_Error(Error::StsUnsupportedFormat, "Unsupported data layout in blobFromImagesWithParams function.");
+}
+
+}

Src/Utility/CommonUtility.h

+// 常用工具
+
+#ifndef __COMMON_UTILITY_H__
+#define __COMMON_UTILITY_H__
+
+#include <CommonDefinition.h>
+
+using namespace cv;
+using namespace cv::dnn;
+
+namespace ortSamples
+{
+
+enum DataLayout
+    {
+        DNN_LAYOUT_UNKNOWN = 0,
+        DNN_LAYOUT_ND = 1,        //!< OpenCV data layout for 2D data.
+        DNN_LAYOUT_NCHW = 2,      //!< OpenCV data layout for 4D data.
+        DNN_LAYOUT_NCDHW = 3,      //!< OpenCV data layout for 5D data.
+        DNN_LAYOUT_NHWC = 4,      //!< Tensorflow-like data layout for 4D data.
+        DNN_LAYOUT_NDHWC = 5,      //!< Tensorflow-like data layout for 5D data.
+        DNN_LAYOUT_PLANAR = 6,     //!< Tensorflow-like data layout, it should only be used at tf or tflite model parsing.
+    };
+
+    enum ImagePaddingMode
+    {
+        DNN_PMODE_NULL = 0,        // !< Default. Resize to required input size without extra processing.
+        DNN_PMODE_CROP_CENTER = 1, // !< Image will be cropped after resize.
+        DNN_PMODE_LETTERBOX = 2,   // !< Resize image to the desired size while preserving the aspect ratio of original image.
+    };
+
+    struct Image2BlobParams
+    {
+        Image2BlobParams():scalefactor(Scalar::all(1.0)), size(Size()), mean(Scalar()), swapRB(false), ddepth(CV_32F),
+                           datalayout(DNN_LAYOUT_NCHW), paddingmode(DNN_PMODE_NULL)
+        {}
+
+        Image2BlobParams(const Scalar& scalefactor_, const Size& size_, const Scalar& mean_, bool swapRB_,
+                         int ddepth_, DataLayout datalayout_, ImagePaddingMode mode_):
+        scalefactor(scalefactor_), size(size_), mean(mean_), swapRB(swapRB_), ddepth(ddepth_),
+        datalayout(datalayout_), paddingmode(mode_)
+        {}
+
+        Scalar scalefactor; //!< scalefactor multiplier for input image values.
+        Size size;    //!< Spatial size for output image.
+        Scalar mean;  //!< Scalar with mean values which are subtracted from channels.
+        bool swapRB;  //!< Flag which indicates that swap first and last channels
+        int ddepth;   //!< Depth of output blob. Choose CV_32F or CV_8U.
+        DataLayout datalayout; //!< Order of output dimensions. Choose DNN_LAYOUT_NCHW or DNN_LAYOUT_NHWC.
+        ImagePaddingMode paddingmode;   //!< Image padding mode. @see ImagePaddingMode.
+    };
+
+void blobFromImagesWithParams(InputArrayOfArrays images_, OutputArray blob_, const Image2BlobParams& param);
+
+}
+
+#endif

Src/Utility/Filesystem.cpp

+#include <Filesystem.h>
+#include <algorithm>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <fstream>
+#ifdef _WIN32
+#include <io.h>
+#include <direct.h>
+#include <Windows.h>
+#else
+#include <unistd.h>
+#include <dirent.h>
+#endif
+
+// 路径分隔符(Linux:‘/’,Windows:’\\’)
+#ifdef _WIN32
+#define  PATH_SEPARATOR '\\'
+#else
+#define  PATH_SEPARATOR '/'
+#endif
+
+using namespace std;
+
+namespace ortSamples
+{
+
+static std::vector<std::string> SplitString(std::string str, std::string separator)
+{
+    std::string::size_type pos;
+    std::vector<std::string> result;
+    str+=separator;//扩展字符串以方便操作
+    int size=str.size();
+
+    for(int i=0; i<size; i++)
+    {
+        pos=str.find(separator,i);
+        if(pos<size)
+        {
+            std::string s=str.substr(i,pos-i);
+            result.push_back(s);
+            i=pos+separator.size()-1;
+        }
+    }
+    return result;
+}
+
+#if defined _WIN32 || defined WINCE
+    const char dir_separators[] = "/\\";
+
+	struct dirent
+	{
+		const char* d_name;
+	};
+
+	struct DIR
+	{
+#ifdef WINRT
+		WIN32_FIND_DATAW data;
+#else
+        WIN32_FIND_DATAA data;
+#endif
+		HANDLE handle;
+		dirent ent;
+#ifdef WINRT
+		DIR() { }
+		~DIR()
+		{
+			if (ent.d_name)
+				delete[] ent.d_name;
+		}
+#endif
+	};
+
+	DIR* opendir(const char* path)
+	{
+		DIR* dir = new DIR;
+		dir->ent.d_name = 0;
+#ifdef WINRT
+		string full_path = string(path) + "\\*";
+		wchar_t wfull_path[MAX_PATH];
+		size_t copied = mbstowcs(wfull_path, full_path.c_str(), MAX_PATH);
+		CV_Assert((copied != MAX_PATH) && (copied != (size_t)-1));
+		dir->handle = ::FindFirstFileExW(wfull_path, FindExInfoStandard,
+			&dir->data, FindExSearchNameMatch, NULL, 0);
+#else
+		dir->handle = ::FindFirstFileExA((string(path) + "\\*").c_str(),
+			FindExInfoStandard, &dir->data, FindExSearchNameMatch, NULL, 0);
+#endif
+		if (dir->handle == INVALID_HANDLE_VALUE)
+		{
+			/*closedir will do all cleanup*/
+			delete dir;
+			return 0;
+		}
+		return dir;
+	}
+
+	dirent* readdir(DIR* dir)
+	{
+#ifdef WINRT
+		if (dir->ent.d_name != 0)
+		{
+			if (::FindNextFileW(dir->handle, &dir->data) != TRUE)
+				return 0;
+		}
+		size_t asize = wcstombs(NULL, dir->data.cFileName, 0);
+		CV_Assert((asize != 0) && (asize != (size_t)-1));
+		char* aname = new char[asize + 1];
+		aname[asize] = 0;
+		wcstombs(aname, dir->data.cFileName, asize);
+		dir->ent.d_name = aname;
+#else
+		if (dir->ent.d_name != 0)
+		{
+			if (::FindNextFileA(dir->handle, &dir->data) != TRUE)
+				return 0;
+		}
+		dir->ent.d_name = dir->data.cFileName;
+#endif
+		return &dir->ent;
+	}
+
+	void closedir(DIR* dir)
+	{
+		::FindClose(dir->handle);
+		delete dir;
+	}
+#else
+# include <dirent.h>
+# include <sys/stat.h>
+	const char dir_separators[] = "/";
+#endif
+
+	static bool isDir(const string &path, DIR* dir)
+	{
+#if defined _WIN32 || defined WINCE
+		DWORD attributes;
+		BOOL status = TRUE;
+		if (dir)
+			attributes = dir->data.dwFileAttributes;
+		else
+		{
+			WIN32_FILE_ATTRIBUTE_DATA all_attrs;
+#ifdef WINRT
+			wchar_t wpath[MAX_PATH];
+			size_t copied = mbstowcs(wpath, path.c_str(), MAX_PATH);
+			CV_Assert((copied != MAX_PATH) && (copied != (size_t)-1));
+			status = ::GetFileAttributesExW(wpath, GetFileExInfoStandard, &all_attrs);
+#else
+			status = ::GetFileAttributesExA(path.c_str(), GetFileExInfoStandard, &all_attrs);
+#endif
+			attributes = all_attrs.dwFileAttributes;
+		}
+
+		return status && ((attributes & FILE_ATTRIBUTE_DIRECTORY) != 0);
+#else
+		(void)dir;
+		struct stat stat_buf;
+		if (0 != stat(path.c_str(), &stat_buf))
+			return false;
+		int is_dir = S_ISDIR(stat_buf.st_mode);
+		return is_dir != 0;
+#endif
+	}
+
+	bool IsDirectory(const string &path)
+	{
+		return isDir(path, NULL);
+	}
+
+	bool Exists(const string& path)
+	{
+
+#if defined _WIN32 || defined WINCE
+			BOOL status = TRUE;
+		{
+			WIN32_FILE_ATTRIBUTE_DATA all_attrs;
+#ifdef WINRT
+			wchar_t wpath[MAX_PATH];
+			size_t copied = mbstowcs(wpath, path.c_str(), MAX_PATH);
+			CV_Assert((copied != MAX_PATH) && (copied != (size_t)-1));
+			status = ::GetFileAttributesExW(wpath, GetFileExInfoStandard, &all_attrs);
+#else
+			status = ::GetFileAttributesExA(path.c_str(), GetFileExInfoStandard, &all_attrs);
+#endif
+		}
+
+		return !!status;
+#else
+		struct stat stat_buf;
+		return (0 == stat(path.c_str(), &stat_buf));
+#endif
+	}
+
+    bool IsPathSeparator(char c)
+    {
+        return c == '/' || c == '\\';
+	}
+
+	string JoinPath(const string& base, const string& path)
+	{
+		if (base.empty())
+			return path;
+		if (path.empty())
+			return base;
+
+		bool baseSep = IsPathSeparator(base[base.size() - 1]);
+		bool pathSep = IsPathSeparator(path[0]);
+		string result;
+		if (baseSep && pathSep)
+		{
+			result = base + path.substr(1);
+		}
+		else if (!baseSep && !pathSep)
+		{
+            result = base + PATH_SEPARATOR + path;
+		}
+		else
+		{
+			result = base + path;
+		}
+		return result;
+	}
+
+	static bool wildcmp(const char *string, const char *wild)
+	{
+		const char *cp = 0, *mp = 0;
+
+		while ((*string) && (*wild != '*'))
+		{
+			if ((*wild != *string) && (*wild != '?'))
+			{
+				return false;
+			}
+
+			wild++;
+			string++;
+		}
+
+		while (*string)
+		{
+			if (*wild == '*')
+			{
+				if (!*++wild)
+				{
+					return true;
+				}
+
+				mp = wild;
+				cp = string + 1;
+			}
+			else if ((*wild == *string) || (*wild == '?'))
+			{
+				wild++;
+				string++;
+			}
+			else
+			{
+				wild = mp;
+				string = cp++;
+			}
+		}
+
+		while (*wild == '*')
+		{
+			wild++;
+		}
+
+		return *wild == 0;
+	}
+
+	static void glob_rec(const string &directory, const string& wildchart, std::vector<string>& result,
+		bool recursive, bool includeDirectories, const string& pathPrefix)
+	{
+		DIR *dir;
+
+		if ((dir = opendir(directory.c_str())) != 0)
+		{
+			/* find all the files and directories within directory */
+			try
+			{
+				struct dirent *ent;
+				while ((ent = readdir(dir)) != 0)
+				{
+					const char* name = ent->d_name;
+					if ((name[0] == 0) || (name[0] == '.' && name[1] == 0) || (name[0] == '.' && name[1] == '.' && name[2] == 0))
+						continue;
+
+					string path = JoinPath(directory, name);
+					string entry = JoinPath(pathPrefix, name);
+
+					if (isDir(path, dir))
+					{
+						if (recursive)
+							glob_rec(path, wildchart, result, recursive, includeDirectories, entry);
+						if (!includeDirectories)
+							continue;
+					}
+
+					if (wildchart.empty() || wildcmp(name, wildchart.c_str()))
+						result.push_back(entry);
+				}
+			}
+			catch (...)
+			{
+				closedir(dir);
+				throw;
+			}
+			closedir(dir);
+		}
+		else
+		{
+			printf("could not open directory: %s", directory.c_str());
+		}
+	}
+
+	void GetFileNameList(const string &directory, const string &pattern, std::vector<string>& result, bool recursive, bool addPath)
+	{
+        // split pattern
+        vector<string> patterns=SplitString(pattern,",");
+
+        result.clear();
+
+        for(int i=0;i<patterns.size();++i)
+        {
+            string eachPattern=patterns[i];
+            std::vector<string> eachResult;
+            glob_rec(directory, eachPattern, eachResult, recursive, true, directory);
+            for(int j=0;j<eachResult.size();++j)
+            {
+				if (IsDirectory(eachResult[j]))
+					continue;
+                if(addPath)
+                {
+                    result.push_back(eachResult[j]);
+                }
+                else
+                {
+                    result.push_back(GetFileName(eachResult[j]));
+                }
+            }
+        }
+		std::sort(result.begin(), result.end());
+	}
+
+	void GetFileNameList2(const string &directory, const string &pattern, std::vector<string>& result, bool recursive, bool addPath)
+	{
+		// split pattern
+		vector<string> patterns = SplitString(pattern, ",");
+
+        result.clear();
+
+		for (int i = 0; i<patterns.size(); ++i)
+		{
+			string eachPattern = patterns[i];
+			std::vector<string> eachResult;
+			glob_rec(directory, eachPattern, eachResult, recursive, true, directory);
+			for (int j = 0; j<eachResult.size(); ++j)
+			{
+				string filePath = eachResult[j];
+				if (IsDirectory(filePath))
+				{
+					filePath = filePath + "/";
+					for (int k = 0; k < filePath.size(); ++k)
+					{
+						if (IsPathSeparator(filePath[k]))
+						{
+							filePath[k] = '/';
+						}
+					}
+				}
+				if (addPath)
+				{
+					result.push_back(filePath);
+				}
+				else
+				{
+					if (!IsDirectory(filePath))
+					{
+						result.push_back(GetFileName(filePath));
+					}
+				}
+			}
+		}
+		std::sort(result.begin(), result.end());
+	}
+
+	void RemoveAll(const string& path)
+	{
+
+		if (!Exists(path))
+			return;
+
+		if (IsDirectory(path))
+		{
+			std::vector<string> entries;
+			GetFileNameList2(path, string(), entries, false, true);
+			for (size_t i = 0; i < entries.size(); i++)
+			{
+				const string& e = entries[i];
+				RemoveAll(e);
+			}
+#ifdef _MSC_VER
+			bool result = _rmdir(path.c_str()) == 0;
+#else
+			bool result = rmdir(path.c_str()) == 0;
+#endif
+			if (!result)
+			{
+				printf("can't remove directory: %s\n", path.c_str());
+			}
+		}
+		else
+		{
+#ifdef _MSC_VER
+			bool result = _unlink(path.c_str()) == 0;
+#else
+			bool result = unlink(path.c_str()) == 0;
+#endif
+			if (!result)
+			{
+				printf("can't remove file: %s\n", path.c_str());
+			}
+		}
+	}
+
+	void Remove(const string &directory, const string &extension)
+	{
+
+		DIR *dir;
+
+		static int numberOfFiles = 0;
+
+		if ((dir = opendir(directory.c_str())) != 0)
+		{
+			/* find all the files and directories within directory */
+			try
+			{
+				struct dirent *ent;
+				while ((ent = readdir(dir)) != 0)
+				{
+					const char* name = ent->d_name;
+					if ((name[0] == 0) || (name[0] == '.' && name[1] == 0) || (name[0] == '.' && name[1] == '.' && name[2] == 0))
+						continue;
+
+					string path = JoinPath(directory, name);
+
+					if (isDir(path, dir))
+					{
+						Remove(path, extension);
+					}
+
+					// �ж���չ��
+					if (extension.empty() || wildcmp(name, extension.c_str()))
+					{
+						RemoveAll(path);
+						++numberOfFiles;
+						printf("%s deleted! number of deleted files:%d\n", path.c_str(), numberOfFiles);
+					}
+
+				}
+			}
+			catch (...)
+			{
+				closedir(dir);
+				throw;
+			}
+			closedir(dir);
+		}
+		else
+		{
+			printf("could not open directory: %s", directory.c_str());
+		}
+
+		// ����RemoveAllɾ��Ŀ¼
+		RemoveAll(directory);
+	}
+	string GetFileName(const string &path)
+	{
+        string fileName;
+        int indexOfPathSeparator = -1;
+        for (int i = path.size() - 1; i >= 0; --i)
+        {
+            if (IsPathSeparator(path[i]))
+            {
+                fileName = path.substr(i + 1, path.size() - i - 1);
+                indexOfPathSeparator = i;
+                break;
+            }
+        }
+        if (indexOfPathSeparator == -1)
+        {
+            fileName = path;
+        }
+
+        return fileName;
+	}
+    string GetFileName_NoExtension(const string &path)
+    {
+        string fileName=GetFileName(path);
+        string fileName_NoExtension;
+        for(int i=fileName.size()-1;i>0;--i)
+        {
+            if(fileName[i]=='.')
+            {
+                fileName_NoExtension=fileName.substr(0,i);
+                break;
+            }
+        }
+
+        return fileName_NoExtension;
+    }
+
+	string GetExtension(const string &path)
+	{
+		string fileName;
+		for (int i = path.size() - 1; i >= 0; --i)
+		{
+			if (path[i]=='.')
+			{
+				fileName = path.substr(i, path.size() - i);
+				break;
+			}
+		}
+
+		return fileName;
+
+	}
+
+	string GetParentPath(const string &path)
+	{
+		string fileName;
+		for (int i = path.size() - 1; i >= 0; --i)
+		{
+			if (IsPathSeparator(path[i]))
+			{
+				fileName = path.substr(0, i+1);
+				break;
+			}
+		}
+
+		return fileName;
+	}
+
+    static bool CreateDirectory(const string &path)
+    {
+    #if defined WIN32 || defined _WIN32 || defined WINCE
+    #ifdef WINRT
+                wchar_t wpath[MAX_PATH];
+            size_t copied = mbstowcs(wpath, path.c_str(), MAX_PATH);
+            CV_Assert((copied != MAX_PATH) && (copied != (size_t)-1));
+            int result = CreateDirectoryA(wpath, NULL) ? 0 : -1;
+    #else
+                int result = _mkdir(path.c_str());
+    #endif
+    #elif defined __linux__ || defined __APPLE__
+                int result = mkdir(path.c_str(), 0777);
+    #else
+                int result = -1;
+    #endif
+
+            if (result == -1)
+            {
+                return IsDirectory(path);
+            }
+            return true;
+    }
+
+	bool CreateDirectories(const string &directoryPath)
+	{
+		string path = directoryPath;
+
+		for (;;)
+		{
+			char last_char = path.empty() ? 0 : path[path.length() - 1];
+			if (IsPathSeparator(last_char))
+			{
+				path = path.substr(0, path.length() - 1);
+				continue;
+			}
+			break;
+		}
+
+		if (path.empty() || path == "./" || path == ".\\" || path == ".")
+			return true;
+		if (IsDirectory(path))
+			return true;
+
+		size_t pos = path.rfind('/');
+		if (pos == string::npos)
+			pos = path.rfind('\\');
+		if (pos != string::npos)
+		{
+			string parent_directory = path.substr(0, pos);
+			if (!parent_directory.empty())
+			{
+				if (!CreateDirectories(parent_directory))
+					return false;
+			}
+		}
+
+		return CreateDirectory(path);
+	}
+
+    bool CopyFile(const string srcPath, const string dstPath)
+    {
+        std::ifstream srcFile(srcPath,ios::binary);
+        std::ofstream dstFile(dstPath,ios::binary);
+
+        if(!srcFile.is_open())
+        {
+            printf("can not open %s\n",srcPath.c_str());
+            return false;
+        }
+        if(!dstFile.is_open())
+        {
+			printf("can not open %s\n", dstPath.c_str());
+            return false;
+        }
+        if(srcPath==dstPath)
+        {
+			printf("src can not be same with dst\n");
+            return false;
+        }
+        char buffer[2048];
+        unsigned int numberOfBytes=0;
+        while(srcFile)
+        {
+            srcFile.read(buffer,2048);
+            dstFile.write(buffer,srcFile.gcount());
+            numberOfBytes+=srcFile.gcount();
+        }
+        srcFile.close();
+        dstFile.close();
+        return true;
+    }
+
+    bool CopyDirectories(string srcPath, const string dstPath)
+    {
+        if(srcPath==dstPath)
+        {
+			printf("src can not be same with dst\n");
+            return false;
+        }
+
+		// ȥ������·���ָ���
+		srcPath = srcPath.substr(0, srcPath.size() - 1);
+
+        vector<string> fileNameList;
+        GetFileNameList2(srcPath, "", fileNameList, true, true);
+
+        string parentPathOfSrc=GetParentPath(srcPath);
+        int length=parentPathOfSrc.size();
+
+        // create all directories
+        for(int i=0;i<fileNameList.size();++i)
+        {
+            // create directory
+            string srcFilePath=fileNameList[i];
+            string subStr=srcFilePath.substr(length,srcFilePath.size()-length);
+            string dstFilePath=dstPath+subStr;
+            string parentPathOfDst=GetParentPath(dstFilePath);
+            CreateDirectories(parentPathOfDst);
+        }
+
+        // copy file
+        for(int i=0;i<fileNameList.size();++i)
+        {
+            string srcFilePath=fileNameList[i];
+			if (IsDirectory(srcFilePath))
+			{
+				continue;
+			}
+            string subStr=srcFilePath.substr(length,srcFilePath.size()-length);
+            string dstFilePath=dstPath+subStr;
+
+            // copy file
+            CopyFile(srcFilePath,dstFilePath);
+
+			// process
+			double process = (1.0*(i + 1) / fileNameList.size()) * 100;
+			printf("%s done! %f \n", GetFileName(fileNameList[i]).c_str(), process);
+        }
+		printf("all done!(the number of files:%zu)\n", fileNameList.size());
+
+        return true;
+
+
+    }
+
+}
+
+

Src/Utility/Filesystem.h

+// 文件以及目录处理
+
+#ifndef __FILE_SYSTEM_H__
+#define __FILE_SYSTEM_H__
+
+#include <string>
+#include <vector>
+ 
+namespace ortSamples
+{
+
+// 路径是否存在
+bool Exists(const std::string &path);
+
+// 路径是否为目录
+bool IsDirectory(const std::string &path);
+
+// 是否是路径分隔符(Linux:‘/’,Windows:’\\’)
+bool IsPathSeparator(char c);
+
+// 路径拼接
+std::string JoinPath(const std::string &base, const std::string &path);
+
+// 创建多级目录,注意：创建多级目录的时候，目标目录是不能有文件存在的
+bool CreateDirectories(const std::string &directoryPath);
+
+/** 生成符合指定模式的文件名列表(支持递归遍历)
+* 
+* pattern: 模式,比如"*.jpg","*.png","*.jpg,*.png"
+* addPath：是否包含父路径
+* 注意：
+    1. 多个模式使用","分割,比如"*.jpg,*.png"
+    2. 支持通配符'*','?' ,比如第一个字符是7的所有文件名:"7*.*", 以512结尾的所有jpg文件名："*512.jpg"
+    3. 使用"*.jpg"，而不是".jpg"
+    4. 空string表示返回所有结果
+    5. 不能返回子目录名
+*
+*/
+void GetFileNameList(const std::string &directory, const std::string &pattern, std::vector<std::string> &result, bool recursive, bool addPath);
+
+// 与GetFileNameList的区别在于如果有子目录，在addPath为true的时候会返回子目录路径(目录名最后有"/")
+void GetFileNameList2(const std::string &directory, const std::string &pattern, std::vector<std::string> &result, bool recursive, bool addPath);
+
+// 删除文件或者目录,支持递归删除
+void Remove(const std::string &directory, const std::string &extension="");
+
+/** 获取路径的文件名和扩展名
+ * 
+ *  示例：path为D:/1/1.txt,则GetFileName()为1.txt,GetFileName_NoExtension()为1,GetExtension()为.txt,GetParentPath()为D:/1/
+*/
+std::string GetFileName(const std::string &path);
+std::string GetFileName_NoExtension(const std::string &path); 
+std::string GetExtension(const std::string &path);
+std::string GetParentPath(const std::string &path);
+
+// 拷贝文件
+bool CopyFile(const std::string srcPath,const std::string dstPath);
+
+/** 拷贝目录
+ * 
+ * 示例：CopyDirectories("D:/0/1/2/","E:/3/");实现把D:/0/1/2/目录拷贝到E:/3/目录中(即拷贝完成后的目录结构为E:/3/2/)
+ * 注意：
+    1.第一个参数的最后不能加”/”
+    2.不能拷贝隐藏文件
+*/
+bool CopyDirectories(std::string srcPath,const std::string dstPath);
+
+}
+
+#endif

Src/Utility/SimpleLog.h

+// 简易日志
+
+#ifndef __SIMPLE_LOG_H__
+#define __SIMPLE_LOG_H__
+
+#include <time.h>
+#include <string>
+#include <map>
+#include <thread>
+#include <mutex>
+#if (defined WIN32 || defined _WIN32)
+#include <Windows.h>
+#else
+#include <sys/time.h>
+#endif
+
+using namespace std;
+
+
+/** 简易日志
+ * 
+ * 不依赖于其他第三方库，只需要包含一个头文件就可以使用。提供了4种日志级别，包括INFO,DEBUG,WARN和ERROR。
+ * 
+ * 示例1:
+    // 初始化日志，在./Log/目录下创建两个日志文件log1.log和log2.log(注意：目录./Log/需要存在，否则日志创建失败)
+    LogManager::GetInstance()->Initialize("./Log/","log1");
+    LogManager::GetInstance()->Initialize("./Log/","log2");
+
+    // 写日志
+    string log = "Hello World";
+    LOG_INFO(LogManager::GetInstance()->GetLogFile("log1"), "%s\n", log.c_str()); // 写入log1.log
+    LOG_INFO(LogManager::GetInstance()->GetLogFile("log2"), "%s\n", log.c_str()); // 写入log2.log
+
+    // 关闭日志
+    LogManager::GetInstance()->Close("log1");
+    LogManager::GetInstance()->Close("log2");
+  
+  * 示例2:
+    // 将日志输出到控制台
+    string log = "Hello World";
+    LOG_INFO(stdout, "%s\n", log.c_str()); 
+
+  * 注意：
+    1. 需要C++11
+    2. 多线程的时候需要加锁(打开#define LOG_MUTEX)，否则会导致日志显示混乱
+
+*/
+
+// #define LOG_MUTEX  // 加锁
+
+class LogManager
+{
+private:
+    LogManager(){}
+
+public:
+    ~LogManager(){}
+    inline void Initialize(const string &parentPath,const string &logName)
+    {
+        // 日志名为空表示输出到控制台
+        if(logName.size()==0)
+            return;
+
+        // 查找该日志文件，如果没有则创建
+        std::map<string, FILE*>::const_iterator iter = logMap.find(logName);
+        if (iter == logMap.end())
+        {
+            string pathOfLog = parentPath+ logName + ".log";
+            FILE *logFile = fopen(pathOfLog.c_str(), "a"); // w:覆盖原有文件,a:追加
+            if(logFile!=NULL)
+            {
+                logMap.insert(std::make_pair(logName, logFile));
+            }
+        }
+
+    }
+    inline FILE* GetLogFile(const string &logName)
+    {
+        std::map<string, FILE*>::const_iterator iter=logMap.find(logName);
+        if(iter==logMap.end())
+        {
+            return NULL;
+        }
+
+        return (*iter).second;
+    }
+    inline void Close(const string &logName)
+    {
+        std::map<string, FILE*>::const_iterator iter=logMap.find(logName);
+        if(iter==logMap.end())
+        {
+            return;
+        }
+
+        fclose((*iter).second);
+        logMap.erase(iter);
+    }
+    inline std::mutex &GetLogMutex()
+    {
+        return logMutex;
+    }
+
+    // Singleton
+    static LogManager* GetInstance()
+    {
+        static LogManager logManager;
+        return &logManager;
+    }
+private:
+    std::map<string, FILE*> logMap;
+    std::mutex logMutex;
+};
+
+#ifdef LOG_MUTEX
+    #define LOCK	LogManager::GetInstance()->GetLogMutex().lock()
+    #define UNLOCK	LogManager::GetInstance()->GetLogMutex().unlock()
+#else
+    #define LOCK
+    #define UNLOCK
+#endif
+
+// log time
+typedef struct  _LogTime
+{
+    string year;
+    string month;
+    string day;
+    string hour;
+    string minute;
+    string second;
+    string millisecond; // ms
+    string microsecond; // us
+    string weekDay;
+}LogTime;
+
+inline LogTime GetTime()
+{
+    LogTime currentTime;
+
+#if (defined WIN32 || defined _WIN32)
+    SYSTEMTIME systemTime;
+    GetLocalTime(&systemTime);
+
+    char temp[12] = { 0 };
+    sprintf(temp, "%04d", systemTime.wYear);
+    currentTime.year=string(temp);
+    sprintf(temp, "%02d", systemTime.wMonth);
+    currentTime.month=string(temp);
+    sprintf(temp, "%02d", systemTime.wDay);
+    currentTime.day=string(temp);
+    sprintf(temp, "%02d", systemTime.wHour);
+    currentTime.hour=string(temp);
+    sprintf(temp, "%02d", systemTime.wMinute);
+    currentTime.minute=string(temp);
+    sprintf(temp, "%02d", systemTime.wSecond);
+    currentTime.second=string(temp);
+    sprintf(temp, "%03d", systemTime.wMilliseconds);
+    currentTime.millisecond=string(temp);
+    sprintf(temp, "%d", systemTime.wDayOfWeek);
+    currentTime.weekDay=string(temp);
+#else
+    struct timeval    tv;
+    struct tm         *p;
+    gettimeofday(&tv, NULL);
+    p = localtime(&tv.tv_sec);
+
+    char temp[8]={0};
+    sprintf(temp,"%04d",1900+p->tm_year);
+    currentTime.year=string(temp);
+    sprintf(temp,"%02d",1+p->tm_mon);
+    currentTime.month=string(temp);
+    sprintf(temp,"%02d",p->tm_mday);
+    currentTime.day=string(temp);
+    sprintf(temp,"%02d",p->tm_hour);
+    currentTime.hour=string(temp);
+    sprintf(temp,"%02d",p->tm_min);
+    currentTime.minute=string(temp);
+    sprintf(temp,"%02d",p->tm_sec);
+    currentTime.second=string(temp);
+    sprintf(temp,"%03d",(int)(tv.tv_usec/1000));
+    currentTime.millisecond = string(temp);
+    sprintf(temp, "%03d", (int)(tv.tv_usec % 1000));
+    currentTime.microsecond = string(temp);
+    sprintf(temp, "%d", p->tm_wday);
+    currentTime.weekDay = string(temp);
+#endif
+    return currentTime;
+}
+
+#define LOG_TIME(logFile) \
+do\
+{\
+    LogTime currentTime=GetTime(); \
+    fprintf(((logFile == NULL) ? stdout : logFile), "%s-%s-%s %s:%s:%s.%s\t",currentTime.year.c_str(),currentTime.month.c_str(),currentTime.day.c_str(),currentTime.hour.c_str(),currentTime.minute.c_str(),currentTime.second.c_str(),currentTime.millisecond.c_str()); \
+}while (0)
+
+
+#define LOG_INFO(logFile,logInfo, ...) \
+do\
+{\
+    LOCK; \
+    LOG_TIME(logFile); \
+    fprintf(((logFile == NULL) ? stdout : logFile), "INFO\t"); \
+    fprintf(((logFile == NULL) ? stdout : logFile), "[%s:%d (%s) ]: ", __FILE__, __LINE__, __FUNCTION__); \
+    fprintf(((logFile == NULL) ? stdout : logFile), logInfo, ## __VA_ARGS__); \
+    fflush(logFile); \
+    UNLOCK; \
+} while (0)
+
+#define LOG_DEBUG(logFile,logInfo, ...) \
+do\
+{\
+    LOCK; \
+    LOG_TIME(logFile);\
+    fprintf(((logFile==NULL)?stdout:logFile), "DEBUG\t"); \
+    fprintf(((logFile==NULL)?stdout:logFile), "[%s:%d (%s) ]: ", __FILE__, __LINE__, __FUNCTION__); \
+    fprintf(((logFile==NULL)?stdout:logFile),logInfo, ## __VA_ARGS__); \
+    fflush(logFile); \
+    UNLOCK; \
+} while (0)
+
+#define LOG_ERROR(logFile,logInfo, ...) \
+do\
+{\
+    LOCK; \
+    LOG_TIME(logFile);\
+    fprintf(((logFile==NULL)?stdout:logFile), "ERROR\t"); \
+    fprintf(((logFile==NULL)?stdout:logFile), "[%s:%d (%s) ]: ", __FILE__, __LINE__, __FUNCTION__); \
+    fprintf(((logFile==NULL)?stdout:logFile),logInfo, ## __VA_ARGS__); \
+    fflush(logFile); \
+    UNLOCK; \
+} while (0)
+
+#define LOG_WARN(logFile,logInfo, ...) \
+do\
+{\
+    LOCK; \
+    LOG_TIME(logFile);\
+    fprintf(((logFile==NULL)?stdout:logFile), "WARN\t"); \
+    fprintf(((logFile==NULL)?stdout:logFile), "[%s:%d (%s) ]: ", __FILE__, __LINE__, __FUNCTION__); \
+    fprintf(((logFile==NULL)?stdout:logFile),logInfo, ## __VA_ARGS__); \
+    fflush(logFile); \
+    UNLOCK; \
+} while (0)
+
+#endif // __SIMPLE_LOG_H__
+

Src/main.cpp

+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <SimpleLog.h>
+#include <Filesystem.h>
+#include <Classifier.h>
+#include <iostream>
+#include <fstream>
+
+int main()
+{
+    // 创建分类器
+    ortSamples::Classifier classifier;
+    ortSamples::InitializationParameterOfClassifier initParamOfClassifier;
+    initParamOfClassifier.configFilePath=CONFIG_FILE;
+    ortSamples::ErrorCode errorCode=classifier.Initialize(initParamOfClassifier);
+    if(errorCode!=ortSamples::SUCCESS)
+    {
+        LOG_ERROR(stdout, "fail to initialize ResNet50!\n");
+        exit(-1);
+    }
+    LOG_INFO(stdout, "succeed to initialize ResNet50\n");
+
+    // 读取测试图片
+    cv::Mat srcImage=cv::imread("../Resource/Images/ImageNet_01.jpg",1);
+
+    // 设置batchsize
+    int batchsize=1;
+    std::vector<cv::Mat> srcImages;
+    for(int i=0;i<batchsize;++i)
+    {
+        srcImages.push_back(srcImage);
+    }
+
+    // 推理
+    std::vector<std::vector<ortSamples::ResultOfPrediction>> predictions;
+    double time1 = cv::getTickCount();
+    classifier.Classify(srcImages,predictions);
+    double time2 = cv::getTickCount();
+    double elapsedTime = (time2 - time1)*1000 / cv::getTickFrequency();
+    LOG_INFO(stdout, "inference time:%f ms\n", elapsedTime);
+    // 读取分类列表
+    std::ifstream file("../Resource/synset.txt");
+    if (!file.is_open()) {
+        std::cerr << "无法打开synset.txt文件" << std::endl;
+        return 1;
+    }
+
+    
+    // 获取推理结果
+    LOG_INFO(stdout,"========== Classification Results ==========\n");
+    for(int i=0;i<predictions.size();++i)
+    {
+        // 一个batch中第i幅图像的结果
+        LOG_INFO(stdout,"========== %d result ==========\n",i);
+        std::vector<ortSamples::ResultOfPrediction> resultOfPredictions=predictions[i];
+        double maxConfidence = -DBL_MAX;
+        int maxLabel = -1; 
+        for(int j=0;j<resultOfPredictions.size();++j)
+        {
+            ortSamples::ResultOfPrediction prediction=resultOfPredictions[j];
+            if (prediction.confidence > maxConfidence) {
+                maxConfidence = prediction.confidence;
+                maxLabel = prediction.label;
+            }
+        }
+        std::string line;
+        int currentLine = 0;
+        while (currentLine < maxLabel+1 && std::getline(file, line)) {
+            currentLine++;
+        }
+        LOG_INFO(stdout, "class=%s ; probability=%f\n", line.c_str(), maxConfidence);
+        
+        //保存图像
+        std::string text = std::string("class=") + line.c_str();
+        cv::Point text_position(5,20);
+        int font_face = cv::FONT_HERSHEY_SIMPLEX;
+        double font_scale = 0.5; // 调整字体大小
+        cv::Scalar font_color(0, 0, 255); // 白色
+        int font_thickness = 1;
+        cv::putText(srcImage, text, text_position, font_face, font_scale, font_color, font_thickness);
+        cv::imwrite("./output_image.jpg", srcImage);
+
+    }
+    file.close();
+    return 0;
+}

docker/Dockerfile

+FROM image.sourcefind.cn:5000/dcu/admin/base/migraphx:4.3.0-ubuntu20.04-dtk24.04.1-py3.10
+RUN source /opt/dtk/env.sh
+

model.properties

+# 模型唯一标识
+modelCode =276
+# 模型名称
+modelName=resnet50_onnxruntime
+# 模型描述
+modelDescription=ResNet50是一种用于图像分类的深度神经网络模型
+# 应用场景
+appScenario=制造,政府,医疗,科研
+# 框架类型
+frameType=onnxruntime

requirements.txt

+./3rdParty/opencv-3.4.11_mini.tar.gz