Remove trailing whitespace

Author: Roman Donchenko

ci/update-requirements.py

@@ -65,7 +65,7 @@ def pc(target, *sources):
     pc('ci/requirements-ac.txt',
         'tools/accuracy_checker/requirements-core.in', 'tools/accuracy_checker/requirements.in')
     pc('ci/requirements-ac-test.txt',
-        'tools/accuracy_checker/requirements.in', 'tools/accuracy_checker/requirements-test.in', 
+        'tools/accuracy_checker/requirements.in', 'tools/accuracy_checker/requirements-test.in',
         'tools/accuracy_checker/requirements-core.in')
     pc('ci/requirements-conversion.txt',
         'tools/downloader/requirements-pytorch.in', 'tools/downloader/requirements-caffe2.in',

demos/classification_demo/grid_mat.hpp

@@ -51,7 +51,7 @@ class GridMat {
         outImg.create((cellSize.height * size.height) + presenter.graphSize.height,
                        cellSize.width * size.width, CV_8UC3);
         outImg.setTo(0);
-        
+
         textSize = cv::getTextSize("", fontType, fontScale, thickness, &baseline);
         accuracyMessageSize = cv::getTextSize("Accuracy (top 0): 0.000", fontType, fontScale, thickness, &baseline);
         testMessageSize = cv::getTextSize(testMessage, fontType, fontScale, thickness, &baseline);
@@ -65,7 +65,7 @@ class GridMat {
                   cv::Scalar(0, 0, 0), cv::FILLED);
 
         presenter.drawGraphs(outImg);
-        
+
         cv::Scalar textColor = cv::Scalar(255, 255, 255);
         int textPadding = 10;
 
@@ -77,7 +77,7 @@ class GridMat {
                     cv::format("Latency: %dms", static_cast<int>(avgLatency * 1000)),
                     cv::Point(textPadding, (textSize.height + textPadding) * 2),
                     fontType, fontScale, textColor, thickness);
-        
+
         if (showAccuracy) {
             cv::putText(outImg,
                         cv::format("Accuracy (top %d): %.3f", FLAGS_nt, accuracy),
@@ -131,13 +131,13 @@ class GridMat {
                         imageInfo.label,
                         cv::Point(labelThickness, cellSize.height - labelThickness - labelTextSize.height),
                         fontType, labelFontScale, textColor, 2);
-            
+
             prevImgs.push(frame);
 
-            cv::Mat cell = outImg(cv::Rect(points[currSourceId], cellSize));                                         
-            frame.copyTo(cell);                                                                                      
+            cv::Mat cell = outImg(cv::Rect(points[currSourceId], cellSize));
+            frame.copyTo(cell);
             cv::rectangle(cell, {0, 0}, {frame.cols, frame.rows}, {255, 50, 50}, labelThickness); // draw a border
-            
+
             if (currSourceId == points.size() - 1) {
                 currSourceId = 0;
             } else {

demos/classification_demo/main.cpp

@@ -86,7 +86,7 @@ std::vector<std::vector<unsigned>> topResults(Blob& inputBlob, unsigned numTop)
     TBlob<float>& tblob = dynamic_cast<TBlob<float>&>(inputBlob);
     size_t batchSize =  tblob.getTensorDesc().getDims()[0];
     numTop = static_cast<unsigned>(std::min<size_t>(size_t(numTop), tblob.size()));
-    
+
     std::vector<std::vector<unsigned>> output(batchSize);
     for (size_t i = 0; i < batchSize; i++) {
         size_t offset = i * (tblob.size() / batchSize);
@@ -100,7 +100,7 @@ std::vector<std::vector<unsigned>> topResults(Blob& inputBlob, unsigned numTop)
 
         output[i].assign(indices.begin(), indices.begin() + numTop);
     }
-    
+
     return output;
 }
 
@@ -143,7 +143,7 @@ int main(int argc, char *argv[]) {
             std::map<std::string, unsigned> classIndicesMap;
             std::ifstream inputGtFile(FLAGS_gt);
             if (!inputGtFile.is_open()) throw std::runtime_error("Can't open the ground truth file.");
-            
+
             std::string line;
             while (std::getline(inputGtFile, line))
             {
@@ -218,7 +218,7 @@ int main(int argc, char *argv[]) {
         }
         if (inputShape[2] != inputShape[3]) {
             throw std::logic_error("Model input has incorrect image shape. Must be NxN square."
-                                   " Got " + std::to_string(inputShape[2]) + 
+                                   " Got " + std::to_string(inputShape[2]) +
                                    "x" + std::to_string(inputShape[3]) + ".");
         }
         int modelInputResolution = inputShape[2];
@@ -324,12 +324,12 @@ int main(int argc, char *argv[]) {
             inferRequests.push_back(executableNetwork.CreateInferRequest());
         }
         // ---------------------------------------------------------------------------------------------------
-        
+
         // ----------------------------------------Create output info-----------------------------------------
         Presenter presenter(FLAGS_u, 0);
         int width;
         int height;
-        std::vector<std::string> gridMatRowsCols = split(FLAGS_res, 'x');        
+        std::vector<std::string> gridMatRowsCols = split(FLAGS_res, 'x');
         if (gridMatRowsCols.size() != 2) {
             throw std::runtime_error("The value of GridMat resolution flag is not valid.");
         } else {
@@ -338,7 +338,7 @@ int main(int argc, char *argv[]) {
         }
         GridMat gridMat(presenter, cv::Size(width, height));
         // ---------------------------------------------------------------------------------------------------
-        
+
         // -----------------------------Prepare variables and data for main loop------------------------------
         typedef std::chrono::duration<double, std::chrono::seconds::period> Sec;
         double avgFPS = 0;
@@ -353,7 +353,7 @@ int main(int argc, char *argv[]) {
         std::condition_variable condVar;
         std::mutex mutex;
         std::exception_ptr irCallbackException;
-        
+
         std::queue<InferRequestInfo> emptyInferRequests;
         std::queue<InferRequestInfo> completedInferRequests;
         for (std::size_t i = 0; i < inferRequests.size(); i++) {
@@ -363,7 +363,7 @@ int main(int argc, char *argv[]) {
         auto startTime = std::chrono::steady_clock::now();
         auto elapsedSeconds = std::chrono::steady_clock::duration{0};
         // ---------------------------------------------------------------------------------------------------
-        
+
         // -------------------------------------Processing infer requests-------------------------------------
         int framesNumOnCalculationStart = 0;
         auto testDuration = std::chrono::seconds{3};
@@ -396,7 +396,7 @@ int main(int argc, char *argv[]) {
                 }
             }
             if (completedInferRequestInfo) {
-                emptyInferRequests.push({completedInferRequestInfo->inferRequest, 
+                emptyInferRequests.push({completedInferRequestInfo->inferRequest,
                                          std::vector<InferRequestInfo::InferRequestImage>()});
 
                 std::vector<unsigned> correctClasses = {};
@@ -433,7 +433,7 @@ int main(int argc, char *argv[]) {
                 }
 
                 framesNum += FLAGS_b;
-                
+
                 avgFPS = framesNum / std::chrono::duration_cast<Sec>(
                     std::chrono::steady_clock::now() - startTime).count();
                 gridMat.updateMat(shownImagesInfo);
@@ -444,7 +444,7 @@ int main(int argc, char *argv[]) {
                 avgLatency = std::chrono::duration_cast<Sec>(latencySum).count() / framesNum;
                 accuracy = static_cast<double>(correctPredictionsCount) / framesNum;
                 gridMat.textUpdate(avgFPS, avgLatency, accuracy, isTestMode, !FLAGS_gt.empty(), presenter);
-                
+
                 if (!FLAGS_no_show) {
                     cv::imshow("classification_demo", gridMat.outImg);
                     key = static_cast<char>(cv::waitKey(1));
@@ -474,7 +474,7 @@ int main(int argc, char *argv[]) {
                                                       &irCallbackException] {
                         {
                             std::lock_guard<std::mutex> callbackLock(mutex);
-                        
+
                             try {
                                 completedInferRequests.push(emptyInferRequest);
                             }
@@ -486,7 +486,7 @@ int main(int argc, char *argv[]) {
                         }
                         condVar.notify_one();
                     });
-                    
+
                     auto inputBlob = emptyInferRequest.inferRequest.GetBlob(inputBlobName);
                     for (unsigned i = 0; i < FLAGS_b; i++) {
                         matU8ToBlob<uint8_t>(emptyInferRequest.images[i].mat, inputBlob, i);
@@ -515,7 +515,7 @@ int main(int argc, char *argv[]) {
         }
         std::cout << presenter.reportMeans() << std::endl;
         // ---------------------------------------------------------------------------------------------------
-        
+
         // ------------------------------------Wait for all infer requests------------------------------------
         for (InferRequest& inferRequest : inferRequests)
             inferRequest.Wait(IInferRequest::WaitMode::RESULT_READY);

demos/common/src/performance_metrics.cpp

@@ -25,7 +25,7 @@ void PerformanceMetrics::update(TimePoint lastRequestStartTime,
         firstFrameProcessed = true;
         return;
     }
-    
+
     currentMovingStatistic.latency += currentTime - lastRequestStartTime;
     currentMovingStatistic.period = currentTime - lastUpdateTime;
     currentMovingStatistic.frameCount++;
@@ -40,7 +40,7 @@ void PerformanceMetrics::update(TimePoint lastRequestStartTime,
 
     // Draw performance stats over frame
     Metrics metrics = getLast();
-    
+
     std::ostringstream out;
     if (!std::isnan(metrics.latency)) {
         out << "Latency: " << std::fixed << std::setprecision(1) << metrics.latency << " ms";
@@ -65,7 +65,7 @@ PerformanceMetrics::Metrics PerformanceMetrics::getLast() const {
                   ? lastMovingStatistic.frameCount
                     / std::chrono::duration_cast<Sec>(lastMovingStatistic.period).count()
                   : std::numeric_limits<double>::signaling_NaN();
-    
+
     return metrics;
 }
 

demos/crossroad_camera_demo/README.md

@@ -89,7 +89,7 @@ If Person Attributes Recognition or Person Reidentification Retail are enabled,
 	* **Person Attributes Recognition time** - Inference time of Person Attributes Recognition averaged by the number of detected persons.
 	* **Person Reidentification time** - Inference time of Person Reidentification averaged by the number of detected persons.
 
-> **NOTE**: On VPU devices (Intel® Movidius™ Neural Compute Stick, Intel® Neural Compute Stick 2, and Intel® Vision Accelerator Design with Intel® Movidius™ VPUs) this demo has been tested on the following Model Downloader available topologies: 
+> **NOTE**: On VPU devices (Intel® Movidius™ Neural Compute Stick, Intel® Neural Compute Stick 2, and Intel® Vision Accelerator Design with Intel® Movidius™ VPUs) this demo has been tested on the following Model Downloader available topologies:
 > * `person-attributes-recognition-crossroad-0230`
 > * `person-reidentification-retail-0031`
 > * `person-vehicle-bike-detection-crossroad-0078`

demos/gaze_estimation_demo/CMakeLists.txt

@@ -10,4 +10,4 @@ ie_add_sample(NAME gaze_estimation_demo
               HEADERS ${HEADERS}
               INCLUDE_DIRECTORIES "${CMAKE_CURRENT_SOURCE_DIR}/include"
               DEPENDENCIES monitors
-              OPENCV_DEPENDENCIES highgui)        
+              OPENCV_DEPENDENCIES highgui)

demos/gaze_estimation_demo/README.md

@@ -7,7 +7,7 @@ The demo also relies on the following auxiliary networks:
 * `face-detection-retail-0004` or `face-detection-adas-0001` detection networks for finding faces
 * `head-pose-estimation-adas-0001`, which estimates head pose in Tait-Bryan angles, serving as an input for gaze estimation model
 * `facial-landmarks-35-adas-0002`, which estimates coordinates of facial landmarks for detected faces. The keypoints at the corners of eyes are used to locate eyes regions required for the gaze estimation model
-* `open-closed-eye-0001`, which estimates eyes state of detected faces.  
+* `open-closed-eye-0001`, which estimates eyes state of detected faces.
 
 For more information about the pre-trained models, refer to the [model documentation](../../models/intel/index.md).
 
@@ -72,7 +72,7 @@ For example, to do inference on a CPU, run the following command:
 
 ## Demo Output
 
-The demo uses OpenCV to display the resulting frame with marked gaze vectors, text reports of **FPS** (frames per second performance) for the demo, and, optionally, marked facial landmarks, head pose angles, and face bounding boxes. 
+The demo uses OpenCV to display the resulting frame with marked gaze vectors, text reports of **FPS** (frames per second performance) for the demo, and, optionally, marked facial landmarks, head pose angles, and face bounding boxes.
 By default, it shows only gaze estimation results. To see inference results of auxiliary networks, use run-time control keys.
 
 ### Run-Time Control Keys
@@ -82,14 +82,14 @@ The following keys are supported:
 * G - to toggle displaying gaze vector
 * B - to toggle displaying face detector bounding boxes
 * O - to toggle displaying head pose information
-* L - to toggle displaying facial landmarks 
+* L - to toggle displaying facial landmarks
 * E - to toggle displaying eyes state
 * A - to switch on displaying all inference results
 * N - to switch off displaying all inference results
 * F - to flip frames horizontally
 * Esc - to quit the demo
 
-> **NOTE**: On VPU devices (Intel® Movidius™ Neural Compute Stick, Intel® Neural Compute Stick 2, and Intel® Vision Accelerator Design with Intel® Movidius™ VPUs) this demo has been tested on the following Model Downloader available topologies: 
+> **NOTE**: On VPU devices (Intel® Movidius™ Neural Compute Stick, Intel® Neural Compute Stick 2, and Intel® Vision Accelerator Design with Intel® Movidius™ VPUs) this demo has been tested on the following Model Downloader available topologies:
 >* `face-detection-adas-0001`
 >* `face-detection-retail-0004`
 >* `facial-landmarks-35-adas-0002`

demos/gaze_estimation_demo/include/gaze_estimator.hpp

@@ -28,7 +28,7 @@ class GazeEstimator: public BaseEstimator {
     IEWrapper ieWrapper;
     std::string outputBlobName;
     bool rollAlign;
-   
+
     void rotateImageAroundCenter(const cv::Mat& srcImage, cv::Mat& dstImage, float angle) const;
 };
 }  // namespace gaze_estimation

demos/gaze_estimation_demo/src/ie_wrapper.cpp

@@ -99,7 +99,7 @@ void IEWrapper::getOutputBlob(const std::string& blobName,
     for (auto dim : blobDims) {
         dataSize *= dim;
     }
-    
+
     LockedMemory<const void> blobMapped = as<MemoryBlob>(request.GetBlob(blobName))->rmap();
     auto buffer = blobMapped.as<float *>();
 

demos/human_pose_estimation_demo/README.md

@@ -56,7 +56,7 @@ For example, to do inference on a CPU, run the following command:
 ## Demo Output
 
 The demo uses OpenCV to display the resulting frame with estimated poses and text report of **FPS** - frames per second performance for the human pose estimation demo.
-> **NOTE**: On VPU devices (Intel® Movidius™ Neural Compute Stick, Intel® Neural Compute Stick 2, and Intel® Vision Accelerator Design with Intel® Movidius™ VPUs) this demo has been tested on the following Model Downloader available topologies: 
+> **NOTE**: On VPU devices (Intel® Movidius™ Neural Compute Stick, Intel® Neural Compute Stick 2, and Intel® Vision Accelerator Design with Intel® Movidius™ VPUs) this demo has been tested on the following Model Downloader available topologies:
 >* `human-pose-estimation-0001`
 > Other models may produce unexpected results on these devices.
 

demos/interactive_face_detection_demo/README.md

@@ -101,7 +101,7 @@ For example, to do inference on a GPU with the OpenVINO™ toolkit pre-train
 The demo uses OpenCV to display the resulting frame with detections (rendered as bounding boxes and labels, if provided).
 The demo reports total image throughput which includes frame decoding time, inference time, time to render bounding boxes and labels, and time to display the results.
 
-> **NOTE**: On VPU devices (Intel® Movidius™ Neural Compute Stick, Intel® Neural Compute Stick 2, and Intel® Vision Accelerator Design with Intel® Movidius™ VPUs) this demo has been tested on the following Model Downloader available topologies: 
+> **NOTE**: On VPU devices (Intel® Movidius™ Neural Compute Stick, Intel® Neural Compute Stick 2, and Intel® Vision Accelerator Design with Intel® Movidius™ VPUs) this demo has been tested on the following Model Downloader available topologies:
 >* `age-gender-recognition-retail-0013`
 >* `emotions-recognition-retail-0003`
 >* `face-detection-adas-0001`

demos/multi_channel/object_detection_demo_yolov3/README.md

@@ -3,7 +3,7 @@
 This demo provides an inference pipeline for multi-channel yolo v3. The demo uses Yolo v3 Object Detection network. You can follow [this](https://docs.openvinotoolkit.org/latest/_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_YOLO_From_Tensorflow.html) page convert the YOLO V3 and tiny YOLO V3 into IR model and execute this demo with converted IR model.
 
 > **NOTES**:
-> If you don't use [this](https://docs.openvinotoolkit.org/latest/_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_YOLO_From_Tensorflow.html) page to convert the model, it may not work. 
+> If you don't use [this](https://docs.openvinotoolkit.org/latest/_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_YOLO_From_Tensorflow.html) page to convert the model, it may not work.
 
 Other demo objectives are:
 
@@ -49,7 +49,7 @@ Options:
     -u                           Optional. List of monitors to show initially.
 ```
 
-To run the demo, you can use public pre-train model and follow [this](https://docs.openvinotoolkit.org/latest/_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_YOLO_From_Tensorflow.html) page for instruction of how to convert it to IR model. 
+To run the demo, you can use public pre-train model and follow [this](https://docs.openvinotoolkit.org/latest/_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_YOLO_From_Tensorflow.html) page for instruction of how to convert it to IR model.
 
 > **NOTE**: Before running the demo with a trained model, make sure the model is converted to the Inference Engine format (\*.xml + \*.bin) using the [Model Optimizer tool](https://docs.openvinotoolkit.org/latest/_docs_MO_DG_Deep_Learning_Model_Optimizer_DevGuide.html).
 
@@ -67,7 +67,7 @@ Video files will be processed repeatedly.
 To achieve 100% utilization of one Myriad X, the thumb rule is to run 4 infer requests on each Myriad X. Option `-nireq 32` can be added to above command to use 100% of HDDL-R card. The 32 here is 8 (Myriad X on HDDL-R card) x 4 (infer requests), such as following command:
 
 ```sh
-./multi_channel_object_detection_demo_yolov3 -m $PATH_OF_YOLO_V3_MODEL -d HDDL 
+./multi_channel_object_detection_demo_yolov3 -m $PATH_OF_YOLO_V3_MODEL -d HDDL
 -i /path/to/file1 /path/to/file2 /path/to/file3 /path/to/file4 -nireq 32
 ```