Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Fix code style for cpp model api demos #3435

Merged
merged 6 commits into from
Apr 1, 2022
Merged

Fix code style for cpp model api demos #3435

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
6 commits
Select commit Hold shift + click to select a range
1355b8e
fix code style for model api demos
ivikhrev Mar 31, 2022
1e28cb9
upd pedestrian trakcer demo
ivikhrev Mar 31, 2022
0d99138
cmath include ordering
ivikhrev Mar 31, 2022
587a203
rename src for jpeg_restoration_model; fix includes
ivikhrev Mar 31, 2022
8b04078
Apply suggestions from code review
ivikhrev Mar 31, 2022
fce7ed3
remove remaining comments
ivikhrev Mar 31, 2022
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
78 changes: 46 additions & 32 deletions demos/classification_benchmark_demo/cpp/grid_mat.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,24 +1,22 @@
// Copyright (C) 2018-2019 Intel Corporation
// Copyright (C) 2018-2022 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//

#pragma once

#include <algorithm>
#include <queue>
#include <set>
#include <string>
#include <vector>
#include <queue>

#include <opencv2/core.hpp>
#include <opencv2/imgproc.hpp>

#include <monitors/presenter.h>
#include <utils/ocv_common.hpp>

#include <opencv2/imgproc.hpp>
#include <opencv2/core.hpp>

enum class PredictionResult { Correct,
Incorrect,
Unknown };
enum class PredictionResult { Correct, Incorrect, Unknown };

