Клименко Владислав. Технология OMP. Повышение контраста полутонового изображения посредством линейной растяжки гистограммы. Вариант 28

.pre-commit-config.yaml

@@ -56,7 +56,7 @@ repos:
       - id: pretty-format-json
         files: \.json$
         exclude: ^(3rdparty/|build.*/|install/)
-        args: [--autofix, --indent=2]
+        args: [--autofix, --indent=2, --no-ensure-ascii]
 
   # Shell script linting with shellcheck (no docker dependency)
   - repo: https://github.com/shellcheck-py/shellcheck-py

tasks/klimenko_v_lsh_contrast_incr_omp/common/include/common.hpp

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <vector>
+
+#include "task/include/task.hpp"
+
+namespace klimenko_v_lsh_contrast_incr_omp {
+
+using InType = std::vector<int>;
+using OutType = std::vector<int>;
+using TestType = int;
+using BaseTask = ppc::task::Task<InType, OutType>;
+
+}  // namespace klimenko_v_lsh_contrast_incr_omp

tasks/klimenko_v_lsh_contrast_incr_omp/info.json

@@ -0,0 +1,9 @@
+{
+  "student": {
+    "first_name": "Владислав",
+    "group_number": "3823Б1ПР2",
+    "last_name": "Клименко",
+    "middle_name": "Сергеевич",
+    "task_number": "2"
+  }
+}

tasks/klimenko_v_lsh_contrast_incr_omp/omp/include/ops_omp.hpp

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "klimenko_v_lsh_contrast_incr_omp/common/include/common.hpp"
+#include "task/include/task.hpp"
+
+namespace klimenko_v_lsh_contrast_incr_omp {
+
+class KlimenkoVLSHContrastIncrOMP : public BaseTask {
+ public:
+  static constexpr ppc::task::TypeOfTask GetStaticTypeOfTask() {
+    return ppc::task::TypeOfTask::kOMP;
+  }
+  explicit KlimenkoVLSHContrastIncrOMP(const InType &in);
+
+ private:
+  bool ValidationImpl() override;
+  bool PreProcessingImpl() override;
+  bool RunImpl() override;
+  bool PostProcessingImpl() override;
+};
+
+}  // namespace klimenko_v_lsh_contrast_incr_omp

tasks/klimenko_v_lsh_contrast_incr_omp/omp/src/ops_omp.cpp

@@ -0,0 +1,63 @@
+#include "klimenko_v_lsh_contrast_incr_omp/omp/include/ops_omp.hpp"
+
+#include <algorithm>
+#include <cstddef>
+#include <vector>
+
+#include "klimenko_v_lsh_contrast_incr_omp/common/include/common.hpp"
+
+namespace klimenko_v_lsh_contrast_incr_omp {
+
+KlimenkoVLSHContrastIncrOMP::KlimenkoVLSHContrastIncrOMP(const InType &in) {
+  SetTypeOfTask(GetStaticTypeOfTask());
+  GetInput() = in;
+}
+
+bool KlimenkoVLSHContrastIncrOMP::ValidationImpl() {
+  return !GetInput().empty();
+}
+
+bool KlimenkoVLSHContrastIncrOMP::PreProcessingImpl() {
+  GetOutput().resize(GetInput().size());
+  return true;
+}
+
+bool KlimenkoVLSHContrastIncrOMP::RunImpl() {
+  const auto &input = GetInput();
+  auto &output = GetOutput();
+
+  if (input.empty()) {
+    return false;
+  }
+
+  const size_t size = input.size();
+
+  int min_val = input[0];
+  int max_val = input[0];
+
+#pragma omp parallel for default(none) shared(input, size) reduction(min : min_val) reduction(max : max_val)
+  for (size_t i = 0; i < size; ++i) {
+    min_val = std::min(input[i], min_val);
+    max_val = std::max(input[i], max_val);
+  }
+
+  if (max_val == min_val) {
+#pragma omp parallel for default(none) shared(input, output, size)
+    for (size_t i = 0; i < size; ++i) {
+      output[i] = input[i];
+    }
+    return true;
+  }
+  const int range = max_val - min_val;
+#pragma omp parallel for default(none) shared(input, output, size, min_val, range)
+  for (size_t i = 0; i < size; ++i) {
+    output[i] = ((input[i] - min_val) * 255) / range;
+  }
+  return true;
+}
+
+bool KlimenkoVLSHContrastIncrOMP::PostProcessingImpl() {
+  return GetOutput().size() == GetInput().size();
+}
+
+}  // namespace klimenko_v_lsh_contrast_incr_omp

tasks/klimenko_v_lsh_contrast_incr_omp/settings.json

@@ -0,0 +1,10 @@
+{
+  "tasks": {
+    "all": "enabled",
+    "omp": "enabled",
+    "seq": "enabled",
+    "stl": "enabled",
+    "tbb": "enabled"
+  },
+  "tasks_type": "threads"
+}

tasks/klimenko_v_lsh_contrast_incr_omp/tests/functional/main.cpp

