completed thesisHEADmaster

1 files changed, 114 insertions, 0 deletions

diff --git a/python/openvino/runtime/common/demo_utils/src/performance_metrics.cpp b/python/openvino/runtime/common/demo_utils/src/performance_metrics.cpp
new file mode 100644
index 0000000..d1e494e
--- /dev/null
+++ b/python/openvino/runtime/common/demo_utils/src/performance_metrics.cpp
@@ -0,0 +1,114 @@
+// Copyright (C) 2020 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include <limits>
+#include "utils/performance_metrics.hpp"
+#include "utils/slog.hpp"
+
+// timeWindow defines the length of the timespan over which the 'current fps' value is calculated
+PerformanceMetrics::PerformanceMetrics(Duration timeWindow)
+    : timeWindowSize(timeWindow)
+    , firstFrameProcessed(false)
+{}
+
+void PerformanceMetrics::update(TimePoint lastRequestStartTime,
+    const cv::Mat& frame,
+    cv::Point position,
+    int fontFace,
+    double fontScale,
+    cv::Scalar color,
+    int thickness,
+    MetricTypes metricType) {
+    update(lastRequestStartTime);
+    paintMetrics(frame, position, fontFace, fontScale, color, thickness, metricType);
+}
+
+void PerformanceMetrics::update(TimePoint lastRequestStartTime) {
+    TimePoint currentTime = Clock::now();
+
+    if (!firstFrameProcessed) {
+        lastUpdateTime = lastRequestStartTime;
+        firstFrameProcessed = true;
+    }
+
+    currentMovingStatistic.latency += currentTime - lastRequestStartTime;
+    currentMovingStatistic.period = currentTime - lastUpdateTime;
+    currentMovingStatistic.frameCount++;
+
+    if (currentTime - lastUpdateTime > timeWindowSize) {
+        lastMovingStatistic = currentMovingStatistic;
+        totalStatistic.combine(lastMovingStatistic);
+        currentMovingStatistic = Statistic();
+
+        lastUpdateTime = currentTime;
+    }
+}
+
+void PerformanceMetrics::paintMetrics(const cv::Mat& frame, cv::Point position, int fontFace,
+    double fontScale, cv::Scalar color, int thickness, MetricTypes metricType) const {
+    // Draw performance stats over frame
+    Metrics metrics = getLast();
+
+    std::ostringstream out;
+    if (!std::isnan(metrics.latency) &&
+        (metricType == PerformanceMetrics::MetricTypes::LATENCY || metricType == PerformanceMetrics::MetricTypes::ALL)) {
+        out << "Latency: " << std::fixed << std::setprecision(1) << metrics.latency << " ms";
+        putHighlightedText(frame, out.str(), position, fontFace, fontScale, color, thickness);
+    }
+    if (!std::isnan(metrics.fps) &&
+        (metricType == PerformanceMetrics::MetricTypes::FPS || metricType == PerformanceMetrics::MetricTypes::ALL)) {
+        out.str("");
+        out << "FPS: " << std::fixed << std::setprecision(1) << metrics.fps;
+        int offset = metricType == PerformanceMetrics::MetricTypes::ALL ? 30 : 0;
+        putHighlightedText(frame, out.str(), {position.x, position.y + offset}, fontFace, fontScale, color, thickness);
+    }
+}
+
+PerformanceMetrics::Metrics PerformanceMetrics::getLast() const {
+    Metrics metrics;
+
+    metrics.latency = lastMovingStatistic.frameCount != 0
+                      ? std::chrono::duration_cast<Ms>(lastMovingStatistic.latency).count()
+                        / lastMovingStatistic.frameCount
+                      : std::numeric_limits<double>::signaling_NaN();
+    metrics.fps = lastMovingStatistic.period != Duration::zero()
+                  ? lastMovingStatistic.frameCount
+                    / std::chrono::duration_cast<Sec>(lastMovingStatistic.period).count()
+                  : std::numeric_limits<double>::signaling_NaN();
+
+    return metrics;
+}
+
+PerformanceMetrics::Metrics PerformanceMetrics::getTotal() const {
+    Metrics metrics;
+
+    int frameCount = totalStatistic.frameCount + currentMovingStatistic.frameCount;
+    if (frameCount != 0) {
+        metrics.latency = std::chrono::duration_cast<Ms>(
+            totalStatistic.latency + currentMovingStatistic.latency).count() / frameCount;
+        metrics.fps = frameCount / std::chrono::duration_cast<Sec>(
+                                       totalStatistic.period + currentMovingStatistic.period).count();
+    } else {
+        metrics.latency = std::numeric_limits<double>::signaling_NaN();
+        metrics.fps = std::numeric_limits<double>::signaling_NaN();
+    }
+
+    return metrics;
+}
+
+void PerformanceMetrics::logTotal() const {
+    Metrics metrics = getTotal();
+
+    slog::info << "\tLatency: " << std::fixed << std::setprecision(1) << metrics.latency << " ms" << slog::endl;
+    slog::info << "\tFPS: " << metrics.fps << slog::endl;
+}
+
+void logLatencyPerStage(double readLat, double preprocLat, double inferLat, double postprocLat, double renderLat) {
+    slog::info << "\tDecoding:\t" << std::fixed << std::setprecision(1) <<
+        readLat << " ms" << slog::endl;
+    slog::info << "\tPreprocessing:\t" << preprocLat << " ms" << slog::endl;
+    slog::info << "\tInference:\t" << inferLat << " ms" << slog::endl;
+    slog::info << "\tPostprocessing:\t" << postprocLat << " ms" << slog::endl;
+    slog::info << "\tRendering:\t" << renderLat << " ms" << slog::endl;
+}