重新进行Cpp代码的格式化

Src/RetinaFace.cpp

@@ -9,36 +9,34 @@
 namespace migraphxSamples
 {
 
-#define SSD_QUANT_BASE     4096 // 基数
-#define SSD_COORDI_NUM     4  // 坐标个数(x1,y1,x2,y2)
+#define SSD_QUANT_BASE 4096 // 基数
+#define SSD_COORDI_NUM 4    // 坐标个数(x1,y1,x2,y2)
 #define SSD_PROPOSAL_WIDTH 6
-#define SSD_HALF           0.5
+#define SSD_HALF 0.5
 #define SSD_ASPECT_RATIO_NUM 6 // 默认最大的宽高比个数
 
-#define SSD_MAX(a,b)    (((a) > (b)) ? (a) : (b))
-#define SSD_MIN(a,b)    (((a) < (b)) ? (a) : (b))
+#define SSD_MAX(a, b) (((a) > (b)) ? (a) : (b))
+#define SSD_MIN(a, b) (((a) < (b)) ? (a) : (b))
 
 // 16字节对齐
 #define SSD_ALIGN_16 16
-#define SSD_ALIGN16(number) ((number + SSD_ALIGN_16-1) / SSD_ALIGN_16*SSD_ALIGN_16)
+#define SSD_ALIGN16(number) ((number + SSD_ALIGN_16 - 1) / SSD_ALIGN_16 * SSD_ALIGN_16)
 
-DetectorRetinaFace::DetectorRetinaFace()
-{
-
-}
+DetectorRetinaFace::DetectorRetinaFace() {}
 
 DetectorRetinaFace::~DetectorRetinaFace()
 {
     configurationFile.release();
-    
+
     // 释放SSD参数的内存空间
     delete[] ssdParameter.buffer;
 }
 
-ErrorCode DetectorRetinaFace::Initialize(InitializationParameterOfDetector initializationParameterOfDetector)
+ErrorCode
+DetectorRetinaFace::Initialize(InitializationParameterOfDetector initializationParameterOfDetector)
 {
     // 读取配置文件
-    std::string configFilePath=initializationParameterOfDetector.configFilePath;
+    std::string configFilePath = initializationParameterOfDetector.configFilePath;
     if(!Exists(configFilePath))
     {
         LOG_ERROR(stdout, "no configuration file!\n");
@@ -46,43 +44,43 @@ ErrorCode DetectorRetinaFace::Initialize(InitializationParameterOfDetector initi
     }
     if(!configurationFile.open(configFilePath, cv::FileStorage::READ))
     {
-       LOG_ERROR(stdout, "fail to open configuration file\n");
-       return FAIL_TO_OPEN_CONFIG_FILE;
+        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["DetectorRetinaFace"];
-    string modelPath=(string)netNode["ModelPath"];
-    scale=(float)netNode["Scale"];
-    meanValue.val[0]=(float)netNode["MeanValue1"];
-    meanValue.val[1]=(float)netNode["MeanValue2"];
-    meanValue.val[2]=(float)netNode["MeanValue3"];
-    swapRB=(bool)(int)netNode["SwapRB"];
-    crop=(bool)(int)netNode["Crop"];
-    useInt8=(bool)(int)netNode["UseInt8"];
-    useFP16=(bool)(int)netNode["UseFP16"];
+    string modelPath     = (string)netNode["ModelPath"];
+    scale                = (float)netNode["Scale"];
+    meanValue.val[0]     = (float)netNode["MeanValue1"];
+    meanValue.val[1]     = (float)netNode["MeanValue2"];
+    meanValue.val[2]     = (float)netNode["MeanValue3"];
+    swapRB               = (bool)(int)netNode["SwapRB"];
+    crop                 = (bool)(int)netNode["Crop"];
+    useInt8              = (bool)(int)netNode["UseInt8"];
+    useFP16              = (bool)(int)netNode["UseFP16"];
 
     // 加载模型
     if(!Exists(modelPath))
     {
-        LOG_ERROR(stdout,"%s not exist!\n",modelPath.c_str());
+        LOG_ERROR(stdout, "%s not exist!\n", modelPath.c_str());
         return MODEL_NOT_EXIST;
     }
     net = migraphx::parse_onnx(modelPath);
-    LOG_INFO(stdout,"succeed to load model: %s\n",GetFileName(modelPath).c_str());
+    LOG_INFO(stdout, "succeed to load model: %s\n", GetFileName(modelPath).c_str());
 
     // 获取模型输入/输出节点信息
-    std::unordered_map<std::string, migraphx::shape> inputs=net.get_inputs();
-    std::unordered_map<std::string, migraphx::shape> outputs=net.get_outputs();
-    inputName=inputs.begin()->first;
-    inputShape=inputs.begin()->second;
-    int N=inputShape.lens()[0];
-    int C=inputShape.lens()[1];
-    int H=inputShape.lens()[2];
-    int W=inputShape.lens()[3];
-    inputSize=cv::Size(W,H);
-    
+    std::unordered_map<std::string, migraphx::shape> inputs  = net.get_inputs();
+    std::unordered_map<std::string, migraphx::shape> outputs = net.get_outputs();
+    inputName                                                = inputs.begin()->first;
+    inputShape                                               = inputs.begin()->second;
+    int N                                                    = inputShape.lens()[0];
+    int C                                                    = inputShape.lens()[1];
+    int H                                                    = inputShape.lens()[2];
+    int W                                                    = inputShape.lens()[3];
+    inputSize                                                = cv::Size(W, H);
+
     // 设置模型为GPU模式
     migraphx::target gpuTarget = migraphx::gpu::target{};
 
@@ -90,25 +88,20 @@ ErrorCode DetectorRetinaFace::Initialize(InitializationParameterOfDetector initi
     if(useInt8)
     {
         // 创建量化校准数据,建议使用测试集中的多张典型图像
-        cv::Mat srcImage=cv::imread("../Resource/Images/FaceDetect_2.jpg",1);
+        cv::Mat srcImage = cv::imread("../Resource/Images/FaceDetect_2.jpg", 1);
         std::vector<cv::Mat> srcImages;
-        for(int i=0;i<inputShape.lens()[0];++i)
+        for(int i = 0; i < inputShape.lens()[0]; ++i)
         {
             srcImages.push_back(srcImage);
         }
 
         cv::Mat inputBlob;
-        cv::dnn::blobFromImages(srcImages,
-                        inputBlob,
-                        scale,
-                        inputSize,
-                        meanValue,
-                        swapRB,
-                        false);
+        cv::dnn::blobFromImages(srcImages, inputBlob, scale, inputSize, meanValue, swapRB, false);
 
         std::unordered_map<std::string, migraphx::argument> inputData;
-        inputData[inputName]= migraphx::argument{inputShape, (float*)inputBlob.data};
-        std::vector<std::unordered_map<std::string, migraphx::argument>> calibrationData = {inputData};
+        inputData[inputName] = migraphx::argument{inputShape, (float*)inputBlob.data};
+        std::vector<std::unordered_map<std::string, migraphx::argument>> calibrationData = {
+            inputData};
 
         // INT8量化
         migraphx::quantize_int8(net, gpuTarget, calibrationData);
@@ -120,10 +113,10 @@ ErrorCode DetectorRetinaFace::Initialize(InitializationParameterOfDetector initi
 
     // 编译模型
     migraphx::compile_options options;
-    options.device_id=0; // 设置GPU设备，默认为0号设备
-    options.offload_copy=true;
-    net.compile(gpuTarget,options);
-    LOG_INFO(stdout,"succeed to compile model: %s\n",GetFileName(modelPath).c_str());
+    options.device_id    = 0; // 设置GPU设备，默认为0号设备
+    options.offload_copy = true;
+    net.compile(gpuTarget, options);
+    LOG_INFO(stdout, "succeed to compile model: %s\n", GetFileName(modelPath).c_str());
 
     // warm up
     std::unordered_map<std::string, migraphx::argument> inputData;
@@ -131,14 +124,14 @@ ErrorCode DetectorRetinaFace::Initialize(InitializationParameterOfDetector initi
     net.eval(inputData);
 
     // log
-    LOG_INFO(stdout,"InputSize:%dx%d\n",inputSize.width,inputSize.height);
-    LOG_INFO(stdout,"InputName:%s\n",inputName.c_str());
-    LOG_INFO(stdout,"Scale:%.6f\n",scale);
-    LOG_INFO(stdout,"Mean:%.2f,%.2f,%.2f\n",meanValue.val[0],meanValue.val[1],meanValue.val[2]);
-    LOG_INFO(stdout,"SwapRB:%d\n",(int)swapRB);
-    LOG_INFO(stdout,"Crop:%d\n",(int)crop);
-    LOG_INFO(stdout,"UseInt8:%d\n",(int)useInt8);
-    LOG_INFO(stdout,"UseFP16:%d\n",(int)useFP16);
+    LOG_INFO(stdout, "InputSize:%dx%d\n", inputSize.width, inputSize.height);
+    LOG_INFO(stdout, "InputName:%s\n", inputName.c_str());
+    LOG_INFO(stdout, "Scale:%.6f\n", scale);
+    LOG_INFO(stdout, "Mean:%.2f,%.2f,%.2f\n", meanValue.val[0], meanValue.val[1], meanValue.val[2]);
+    LOG_INFO(stdout, "SwapRB:%d\n", (int)swapRB);
+    LOG_INFO(stdout, "Crop:%d\n", (int)crop);
+    LOG_INFO(stdout, "UseInt8:%d\n", (int)useInt8);
+    LOG_INFO(stdout, "UseFP16:%d\n", (int)useFP16);
 
     // 读取SSD 参数
     GetSSDParameter();
@@ -146,10 +139,11 @@ ErrorCode DetectorRetinaFace::Initialize(InitializationParameterOfDetector initi
     return SUCCESS;
 }
 
-ErrorCode DetectorRetinaFace::Detect(const cv::Mat &srcImage,std::vector<ResultOfDetection> &resultsOfDetection)
+ErrorCode DetectorRetinaFace::Detect(const cv::Mat& srcImage,
+                                     std::vector<ResultOfDetection>& resultsOfDetection)
 {
 
-    if(srcImage.empty()||srcImage.type()!=CV_8UC3)
+    if(srcImage.empty() || srcImage.type() != CV_8UC3)
     {
         LOG_ERROR(stdout, "image error!\n");
         return IMAGE_ERROR;
@@ -157,410 +151,423 @@ ErrorCode DetectorRetinaFace::Detect(const cv::Mat &srcImage,std::vector<ResultO
 
     // 数据预处理并转换为NCHW格式
     cv::Mat inputBlob;
-    cv::dnn::blobFromImage(srcImage,
-                    inputBlob,
-                    scale,
-                    inputSize,
-                    meanValue,
-                    swapRB,
-                    false);
- 
+    cv::dnn::blobFromImage(srcImage, inputBlob, scale, inputSize, meanValue, swapRB, false);
+
     // 创建输入数据
     std::unordered_map<std::string, migraphx::argument> inputData;
-    inputData[inputName]= migraphx::argument{inputShape, (float*)inputBlob.data};
+    inputData[inputName] = migraphx::argument{inputShape, (float*)inputBlob.data};
 
     // 推理
-    std::vector<migraphx::argument> inferenceResults=net.eval(inputData);
+    std::vector<migraphx::argument> inferenceResults = net.eval(inputData);
     std::vector<std::vector<float>> regressions;
     std::vector<std::vector<float>> classifications;
-    for(int i=0;i<ssdParameter.numberOfPriorBoxLayer;++i) // 执行Permute操作
+    for(int i = 0; i < ssdParameter.numberOfPriorBoxLayer; ++i) // 执行Permute操作
     {
-        int numberOfPriorBox=ssdParameter.detectInputChn[i]/(4*(ssdParameter.priorBoxHeight[i] * ssdParameter.priorBoxWidth[i]));
+        int numberOfPriorBox =
+            ssdParameter.detectInputChn[i] /
+            (4 * (ssdParameter.priorBoxHeight[i] * ssdParameter.priorBoxWidth[i]));
 
         // BboxHead
         std::vector<float> regression;
-        migraphx::argument result0  = inferenceResults[2*i]; 
+        migraphx::argument result0 = inferenceResults[2 * i];
         result0.visit([&](auto output) { regression.assign(output.begin(), output.end()); });
-        regression=PermuteLayer(regression,ssdParameter.priorBoxWidth[i],ssdParameter.priorBoxHeight[i],numberOfPriorBox*4);
+        regression = PermuteLayer(regression,
+                                  ssdParameter.priorBoxWidth[i],
+                                  ssdParameter.priorBoxHeight[i],
+                                  numberOfPriorBox * 4);
         regressions.push_back(regression);
-        
+
         // ClassHead
         std::vector<float> classification;
-        migraphx::argument result1  = inferenceResults[2*i+1]; 
+        migraphx::argument result1 = inferenceResults[2 * i + 1];
         result1.visit([&](auto output) { classification.assign(output.begin(), output.end()); });
-        classification=PermuteLayer(classification,ssdParameter.priorBoxWidth[i],ssdParameter.priorBoxHeight[i],numberOfPriorBox*ssdParameter.classNum);
+        classification = PermuteLayer(classification,
+                                      ssdParameter.priorBoxWidth[i],
+                                      ssdParameter.priorBoxHeight[i],
+                                      numberOfPriorBox * ssdParameter.classNum);
         classifications.push_back(classification);
     }
 
     // 对推理结果进行处理，得到最后SSD检测的结果
-    GetResult(classifications,regressions,resultsOfDetection);
+    GetResult(classifications, regressions, resultsOfDetection);
 
     // 转换到原图坐标
-    for(int i=0;i<resultsOfDetection.size();++i)
+    for(int i = 0; i < resultsOfDetection.size(); ++i)
     {
-        float ratioOfWidth=(1.0*srcImage.cols)/inputSize.width;
-        float ratioOfHeight=(1.0*srcImage.rows)/inputSize.height;
+        float ratioOfWidth  = (1.0 * srcImage.cols) / inputSize.width;
+        float ratioOfHeight = (1.0 * srcImage.rows) / inputSize.height;
 
-        resultsOfDetection[i].boundingBox.x*=ratioOfWidth;
-        resultsOfDetection[i].boundingBox.width*=ratioOfWidth;
-        resultsOfDetection[i].boundingBox.y*=ratioOfHeight;
-        resultsOfDetection[i].boundingBox.height*=ratioOfHeight;
+        resultsOfDetection[i].boundingBox.x *= ratioOfWidth;
+        resultsOfDetection[i].boundingBox.width *= ratioOfWidth;
+        resultsOfDetection[i].boundingBox.y *= ratioOfHeight;
+        resultsOfDetection[i].boundingBox.height *= ratioOfHeight;
     }
 
     // 按照置信度排序
-    sort(resultsOfDetection.begin(), resultsOfDetection.end(),CompareConfidence);
+    sort(resultsOfDetection.begin(), resultsOfDetection.end(), CompareConfidence);
 
     return SUCCESS;
 }
 
 void DetectorRetinaFace::GetSSDParameter()
 {
-    cv::FileNode rootNode = configurationFile["DetectorRetinaFace"];
-    ssdParameter.numberOfPriorBoxLayer=(int)rootNode["PriorBoxLayerNumber"];
+    cv::FileNode rootNode              = configurationFile["DetectorRetinaFace"];
+    ssdParameter.numberOfPriorBoxLayer = (int)rootNode["PriorBoxLayerNumber"];
 
     ssdParameter.srcImageHeight = inputSize.height;
-    ssdParameter.srcImageWidth = inputSize.width;
+    ssdParameter.srcImageWidth  = inputSize.width;
 
     // MinSize,MaxSize
     ssdParameter.priorBoxMinSize.resize(ssdParameter.numberOfPriorBoxLayer);
     ssdParameter.priorBoxMaxSize.resize(ssdParameter.numberOfPriorBoxLayer);
-    for (int i = 0; i < ssdParameter.numberOfPriorBoxLayer; ++i)
-	{
-		char nodeName[256] = { 0 };
+    for(int i = 0; i < ssdParameter.numberOfPriorBoxLayer; ++i)
+    {
+        char nodeName[256] = {0};
 
-		// miniSize
+        // miniSize
         {
-            int j=0;
+            int j = 0;
             while(true)
             {
-               sprintf(nodeName, "MinSize%d%d", (i + 1),++j);
-               cv::FileNode miniSizeNode = rootNode[nodeName];
-               if(miniSizeNode.empty())
-               {
-                   break;
-               }
-               else
-               {
-                 ssdParameter.priorBoxMinSize[i].push_back((float)rootNode[nodeName]);
-               }
+                sprintf(nodeName, "MinSize%d%d", (i + 1), ++j);
+                cv::FileNode miniSizeNode = rootNode[nodeName];
+                if(miniSizeNode.empty())
+                {
+                    break;
+                }
+                else
+                {
+                    ssdParameter.priorBoxMinSize[i].push_back((float)rootNode[nodeName]);
+                }
             }
         }
 
-		// maxSize
+        // maxSize
         {
-            int j=0;
+            int j = 0;
             while(true)
             {
-               sprintf(nodeName, "MaxSize%d%d", (i + 1),++j);
-               cv::FileNode maxSizeNode = rootNode[nodeName];
-               if(maxSizeNode.empty())
-               {
-                   break;
-               }
-               else
-               {
-                 ssdParameter.priorBoxMaxSize[i].push_back((float)rootNode[nodeName]);
-               }
+                sprintf(nodeName, "MaxSize%d%d", (i + 1), ++j);
+                cv::FileNode maxSizeNode = rootNode[nodeName];
+                if(maxSizeNode.empty())
+                {
+                    break;
+                }
+                else
+                {
+                    ssdParameter.priorBoxMaxSize[i].push_back((float)rootNode[nodeName]);
+                }
             }
         }
-	}
+    }
 
     // MinSizeNumber,MaxSizeNumber
-    for (int i = 0; i < ssdParameter.numberOfPriorBoxLayer; ++i)
+    for(int i = 0; i < ssdParameter.numberOfPriorBoxLayer; ++i)
     {
         ssdParameter.minSizeNum[i] = ssdParameter.priorBoxMinSize[i].size();
-        ssdParameter.maxSizeNum[i] = ssdParameter.priorBoxMaxSize[i].size();;
+        ssdParameter.maxSizeNum[i] = ssdParameter.priorBoxMaxSize[i].size();
+        ;
     }
 
     // Flip,Clip
-    for (int i = 0; i < ssdParameter.numberOfPriorBoxLayer; ++i)
-	{
-		char nodeName[256] = { 0 };
+    for(int i = 0; i < ssdParameter.numberOfPriorBoxLayer; ++i)
+    {
+        char nodeName[256] = {0};
 
-		// Flip
-		sprintf(nodeName, "Flip%d", i + 1);
-		int flip = (int)rootNode[nodeName];
-		ssdParameter.flip[i] = flip;
+        // Flip
+        sprintf(nodeName, "Flip%d", i + 1);
+        int flip             = (int)rootNode[nodeName];
+        ssdParameter.flip[i] = flip;
 
-		// Clip
-		sprintf(nodeName, "Clip%d", i + 1);
-		int clip = (int)rootNode[nodeName];
-		ssdParameter.clip[i] = clip;
-	}
+        // Clip
+        sprintf(nodeName, "Clip%d", i + 1);
+        int clip             = (int)rootNode[nodeName];
+        ssdParameter.clip[i] = clip;
+    }
 
     // AspectRatio
     ssdParameter.priorBoxAspectRatio.resize(ssdParameter.numberOfPriorBoxLayer);
-    for (int i = 0; i < ssdParameter.numberOfPriorBoxLayer; ++i)
-	{
-        char nodeName[256] = { 0 };
-        int j=0;
+    for(int i = 0; i < ssdParameter.numberOfPriorBoxLayer; ++i)
+    {
+        char nodeName[256] = {0};
+        int j              = 0;
         while(true)
         {
-           sprintf(nodeName, "AspectRatio%d%d", (i + 1),++j);
-           cv::FileNode aspectRatioNode = rootNode[nodeName];
-           if(aspectRatioNode.empty())
-           {
-               break;
-           }
-           else
-           {
-             ssdParameter.priorBoxAspectRatio[i].push_back((float)rootNode[nodeName]);
-           }
+            sprintf(nodeName, "AspectRatio%d%d", (i + 1), ++j);
+            cv::FileNode aspectRatioNode = rootNode[nodeName];
+            if(aspectRatioNode.empty())
+            {
+                break;
+            }
+            else
+            {
+                ssdParameter.priorBoxAspectRatio[i].push_back((float)rootNode[nodeName]);
+            }
         }
     }
 
     // aspect ratio number
-    for (int i = 0; i < ssdParameter.numberOfPriorBoxLayer; ++i)
+    for(int i = 0; i < ssdParameter.numberOfPriorBoxLayer; ++i)
     {
         ssdParameter.inputAspectRatioNum[i] = ssdParameter.priorBoxAspectRatio[i].size();
     }
 
     // PriorBoxStep
-    for (int i = 0; i < ssdParameter.numberOfPriorBoxLayer; ++i)
-	{
-		char nodeName[256] = { 0 };
-
-		// width
-		sprintf(nodeName, "PriorBoxStepWidth%d", i + 1);
-		int width = (int)rootNode[nodeName];
-		ssdParameter.priorBoxStepWidth[i] = width;
+    for(int i = 0; i < ssdParameter.numberOfPriorBoxLayer; ++i)
+    {
+        char nodeName[256] = {0};
 
-		// height
-		sprintf(nodeName, "PriorBoxStepHeight%d", i + 1);
-		int height = (int)rootNode[nodeName];
-		ssdParameter.priorBoxStepHeight[i] = height;
+        // width
+        sprintf(nodeName, "PriorBoxStepWidth%d", i + 1);
+        int width                         = (int)rootNode[nodeName];
+        ssdParameter.priorBoxStepWidth[i] = width;
 
-	}
+        // height
+        sprintf(nodeName, "PriorBoxStepHeight%d", i + 1);
+        int height                         = (int)rootNode[nodeName];
+        ssdParameter.priorBoxStepHeight[i] = height;
+    }
 
     // PriorBoxWidth,PriorBoxHeight
-    for (int i = 0; i < ssdParameter.numberOfPriorBoxLayer; ++i)
+    for(int i = 0; i < ssdParameter.numberOfPriorBoxLayer; ++i)
     {
-        ssdParameter.priorBoxWidth[i] = ssdParameter.srcImageWidth/ssdParameter.priorBoxStepWidth[i];
-        ssdParameter.priorBoxHeight[i] = ssdParameter.srcImageHeight/ssdParameter.priorBoxStepHeight[i];
+        ssdParameter.priorBoxWidth[i] =
+            ssdParameter.srcImageWidth / ssdParameter.priorBoxStepWidth[i];
+        ssdParameter.priorBoxHeight[i] =
+            ssdParameter.srcImageHeight / ssdParameter.priorBoxStepHeight[i];
     }
 
     ssdParameter.offset = (float)rootNode["Offset"];
 
-    ssdParameter.priorBoxVar[0] = (int)(0.1f*SSD_QUANT_BASE);
-    ssdParameter.priorBoxVar[1] = (int)(0.1f*SSD_QUANT_BASE);
-    ssdParameter.priorBoxVar[2] = (int)(0.2f*SSD_QUANT_BASE);
-    ssdParameter.priorBoxVar[3] = (int)(0.2f*SSD_QUANT_BASE);
+    ssdParameter.priorBoxVar[0] = (int)(0.1f * SSD_QUANT_BASE);
+    ssdParameter.priorBoxVar[1] = (int)(0.1f * SSD_QUANT_BASE);
+    ssdParameter.priorBoxVar[2] = (int)(0.2f * SSD_QUANT_BASE);
+    ssdParameter.priorBoxVar[3] = (int)(0.2f * SSD_QUANT_BASE);
 
-    int classNumber = (int)rootNode["ClassNumber"];
+    int classNumber              = (int)rootNode["ClassNumber"];
     ssdParameter.softMaxInHeight = classNumber;
 
-    ssdParameter.concatNum = ssdParameter.numberOfPriorBoxLayer;
-    ssdParameter.softMaxOutWidth = 1;
+    ssdParameter.concatNum        = ssdParameter.numberOfPriorBoxLayer;
+    ssdParameter.softMaxOutWidth  = 1;
     ssdParameter.softMaxOutHeight = classNumber;
 
-    int totalSizeOfClasReg=0;// 分类和回归一共需要的内存空间大小
-	for (int i = 0; i < ssdParameter.numberOfPriorBoxLayer; ++i)
-	{
-        int priorBoxNumber=0;
-        priorBoxNumber+=1;// aspect ratio=1
-        for (int j = 0; j < ssdParameter.inputAspectRatioNum[i]; j++)
+    int totalSizeOfClasReg = 0; // 分类和回归一共需要的内存空间大小
+    for(int i = 0; i < ssdParameter.numberOfPriorBoxLayer; ++i)
+    {
+        int priorBoxNumber = 0;
+        priorBoxNumber += 1; // aspect ratio=1
+        for(int j = 0; j < ssdParameter.inputAspectRatioNum[i]; j++)
         {
             ++priorBoxNumber;
-            if (ssdParameter.flip[j]==1)
+            if(ssdParameter.flip[j] == 1)
             {
                 ++priorBoxNumber;
             }
         }
         priorBoxNumber = ssdParameter.minSizeNum[i] * priorBoxNumber + ssdParameter.maxSizeNum[i];
 
-		int totalPriorBoxNumber = priorBoxNumber*ssdParameter.priorBoxHeight[i] * ssdParameter.priorBoxWidth[i];
-		ssdParameter.softMaxInChn[i] = totalPriorBoxNumber * classNumber;
-		ssdParameter.softMaxOutChn += totalPriorBoxNumber;
-		ssdParameter.detectInputChn[i] = totalPriorBoxNumber * 4;
-
-        totalSizeOfClasReg+=(ssdParameter.softMaxInChn[i]+ssdParameter.detectInputChn[i]);
+        int totalPriorBoxNumber =
+            priorBoxNumber * ssdParameter.priorBoxHeight[i] * ssdParameter.priorBoxWidth[i];
+        ssdParameter.softMaxInChn[i] = totalPriorBoxNumber * classNumber;
+        ssdParameter.softMaxOutChn += totalPriorBoxNumber;
+        ssdParameter.detectInputChn[i] = totalPriorBoxNumber * 4;
 
-	}
+        totalSizeOfClasReg += (ssdParameter.softMaxInChn[i] + ssdParameter.detectInputChn[i]);
+    }
 
     // DetectionOut
     ssdParameter.classNum = classNumber;
-    ssdParameter.topK = (int)rootNode["TopK"];;
-    ssdParameter.keepTopK = (int)rootNode["KeepTopK"];
-    ssdParameter.NMSThresh = (int)((float)rootNode["NMSThreshold"]* SSD_QUANT_BASE);
-    ssdParameter.confThresh=(int)((float)rootNode["ConfidenceThreshold"]*SSD_QUANT_BASE);
-    
-    for (int i = 0; i < ssdParameter.numberOfPriorBoxLayer ; i++)
+    ssdParameter.topK     = (int)rootNode["TopK"];
+    ;
+    ssdParameter.keepTopK   = (int)rootNode["KeepTopK"];
+    ssdParameter.NMSThresh  = (int)((float)rootNode["NMSThreshold"] * SSD_QUANT_BASE);
+    ssdParameter.confThresh = (int)((float)rootNode["ConfidenceThreshold"] * SSD_QUANT_BASE);
+
+    for(int i = 0; i < ssdParameter.numberOfPriorBoxLayer; i++)
     {
-        int numberOfPriorBox=ssdParameter.detectInputChn[i]/(4*(ssdParameter.priorBoxHeight[i] * ssdParameter.priorBoxWidth[i]));
+        int numberOfPriorBox =
+            ssdParameter.detectInputChn[i] /
+            (4 * (ssdParameter.priorBoxHeight[i] * ssdParameter.priorBoxWidth[i]));
 
-        ssdParameter.convHeight[2*i]=ssdParameter.priorBoxHeight[i];
-        ssdParameter.convWidth[2*i]=ssdParameter.priorBoxWidth[i];
-        ssdParameter.convChannel[2*i]=numberOfPriorBox*4;
+        ssdParameter.convHeight[2 * i]  = ssdParameter.priorBoxHeight[i];
+        ssdParameter.convWidth[2 * i]   = ssdParameter.priorBoxWidth[i];
+        ssdParameter.convChannel[2 * i] = numberOfPriorBox * 4;
 
-        ssdParameter.convHeight[2*i+1]=ssdParameter.priorBoxHeight[i];
-        ssdParameter.convWidth[2*i+1]=ssdParameter.priorBoxWidth[i];
-        ssdParameter.convChannel[2*i+1]=numberOfPriorBox*ssdParameter.classNum;
+        ssdParameter.convHeight[2 * i + 1]  = ssdParameter.priorBoxHeight[i];
+        ssdParameter.convWidth[2 * i + 1]   = ssdParameter.priorBoxWidth[i];
+        ssdParameter.convChannel[2 * i + 1] = numberOfPriorBox * ssdParameter.classNum;
 
-        ssdParameter.convStride[i] = SSD_ALIGN16(ssdParameter.convChannel[2*i+1] * sizeof(int)) / sizeof(int);
+        ssdParameter.convStride[i] =
+            SSD_ALIGN16(ssdParameter.convChannel[2 * i + 1] * sizeof(int)) / sizeof(int);
     }
 
     // 计算softMaxOutputData内存空间大小
-    int softMaxSize=0;
+    int softMaxSize = 0;
     for(int i = 0; i < ssdParameter.concatNum; i++)
     {
         softMaxSize += ssdParameter.softMaxInChn[i];
     }
 
     // 计算getResultBuffer内存空间大小
-    int priorNum = 0;
+    int priorNum      = 0;
     int detectionSize = 0;
     for(int i = 0; i < ssdParameter.concatNum; i++)
     {
-        priorNum+=ssdParameter.detectInputChn[i]/SSD_COORDI_NUM;
+        priorNum += ssdParameter.detectInputChn[i] / SSD_COORDI_NUM;
     }
-    detectionSize+=priorNum*SSD_COORDI_NUM;
-    detectionSize+=priorNum*SSD_PROPOSAL_WIDTH*2;
-    detectionSize+=priorNum*2;
+    detectionSize += priorNum * SSD_COORDI_NUM;
+    detectionSize += priorNum * SSD_PROPOSAL_WIDTH * 2;
+    detectionSize += priorNum * 2;
 
     // 计算dstRoi,classRoiNum,dstScore内存空间大小
-    int dstRoiSize = 0;
-    int dstScoreSize = 0;
+    int dstRoiSize      = 0;
+    int dstScoreSize    = 0;
     int classRoiNumSize = 0;
-    dstRoiSize = SSD_ALIGN16(ssdParameter.classNum*ssdParameter.topK*SSD_COORDI_NUM);
-    dstScoreSize = SSD_ALIGN16(ssdParameter.classNum*ssdParameter.topK);
-    classRoiNumSize = SSD_ALIGN16(ssdParameter.classNum);
+    dstRoiSize          = SSD_ALIGN16(ssdParameter.classNum * ssdParameter.topK * SSD_COORDI_NUM);
+    dstScoreSize        = SSD_ALIGN16(ssdParameter.classNum * ssdParameter.topK);
+    classRoiNumSize     = SSD_ALIGN16(ssdParameter.classNum);
 
     // 申请内存，并分配
-    int totalSize=totalSizeOfClasReg+SSD_COORDI_NUM*2*ssdParameter.softMaxOutChn+softMaxSize+detectionSize+dstRoiSize+classRoiNumSize+dstScoreSize;
-    ssdParameter.buffer=new int[totalSize];
-    int *data=ssdParameter.buffer;
-    memset(data,0,totalSize*sizeof(int));// 初始化0
-    int offset=0;
-    for (int i = 0; i < ssdParameter.numberOfPriorBoxLayer; ++i)
-	{
-        
-        int *dataOfClasReg=data+offset;
-        ssdParameter.classification[i]=dataOfClasReg;
-        ssdParameter.regression[i]=dataOfClasReg+ssdParameter.softMaxInChn[i];
-
-        offset+=(ssdParameter.softMaxInChn[i]+ssdParameter.detectInputChn[i]);
+    int totalSize = totalSizeOfClasReg + SSD_COORDI_NUM * 2 * ssdParameter.softMaxOutChn +
+                    softMaxSize + detectionSize + dstRoiSize + classRoiNumSize + dstScoreSize;
+    ssdParameter.buffer = new int[totalSize];
+    int* data           = ssdParameter.buffer;
+    memset(data, 0, totalSize * sizeof(int)); // 初始化0
+    int offset = 0;
+    for(int i = 0; i < ssdParameter.numberOfPriorBoxLayer; ++i)
+    {
 
-    }
-    ssdParameter.priorboxOutputData=data+totalSizeOfClasReg;
-    ssdParameter.softMaxOutputData=ssdParameter.priorboxOutputData+SSD_COORDI_NUM*2*ssdParameter.softMaxOutChn;
-    ssdParameter.getResultBuffer=ssdParameter.softMaxOutputData+softMaxSize;
-    ssdParameter.dstRoi=ssdParameter.getResultBuffer+detectionSize;
-    ssdParameter.classRoiNum=ssdParameter.dstRoi+dstRoiSize;
-    ssdParameter.dstScore=ssdParameter.classRoiNum+classRoiNumSize;
+        int* dataOfClasReg             = data + offset;
+        ssdParameter.classification[i] = dataOfClasReg;
+        ssdParameter.regression[i]     = dataOfClasReg + ssdParameter.softMaxInChn[i];
 
+        offset += (ssdParameter.softMaxInChn[i] + ssdParameter.detectInputChn[i]);
+    }
+    ssdParameter.priorboxOutputData = data + totalSizeOfClasReg;
+    ssdParameter.softMaxOutputData =
+        ssdParameter.priorboxOutputData + SSD_COORDI_NUM * 2 * ssdParameter.softMaxOutChn;
+    ssdParameter.getResultBuffer = ssdParameter.softMaxOutputData + softMaxSize;
+    ssdParameter.dstRoi          = ssdParameter.getResultBuffer + detectionSize;
+    ssdParameter.classRoiNum     = ssdParameter.dstRoi + dstRoiSize;
+    ssdParameter.dstScore        = ssdParameter.classRoiNum + classRoiNumSize;
 }
 
-void DetectorRetinaFace::GetResult(const vector<vector<float>> &classifications,const vector<vector<float>> &regressions,vector<ResultOfDetection> &resultsOfDetection)
+void DetectorRetinaFace::GetResult(const vector<vector<float>>& classifications,
+                                   const vector<vector<float>>& regressions,
+                                   vector<ResultOfDetection>& resultsOfDetection)
 {
-    int numberOfPriorBoxLayer=ssdParameter.numberOfPriorBoxLayer;
+    int numberOfPriorBoxLayer = ssdParameter.numberOfPriorBoxLayer;
 
     // 类型转换
     for(int i = 0; i < numberOfPriorBoxLayer; i++)
     {
         // 分类
-        vector<float> classificationOfEachLayer=classifications[i];
-        for(int j=0;j<classificationOfEachLayer.size();++j)
+        vector<float> classificationOfEachLayer = classifications[i];
+        for(int j = 0; j < classificationOfEachLayer.size(); ++j)
         {
-            (ssdParameter.classification[i])[j]=classificationOfEachLayer[j]*SSD_QUANT_BASE;
+            (ssdParameter.classification[i])[j] = classificationOfEachLayer[j] * SSD_QUANT_BASE;
         }
 
         // 回归
-        vector<float> regressionOfEachLayer=regressions[i];
-        for(int j=0;j<regressionOfEachLayer.size();++j)
+        vector<float> regressionOfEachLayer = regressions[i];
+        for(int j = 0; j < regressionOfEachLayer.size(); ++j)
         {
-            (ssdParameter.regression[i])[j]=regressionOfEachLayer[j]*SSD_QUANT_BASE;
+            (ssdParameter.regression[i])[j] = regressionOfEachLayer[j] * SSD_QUANT_BASE;
         }
-
     }
 
     int* priorboxOutputData[SSD_MAX_PRIORBOX_LAYER_NUM];
     int* softMaxInputData[SSD_MAX_PRIORBOX_LAYER_NUM];
     int* detectionLocData[SSD_MAX_PRIORBOX_LAYER_NUM];
-    int* softMaxOutputData = NULL;
+    int* softMaxOutputData  = NULL;
     int* detectionOutTmpBuf = NULL;
-    int  softMaxWidth[SSD_MAX_PRIORBOX_LAYER_NUM];
+    int softMaxWidth[SSD_MAX_PRIORBOX_LAYER_NUM];
     int size = 0;
-    int i = 0;
+    int i    = 0;
 
-    /////////////////////////////////// PriorBoxLayer：生成所有priorbox ///////////////////////////////////
+    /////////////////////////////////// PriorBoxLayer：生成所有priorbox
+    //////////////////////////////////////
     // 分配priorboxOutputData内存空间
     priorboxOutputData[0] = ssdParameter.priorboxOutputData;
-    for (i = 1; i < numberOfPriorBoxLayer; i++)
+    for(i = 1; i < numberOfPriorBoxLayer; i++)
     {
-        size=ssdParameter.softMaxInChn[i-1]/ssdParameter.classNum*SSD_COORDI_NUM*2;
+        size = ssdParameter.softMaxInChn[i - 1] / ssdParameter.classNum * SSD_COORDI_NUM * 2;
         priorboxOutputData[i] = priorboxOutputData[i - 1] + size;
     }
-    for (i = 0; i < numberOfPriorBoxLayer; i++)
+    for(i = 0; i < numberOfPriorBoxLayer; i++)
     {
-        PriorBoxLayer(i,priorboxOutputData[i]);
+        PriorBoxLayer(i, priorboxOutputData[i]);
     }
 
-    /////////////////////////////////// SoftmaxLayer：计算所有priorbox的置信度 ///////////////////////////////////
+    /////////////////////////////////// SoftmaxLayer：计算所有priorbox的置信度
+    //////////////////////////////////////
     // 分配softMaxOutputData内存空间
-    softMaxOutputData =ssdParameter.softMaxOutputData;
+    softMaxOutputData = ssdParameter.softMaxOutputData;
     for(i = 0; i < numberOfPriorBoxLayer; i++)
     {
         softMaxInputData[i] = ssdParameter.classification[i];
-        softMaxWidth[i] = ssdParameter.convChannel[i*2+1];
+        softMaxWidth[i]     = ssdParameter.convChannel[i * 2 + 1];
     }
-    SoftmaxLayer(softMaxWidth,softMaxInputData, softMaxOutputData);
+    SoftmaxLayer(softMaxWidth, softMaxInputData, softMaxOutputData);
 
-    /////////////////////////////////// DetectionOutputLayer：对网络输出值解码并经过NMS得到最后的检测结果 ///////////////////////////////////
+    ///////////////////////////////////
+    ///DetectionOutputLayer：对网络输出值解码并经过NMS得到最后的检测结果
+    //////////////////////////////////////
     // 分配DetectionOut内存空间
     detectionOutTmpBuf = ssdParameter.getResultBuffer;
     for(i = 0; i < numberOfPriorBoxLayer; i++)
     {
         detectionLocData[i] = ssdParameter.regression[i];
     }
-    DetectionOutputLayer(detectionLocData, priorboxOutputData, softMaxOutputData,detectionOutTmpBuf);
+    DetectionOutputLayer(
+        detectionLocData, priorboxOutputData, softMaxOutputData, detectionOutTmpBuf);
 
     // 获取最后的检测结果
     CreateDetectionResults(resultsOfDetection);
 }
 
-
-void DetectorRetinaFace::PriorBoxLayer(int indexOfLayer,int* priorboxOutputData)
+void DetectorRetinaFace::PriorBoxLayer(int indexOfLayer, int* priorboxOutputData)
 {
     // 参数赋值
-    int priorBoxWidth=ssdParameter.priorBoxWidth[indexOfLayer];
-    int priorBoxHeight=ssdParameter.priorBoxHeight[indexOfLayer];
-    int srcImageWidth=ssdParameter.srcImageWidth;
-    int srcImageHeight=ssdParameter.srcImageHeight;
-    vector<float> priorBoxMinSize=ssdParameter.priorBoxMinSize[indexOfLayer];
-    int minSizeNum=ssdParameter.minSizeNum[indexOfLayer];
-    vector<float> priorBoxMaxSize=ssdParameter.priorBoxMaxSize[indexOfLayer];
-    int maxSizeNum=ssdParameter.maxSizeNum[indexOfLayer];
-    int flip=ssdParameter.flip[indexOfLayer];
-    int clip=ssdParameter.clip[indexOfLayer];
-    int inputAspectRatioNum=ssdParameter.inputAspectRatioNum[indexOfLayer];
-    vector<float> priorBoxAspectRatio=ssdParameter.priorBoxAspectRatio[indexOfLayer];
-    float priorBoxStepWidth=ssdParameter.priorBoxStepWidth[indexOfLayer];
-    float priorBoxStepHeight= ssdParameter.priorBoxStepHeight[indexOfLayer];
-    float offset=ssdParameter.offset;
-    int *priorBoxVar=ssdParameter.priorBoxVar;
-
-    int aspectRatioNum = 0;
-    int index = 0;
-    float aspectRatio[SSD_ASPECT_RATIO_NUM] = { 0 };
-    int numPrior = 0;
-    float centerX = 0;
-    float centerY = 0;
-    float boxHeight = 0;
-    float boxWidth = 0;
-    float maxBoxWidth = 0;
-    int i = 0;
-    int j = 0;
-    int n = 0;
-    int h = 0;
-    int w = 0;
+    int priorBoxWidth                 = ssdParameter.priorBoxWidth[indexOfLayer];
+    int priorBoxHeight                = ssdParameter.priorBoxHeight[indexOfLayer];
+    int srcImageWidth                 = ssdParameter.srcImageWidth;
+    int srcImageHeight                = ssdParameter.srcImageHeight;
+    vector<float> priorBoxMinSize     = ssdParameter.priorBoxMinSize[indexOfLayer];
+    int minSizeNum                    = ssdParameter.minSizeNum[indexOfLayer];
+    vector<float> priorBoxMaxSize     = ssdParameter.priorBoxMaxSize[indexOfLayer];
+    int maxSizeNum                    = ssdParameter.maxSizeNum[indexOfLayer];
+    int flip                          = ssdParameter.flip[indexOfLayer];
+    int clip                          = ssdParameter.clip[indexOfLayer];
+    int inputAspectRatioNum           = ssdParameter.inputAspectRatioNum[indexOfLayer];
+    vector<float> priorBoxAspectRatio = ssdParameter.priorBoxAspectRatio[indexOfLayer];
+    float priorBoxStepWidth           = ssdParameter.priorBoxStepWidth[indexOfLayer];
+    float priorBoxStepHeight          = ssdParameter.priorBoxStepHeight[indexOfLayer];
+    float offset                      = ssdParameter.offset;
+    int* priorBoxVar                  = ssdParameter.priorBoxVar;
+
+    int aspectRatioNum                      = 0;
+    int index                               = 0;
+    float aspectRatio[SSD_ASPECT_RATIO_NUM] = {0};
+    int numPrior                            = 0;
+    float centerX                           = 0;
+    float centerY                           = 0;
+    float boxHeight                         = 0;
+    float boxWidth                          = 0;
+    float maxBoxWidth                       = 0;
+    int i                                   = 0;
+    int j                                   = 0;
+    int n                                   = 0;
+    int h                                   = 0;
+    int w                                   = 0;
 
     aspectRatioNum = 0;
     aspectRatio[0] = 1;
     aspectRatioNum++;
-    for (i = 0; i < inputAspectRatioNum; i++)
+    for(i = 0; i < inputAspectRatioNum; i++)
     {
         aspectRatio[aspectRatioNum++] = priorBoxAspectRatio[i];
-        if (flip)
+        if(flip)
         {
             aspectRatio[aspectRatioNum++] = 1.0f / priorBoxAspectRatio[i];
         }
@@ -568,28 +575,28 @@ void DetectorRetinaFace::PriorBoxLayer(int indexOfLayer,int* priorboxOutputData)
     numPrior = minSizeNum * aspectRatioNum + maxSizeNum;
 
     index = 0;
-    for (h = 0; h < priorBoxHeight; h++)
+    for(h = 0; h < priorBoxHeight; h++)
     {
-        for (w = 0; w < priorBoxWidth; w++)
+        for(w = 0; w < priorBoxWidth; w++)
         {
             centerX = (w + offset) * priorBoxStepWidth;
             centerY = (h + offset) * priorBoxStepHeight;
-            for (n = 0; n < minSizeNum; n++)
+            for(n = 0; n < minSizeNum; n++)
             {
                 // 首先产生宽高比为1的priorbox
-                boxHeight = priorBoxMinSize[n];
-                boxWidth = priorBoxMinSize[n];
+                boxHeight                   = priorBoxMinSize[n];
+                boxWidth                    = priorBoxMinSize[n];
                 priorboxOutputData[index++] = (int)(centerX - boxWidth * SSD_HALF);
                 priorboxOutputData[index++] = (int)(centerY - boxHeight * SSD_HALF);
                 priorboxOutputData[index++] = (int)(centerX + boxWidth * SSD_HALF);
                 priorboxOutputData[index++] = (int)(centerY + boxHeight * SSD_HALF);
 
                 // 对于max_size,生成宽高比为1的priorbox,宽高为sqrt(min_size * max_size)
-                if(maxSizeNum>0)
+                if(maxSizeNum > 0)
                 {
-                    maxBoxWidth = sqrt(priorBoxMinSize[n] * priorBoxMaxSize[n]);
-                    boxHeight = maxBoxWidth;
-                    boxWidth = maxBoxWidth;
+                    maxBoxWidth                 = sqrt(priorBoxMinSize[n] * priorBoxMaxSize[n]);
+                    boxHeight                   = maxBoxWidth;
+                    boxWidth                    = maxBoxWidth;
                     priorboxOutputData[index++] = (int)(centerX - boxWidth * SSD_HALF);
                     priorboxOutputData[index++] = (int)(centerY - boxHeight * SSD_HALF);
                     priorboxOutputData[index++] = (int)(centerX + boxWidth * SSD_HALF);
@@ -597,10 +604,10 @@ void DetectorRetinaFace::PriorBoxLayer(int indexOfLayer,int* priorboxOutputData)
                 }
 
                 // 剩下的priorbox
-                for (i = 1; i < aspectRatioNum; i++)
+                for(i = 1; i < aspectRatioNum; i++)
                 {
-                    boxWidth = (float)(priorBoxMinSize[n] * sqrt( aspectRatio[i] ));
-                    boxHeight = (float)(priorBoxMinSize[n]/sqrt( aspectRatio[i] ));
+                    boxWidth  = (float)(priorBoxMinSize[n] * sqrt(aspectRatio[i]));
+                    boxHeight = (float)(priorBoxMinSize[n] / sqrt(aspectRatio[i]));
 
                     priorboxOutputData[index++] = (int)(centerX - boxWidth * SSD_HALF);
                     priorboxOutputData[index++] = (int)(centerY - boxHeight * SSD_HALF);
@@ -611,23 +618,25 @@ void DetectorRetinaFace::PriorBoxLayer(int indexOfLayer,int* priorboxOutputData)
         }
     }
 
-    // 越界处理 [0, srcImageWidth] & [0, srcImageHeight] 
-    if (clip)
+    // 越界处理 [0, srcImageWidth] & [0, srcImageHeight]
+    if(clip)
     {
-        for (i = 0; i < (int)(priorBoxWidth * priorBoxHeight * SSD_COORDI_NUM*numPrior / 2); i++)
+        for(i = 0; i < (int)(priorBoxWidth * priorBoxHeight * SSD_COORDI_NUM * numPrior / 2); i++)
         {
-            priorboxOutputData[2 * i] = SSD_MIN((int)SSD_MAX(priorboxOutputData[2 * i], 0), srcImageWidth);
-            priorboxOutputData[2 * i + 1] = SSD_MIN((int)SSD_MAX(priorboxOutputData[2 * i + 1], 0), srcImageHeight);
+            priorboxOutputData[2 * i] =
+                SSD_MIN((int)SSD_MAX(priorboxOutputData[2 * i], 0), srcImageWidth);
+            priorboxOutputData[2 * i + 1] =
+                SSD_MIN((int)SSD_MAX(priorboxOutputData[2 * i + 1], 0), srcImageHeight);
         }
     }
     // var
-    for (h = 0; h < priorBoxHeight; h++)
+    for(h = 0; h < priorBoxHeight; h++)
     {
-        for (w = 0; w < priorBoxWidth; w++)
+        for(w = 0; w < priorBoxWidth; w++)
         {
-            for (i = 0; i < numPrior; i++)
+            for(i = 0; i < numPrior; i++)
             {
-                for (j = 0; j < SSD_COORDI_NUM; j++)
+                for(j = 0; j < SSD_COORDI_NUM; j++)
                 {
                     priorboxOutputData[index++] = (int)priorBoxVar[j];
                 }
@@ -636,38 +645,40 @@ void DetectorRetinaFace::PriorBoxLayer(int indexOfLayer,int* priorboxOutputData)
     }
 }
 
-void DetectorRetinaFace::SoftmaxLayer(int softMaxWidth[],int* softMaxInputData[], int* softMaxOutputData)
+void DetectorRetinaFace::SoftmaxLayer(int softMaxWidth[],
+                                      int* softMaxInputData[],
+                                      int* softMaxOutputData)
 {
 
     // 参数赋值
-    int softMaxInHeight=ssdParameter.softMaxInHeight;
-    int *softMaxInChn=ssdParameter.softMaxInChn;
-    int concatNum=ssdParameter.concatNum;
-    int *convStride=ssdParameter.convStride;
-
-    int* inputData = NULL;
-    int* outputTmp = NULL;
-    int outerNum = 0;
-    int innerNum = 0;
+    int softMaxInHeight = ssdParameter.softMaxInHeight;
+    int* softMaxInChn   = ssdParameter.softMaxInChn;
+    int concatNum       = ssdParameter.concatNum;
+    int* convStride     = ssdParameter.convStride;
+
+    int* inputData   = NULL;
+    int* outputTmp   = NULL;
+    int outerNum     = 0;
+    int innerNum     = 0;
     int inputChannel = 0;
-    int i = 0;
-    int concatCnt = 0;
-    int stride = 0;
-    int skip = 0;
-    int left = 0;
-    outputTmp = softMaxOutputData;
-    for (concatCnt = 0; concatCnt < concatNum; concatCnt++)
+    int i            = 0;
+    int concatCnt    = 0;
+    int stride       = 0;
+    int skip         = 0;
+    int left         = 0;
+    outputTmp        = softMaxOutputData;
+    for(concatCnt = 0; concatCnt < concatNum; concatCnt++)
     {
-        inputData = softMaxInputData[concatCnt];
-        stride = convStride[concatCnt];
+        inputData    = softMaxInputData[concatCnt];
+        stride       = convStride[concatCnt];
         inputChannel = softMaxInChn[concatCnt];
-        outerNum = inputChannel / softMaxInHeight;
-        innerNum = softMaxInHeight;
-        skip = softMaxWidth[concatCnt] / innerNum;
-        left = stride - softMaxWidth[concatCnt];
-        for (i = 0; i < outerNum; i++)
+        outerNum     = inputChannel / softMaxInHeight;
+        innerNum     = softMaxInHeight;
+        skip         = softMaxWidth[concatCnt] / innerNum;
+        left         = stride - softMaxWidth[concatCnt];
+        for(i = 0; i < outerNum; i++)
         {
-            ComputeSoftMax(inputData, (int)innerNum,outputTmp);
+            ComputeSoftMax(inputData, (int)innerNum, outputTmp);
             inputData += innerNum;
             outputTmp += innerNum;
         }
@@ -678,71 +689,73 @@ void DetectorRetinaFace::ComputeSoftMax(int* src, int size, int* dst)
 {
     int max = 0;
     int sum = 0;
-    int i = 0;
-    for (i = 0; i < size; ++i)
+    int i   = 0;
+    for(i = 0; i < size; ++i)
     {
-        if (max < src[i])
+        if(max < src[i])
         {
             max = src[i];
         }
     }
-    for (i = 0; i < size; ++i)
+    for(i = 0; i < size; ++i)
     {
-        dst[i] = (int)(SSD_QUANT_BASE* exp((float)(src[i] - max) / SSD_QUANT_BASE));
+        dst[i] = (int)(SSD_QUANT_BASE * exp((float)(src[i] - max) / SSD_QUANT_BASE));
         sum += dst[i];
     }
-    for (i = 0; i < size; ++i)
+    for(i = 0; i < size; ++i)
     {
         dst[i] = (int)(((float)dst[i] / (float)sum) * SSD_QUANT_BASE);
     }
-
 }
 
-void DetectorRetinaFace::DetectionOutputLayer(int* allLocPreds[], int* allPriorBoxes[],int* confScores, int* assistMemPool)
+void DetectorRetinaFace::DetectionOutputLayer(int* allLocPreds[],
+                                              int* allPriorBoxes[],
+                                              int* confScores,
+                                              int* assistMemPool)
 {
 
     // 参数赋值
-    int concatNum=ssdParameter.concatNum;
-    int confThresh=ssdParameter.confThresh;
-    int classNum=ssdParameter.classNum;
-    int topK=ssdParameter.topK;
-    int keepTopK=ssdParameter.keepTopK;
-    int NMSThresh=ssdParameter.NMSThresh;
-    int *detectInputChn=ssdParameter.detectInputChn;
-    int* dstScoreSrc=ssdParameter.dstScore;
-    int* dstBboxSrc=ssdParameter.dstRoi;
-    int* roiOutCntSrc=ssdParameter.classRoiNum;
-
-    int* locPreds = NULL;
-    int* priorBoxes = NULL;
-    int* priorVar = NULL;
-    int* allDecodeBoxes = NULL;
-    int* dstScore = NULL;
-    int* dstBbox = NULL;
-    int* classRoiNum = NULL;
-    int roiOutCnt = 0;
-    int* singleProposal = NULL;
-    int* afterTopK = NULL;
-    QuickSortStack* stack = NULL;
-    int priorNum = 0;
-    int numPredsPerClass = 0;
-    float priorWidth = 0;
-    float priorHeight = 0;
-    float priorCenterX = 0;
-    float priorCenterY = 0;
+    int concatNum       = ssdParameter.concatNum;
+    int confThresh      = ssdParameter.confThresh;
+    int classNum        = ssdParameter.classNum;
+    int topK            = ssdParameter.topK;
+    int keepTopK        = ssdParameter.keepTopK;
+    int NMSThresh       = ssdParameter.NMSThresh;
+    int* detectInputChn = ssdParameter.detectInputChn;
+    int* dstScoreSrc    = ssdParameter.dstScore;
+    int* dstBboxSrc     = ssdParameter.dstRoi;
+    int* roiOutCntSrc   = ssdParameter.classRoiNum;
+
+    int* locPreds          = NULL;
+    int* priorBoxes        = NULL;
+    int* priorVar          = NULL;
+    int* allDecodeBoxes    = NULL;
+    int* dstScore          = NULL;
+    int* dstBbox           = NULL;
+    int* classRoiNum       = NULL;
+    int roiOutCnt          = 0;
+    int* singleProposal    = NULL;
+    int* afterTopK         = NULL;
+    QuickSortStack* stack  = NULL;
+    int priorNum           = 0;
+    int numPredsPerClass   = 0;
+    float priorWidth       = 0;
+    float priorHeight      = 0;
+    float priorCenterX     = 0;
+    float priorCenterY     = 0;
     float decodeBoxCenterX = 0;
     float decodeBoxCenterY = 0;
-    float decodeBoxWidth = 0;
-    float decodeBoxHeight = 0;
-    int srcIdx = 0;
-    int afterFilter = 0;
-    int afterTopK2 = 0;
-    int keepCnt = 0;
-    int i = 0;
-    int j = 0;
-    int offset = 0;
-    priorNum = 0;
-    for (i = 0; i < concatNum; i++)
+    float decodeBoxWidth   = 0;
+    float decodeBoxHeight  = 0;
+    int srcIdx             = 0;
+    int afterFilter        = 0;
+    int afterTopK2         = 0;
+    int keepCnt            = 0;
+    int i                  = 0;
+    int j                  = 0;
+    int offset             = 0;
+    priorNum               = 0;
+    for(i = 0; i < concatNum; i++)
     {
         priorNum += detectInputChn[i] / SSD_COORDI_NUM;
     }
@@ -750,36 +763,47 @@ void DetectorRetinaFace::DetectionOutputLayer(int* allLocPreds[], int* allPriorB
     // 缓存
     allDecodeBoxes = assistMemPool;
     singleProposal = allDecodeBoxes + priorNum * SSD_COORDI_NUM;
-    afterTopK = singleProposal + SSD_PROPOSAL_WIDTH * priorNum;
-    stack = (QuickSortStack*)(afterTopK + priorNum * SSD_PROPOSAL_WIDTH);
-    srcIdx = 0;
-    for (i = 0; i < concatNum; i++)
+    afterTopK      = singleProposal + SSD_PROPOSAL_WIDTH * priorNum;
+    stack          = (QuickSortStack*)(afterTopK + priorNum * SSD_PROPOSAL_WIDTH);
+    srcIdx         = 0;
+    for(i = 0; i < concatNum; i++)
     {
         // 回归预测值
-        locPreds = allLocPreds[i];
+        locPreds         = allLocPreds[i];
         numPredsPerClass = detectInputChn[i] / SSD_COORDI_NUM;
 
         // 获取priorbox
         priorBoxes = allPriorBoxes[i];
-        priorVar = priorBoxes + numPredsPerClass*SSD_COORDI_NUM;
-        for (j = 0; j < numPredsPerClass; j++)
+        priorVar   = priorBoxes + numPredsPerClass * SSD_COORDI_NUM;
+        for(j = 0; j < numPredsPerClass; j++)
         {
-            priorWidth = (float)(priorBoxes[j*SSD_COORDI_NUM+2] - priorBoxes[j*SSD_COORDI_NUM]);
-            priorHeight = (float)(priorBoxes[j*SSD_COORDI_NUM+3] - priorBoxes[j*SSD_COORDI_NUM + 1]);
-            priorCenterX = (priorBoxes[j*SSD_COORDI_NUM+2] + priorBoxes[j*SSD_COORDI_NUM])*SSD_HALF;
-            priorCenterY = (priorBoxes[j*SSD_COORDI_NUM+3] + priorBoxes[j*SSD_COORDI_NUM+1])*SSD_HALF;
-
-            decodeBoxCenterX = ((float)priorVar[j*SSD_COORDI_NUM]/SSD_QUANT_BASE)*
-                ((float)locPreds[j*SSD_COORDI_NUM]/SSD_QUANT_BASE)*priorWidth+priorCenterX;
-
-            decodeBoxCenterY = ((float)priorVar[j*SSD_COORDI_NUM+1]/SSD_QUANT_BASE)*
-                ((float)locPreds[j*SSD_COORDI_NUM+1]/SSD_QUANT_BASE)*priorHeight+priorCenterY;
-
-            decodeBoxWidth = exp(((float)priorVar[j*SSD_COORDI_NUM+2]/SSD_QUANT_BASE)*
-                ((float)locPreds[j*SSD_COORDI_NUM+2]/SSD_QUANT_BASE))*priorWidth;
-
-            decodeBoxHeight = exp(((float)priorVar[j*SSD_COORDI_NUM+3]/SSD_QUANT_BASE)*
-                ((float)locPreds[j*SSD_COORDI_NUM+3]/SSD_QUANT_BASE))*priorHeight;
+            priorWidth =
+                (float)(priorBoxes[j * SSD_COORDI_NUM + 2] - priorBoxes[j * SSD_COORDI_NUM]);
+            priorHeight =
+                (float)(priorBoxes[j * SSD_COORDI_NUM + 3] - priorBoxes[j * SSD_COORDI_NUM + 1]);
+            priorCenterX =
+                (priorBoxes[j * SSD_COORDI_NUM + 2] + priorBoxes[j * SSD_COORDI_NUM]) * SSD_HALF;
+            priorCenterY =
+                (priorBoxes[j * SSD_COORDI_NUM + 3] + priorBoxes[j * SSD_COORDI_NUM + 1]) *
+                SSD_HALF;
+
+            decodeBoxCenterX = ((float)priorVar[j * SSD_COORDI_NUM] / SSD_QUANT_BASE) *
+                                   ((float)locPreds[j * SSD_COORDI_NUM] / SSD_QUANT_BASE) *
+                                   priorWidth +
+                               priorCenterX;
+
+            decodeBoxCenterY = ((float)priorVar[j * SSD_COORDI_NUM + 1] / SSD_QUANT_BASE) *
+                                   ((float)locPreds[j * SSD_COORDI_NUM + 1] / SSD_QUANT_BASE) *
+                                   priorHeight +
+                               priorCenterY;
+
+            decodeBoxWidth = exp(((float)priorVar[j * SSD_COORDI_NUM + 2] / SSD_QUANT_BASE) *
+                                 ((float)locPreds[j * SSD_COORDI_NUM + 2] / SSD_QUANT_BASE)) *
+                             priorWidth;
+
+            decodeBoxHeight = exp(((float)priorVar[j * SSD_COORDI_NUM + 3] / SSD_QUANT_BASE) *
+                                  ((float)locPreds[j * SSD_COORDI_NUM + 3] / SSD_QUANT_BASE)) *
+                              priorHeight;
 
             allDecodeBoxes[srcIdx++] = (int)(decodeBoxCenterX - decodeBoxWidth * SSD_HALF);
             allDecodeBoxes[srcIdx++] = (int)(decodeBoxCenterY - decodeBoxHeight * SSD_HALF);
@@ -790,39 +814,42 @@ void DetectorRetinaFace::DetectionOutputLayer(int* allLocPreds[], int* allPriorB
 
     // 对每一类做NMS
     afterTopK2 = 0;
-    for (i = 0; i < classNum; i++)
+    for(i = 0; i < classNum; i++)
     {
-        if(i==0)
+        if(i == 0)
             continue;
 
-        for (j = 0; j < priorNum; j++)
+        for(j = 0; j < priorNum; j++)
         {
-            singleProposal[j * SSD_PROPOSAL_WIDTH] = allDecodeBoxes[j * SSD_COORDI_NUM];
+            singleProposal[j * SSD_PROPOSAL_WIDTH]     = allDecodeBoxes[j * SSD_COORDI_NUM];
             singleProposal[j * SSD_PROPOSAL_WIDTH + 1] = allDecodeBoxes[j * SSD_COORDI_NUM + 1];
             singleProposal[j * SSD_PROPOSAL_WIDTH + 2] = allDecodeBoxes[j * SSD_COORDI_NUM + 2];
             singleProposal[j * SSD_PROPOSAL_WIDTH + 3] = allDecodeBoxes[j * SSD_COORDI_NUM + 3];
-            singleProposal[j * SSD_PROPOSAL_WIDTH + 4] = confScores[j*classNum + i];
+            singleProposal[j * SSD_PROPOSAL_WIDTH + 4] = confScores[j * classNum + i];
             singleProposal[j * SSD_PROPOSAL_WIDTH + 5] = 0;
         }
-        QuickSort(singleProposal, 0, priorNum - 1, stack,topK);
+        QuickSort(singleProposal, 0, priorNum - 1, stack, topK);
         afterFilter = (priorNum < topK) ? priorNum : topK;
         NonMaxSuppression(singleProposal, afterFilter, NMSThresh, afterFilter);
-        roiOutCnt = 0;
-        dstScore = (int*)dstScoreSrc;
-        dstBbox = (int*)dstBboxSrc;
+        roiOutCnt   = 0;
+        dstScore    = (int*)dstScoreSrc;
+        dstBbox     = (int*)dstBboxSrc;
         classRoiNum = (int*)roiOutCntSrc;
         dstScore += (int)afterTopK2;
         dstBbox += (int)(afterTopK2 * SSD_COORDI_NUM);
-        for (j = 0; j < topK; j++)
+        for(j = 0; j < topK; j++)
         {
-            if (singleProposal[j * SSD_PROPOSAL_WIDTH + 5] == 0 &&
-                singleProposal[j * SSD_PROPOSAL_WIDTH + 4] > (int)confThresh)
+            if(singleProposal[j * SSD_PROPOSAL_WIDTH + 5] == 0 &&
+               singleProposal[j * SSD_PROPOSAL_WIDTH + 4] > (int)confThresh)
             {
-                dstScore[roiOutCnt] = singleProposal[j * 6 + 4];
+                dstScore[roiOutCnt]                 = singleProposal[j * 6 + 4];
                 dstBbox[roiOutCnt * SSD_COORDI_NUM] = singleProposal[j * SSD_PROPOSAL_WIDTH];
-                dstBbox[roiOutCnt * SSD_COORDI_NUM + 1] = singleProposal[j * SSD_PROPOSAL_WIDTH + 1];
-                dstBbox[roiOutCnt * SSD_COORDI_NUM + 2] = singleProposal[j * SSD_PROPOSAL_WIDTH + 2];
-                dstBbox[roiOutCnt * SSD_COORDI_NUM + 3] = singleProposal[j * SSD_PROPOSAL_WIDTH + 3];
+                dstBbox[roiOutCnt * SSD_COORDI_NUM + 1] =
+                    singleProposal[j * SSD_PROPOSAL_WIDTH + 1];
+                dstBbox[roiOutCnt * SSD_COORDI_NUM + 2] =
+                    singleProposal[j * SSD_PROPOSAL_WIDTH + 2];
+                dstBbox[roiOutCnt * SSD_COORDI_NUM + 3] =
+                    singleProposal[j * SSD_PROPOSAL_WIDTH + 3];
                 roiOutCnt++;
             }
         }
@@ -831,20 +858,20 @@ void DetectorRetinaFace::DetectionOutputLayer(int* allLocPreds[], int* allPriorB
     }
 
     keepCnt = 0;
-    offset = 0;
-    if (afterTopK2 > keepTopK)
+    offset  = 0;
+    if(afterTopK2 > keepTopK)
     {
         offset = classRoiNum[0];
-        for (i = 1; i < classNum; i++)
+        for(i = 1; i < classNum; i++)
         {
-            dstScore = (int*)dstScoreSrc;
-            dstBbox = (int*)dstBboxSrc;
+            dstScore    = (int*)dstScoreSrc;
+            dstBbox     = (int*)dstBboxSrc;
             classRoiNum = (int*)roiOutCntSrc;
             dstScore += (int)(offset);
             dstBbox += (int)(offset * SSD_COORDI_NUM);
-            for (j = 0; j < (int)classRoiNum[i]; j++)
+            for(j = 0; j < (int)classRoiNum[i]; j++)
             {
-                afterTopK[keepCnt * SSD_PROPOSAL_WIDTH] = dstBbox[j * SSD_COORDI_NUM];
+                afterTopK[keepCnt * SSD_PROPOSAL_WIDTH]     = dstBbox[j * SSD_COORDI_NUM];
                 afterTopK[keepCnt * SSD_PROPOSAL_WIDTH + 1] = dstBbox[j * SSD_COORDI_NUM + 1];
                 afterTopK[keepCnt * SSD_PROPOSAL_WIDTH + 2] = dstBbox[j * SSD_COORDI_NUM + 2];
                 afterTopK[keepCnt * SSD_PROPOSAL_WIDTH + 3] = dstBbox[j * SSD_COORDI_NUM + 3];
@@ -854,24 +881,24 @@ void DetectorRetinaFace::DetectionOutputLayer(int* allLocPreds[], int* allPriorB
             }
             offset = offset + classRoiNum[i];
         }
-        QuickSort(afterTopK, 0, keepCnt - 1, stack,keepCnt);
+        QuickSort(afterTopK, 0, keepCnt - 1, stack, keepCnt);
 
         offset = 0;
         offset = classRoiNum[0];
-        for (i = 1; i < classNum; i++)
+        for(i = 1; i < classNum; i++)
         {
-            roiOutCnt = 0;
-            dstScore = (int*)dstScoreSrc;
-            dstBbox = (int*)dstBboxSrc;
+            roiOutCnt   = 0;
+            dstScore    = (int*)dstScoreSrc;
+            dstBbox     = (int*)dstBboxSrc;
             classRoiNum = (int*)roiOutCntSrc;
             dstScore += (int)(offset);
             dstBbox += (int)(offset * SSD_COORDI_NUM);
-            for (j = 0; j < keepTopK; j++)
+            for(j = 0; j < keepTopK; j++)
             {
-                if (afterTopK[j * SSD_PROPOSAL_WIDTH + 5] == i)
+                if(afterTopK[j * SSD_PROPOSAL_WIDTH + 5] == i)
                 {
-                    dstScore[roiOutCnt] = afterTopK[j * SSD_PROPOSAL_WIDTH + 4];
-                    dstBbox[roiOutCnt * SSD_COORDI_NUM] = afterTopK[j * SSD_PROPOSAL_WIDTH];
+                    dstScore[roiOutCnt]                     = afterTopK[j * SSD_PROPOSAL_WIDTH + 4];
+                    dstBbox[roiOutCnt * SSD_COORDI_NUM]     = afterTopK[j * SSD_PROPOSAL_WIDTH];
                     dstBbox[roiOutCnt * SSD_COORDI_NUM + 1] = afterTopK[j * SSD_PROPOSAL_WIDTH + 1];
                     dstBbox[roiOutCnt * SSD_COORDI_NUM + 2] = afterTopK[j * SSD_PROPOSAL_WIDTH + 2];
                     dstBbox[roiOutCnt * SSD_COORDI_NUM + 3] = afterTopK[j * SSD_PROPOSAL_WIDTH + 3];
@@ -884,40 +911,40 @@ void DetectorRetinaFace::DetectionOutputLayer(int* allLocPreds[], int* allPriorB
     }
 }
 
-vector<float> DetectorRetinaFace::PermuteLayer(const vector<float> &data,int width,int height,int channels)
+vector<float>
+DetectorRetinaFace::PermuteLayer(const vector<float>& data, int width, int height, int channels)
 {
     vector<float> result(data.size());
-    int index=0;
-    int channelStep=width*height;
-    for(int h=0; h<height;h++)
+    int index       = 0;
+    int channelStep = width * height;
+    for(int h = 0; h < height; h++)
     {
-        for(int w=0;w<width;w++)
+        for(int w = 0; w < width; w++)
         {
-            for(int c = 0;c < channels;c++)
+            for(int c = 0; c < channels; c++)
             {
-                result[index++] = data[c*channelStep + h*width + w];
+                result[index++] = data[c * channelStep + h * width + w];
             }
         }
     }
     return result;
-
 }
 
-void DetectorRetinaFace::QuickSort(int* src,int low, int high, QuickSortStack *stack,int maxNum)
+void DetectorRetinaFace::QuickSort(int* src, int low, int high, QuickSortStack* stack, int maxNum)
 {
-    int i = low;
-    int j = high;
-    int top = 0;
+    int i             = low;
+    int j             = high;
+    int top           = 0;
     int keyConfidence = src[SSD_PROPOSAL_WIDTH * low + 4];
-    stack[top].min = low;
-    stack[top].max = high;
+    stack[top].min    = low;
+    stack[top].max    = high;
 
     while(top > -1)
     {
-        low = stack[top].min;
+        low  = stack[top].min;
         high = stack[top].max;
-        i = low;
-        j = high;
+        i    = low;
+        j    = high;
         top--;
 
         keyConfidence = src[SSD_PROPOSAL_WIDTH * low + 4];
@@ -930,88 +957,102 @@ void DetectorRetinaFace::QuickSort(int* src,int low, int high, QuickSortStack *s
             }
             if(i < j)
             {
-                Swap(&src[i*SSD_PROPOSAL_WIDTH], &src[j*SSD_PROPOSAL_WIDTH]);
+                Swap(&src[i * SSD_PROPOSAL_WIDTH], &src[j * SSD_PROPOSAL_WIDTH]);
                 i++;
             }
 
-            while((i < j) && (keyConfidence < src[i*SSD_PROPOSAL_WIDTH + 4]))
+            while((i < j) && (keyConfidence < src[i * SSD_PROPOSAL_WIDTH + 4]))
             {
                 i++;
             }
             if(i < j)
             {
-                Swap(&src[i*SSD_PROPOSAL_WIDTH], &src[j*SSD_PROPOSAL_WIDTH]);
+                Swap(&src[i * SSD_PROPOSAL_WIDTH], &src[j * SSD_PROPOSAL_WIDTH]);
                 j--;
             }
         }
 
         if(low <= maxNum)
         {
-                if(low < i-1)
-                {
-                    top++;
-                    stack[top].min = low;
-                    stack[top].max = i-1;
-                }
+            if(low < i - 1)
+            {
+                top++;
+                stack[top].min = low;
+                stack[top].max = i - 1;
+            }
 
-                if(high > i+1)
-                {
-                    top++;
-                    stack[top].min = i+1;
-                    stack[top].max = high;
-                }
+            if(high > i + 1)
+            {
+                top++;
+                stack[top].min = i + 1;
+                stack[top].max = high;
+            }
         }
     }
 }
 
-void DetectorRetinaFace::NonMaxSuppression( int* proposals, int anchorsNum,int NMSThresh,int maxRoiNum)
+void DetectorRetinaFace::NonMaxSuppression(int* proposals,
+                                           int anchorsNum,
+                                           int NMSThresh,
+                                           int maxRoiNum)
 {
-    int xMin1 = 0;
-    int yMin1 = 0;
-    int xMax1 = 0;
-    int yMax1 = 0;
-    int xMin2 = 0;
-    int yMin2 = 0;
-    int xMax2 = 0;
-    int yMax2 = 0;
+    int xMin1     = 0;
+    int yMin1     = 0;
+    int xMax1     = 0;
+    int yMax1     = 0;
+    int xMin2     = 0;
+    int yMin2     = 0;
+    int xMax2     = 0;
+    int yMax2     = 0;
     int areaTotal = 0;
     int areaInter = 0;
-    int i = 0;
-    int j = 0;
-    int num = 0;
-    int NoOverlap  = 1;
-    for (i = 0; i < anchorsNum && num < maxRoiNum; i++)
+    int i         = 0;
+    int j         = 0;
+    int num       = 0;
+    int NoOverlap = 1;
+    for(i = 0; i < anchorsNum && num < maxRoiNum; i++)
     {
-        if( proposals[SSD_PROPOSAL_WIDTH*i+5] == 0 )
+        if(proposals[SSD_PROPOSAL_WIDTH * i + 5] == 0)
         {
             num++;
-            xMin1 =  proposals[SSD_PROPOSAL_WIDTH*i];
-            yMin1 =  proposals[SSD_PROPOSAL_WIDTH*i+1];
-            xMax1 =  proposals[SSD_PROPOSAL_WIDTH*i+2];
-            yMax1 =  proposals[SSD_PROPOSAL_WIDTH*i+3];
-            for(j= i+1;j< anchorsNum; j++)
+            xMin1 = proposals[SSD_PROPOSAL_WIDTH * i];
+            yMin1 = proposals[SSD_PROPOSAL_WIDTH * i + 1];
+            xMax1 = proposals[SSD_PROPOSAL_WIDTH * i + 2];
+            yMax1 = proposals[SSD_PROPOSAL_WIDTH * i + 3];
+            for(j = i + 1; j < anchorsNum; j++)
             {
-                if( proposals[SSD_PROPOSAL_WIDTH*j+5] == 0 )
+                if(proposals[SSD_PROPOSAL_WIDTH * j + 5] == 0)
                 {
-                    xMin2 = proposals[SSD_PROPOSAL_WIDTH*j];
-                    yMin2 = proposals[SSD_PROPOSAL_WIDTH*j+1];
-                    xMax2 = proposals[SSD_PROPOSAL_WIDTH*j+2];
-                    yMax2 = proposals[SSD_PROPOSAL_WIDTH*j+3];
-                    NoOverlap = (xMin2>xMax1)||(xMax2<xMin1)||(yMin2>yMax1)||(yMax2<yMin1);
+                    xMin2 = proposals[SSD_PROPOSAL_WIDTH * j];
+                    yMin2 = proposals[SSD_PROPOSAL_WIDTH * j + 1];
+                    xMax2 = proposals[SSD_PROPOSAL_WIDTH * j + 2];
+                    yMax2 = proposals[SSD_PROPOSAL_WIDTH * j + 3];
+                    NoOverlap =
+                        (xMin2 > xMax1) || (xMax2 < xMin1) || (yMin2 > yMax1) || (yMax2 < yMin1);
                     if(NoOverlap)
                     {
                         continue;
                     }
-                    ComputeOverlap(xMin1, yMin1, xMax1, yMax1, xMin2, yMin2, xMax2, yMax2, &areaTotal, &areaInter);
-                    if(areaInter*SSD_QUANT_BASE > ((int)NMSThresh*areaTotal))
+                    ComputeOverlap(xMin1,
+                                   yMin1,
+                                   xMax1,
+                                   yMax1,
+                                   xMin2,
+                                   yMin2,
+                                   xMax2,
+                                   yMax2,
+                                   &areaTotal,
+                                   &areaInter);
+                    if(areaInter * SSD_QUANT_BASE > ((int)NMSThresh * areaTotal))
                     {
-                        if( proposals[SSD_PROPOSAL_WIDTH*i+4] >= proposals[SSD_PROPOSAL_WIDTH*j+4] )
+                        if(proposals[SSD_PROPOSAL_WIDTH * i + 4] >=
+                           proposals[SSD_PROPOSAL_WIDTH * j + 4])
                         {
-                            proposals[SSD_PROPOSAL_WIDTH*j+5] = 1;
+                            proposals[SSD_PROPOSAL_WIDTH * j + 5] = 1;
                         }
                         else
                         {
-                            proposals[SSD_PROPOSAL_WIDTH*i+5] = 1;
+                            proposals[SSD_PROPOSAL_WIDTH * i + 5] = 1;
                         }
                     }
                 }
@@ -1020,19 +1061,27 @@ void DetectorRetinaFace::NonMaxSuppression( int* proposals, int anchorsNum,int N
     }
 }
 
-void DetectorRetinaFace::ComputeOverlap(int xMin1, int yMin1, int xMax1, int yMax1, int xMin2,
-    int yMin2, int xMax2, int yMax2,  int* areaSum, int* areaInter)
+void DetectorRetinaFace::ComputeOverlap(int xMin1,
+                                        int yMin1,
+                                        int xMax1,
+                                        int yMax1,
+                                        int xMin2,
+                                        int yMin2,
+                                        int xMax2,
+                                        int yMax2,
+                                        int* areaSum,
+                                        int* areaInter)
 {
-    
-    int inter = 0;
-    int s32Total = 0;
-    int xMin = 0;
-    int yMin = 0;
-    int xMax = 0;
-    int yMax = 0;
-    int area1 = 0;
-    int area2 = 0;
-    int interWidth = 0;
+
+    int inter       = 0;
+    int s32Total    = 0;
+    int xMin        = 0;
+    int yMin        = 0;
+    int xMax        = 0;
+    int yMax        = 0;
+    int area1       = 0;
+    int area2       = 0;
+    int interWidth  = 0;
     int interHeight = 0;
 
     xMin = SSD_MAX(xMin1, xMin2);
@@ -1040,11 +1089,11 @@ void DetectorRetinaFace::ComputeOverlap(int xMin1, int yMin1, int xMax1, int yMa
     xMax = SSD_MIN(xMax1, xMax2);
     yMax = SSD_MIN(yMax1, yMax2);
 
-    interWidth = xMax - xMin + 1;
+    interWidth  = xMax - xMin + 1;
     interHeight = yMax - yMin + 1;
 
-    interWidth = ( interWidth >= 0 ) ? interWidth : 0;
-    interHeight = ( interHeight >= 0 ) ? interHeight : 0;
+    interWidth  = (interWidth >= 0) ? interWidth : 0;
+    interHeight = (interHeight >= 0) ? interHeight : 0;
 
     inter = interWidth * interHeight;
     area1 = (xMax1 - xMin1 + 1) * (yMax1 - yMin1 + 1);
@@ -1052,72 +1101,71 @@ void DetectorRetinaFace::ComputeOverlap(int xMin1, int yMin1, int xMax1, int yMa
 
     s32Total = area1 + area2 - inter;
 
-    *areaSum = s32Total;
+    *areaSum   = s32Total;
     *areaInter = inter;
 }
 
 void DetectorRetinaFace::Swap(int* src1, int* src2)
 {
-    int i = 0;
+    int i    = 0;
     int temp = 0;
-    for( i = 0; i < SSD_PROPOSAL_WIDTH; i++ )
+    for(i = 0; i < SSD_PROPOSAL_WIDTH; i++)
     {
-        temp = src1[i];
+        temp    = src1[i];
         src1[i] = src2[i];
         src2[i] = temp;
     }
 }
 
-void DetectorRetinaFace::CreateDetectionResults(std::vector<ResultOfDetection> &resultsOfDetection)
+void DetectorRetinaFace::CreateDetectionResults(std::vector<ResultOfDetection>& resultsOfDetection)
 {
     // 参数赋值
-    int* score=ssdParameter.dstScore;
-    int* roi=ssdParameter.dstRoi;
-    int* classRoiNum=ssdParameter.classRoiNum;
-    float printResultThresh=((float)ssdParameter.confThresh)/SSD_QUANT_BASE;
-    int classNum=ssdParameter.classNum;
+    int* score              = ssdParameter.dstScore;
+    int* roi                = ssdParameter.dstRoi;
+    int* classRoiNum        = ssdParameter.classRoiNum;
+    float printResultThresh = ((float)ssdParameter.confThresh) / SSD_QUANT_BASE;
+    int classNum            = ssdParameter.classNum;
 
     int i = 0, j = 0;
     int roiNumBias = 0;
-    int scoreBias = 0;
-    int bboxBias = 0;
-    float score2 = 0.0f;
-    int xMin = 0,yMin= 0,xMax = 0,yMax = 0;
+    int scoreBias  = 0;
+    int bboxBias   = 0;
+    float score2   = 0.0f;
+    int xMin = 0, yMin = 0, xMax = 0, yMax = 0;
 
     roiNumBias += classRoiNum[0];
-    for (i = 1; i < classNum; i++)
+    for(i = 1; i < classNum; i++)
     {
         scoreBias = roiNumBias;
-        bboxBias = roiNumBias * SSD_COORDI_NUM;
+        bboxBias  = roiNumBias * SSD_COORDI_NUM;
 
-        if((float)score[scoreBias] / SSD_QUANT_BASE >=
-            printResultThresh && classRoiNum[i]!=0)
+        if((float)score[scoreBias] / SSD_QUANT_BASE >= printResultThresh && classRoiNum[i] != 0)
         {
-            //printf("==== The %d th class box info====\n", i);
+            // printf("==== The %d th class box info====\n", i);
         }
-        for (j = 0; j < (int)classRoiNum[i]; j++)
+        for(j = 0; j < (int)classRoiNum[i]; j++)
         {
             score2 = (float)score[scoreBias + j] / SSD_QUANT_BASE;
-            if (score2 < printResultThresh)
+            if(score2 < printResultThresh)
             {
                 break;
             }
-            xMin = roi[bboxBias + j*SSD_COORDI_NUM];
-            yMin = roi[bboxBias + j*SSD_COORDI_NUM + 1];
-            xMax = roi[bboxBias + j*SSD_COORDI_NUM + 2];
-            yMax = roi[bboxBias + j*SSD_COORDI_NUM + 3];
+            xMin = roi[bboxBias + j * SSD_COORDI_NUM];
+            yMin = roi[bboxBias + j * SSD_COORDI_NUM + 1];
+            xMax = roi[bboxBias + j * SSD_COORDI_NUM + 2];
+            yMax = roi[bboxBias + j * SSD_COORDI_NUM + 3];
 
             ResultOfDetection result;
-            result.boundingBox.x=xMin;
-            result.boundingBox.y=yMin;
-            result.boundingBox.width=xMax-xMin+1;
-            result.boundingBox.height=yMax-yMin+1;
-            result.classID=i;
-            result.confidence=score2;
+            result.boundingBox.x      = xMin;
+            result.boundingBox.y      = yMin;
+            result.boundingBox.width  = xMax - xMin + 1;
+            result.boundingBox.height = yMax - yMin + 1;
+            result.classID            = i;
+            result.confidence         = score2;
             resultsOfDetection.push_back(result);
         }
         roiNumBias += classRoiNum[i];
     }
 }
 
-}
+} // namespace migraphxSamples

Src/RetinaFace.h

@@ -10,34 +10,49 @@ namespace migraphxSamples
 
 class DetectorRetinaFace
 {
-public:
+    public:
     DetectorRetinaFace();
-    
+
     ~DetectorRetinaFace();
 
     ErrorCode Initialize(InitializationParameterOfDetector initializationParameterOfDetector);
 
-    ErrorCode Detect(const cv::Mat &srcImage,std::vector<ResultOfDetection> &resultsOfDetection);
+    ErrorCode Detect(const cv::Mat& srcImage, std::vector<ResultOfDetection>& resultsOfDetection);
 
-private:
+    private:
     void GetSSDParameter();
-    void GetResult(const std::vector<std::vector<float>> &classification,const std::vector<std::vector<float>> &regression,std::vector<ResultOfDetection> &resultsOfDetection);
+    void GetResult(const std::vector<std::vector<float>>& classification,
+                   const std::vector<std::vector<float>>& regression,
+                   std::vector<ResultOfDetection>& resultsOfDetection);
 
-    std::vector<float> PermuteLayer(const std::vector<float> &data,int width,int height,int channels);
-    void PriorBoxLayer(int indexOfLayer,int* priorboxOutputData);
-    void SoftmaxLayer(int softMaxWidth[],int* softMaxInputData[], int* softMaxOutputData);
-    void DetectionOutputLayer(int* allLocPreds[], int* allPriorBoxes[],int* confScores, int* assistMemPool);
+    std::vector<float>
+    PermuteLayer(const std::vector<float>& data, int width, int height, int channels);
+    void PriorBoxLayer(int indexOfLayer, int* priorboxOutputData);
+    void SoftmaxLayer(int softMaxWidth[], int* softMaxInputData[], int* softMaxOutputData);
+    void DetectionOutputLayer(int* allLocPreds[],
+                              int* allPriorBoxes[],
+                              int* confScores,
+                              int* assistMemPool);
 
     void ComputeSoftMax(int* src, int size, int* dst);
-    void QuickSort(int* src,int low, int high, QuickSortStack *stack,int maxNum);
-    void NonMaxSuppression( int* proposals, int anchorsNum,int NMSThresh,int maxRoiNum);
+    void QuickSort(int* src, int low, int high, QuickSortStack* stack, int maxNum);
+    void NonMaxSuppression(int* proposals, int anchorsNum, int NMSThresh, int maxRoiNum);
     void Swap(int* src1, int* src2);
-    void ComputeOverlap(int xMin1, int yMin1, int xMax1, int yMax1, int xMin2,int yMin2, int xMax2, int yMax2,  int* areaSum, int* areaInter);
-    void CreateDetectionResults(std::vector<ResultOfDetection> &resultsOfDetection);
+    void ComputeOverlap(int xMin1,
+                        int yMin1,
+                        int xMax1,
+                        int yMax1,
+                        int xMin2,
+                        int yMin2,
+                        int xMax2,
+                        int yMax2,
+                        int* areaSum,
+                        int* areaInter);
+    void CreateDetectionResults(std::vector<ResultOfDetection>& resultsOfDetection);
 
-private:
+    private:
     cv::FileStorage configurationFile;
-    
+
     migraphx::program net;
     cv::Size inputSize;
     std::string inputName;
@@ -51,10 +66,8 @@ private:
     bool useFP16;
 
     SSDParameter ssdParameter;
-
 };
 
-}
+} // namespace migraphxSamples
 
 #endif
-

Src/Utility/CommonDefinition.h

@@ -7,33 +7,33 @@
 
 namespace migraphxSamples
 {
-   
+
 // 路径分隔符(Linux:‘/’,Windows:’\\’)
 #ifdef _WIN32
-#define  PATH_SEPARATOR '\\'
+#define PATH_SEPARATOR '\\'
 #else
-#define  PATH_SEPARATOR '/'
+#define PATH_SEPARATOR '/'
 #endif
 
-#define CONFIG_FILE                                                     "../Resource/Configuration.xml"
+#define CONFIG_FILE "../Resource/Configuration.xml"
 
 typedef enum _ErrorCode
 {
-    SUCCESS=0,  // 0
-    MODEL_NOT_EXIST, // 模型不存在
-    CONFIG_FILE_NOT_EXIST, // 配置文件不存在
-    FAIL_TO_LOAD_MODEL, // 加载模型失败
+    SUCCESS = 0,              // 0
+    MODEL_NOT_EXIST,          // 模型不存在
+    CONFIG_FILE_NOT_EXIST,    // 配置文件不存在
+    FAIL_TO_LOAD_MODEL,       // 加载模型失败
     FAIL_TO_OPEN_CONFIG_FILE, // 加载配置文件失败
-    IMAGE_ERROR, // 图像错误
-}ErrorCode;
+    IMAGE_ERROR,              // 图像错误
+} ErrorCode;
 
 typedef struct _ResultOfPrediction
 {
     float confidence;
     int label;
-    _ResultOfPrediction():confidence(0.0f),label(0){}
+    _ResultOfPrediction() : confidence(0.0f), label(0) {}
 
-}ResultOfPrediction;
+} ResultOfPrediction;
 
 typedef struct _ResultOfDetection
 {
@@ -43,17 +43,16 @@ typedef struct _ResultOfDetection
     std::string className;
     bool exist;
 
-    _ResultOfDetection():confidence(0.0f),classID(0),exist(true){}
+    _ResultOfDetection() : confidence(0.0f), classID(0), exist(true) {}
 
-}ResultOfDetection;
+} ResultOfDetection;
 
 typedef struct _InitializationParameterOfDetector
 {
     std::string parentPath;
     std::string configFilePath;
-}InitializationParameterOfDetector;
+} InitializationParameterOfDetector;
 
-}
+} // namespace migraphxSamples
 
 #endif
-

Src/Utility/CommonUtility.cpp

@@ -3,34 +3,37 @@
 namespace migraphxSamples
 {
 
-bool CompareConfidence(const ResultOfDetection &L,const ResultOfDetection &R)
+bool CompareConfidence(const ResultOfDetection& L, const ResultOfDetection& R)
 {
     return L.confidence > R.confidence;
 }
 
-bool CompareArea(const ResultOfDetection &L,const ResultOfDetection &R)
+bool CompareArea(const ResultOfDetection& L, const ResultOfDetection& R)
 {
     return L.boundingBox.area() > R.boundingBox.area();
 }
 
-void NMS(std::vector<ResultOfDetection> &detections, float IOUThreshold)
+void NMS(std::vector<ResultOfDetection>& detections, float IOUThreshold)
 {
     // sort
     std::sort(detections.begin(), detections.end(), CompareConfidence);
 
-    for (int i = 0; i<detections.size(); ++i)
+    for(int i = 0; i < detections.size(); ++i)
     {
-        if (detections[i].exist)
+        if(detections[i].exist)
         {
-            for (int j = i + 1; j<detections.size(); ++j)
+            for(int j = i + 1; j < detections.size(); ++j)
             {
-                if (detections[j].exist)
+                if(detections[j].exist)
                 {
                     // compute IOU
-                    float intersectionArea = (detections[i].boundingBox & detections[j].boundingBox).area();
-                    float intersectionRate = intersectionArea / (detections[i].boundingBox.area() + detections[j].boundingBox.area() - intersectionArea);
+                    float intersectionArea =
+                        (detections[i].boundingBox & detections[j].boundingBox).area();
+                    float intersectionRate =
+                        intersectionArea / (detections[i].boundingBox.area() +
+                                            detections[j].boundingBox.area() - intersectionArea);
 
-                    if (intersectionRate>IOUThreshold)
+                    if(intersectionRate > IOUThreshold)
                     {
                         detections[j].exist = false;
                     }
@@ -38,7 +41,6 @@ void NMS(std::vector<ResultOfDetection> &detections, float IOUThreshold)
             }
         }
     }
-
 }
 
-}
+} // namespace migraphxSamples

Src/Utility/CommonUtility.h

@@ -9,12 +9,12 @@ namespace migraphxSamples
 {
 
 // 排序规则: 按照置信度或者按照面积排序
-bool CompareConfidence(const ResultOfDetection &L,const ResultOfDetection &R);
-bool CompareArea(const ResultOfDetection &L,const ResultOfDetection &R);
+bool CompareConfidence(const ResultOfDetection& L, const ResultOfDetection& R);
+bool CompareArea(const ResultOfDetection& L, const ResultOfDetection& R);
 
 // 非极大抑制
-void NMS(std::vector<ResultOfDetection> &detections, float IOUThreshold);
+void NMS(std::vector<ResultOfDetection>& detections, float IOUThreshold);
 
-}
+} // namespace migraphxSamples
 
 #endif

Src/Utility/Filesystem.cpp

@@ -14,9 +14,9 @@
 
 // 路径分隔符(Linux:‘/’,Windows:’\\’)
 #ifdef _WIN32
-#define  PATH_SEPARATOR '\\'
+#define PATH_SEPARATOR '\\'
 #else
-#define  PATH_SEPARATOR '/'
+#define PATH_SEPARATOR '/'
 #endif
 
 using namespace std;
@@ -28,666 +28,672 @@ static std::vector<std::string> SplitString(std::string str, std::string separat
 {
     std::string::size_type pos;
     std::vector<std::string> result;
-    str+=separator;//扩展字符串以方便操作
-    int size=str.size();
+    str += separator; // 扩展字符串以方便操作
+    int size = str.size();
 
-    for(int i=0; i<size; i++)
+    for(int i = 0; i < size; i++)
     {
-        pos=str.find(separator,i);
-        if(pos<size)
+        pos = str.find(separator, i);
+        if(pos < size)
         {
-            std::string s=str.substr(i,pos-i);
+            std::string s = str.substr(i, pos - i);
             result.push_back(s);
-            i=pos+separator.size()-1;
+            i = pos + separator.size() - 1;
         }
     }
     return result;
 }
 
 #if defined _WIN32 || defined WINCE
-    const char dir_separators[] = "/\\";
+const char dir_separators[] = "/\\";
 
-	struct dirent
-	{
-		const char* d_name;
-	};
+struct dirent
+{
+    const char* d_name;
+};
 
-	struct DIR
-	{
+struct DIR
+{
 #ifdef WINRT
-		WIN32_FIND_DATAW data;
+    WIN32_FIND_DATAW data;
 #else
-        WIN32_FIND_DATAA data;
+    WIN32_FIND_DATAA data;
 #endif
-		HANDLE handle;
-		dirent ent;
+    HANDLE handle;
+    dirent ent;
 #ifdef WINRT
-		DIR() { }
-		~DIR()
-		{
-			if (ent.d_name)
-				delete[] ent.d_name;
-		}
+    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;
+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);
+    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);
+    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)
-	{
+    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;
+    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;
+    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;
-	}
+    return &dir->ent;
+}
+
+void closedir(DIR* dir)
+{
+    ::FindClose(dir->handle);
+    delete dir;
+}
 #else
-# include <dirent.h>
-# include <sys/stat.h>
-	const char dir_separators[] = "/";
+#include <dirent.h>
+#include <sys/stat.h>
+const char dir_separators[] = "/";
 #endif
 
-	static bool isDir(const string &path, DIR* dir)
-	{
+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;
+    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);
+        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);
+        status = ::GetFileAttributesExA(path.c_str(), GetFileExInfoStandard, &all_attrs);
 #endif
-			attributes = all_attrs.dwFileAttributes;
-		}
+        attributes = all_attrs.dwFileAttributes;
+    }
 
-		return status && ((attributes & FILE_ATTRIBUTE_DIRECTORY) != 0);
+    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;
+    (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 IsDirectory(const string& path) { return isDir(path, NULL); }
 
-	bool Exists(const string& path)
-	{
+bool Exists(const string& path)
+{
 
 #if defined _WIN32 || defined WINCE
-			BOOL status = TRUE;
-		{
-			WIN32_FILE_ATTRIBUTE_DATA all_attrs;
+    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);
+        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);
+        status = ::GetFileAttributesExA(path.c_str(), GetFileExInfoStandard, &all_attrs);
 #endif
-		}
+    }
 
-		return !!status;
+    return !!status;
 #else
-		struct stat stat_buf;
-		return (0 == stat(path.c_str(), &stat_buf));
+    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)
+}
+
+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 != '?'))
         {
-            string eachPattern=patterns[i];
-            std::vector<string> eachResult;
-            glob_rec(directory, eachPattern, eachResult, recursive, true, directory);
-            for(int j=0;j<eachResult.size();++j)
+            return false;
+        }
+
+        wild++;
+        string++;
+    }
+
+    while(*string)
+    {
+        if(*wild == '*')
+        {
+            if(!*++wild)
             {
-				if (IsDirectory(eachResult[j]))
-					continue;
-                if(addPath)
+                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)
                 {
-                    result.push_back(eachResult[j]);
+                    if(IsPathSeparator(filePath[k]))
+                    {
+                        filePath[k] = '/';
+                    }
                 }
-                else
+            }
+            if(addPath)
+            {
+                result.push_back(filePath);
+            }
+            else
+            {
+                if(!IsDirectory(filePath))
                 {
-                    result.push_back(GetFileName(eachResult[j]));
+                    result.push_back(GetFileName(filePath));
                 }
             }
         }
-		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);
-			}
+    }
+    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;
+        bool result = _rmdir(path.c_str()) == 0;
 #else
-			bool result = rmdir(path.c_str()) == 0;
+        bool result = rmdir(path.c_str()) == 0;
 #endif
-			if (!result)
-			{
-				printf("can't remove directory: %s\n", path.c_str());
-			}
-		}
-		else
-		{
+        if(!result)
+        {
+            printf("can't remove directory: %s\n", path.c_str());
+        }
+    }
+    else
+    {
 #ifdef _MSC_VER
-			bool result = _unlink(path.c_str()) == 0;
+        bool result = _unlink(path.c_str()) == 0;
 #else
-			bool result = unlink(path.c_str()) == 0;
+        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)
+        if(!result)
         {
-            fileName = path;
+            printf("can't remove file: %s\n", path.c_str());
         }
+    }
+}
+
+void Remove(const string& directory, const string& extension)
+{
 
-        return fileName;
-	}
-    string GetFileName_NoExtension(const string &path)
+    DIR* dir;
+
+    static int numberOfFiles = 0;
+
+    if((dir = opendir(directory.c_str())) != 0)
     {
-        string fileName=GetFileName(path);
-        string fileName_NoExtension;
-        for(int i=fileName.size()-1;i>0;--i)
+        /* find all the files and directories within directory */
+        try
         {
-            if(fileName[i]=='.')
+            struct dirent* ent;
+            while((ent = readdir(dir)) != 0)
             {
-                fileName_NoExtension=fileName.substr(0,i);
-                break;
-            }
-        }
+                const char* name = ent->d_name;
+                if((name[0] == 0) || (name[0] == '.' && name[1] == 0) ||
+                   (name[0] == '.' && name[1] == '.' && name[2] == 0))
+                    continue;
 
-        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);
+                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);
+                }
             }
-            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())
+        }
+        catch(...)
         {
-            printf("can not open %s\n",srcPath.c_str());
-            return false;
+            closedir(dir);
+            throw;
         }
-        if(!dstFile.is_open())
+        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]))
         {
-			printf("can not open %s\n", dstPath.c_str());
-            return false;
+            fileName             = path.substr(i + 1, path.size() - i - 1);
+            indexOfPathSeparator = i;
+            break;
         }
