1. Fix the issue that demo lost the inference of the last frame when …

…inputting video. 2. Update the correctness checker that allows insignificant difference for the ROI.

Signed-off-by: Wang, Yang <[email protected]>

demos/security_barrier_camera_demo/cpp/main.cpp

@@ -121,6 +121,8 @@ struct Context {
         detectorsInfers.assign(detectorInferRequests);
         attributesInfers.assign(attributesInferRequests);
         platesInfers.assign(lprInferRequests);
+        totalInferFrameCounter = 0;
+        totalFrameCount = 0;
     }
 
     struct {
@@ -172,6 +174,11 @@ struct Context {
     bool isVideo;
     std::atomic<std::vector<ov::InferRequest>::size_type> freeDetectionInfersCount;
     std::atomic<uint32_t> frameCounter;
+
+    // Record the inferred frames count
+    std::atomic<uint32_t> totalInferFrameCounter;
+    std::atomic<uint32_t> totalFrameCount;
+
     InferRequestsContainer detectorsInfers, attributesInfers, platesInfers;
     PerformanceMetrics metrics;
 };
@@ -292,10 +299,6 @@ ReborningVideoFrame::~ReborningVideoFrame() {
         context.videoFramesContext.lastFrameIdsMutexes[sourceID].lock();
         const auto frameId = ++context.videoFramesContext.lastframeIds[sourceID];
         context.videoFramesContext.lastFrameIdsMutexes[sourceID].unlock();
-
-        // Stop reborning when frame ID reached to input queue size
-        if (!context.isVideo && frameId >= FLAGS_n_iqs)
-            return;
         std::shared_ptr<ReborningVideoFrame> reborn = std::make_shared<ReborningVideoFrame>(context, sourceID, frameId, frame);
         worker->push(std::make_shared<Reader>(reborn));
     } catch (const std::bad_weak_ptr&) {}
@@ -384,7 +387,7 @@ void Drawer::process() {
             if (!context.isVideo) {
                 try {
                     // Exit only when inferences on all of frames are finished.
-                    if (context.frameCounter >= FLAGS_n_iqs * context.readersContext.inputChannels.size())
+                    if (context.totalInferFrameCounter >= FLAGS_ni * context.totalFrameCount)
                         std::shared_ptr<Worker>(context.drawersContext.drawersWorker)->stop();
                 }
                 catch (const std::bad_weak_ptr&) {}
@@ -569,6 +572,8 @@ void DetectionsProcessor::process() {
         tryPush(context.detectionsProcessorsContext.detectionsProcessorsWorker,
             std::make_shared<DetectionsProcessor>(sharedVideoFrame, std::move(classifiersAggregator), std::move(vehicleRects), std::move(plateRects)));
     }
+    // Count the frames passed inference
+    context.totalInferFrameCounter++;
 }
 
 bool InferTask::isReady() {
@@ -591,10 +596,10 @@ void InferTask::process() {
     InferRequestsContainer& detectorsInfers = context.detectorsInfers;
     std::reference_wrapper<ov::InferRequest> inferRequest = detectorsInfers.inferRequests.container.back();
     detectorsInfers.inferRequests.container.pop_back();
+
     detectorsInfers.inferRequests.mutex.unlock();
 
     context.inferTasksContext.detector.setImage(inferRequest, sharedVideoFrame->frame);
-
     inferRequest.get().set_callback(
         std::bind(
             [](VideoFrame::Ptr sharedVideoFrame,
@@ -635,6 +640,12 @@ void Reader::process() {
         context.readersContext.lastCapturedFrameIds[sourceID]++;
         context.readersContext.lastCapturedFrameIdsMutexes[sourceID].unlock();
         try {
+            if (context.totalInferFrameCounter < FLAGS_ni * context.totalFrameCount)
+            {
+                // Rebron this invalid frame to end the worker at next time
+                std::shared_ptr<Worker>(context.drawersContext.drawersWorker)->push(std::make_shared<Reader>(sharedVideoFrame));
+                return;
+            }
             std::shared_ptr<Worker>(context.drawersContext.drawersWorker)->stop();
         } catch (const std::bad_weak_ptr&) {}
     }
@@ -674,6 +685,8 @@ int main(int argc, char* argv[]) {
                 videoCapturSourcess.push_back(std::make_shared<VideoCaptureSource>(videoCapture, FLAGS_loop_video));
             }
         }
+
+        uint32_t totalFrameCount = 0;
         for (const std::string& file : files) {
             cv::Mat frame = cv::imread(file, cv::IMREAD_COLOR);
             if (frame.empty()) {
@@ -683,8 +696,12 @@ int main(int argc, char* argv[]) {
                     return 1;
                 }
                 videoCapturSourcess.push_back(std::make_shared<VideoCaptureSource>(videoCapture, FLAGS_loop_video));
+                // Get the total frame count from this video
+                totalFrameCount = static_cast<uint32_t>(videoCapture.get(cv::CAP_PROP_FRAME_COUNT));
             } else {
                 imageSourcess.push_back(std::make_shared<ImageSource>(frame, true));
+                // Get the total frame count from the inputting images
+                totalFrameCount++;
             }
         }
         uint32_t channelsNum = 0 == FLAGS_ni ? videoCapturSourcess.size() + imageSourcess.size() : FLAGS_ni;
@@ -802,6 +819,8 @@ int main(int argc, char* argv[]) {
                         nireq,
                         isVideo,
                         nclassifiersireq, nrecognizersireq};
+        // initilize the inputting frames count
+        context.totalFrameCount = totalFrameCount;
         // Create a worker after a context because the context has only weak_ptr<Worker>, but the worker is going to
         // indirectly store ReborningVideoFrames which have a reference to the context. So there won't be a situation
         // when the context is destroyed and the worker still lives with its ReborningVideoFrames referring to the

demos/tests/correctness_cases.py

@@ -29,21 +29,52 @@ def __init__(self, demo):
     def __call__(self, output, test_case, device, execution_time=-1):
         pass
 
+    def compare_roi(self, source_roi, dest_roi):
+        source = []
+        dest = []
+        if len(source_roi) != len(dest_roi):
+            print (source)
+            print (dest)
+            return False
+        for item in source_roi:
+            source.append(float(item))
+
+        for item in dest_roi:
+            dest.append(float(item))
+        flag = True
+        prob_gap = 0.01
+        pos_gap = 5
+        for index in range(len(source)):
+            if index <= 1:
+                if abs(source[index] - dest[index]) > prob_gap:
+                    flag = False
+                    print (source)
+                    print (dest)
+                    break
+            else:
+                if abs(source[index] - dest[index]) > pos_gap:
+                    flag = False
+                    print (source)
+                    print (dest)
+                    break
+        return flag
+
     def check_difference(self):
         flag = True
-        devices_list = {"AUTO:GPU,CPU" : ["CPU", "GPU"],
+        devices_list = {
+                        #"AUTO:GPU,CPU" : ["CPU", "GPU"],
                         "AUTO:CPU" : ["CPU"],
-                        "AUTO:GPU" : ["GPU"],
-                        "MULTI:GPU,CPU" : ["CPU", "GPU"]}
+                        #"AUTO:GPU" : ["GPU"],
+                        "MULTI:CPU,GPU" : ["CPU", "GPU"]}
         err_msg = ''
+        multi_correctness = {'CPU': True, 'GPU': True}
         for device in devices_list:
             for target in devices_list[device]:
                 if device not in self.results or target not in self.results:
-                    flag = False
-                    err_msg += "\tMiss the results of device {} or device {}.\n".format(device, target)
+                        flag = False
+                        err_msg += "\tMiss the results of device {} or device {}.\n".format(device, target)
                 if device in self.results and target in self.results:
                     if self.results[device] != self.results[target]:
-                        flag = False
                         err_msg += "\tInconsistent results between device {} and {} \n".format(device, target)
                         # Show the detailed inconsistent results
                         for case in self.results[target]:
@@ -59,10 +90,25 @@ def check_difference(self):
                                     for frame in self.results[target][case][channel]:
                                         if channel not in self.results[device][case] or (channel in self.results[device][case] and frame not in self.results[device][case][channel]):
                                             err_msg += ("\t\t\t[Not Found on {}]Channel {} - Frame {} : {}\n".format(device, channel, frame, self.results[target][case][channel][frame]))
-                                        elif self.results[device][case][channel][frame] != self.results[target][case][channel][frame]:
-                                            err_msg += ("\t\t\tInconsist result:\n\t\t\t\t[{}] Channel {} - Frame {} : {}\n".format(target, channel, frame, self.results[target][case][channel][frame]))
-                                            err_msg += ("\t\t\t\t[{}] Channel {} - Frame {} : {}\n".format(device, channel, frame, self.results[device][case][channel][frame]))
+                                        else:
+                                            for obj in self.results[target][case][channel][frame]:
+                                                if obj not in self.results[device][case][channel][frame]:
+                                                    flag = False
+                                                    err_msg += ("\t\t\t[Not Found on {}]Channel {} - Frame {} : {}\n".format(device, channel, frame, self.results[target][case][channel][frame]))
+                                                elif not self.compare_roi(self.results[device][case][channel][frame][obj],self.results[target][case][channel][frame][obj]):
+                                                    if device != 'MULTI:CPU,GPU':
+                                                        flag = False
+                                                    else:
+                                                        multi_correctness[target] = False
+                                                    err_msg += ("\t\t\tInconsist result:\n\t\t\t\t[{}] Channel {} - Frame {} : {}\n".format(target, channel, frame, self.results[target][case][channel][frame]))
+                                                    err_msg += ("\t\t\t\t[{}] Channel {} - Frame {} : {}\n".format(device, channel, frame, self.results[device][case][channel][frame]))
                                 err_msg += ('\t\t---------------------------------------------------------\n')
+        # Check correctness for MULTI device
+        for device in devices_list:
+            if 'MULTI:' not in device:
+                continue
+            if multi_correctness['CPU'] == False and multi_correctness['GPU'] == False:
+                flag = False
         if not flag:
             print("Correctness checking: Failure\n{}".format(err_msg))
         return flag
@@ -137,6 +183,6 @@ def __call__(self, output, test_case, device, execution_time=0):
 
 DEMOS = [
     deepcopy(BASE['security_barrier_camera_demo/cpp'])
-    .update_option({'-r': None, '-n_iqs': '1'})
+    .update_option({'-r': None,'-ni': '16', '-n_iqs': '1', '-i': '/home/wy/data_for_security_barrier_camera_demo/images_10/output.mp4'})
     .add_parser(DemoSecurityBarrierCamera)
 ]