class GridMat {
public:
Expand All @@ -27,9 +25,8 @@ class GridMat {
explicit GridMat(Presenter& presenter,
const cv::Size maxDisp = cv::Size{1920, 1080},
const cv::Size aspectRatio = cv::Size{16, 9},
double targetFPS = 60
):
currSourceId{0} {
double targetFPS = 60)
: currSourceId{0} {
cv::Size size(static_cast<int>(std::round(sqrt(1. * targetFPS * aspectRatio.width / aspectRatio.height))),
static_cast<int>(std::round(sqrt(1. * targetFPS * aspectRatio.height / aspectRatio.width))));
if (size.width == 0 || size.height == 0) {
Expand All @@ -45,12 +42,13 @@ class GridMat {
}

outImg.create((cellSize.height * size.height) + presenter.graphSize.height,
cellSize.width * size.width, CV_8UC3);
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);
testMessageSize = cv::getTextSize(GridMat::testMessage, fontType, fontScale, thickness, &baseline);
}

void textUpdate(PerformanceMetrics& metrics,
Expand All @@ -60,28 +58,37 @@ class GridMat {
bool isFpsTest,
bool showAccuracy,
Presenter& presenter) {
rectangle(outImg,
{0, 0}, {outImg.cols, presenter.graphSize.height},
cv::Scalar(0, 0, 0), cv::FILLED);
rectangle(outImg, {0, 0}, {outImg.cols, presenter.graphSize.height}, cv::Scalar(0, 0, 0), cv::FILLED);

presenter.drawGraphs(outImg);

metrics.update(lastRequestStartTime, outImg, cv::Point(textPadding, textSize.height + textPadding),
fontType, fontScale, cv::Scalar(255, 100, 100), thickness);
metrics.update(lastRequestStartTime,
outImg,
cv::Point(textPadding, textSize.height + textPadding),
fontType,
fontScale,
cv::Scalar(255, 100, 100),
thickness);

if (showAccuracy) {
cv::putText(outImg,
cv::format("Accuracy (top %d): %.3f", nTop, accuracy),
cv::Point(outImg.cols - accuracyMessageSize.width - textPadding, textSize.height + textPadding),
fontType, fontScale, cv::Scalar(255, 255, 255), thickness);
fontType,
fontScale,
cv::Scalar(255, 255, 255),
thickness);
}

if (isFpsTest) {
cv::putText(outImg,
testMessage,
cv::Point(outImg.cols - testMessageSize.width - textPadding,
(textSize.height + textPadding) * 2),
fontType, fontScale, cv::Scalar(50, 50, 255), thickness);
cv::putText(
outImg,
GridMat::testMessage,
cv::Point(outImg.cols - testMessageSize.width - textPadding, (textSize.height + textPadding) * 2),
fontType,
fontScale,
cv::Scalar(50, 50, 255),
thickness);
}
}

Expand All @@ -94,21 +101,28 @@ class GridMat {
cv::Scalar textColor;
switch (predictionResul) {
case PredictionResult::Correct:
textColor = cv::Scalar(75, 255, 75); break; // green
textColor = cv::Scalar(75, 255, 75); // green
break;
case PredictionResult::Incorrect:
textColor = cv::Scalar(50, 50, 255); break; // red
textColor = cv::Scalar(50, 50, 255); // red
break;
case PredictionResult::Unknown:
textColor = cv::Scalar(200, 10, 10); break; // blue
textColor = cv::Scalar(200, 10, 10); // blue
break;
default:
throw std::runtime_error("Undefined type of prediction result");
}
int labelThickness = cellSize.width / 20;
cv::Size labelTextSize = cv::getTextSize(label, fontType, 1, 2, &baseline);
double labelFontScale = static_cast<double>(cellSize.width - 2 * labelThickness) / labelTextSize.width;
cv::resize(mat, prevImg, cellSize);
putHighlightedText(prevImg, label,
cv::Point(labelThickness, cellSize.height - labelThickness - labelTextSize.height),
fontType, labelFontScale, textColor, 2);
putHighlightedText(prevImg,
label,
cv::Point(labelThickness, cellSize.height - labelThickness - labelTextSize.height),
fontType,
labelFontScale,
textColor,
2);
cv::Mat cell = outImg(cv::Rect(points[currSourceId], cellSize));
prevImg.copyTo(cell);
cv::rectangle(cell, {0, 0}, {cell.cols, cell.rows}, {255, 50, 50}, labelThickness); // draw a border
Expand All @@ -129,11 +143,11 @@ class GridMat {
static constexpr double fontScale = 1.5;
static const int thickness = 2;
static const int textPadding = 10;
static const std::string testMessage;
static constexpr const char testMessage[] = "Testing, please wait...";
int baseline;
cv::Size textSize;
cv::Size accuracyMessageSize;
cv::Size testMessageSize;
};

const std::string GridMat::testMessage = "Testing, please wait...";
constexpr const char GridMat::testMessage[];
89 changes: 57 additions & 32 deletions demos/classification_benchmark_demo/cpp/main.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -2,25 +2,38 @@
// SPDX-License-Identifier: Apache-2.0
//

#include <stddef.h>

#include <algorithm>
#include <chrono>
#include <exception>
#include <fstream>
#include <iostream>
#include <limits>
#include <map>
#include <memory>
#include <ratio>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>

#include <gflags/gflags.h>
#include <opencv2/opencv.hpp>
#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <opencv2/imgcodecs.hpp>
#include <openvino/openvino.hpp>

#include <models/classification_model.h>
#include <models/input_data.h>
#include <models/model_base.h>
#include <models/results.h>
#include <monitors/presenter.h>
#include <pipelines/async_pipeline.h>
#include <pipelines/metadata.h>

#include <utils/args_helper.hpp>
#include <utils/common.hpp>
#include <utils/ocv_common.hpp>
#include <utils/config_factory.h>
#include <utils/performance_metrics.hpp>
#include <utils/slog.hpp>

Expand Down Expand Up @@ -88,7 +101,7 @@ static void showUsage() {
std::cout << " -u " << utilization_monitors_message << std::endl;
}

bool ParseAndCheckCommandLine(int argc, char *argv[]) {
bool ParseAndCheckCommandLine(int argc, char* argv[]) {
// ---------------------------Parsing and validation of input args--------------------------------------
gflags::ParseCommandLineNonHelpFlags(&argc, &argv, true);
if (FLAGS_h) {
Expand Down Expand Up @@ -119,7 +132,7 @@ cv::Mat centerSquareCrop(const cv::Mat& image) {
return image(cv::Rect(0, (image.rows - image.cols) / 2, image.cols, image.cols));
}

int main(int argc, char *argv[]) {
int main(int argc, char* argv[]) {
try {
PerformanceMetrics metrics, readerMetrics, renderMetrics;

Expand All @@ -132,7 +145,8 @@ int main(int argc, char *argv[]) {
std::vector<std::string> imageNames;
std::vector<cv::Mat> inputImages;
parseInputFilesArguments(imageNames);
if (imageNames.empty()) throw std::runtime_error("No images provided");
if (imageNames.empty())
throw std::runtime_error("No images provided");
std::sort(imageNames.begin(), imageNames.end());
for (size_t i = 0; i < imageNames.size(); i++) {
const std::string& name = imageNames[i];
Expand Down Expand Up @@ -194,18 +208,20 @@ int main(int argc, char *argv[]) {

//------------------------------ Running routines ----------------------------------------------
std::vector<std::string> labels = ClassificationModel::loadLabels(FLAGS_labels);
for (const auto & classIndex : classIndices) {
for (const auto& classIndex : classIndices) {
if (classIndex >= labels.size()) {
throw std::runtime_error("Class index " + std::to_string(classIndex)
+ " is outside the range supported by the model.");
}
throw std::runtime_error("Class index " + std::to_string(classIndex) +
" is outside the range supported by the model.");
}
}

slog::info << ov::get_openvino_version() << slog::endl;
ov::Core core;

AsyncPipeline pipeline(std::unique_ptr<ModelBase>(new ClassificationModel(FLAGS_m, FLAGS_nt, FLAGS_auto_resize, labels, FLAGS_layout)),
ConfigFactory::getUserConfig(FLAGS_d, FLAGS_nireq, FLAGS_nstreams, FLAGS_nthreads), core);
AsyncPipeline pipeline(std::unique_ptr<ModelBase>(
new ClassificationModel(FLAGS_m, FLAGS_nt, FLAGS_auto_resize, labels, FLAGS_layout)),
ConfigFactory::getUserConfig(FLAGS_d, FLAGS_nireq, FLAGS_nstreams, FLAGS_nthreads),
core);

Presenter presenter(FLAGS_u, 0);
int width;
Expand Down Expand Up @@ -238,9 +254,11 @@ int main(int argc, char *argv[]) {
if (isTestMode && elapsedSeconds >= testDuration) {
isTestMode = false;
typedef std::chrono::duration<double, std::chrono::seconds::period> Sec;
gridMat = GridMat(presenter, cv::Size(width, height), cv::Size(16, 9),
(framesNum - framesNumOnCalculationStart) / std::chrono::duration_cast<Sec>(
fpsCalculationDuration).count());
gridMat = GridMat(presenter,
cv::Size(width, height),
cv::Size(16, 9),
(framesNum - framesNumOnCalculationStart) /
std::chrono::duration_cast<Sec>(fpsCalculationDuration).count());
metrics = PerformanceMetrics();
startTime = std::chrono::steady_clock::now();
framesNum = 0;
Expand All @@ -252,14 +270,17 @@ int main(int argc, char *argv[]) {
auto imageStartTime = std::chrono::steady_clock::now();

pipeline.submitData(ImageInputData(inputImages[nextImageIndex]),
std::make_shared<ClassificationImageMetaData>(inputImages[nextImageIndex], imageStartTime, classIndices[nextImageIndex]));
std::make_shared<ClassificationImageMetaData>(inputImages[nextImageIndex],
imageStartTime,
classIndices[nextImageIndex]));
nextImageIndex++;
if (nextImageIndex == imageNames.size()) {
nextImageIndex = 0;
}
}

//--- Waiting for free input slot or output data available. Function will return immediately if any of them are available.
//--- Waiting for free input slot or output data available. Function will return immediately if any of them
// are available.
pipeline.waitForData(false);

//--- Checking for results and rendering data if it's ready
Expand All @@ -269,8 +290,8 @@ int main(int argc, char *argv[]) {
if (!classificationResult.metaData) {
throw std::invalid_argument("Renderer: metadata is null");
}
const ClassificationImageMetaData& classificationImageMetaData
= classificationResult.metaData->asRef<const ClassificationImageMetaData>();
const ClassificationImageMetaData& classificationImageMetaData =
classificationResult.metaData->asRef<const ClassificationImageMetaData>();

auto outputImg = classificationImageMetaData.img;

Expand All @@ -295,8 +316,13 @@ int main(int argc, char *argv[]) {
framesNum++;
gridMat.updateMat(outputImg, label, predictionResult);
accuracy = static_cast<double>(correctPredictionsCount) / framesNum;
gridMat.textUpdate(metrics, classificationResult.metaData->asRef<ImageMetaData>().timeStamp, accuracy, FLAGS_nt, isTestMode,
!FLAGS_gt.empty(), presenter);
gridMat.textUpdate(metrics,
classificationResult.metaData->asRef<ImageMetaData>().timeStamp,
accuracy,
FLAGS_nt,
isTestMode,
!FLAGS_gt.empty(),
presenter);
renderMetrics.update(renderingStart);
elapsedSeconds = std::chrono::steady_clock::now() - startTime;
if (!FLAGS_no_show) {
Expand All @@ -305,17 +331,16 @@ int main(int argc, char *argv[]) {
int key = cv::waitKey(1);
if (27 == key || 'q' == key || 'Q' == key) { // Esc
keepRunning = false;
}
else if (32 == key || 'r' == key || 'R' == key) { // press space or r to restart testing if needed
} else if (32 == key || 'r' == key ||
'R' == key) { // press space or r to restart testing if needed
isTestMode = true;
framesNum = 0;
framesNumOnCalculationStart = 0;
correctPredictionsCount = 0;
accuracy = 0;
elapsedSeconds = std::chrono::steady_clock::duration(0);
startTime = std::chrono::steady_clock::now();
}
else {
} else {
presenter.handleKey(key);
}
}
Expand All @@ -328,16 +353,16 @@ int main(int argc, char *argv[]) {

slog::info << "Metrics report:" << slog::endl;
metrics.logTotal();
logLatencyPerStage(readerMetrics.getTotal().latency, pipeline.getPreprocessMetrics().getTotal().latency,
pipeline.getInferenceMetircs().getTotal().latency, pipeline.getPostprocessMetrics().getTotal().latency,
renderMetrics.getTotal().latency);
logLatencyPerStage(readerMetrics.getTotal().latency,
pipeline.getPreprocessMetrics().getTotal().latency,
pipeline.getInferenceMetircs().getTotal().latency,
pipeline.getPostprocessMetrics().getTotal().latency,
renderMetrics.getTotal().latency);
slog::info << presenter.reportMeans() << slog::endl;
}
catch (const std::exception& error) {
} catch (const std::exception& error) {
slog::err << error.what() << slog::endl;
return 1;
}
catch (...) {
} catch (...) {
slog::err << "Unknown/internal exception happened." << slog::endl;
return 1;
}
Expand Down
Loading