-        if(srcPath==dstPath)
+    }
+    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] == '.')
         {
-			printf("src can not be same with dst\n");
-            return false;
+            fileName_NoExtension = fileName.substr(0, i);
+            break;
         }
-        char buffer[2048];
-        unsigned int numberOfBytes=0;
-        while(srcFile)
+    }
+
+    return fileName_NoExtension;
+}
+
+string GetExtension(const string& path)
+{
+    string fileName;
+    for(int i = path.size() - 1; i >= 0; --i)
+    {
+        if(path[i] == '.')
         {
-            srcFile.read(buffer,2048);
-            dstFile.write(buffer,srcFile.gcount());
-            numberOfBytes+=srcFile.gcount();
+            fileName = path.substr(i, path.size() - i);
+            break;
         }
-        srcFile.close();
-        dstFile.close();
-        return true;
     }
 
-    bool CopyDirectories(string srcPath, const string dstPath)
+    return fileName;
+}
+
+string GetParentPath(const string& path)
+{
+    string fileName;
+    for(int i = path.size() - 1; i >= 0; --i)
     {
-        if(srcPath==dstPath)
+        if(IsPathSeparator(path[i]))
         {
-			printf("src can not be same with dst\n");
-            return false;
+            fileName = path.substr(0, i + 1);
+            break;
         }
+    }
 
-		// ȥ������·���ָ���
-		srcPath = srcPath.substr(0, srcPath.size() - 1);
+    return fileName;
+}
 