@@ -0,0 +1,81 @@
+#include <gtest/gtest.h>
+
+#include <algorithm>
+#include <array>
+#include <cstddef>
+#include <string>
+
+#include "klimenko_v_lsh_contrast_incr_omp/common/include/common.hpp"
+#include "klimenko_v_lsh_contrast_incr_omp/omp/include/ops_omp.hpp"
+#include "util/include/func_test_util.hpp"
+#include "util/include/util.hpp"
+
+namespace klimenko_v_lsh_contrast_incr_omp {
+
+class KlimenkoVRunOMPFuncTestsLSH : public ppc::util::BaseRunFuncTests<InType, OutType, TestType> {
+ public:
+  static std::string PrintTestParam(const TestType &test_param) {
+    return std::to_string(test_param);
+  }
+
+ protected:
+  void SetUp() override {
+    TestType size = std::get<static_cast<std::size_t>(ppc::util::GTestParamIndex::kTestParams)>(GetParam());
+
+    input_data_.resize(size);
+    for (int i = 0; i < size; ++i) {
+      input_data_[i] = 50 + (i % 101);
+    }
+  }
+
+  bool CheckTestOutputData(OutType &output_data) final {
+    if (output_data.size() != input_data_.size()) {
+      return false;
+    }
+
+    auto minmax = std::ranges::minmax_element(input_data_);
+    int min_val = *minmax.min;
+    int max_val = *minmax.max;
+
+    if (max_val == min_val) {
+      return output_data == input_data_;
+    }
+
+    for (size_t i = 0; i < input_data_.size(); ++i) {
+      int expected = ((input_data_[i] - min_val) * 255) / (max_val - min_val);
+
+      if (expected != output_data[i]) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  InType GetTestInputData() final {
+    return input_data_;
+  }
+
+ private:
+  InType input_data_;
+};
+
+namespace {
+
+TEST_P(KlimenkoVRunOMPFuncTestsLSH, ContrastStretching) {
+  ExecuteTest(GetParam());
+}
+
+const std::array<TestType, 3> kTestParam = {16, 256, 1024};
+
+const auto kTestTasksList = ppc::util::AddFuncTask<KlimenkoVLSHContrastIncrOMP, InType>(
+    kTestParam, PPC_SETTINGS_klimenko_v_lsh_contrast_incr_omp);
+
+const auto kGtestValues = ppc::util::ExpandToValues(kTestTasksList);
+
+const auto kTestName = KlimenkoVRunOMPFuncTestsLSH::PrintFuncTestName<KlimenkoVRunOMPFuncTestsLSH>;
+
+INSTANTIATE_TEST_SUITE_P(ContrastIncrTests, KlimenkoVRunOMPFuncTestsLSH, kGtestValues, kTestName);
+
+}  // namespace
+
+}  // namespace klimenko_v_lsh_contrast_incr_omp

tasks/klimenko_v_lsh_contrast_incr_omp/tests/performance/main.cpp

@@ -0,0 +1,55 @@
+#include <gtest/gtest.h>
+
+#include <cstddef>
+#include <random>
+
+#include "klimenko_v_lsh_contrast_incr_omp/common/include/common.hpp"
+#include "klimenko_v_lsh_contrast_incr_omp/omp/include/ops_omp.hpp"
+#include "util/include/perf_test_util.hpp"
+
+namespace klimenko_v_lsh_contrast_incr_omp {
+
+class KlimenkoVLSHContrastIncrOMPPerfTests : public ppc::util::BaseRunPerfTests<InType, OutType> {
+ public:
+  void SetUp() override {
+    const size_t size = 10000000;
+    input_data_.resize(size);
+
+    std::random_device rd;
+    std::mt19937 gen(rd());
+    std::uniform_int_distribution<int> dist(0, 255);
+    for (auto &pixel : input_data_) {
+      pixel = dist(gen);
+    }
+  }
+
+  bool CheckTestOutputData(OutType &output_data) final {
+    return output_data.size() == input_data_.size();
+  }
+
+  InType GetTestInputData() final {
+    return input_data_;
+  }
+
+ private:
+  InType input_data_;
+};
+
+TEST_P(KlimenkoVLSHContrastIncrOMPPerfTests, RunPerfModes) {
+  ExecuteTest(GetParam());
+}
+
+namespace {
+
+const auto kAllPerfTasks =
+    ppc::util::MakeAllPerfTasks<InType, KlimenkoVLSHContrastIncrOMP>(PPC_SETTINGS_klimenko_v_lsh_contrast_incr_omp);
+
+const auto kGtestValues = ppc::util::TupleToGTestValues(kAllPerfTasks);
+
+const auto kPerfTestName = KlimenkoVLSHContrastIncrOMPPerfTests::CustomPerfTestName;
+
+INSTANTIATE_TEST_SUITE_P(RunModeTests, KlimenkoVLSHContrastIncrOMPPerfTests, kGtestValues, kPerfTestName);
+
+}  // namespace
+
+}  // namespace klimenko_v_lsh_contrast_incr_omp