-        vector<string> fileNameList;
-        GetFileNameList2(srcPath, "", fileNameList, true, true);
+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
 
-        string parentPathOfSrc=GetParentPath(srcPath);
-        int length=parentPathOfSrc.size();
+    if(result == -1)
+    {
+        return IsDirectory(path);
+    }
+    return true;
+}
 
-        // create all directories
-        for(int i=0;i<fileNameList.size();++i)
+bool CreateDirectories(const string& directoryPath)
+{
+    string path = directoryPath;
+
+    for(;;)
+    {
+        char last_char = path.empty() ? 0 : path[path.length() - 1];
+        if(IsPathSeparator(last_char))
         {
-            // create directory
-            string srcFilePath=fileNameList[i];
-            string subStr=srcFilePath.substr(length,srcFilePath.size()-length);
-            string dstFilePath=dstPath+subStr;
-            string parentPathOfDst=GetParentPath(dstFilePath);
-            CreateDirectories(parentPathOfDst);
+            path = path.substr(0, path.length() - 1);
+            continue;
         }
+        break;
+    }
 
-        // copy file
-        for(int i=0;i<fileNameList.size();++i)
+    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())
         {
-            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);
+            if(!CreateDirectories(parent_directory))
+                return false;
         }
-		printf("all done!(the number of files:%d)\n", fileNameList.size());
+    }
 
-        return true;
+    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:%d)\n", fileNameList.size());
+
+    return true;
+}
 
+} // namespace migraphxSamples

Src/Utility/Filesystem.h

@@ -5,27 +5,27 @@
 
 #include <string>
 #include <vector>
- 
+
 namespace migraphxSamples
 {
 
 // 路径是否存在
-bool Exists(const std::string &path);
+bool Exists(const std::string& path);
 
 // 路径是否为目录
-bool IsDirectory(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);
+std::string JoinPath(const std::string& base, const std::string& path);
 
 // 创建多级目录,注意：创建多级目录的时候，目标目录是不能有文件存在的
-bool CreateDirectories(const std::string &directoryPath);
+bool CreateDirectories(const std::string& directoryPath);
 
 /** 生成符合指定模式的文件名列表(支持递归遍历)
-* 
+*
 * pattern: 模式,比如"*.jpg","*.png","*.jpg,*.png"
 * addPath：是否包含父路径
 * 注意：
@@ -36,35 +36,43 @@ bool CreateDirectories(const std::string &directoryPath);
     5. 不能返回子目录名
 *
 */
-void GetFileNameList(const std::string &directory, const std::string &pattern, std::vector<std::string> &result, bool recursive, bool addPath);
+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 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="");
+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);
+ */
+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);
+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);
+bool CopyDirectories(std::string srcPath, const std::string dstPath);
 
-}
+} // namespace migraphxSamples
 
 #endif

Src/Utility/SSDDefinition.h

@@ -8,7 +8,7 @@
 namespace migraphxSamples
 {
 
-#define SSD_MAX_PRIORBOX_LAYER_NUM      10 // 能够支持的最大检测层数量
+#define SSD_MAX_PRIORBOX_LAYER_NUM 10 // 能够支持的最大检测层数量
 
 // SSD参数
 typedef struct _SSDParameter
@@ -16,23 +16,23 @@ typedef struct _SSDParameter
     int numberOfPriorBoxLayer; // 检测层数量
 
     // Model Parameters
-    int convHeight[SSD_MAX_PRIORBOX_LAYER_NUM*2];
-    int convWidth[SSD_MAX_PRIORBOX_LAYER_NUM*2];
-    int convChannel[SSD_MAX_PRIORBOX_LAYER_NUM*2];
+    int convHeight[SSD_MAX_PRIORBOX_LAYER_NUM * 2];
+    int convWidth[SSD_MAX_PRIORBOX_LAYER_NUM * 2];
+    int convChannel[SSD_MAX_PRIORBOX_LAYER_NUM * 2];
 
     // PriorBoxLayer Parameters
-    int priorBoxWidth[SSD_MAX_PRIORBOX_LAYER_NUM]; // 每个检测层priorbox的宽
-    int priorBoxHeight[SSD_MAX_PRIORBOX_LAYER_NUM];// 每个检测层priorbox的高
+    int priorBoxWidth[SSD_MAX_PRIORBOX_LAYER_NUM];   // 每个检测层priorbox的宽
+    int priorBoxHeight[SSD_MAX_PRIORBOX_LAYER_NUM];  // 每个检测层priorbox的高
     std::vector<std::vector<float>> priorBoxMinSize; // 每个检测层priorbox的minsize
     std::vector<std::vector<float>> priorBoxMaxSize; // 每个检测层priorbox的maxsize
-    int minSizeNum[SSD_MAX_PRIORBOX_LAYER_NUM]; // 每个检测层priorbox的minsize数量
-    int maxSizeNum[SSD_MAX_PRIORBOX_LAYER_NUM]; // 每个检测层priorbox的maxsize数量
-    int srcImageHeight;// 原图大小
+    int minSizeNum[SSD_MAX_PRIORBOX_LAYER_NUM];      // 每个检测层priorbox的minsize数量
+    int maxSizeNum[SSD_MAX_PRIORBOX_LAYER_NUM];      // 每个检测层priorbox的maxsize数量
+    int srcImageHeight;                              // 原图大小
     int srcImageWidth;
-    int inputAspectRatioNum[SSD_MAX_PRIORBOX_LAYER_NUM];// 每个检测层宽高比的数量 
-    std::vector<std::vector<float>> priorBoxAspectRatio;// 每个检测层的宽高比
-    float priorBoxStepWidth[SSD_MAX_PRIORBOX_LAYER_NUM];// 每个检测层步长的宽
-    float priorBoxStepHeight[SSD_MAX_PRIORBOX_LAYER_NUM];// 每个检测层步长的高
+    int inputAspectRatioNum[SSD_MAX_PRIORBOX_LAYER_NUM];  // 每个检测层宽高比的数量
+    std::vector<std::vector<float>> priorBoxAspectRatio;  // 每个检测层的宽高比
+    float priorBoxStepWidth[SSD_MAX_PRIORBOX_LAYER_NUM];  // 每个检测层步长的宽
+    float priorBoxStepHeight[SSD_MAX_PRIORBOX_LAYER_NUM]; // 每个检测层步长的高
     float offset;
     int flip[SSD_MAX_PRIORBOX_LAYER_NUM];
     int clip[SSD_MAX_PRIORBOX_LAYER_NUM];
@@ -47,7 +47,7 @@ typedef struct _SSDParameter
     int softMaxOutChn;
 
     // DetectionOutLayer Parameters
-    int classNum;// 类别数(包含背景类)
+    int classNum; // 类别数(包含背景类)
     int topK;
     int keepTopK;
     int NMSThresh;
@@ -56,39 +56,41 @@ typedef struct _SSDParameter
     int convStride[SSD_MAX_PRIORBOX_LAYER_NUM];
 
     // buffer
-    int *buffer;
-    int *classification[SSD_MAX_PRIORBOX_LAYER_NUM];// 分类数据
-    int *regression[SSD_MAX_PRIORBOX_LAYER_NUM];// 回归
-    int *priorboxOutputData;
-    int *softMaxOutputData;
-    int *getResultBuffer;
-    int *dstScore;
-    int *dstRoi;
-    int *classRoiNum;
-    _SSDParameter():srcImageHeight(0),
-                    srcImageWidth(0),
-                    offset(0.0),
-                    softMaxInHeight(0),
-                    concatNum(0),
-                    softMaxOutWidth(0),
-                    softMaxOutHeight(0),
-                    softMaxOutChn(0),
-                    buffer(NULL),
-                    priorboxOutputData(NULL),
-                    softMaxOutputData(NULL),
-                    getResultBuffer(NULL),
-                    dstScore(NULL),
-                    dstRoi(NULL),
-                    classRoiNum(NULL){}
-}SSDParameter;
+    int* buffer;
+    int* classification[SSD_MAX_PRIORBOX_LAYER_NUM]; // 分类数据
+    int* regression[SSD_MAX_PRIORBOX_LAYER_NUM];     // 回归
+    int* priorboxOutputData;
+    int* softMaxOutputData;
+    int* getResultBuffer;
+    int* dstScore;
+    int* dstRoi;
+    int* classRoiNum;
+    _SSDParameter()
+        : srcImageHeight(0),
+          srcImageWidth(0),
+          offset(0.0),
+          softMaxInHeight(0),
+          concatNum(0),
+          softMaxOutWidth(0),
+          softMaxOutHeight(0),
+          softMaxOutChn(0),
+          buffer(NULL),
+          priorboxOutputData(NULL),
+          softMaxOutputData(NULL),
+          getResultBuffer(NULL),
+          dstScore(NULL),
+          dstRoi(NULL),
+          classRoiNum(NULL)
+    {
+    }
+} SSDParameter;
 
 typedef struct _QuickSortStack
 {
     int min;
     int max;
-}QuickSortStack;
+} QuickSortStack;
 
-}
+} // namespace migraphxSamples
 
 #endif
-

Src/Utility/SimpleLog.h

@@ -8,7 +8,7 @@
 #include <map>
 #include <thread>
 #include <mutex>
-#if (defined WIN32 || defined _WIN32)
+#if(defined WIN32 || defined _WIN32)
 #include <Windows.h>
 #else
 #include <sys/time.h>
@@ -16,13 +16,13 @@
 
 using namespace std;
 
-
 /** 简易日志
- * 
+ *
  * 不依赖于其他第三方库，只需要包含一个头文件就可以使用。提供了4种日志级别，包括INFO,DEBUG,WARN和ERROR。
- * 
+ *
  * 示例1:
-    // 初始化日志，在./Log/目录下创建两个日志文件log1.log和log2.log(注意：目录./Log/需要存在，否则日志创建失败)
+    //
+ 初始化日志，在./Log/目录下创建两个日志文件log1.log和log2.log(注意：目录./Log/需要存在，否则日志创建失败)
     LogManager::GetInstance()->Initialize("./Log/","log1");
     LogManager::GetInstance()->Initialize("./Log/","log2");
 
@@ -34,11 +34,11 @@ using namespace std;
     // 关闭日志
     LogManager::GetInstance()->Close("log1");
     LogManager::GetInstance()->Close("log2");
-  
+
   * 示例2:
     // 将日志输出到控制台
     string log = "Hello World";
-    LOG_INFO(stdout, "%s\n", log.c_str()); 
+    LOG_INFO(stdout, "%s\n", log.c_str());
 
   * 注意：
     1. 需要C++11
@@ -50,44 +50,43 @@ using namespace std;
 
 class LogManager
 {
-private:
-    LogManager(){}
+    private:
+    LogManager() {}
 
-public:
-    ~LogManager(){}
-    inline void Initialize(const string &parentPath,const string &logName)
+    public:
+    ~LogManager() {}
+    inline void Initialize(const string& parentPath, const string& logName)
     {
         // 日志名为空表示输出到控制台
-        if(logName.size()==0)
+        if(logName.size() == 0)
             return;
 
         // 查找该日志文件，如果没有则创建
         std::map<string, FILE*>::const_iterator iter = logMap.find(logName);
-        if (iter == logMap.end())
+        if(iter == logMap.end())
         {
-            string pathOfLog = parentPath+ logName + ".log";
-            FILE *logFile = fopen(pathOfLog.c_str(), "a"); // w:覆盖原有文件,a:追加
-            if(logFile!=NULL)
+            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)
+    inline FILE* GetLogFile(const string& logName)
     {
-        std::map<string, FILE*>::const_iterator iter=logMap.find(logName);
-        if(iter==logMap.end())
+        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)
+    inline void Close(const string& logName)
     {
-        std::map<string, FILE*>::const_iterator iter=logMap.find(logName);
-        if(iter==logMap.end())
+        std::map<string, FILE*>::const_iterator iter = logMap.find(logName);
+        if(iter == logMap.end())
         {
             return;
         }
@@ -95,10 +94,7 @@ public:
         fclose((*iter).second);
         logMap.erase(iter);
     }
-    inline std::mutex &GetLogMutex()
-    {
-        return logMutex;
-    }
+    inline std::mutex& GetLogMutex() { return logMutex; }
 
     // Singleton
     static LogManager* GetInstance()
@@ -106,21 +102,22 @@ public:
         static LogManager logManager;
         return &logManager;
     }
-private:
+
+    private:
     std::map<string, FILE*> logMap;
     std::mutex logMutex;
 };
 
 #ifdef LOG_MUTEX
-    #define LOCK	LogManager::GetInstance()->GetLogMutex().lock()
-    #define UNLOCK	LogManager::GetInstance()->GetLogMutex().unlock()
+#define LOCK LogManager::GetInstance()->GetLogMutex().lock()
+#define UNLOCK LogManager::GetInstance()->GetLogMutex().unlock()
 #else
-    #define LOCK
-    #define UNLOCK
+#define LOCK
+#define UNLOCK
 #endif
 
 // log time
-typedef struct  _LogTime
+typedef struct _LogTime
 {
     string year;
     string month;
@@ -131,53 +128,53 @@ typedef struct  _LogTime
     string millisecond; // ms
     string microsecond; // us
     string weekDay;
-}LogTime;
+} LogTime;
 
 inline LogTime GetTime()
 {
     LogTime currentTime;
 
-#if (defined WIN32 || defined _WIN32)
+#if(defined WIN32 || defined _WIN32)
     SYSTEMTIME systemTime;
     GetLocalTime(&systemTime);
 
-    char temp[8] = { 0 };
+    char temp[8] = {0};
     sprintf(temp, "%04d", systemTime.wYear);
-    currentTime.year=string(temp);
+    currentTime.year = string(temp);
     sprintf(temp, "%02d", systemTime.wMonth);
-    currentTime.month=string(temp);
+    currentTime.month = string(temp);
     sprintf(temp, "%02d", systemTime.wDay);
-    currentTime.day=string(temp);
+    currentTime.day = string(temp);
     sprintf(temp, "%02d", systemTime.wHour);
-    currentTime.hour=string(temp);
+    currentTime.hour = string(temp);
     sprintf(temp, "%02d", systemTime.wMinute);
-    currentTime.minute=string(temp);
+    currentTime.minute = string(temp);
     sprintf(temp, "%02d", systemTime.wSecond);
-    currentTime.second=string(temp);
+    currentTime.second = string(temp);
     sprintf(temp, "%03d", systemTime.wMilliseconds);
-    currentTime.millisecond=string(temp);
+    currentTime.millisecond = string(temp);
     sprintf(temp, "%d", systemTime.wDayOfWeek);
-    currentTime.weekDay=string(temp);
+    currentTime.weekDay = string(temp);
 #else
-    struct timeval    tv;
-    struct tm         *p;
+    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));
+    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);
@@ -187,61 +184,83 @@ inline LogTime GetTime()
     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)
+#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)
 
-#endif // __SIMPLE_LOG_H__
+#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

@@ -11,8 +11,8 @@ int main()
     migraphxSamples::DetectorRetinaFace detector;
     migraphxSamples::InitializationParameterOfDetector initParamOfDetectorRetinaFace;
     initParamOfDetectorRetinaFace.configFilePath = CONFIG_FILE;
-    migraphxSamples::ErrorCode errorCode=detector.Initialize(initParamOfDetectorRetinaFace);
-    if(errorCode!=migraphxSamples::SUCCESS)
+    migraphxSamples::ErrorCode errorCode = detector.Initialize(initParamOfDetectorRetinaFace);
+    if(errorCode != migraphxSamples::SUCCESS)
     {
         LOG_ERROR(stdout, "fail to initialize detector!\n");
         exit(-1);
@@ -20,24 +20,30 @@ int main()
     LOG_INFO(stdout, "succeed to initialize detector\n");
 
     // 读取测试图片
-    cv::Mat srcImage=cv::imread("../Resource/Images/FaceDetect.jpg",1);
+    cv::Mat srcImage = cv::imread("../Resource/Images/FaceDetect.jpg", 1);
 
     // 推理
     std::vector<migraphxSamples::ResultOfDetection> predictions;
-    detector.Detect(srcImage,predictions);
+    detector.Detect(srcImage, predictions);
 
     // 获取推理结果
-    LOG_INFO(stdout,"========== Detection Results ==========\n");
-    for(int i=0;i<predictions.size();++i)
+    LOG_INFO(stdout, "========== Detection Results ==========\n");
+    for(int i = 0; i < predictions.size(); ++i)
     {
-        migraphxSamples::ResultOfDetection result=predictions[i];
-        cv::rectangle(srcImage,result.boundingBox,cv::Scalar(0,255,255),2);
-        
-        LOG_INFO(stdout,"box:%d %d %d %d,label:%d,confidence:%f\n",predictions[i].boundingBox.x,
-        predictions[i].boundingBox.y,predictions[i].boundingBox.width,predictions[i].boundingBox.height,predictions[i].classID,predictions[i].confidence);
+        migraphxSamples::ResultOfDetection result = predictions[i];
+        cv::rectangle(srcImage, result.boundingBox, cv::Scalar(0, 255, 255), 2);
+
+        LOG_INFO(stdout,
+                 "box:%d %d %d %d,label:%d,confidence:%f\n",
+                 predictions[i].boundingBox.x,
+                 predictions[i].boundingBox.y,
+                 predictions[i].boundingBox.width,
+                 predictions[i].boundingBox.height,
+                 predictions[i].classID,
+                 predictions[i].confidence);
     }
-    cv::imwrite("Result.jpg",srcImage);
-    LOG_INFO(stdout,"Detection results have been saved to ./Result.jpg\n");
+    cv::imwrite("Result.jpg", srcImage);
+    LOG_INFO(stdout, "Detection results have been saved to ./Result.jpg\n");
 
     return 0;
 }
\ No newline at end of file