GCC Code Coverage Report

Directory: ./
File: tasks/peterson_r_graham_scan/stl/src/ops_stl.cpp
Date: 2026-06-04 20:25:32
Exec Total Coverage
Lines: 45 67 67.2%
Functions: 8 13 61.5%
Branches: 25 88 28.4%
Line Branch Exec Source
1 #include "peterson_r_graham_scan/stl/include/ops_stl.hpp"
2
3 #include <algorithm>
4 #include <cmath>
5 #include <cstddef>
6 #include <iterator>
7 #include <numbers>
8 #include <utility>
9 #include <vector>
10
11 #include "peterson_r_graham_scan/stl/include/common.hpp"
12
13 namespace peterson_r_graham_scan_stl {
14
15 namespace {
16 constexpr double kTolerance = 0.0;
17
18 double CalculateOrientation(const Point2D &origin, const Point2D &a, const Point2D &b) {
19 184 return ((a.coord_x - origin.coord_x) * (b.coord_y - origin.coord_y)) -
20 184 ((a.coord_y - origin.coord_y) * (b.coord_x - origin.coord_x));
21 }
22
23 double CalculateSquaredDistance(const Point2D &first, const Point2D &second) {
24 ✗ const double dx = first.coord_x - second.coord_x;
25 ✗ const double dy = first.coord_y - second.coord_y;
26 ✗ return (dx * dx) + (dy * dy);
27 }
28
29 class PointComparator {
30 public:
31 explicit PointComparator(const Point2D *reference) : origin_ptr_(reference) {}
32
33 112 bool operator()(const Point2D &lhs, const Point2D &rhs) const {
34
1/2
✓ Branch 0 taken 112 times.
✗ Branch 1 not taken.
 112 const double orientation = CalculateOrientation(*origin_ptr_, lhs, rhs);
35
1/2
✓ Branch 0 taken 112 times.
✗ Branch 1 not taken.
 112 if (std::abs(orientation) > kTolerance) {
36 112 return orientation > 0;
37 }
38 ✗ return CalculateSquaredDistance(*origin_ptr_, lhs) < CalculateSquaredDistance(*origin_ptr_, rhs);
39 }
40
41 private:
42 const Point2D *origin_ptr_;
43 };
44 } // namespace
45
46 24 PetersonGrahamScannerSTL::PetersonGrahamScannerSTL(const InputValue &in) {
47 SetTypeOfTask(GetStaticTypeOfTask());
48 24 GetInput() = in;
49 GetOutput() = 0;
50 24 }
51
52 ✗ void PetersonGrahamScannerSTL::LoadPoints(const PointSet &points) {
53 ✗ input_points_ = points;
54 ✗ external_data_provided_ = true;
55 ✗ }
56
57 ✗ PointSet PetersonGrahamScannerSTL::GetConvexHull() const {
58 ✗ return hull_points_;
59 }
60
61 24 bool PetersonGrahamScannerSTL::ValidationImpl() {
62 24 return GetInput() >= 0;
63 }
64
65
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 24 times.
 24 bool PetersonGrahamScannerSTL::PreProcessingImpl() {
66 hull_points_.clear();
67
68
1/2
✓ Branch 0 taken 24 times.
✗ Branch 1 not taken.
 24 if (!external_data_provided_) {
69 input_points_.clear();
70 24 const int count = GetInput();
71
1/2
✓ Branch 0 taken 24 times.
✗ Branch 1 not taken.
 24 if (count <= 0) {
72 return true;
73 }
74
75 24 input_points_.resize(count);
76 24 const double angle_step = 2.0 * std::numbers::pi / count;
77
78
2/2
✓ Branch 0 taken 120 times.
✓ Branch 1 taken 24 times.
 144 for (int i = 0; i < count; ++i) {
79 120 const double angle = angle_step * i;
80 120 input_points_[i] = Point2D(std::cos(angle), std::sin(angle));
81 }
82 }
83
84 return true;
85 }
86
87
1/2
✓ Branch 0 taken 24 times.
✗ Branch 1 not taken.
 24 bool PetersonGrahamScannerSTL::AreAllPointsIdentical(const PointSet &points) {
88
1/2
✓ Branch 0 taken 24 times.
✗ Branch 1 not taken.
 24 if (points.empty()) {
89 return true;
90 }
91
92 const Point2D &reference = points[0];
93 24 return std::all_of(points.begin() + 1, points.end(), [&reference](const Point2D &point) {
94
2/28
✗ Branch 0 not taken.
✓ Branch 1 taken 16 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✗ Branch 11 not taken.
✗ Branch 12 not taken.
✗ Branch 13 not taken.
✗ Branch 14 not taken.
✗ Branch 15 not taken.
✗ Branch 16 not taken.
✗ Branch 17 not taken.
✗ Branch 18 not taken.
✗ Branch 19 not taken.
✗ Branch 20 not taken.
✓ Branch 21 taken 8 times.
✗ Branch 22 not taken.
✗ Branch 23 not taken.
✗ Branch 24 not taken.
✗ Branch 25 not taken.
✗ Branch 26 not taken.
✗ Branch 27 not taken.
 24 return std::abs(point.coord_x - reference.coord_x) <= kTolerance &&
95 ✗ std::abs(point.coord_y - reference.coord_y) <= kTolerance;
96 });
97 }
98
99 ✗ std::size_t PetersonGrahamScannerSTL::FindLowestPointParallel(const PointSet &points) {
100 auto it = std::ranges::min_element(points, [](const Point2D &lhs, const Point2D &rhs) {
101
2/4
✓ Branch 0 taken 40 times.
✓ Branch 1 taken 56 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 96 if (lhs.coord_y < rhs.coord_y) {
102 return true;
103 }
104 if (std::abs(lhs.coord_y - rhs.coord_y) < kTolerance) {
105 return lhs.coord_x < rhs.coord_x;
106 }
107 return false;
108 });
109
110 ✗ return static_cast<std::size_t>(std::distance(points.begin(), it));
111 }
112
113
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 24 times.
 24 void PetersonGrahamScannerSTL::SortPointsByAngleParallel(PointSet &points) {
114
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 24 times.
 24 if (points.size() < 2) {
115 ✗ return;
116 }
117
118 24 const Point2D origin = points[0];
119 PointComparator comparator(&origin);
120 24 std::sort(points.begin() + 1, points.end(), comparator);
121 }
122
123
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 24 times.
 24 bool PetersonGrahamScannerSTL::RunImpl() {
124 hull_points_.clear();
125 24 const int total_points = static_cast<int>(input_points_.size());
126
127
1/2
✓ Branch 0 taken 24 times.
✗ Branch 1 not taken.
 24 if (total_points == 0) {
128 return true;
129 }
130
131
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 24 times.
 24 if (AreAllPointsIdentical(input_points_)) {
132 ✗ hull_points_.push_back(input_points_.front());
133 ✗ return true;
134 }
135
136
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 24 times.
 24 if (total_points < 3) {
137 ✗ hull_points_ = input_points_;
138 ✗ return true;
139 }
140
141 const std::size_t lowest_idx = FindLowestPointParallel(input_points_);
142 std::swap(input_points_[0], input_points_[lowest_idx]);
143
144 24 SortPointsByAngleParallel(input_points_);
145
146 24 std::vector<Point2D> stack;
147
1/2
✓ Branch 1 taken 24 times.
✗ Branch 2 not taken.
 24 stack.reserve(total_points);
148 stack.push_back(input_points_[0]);
149 stack.push_back(input_points_[1]);
150
151
2/2
✓ Branch 0 taken 72 times.
✓ Branch 1 taken 24 times.
 96 for (int i = 2; i < total_points; ++i) {
152
1/2
✓ Branch 0 taken 72 times.
✗ Branch 1 not taken.
 72 while (static_cast<int>(stack.size()) >= 2) {
153 const Point2D &second_last = stack[stack.size() - 2];
154 const Point2D &last = stack.back();
155
156
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 72 times.
 72 if (CalculateOrientation(second_last, last, input_points_[i]) <= kTolerance) {
157 stack.pop_back();
158 } else {
159 break;
160 }
161 }
162
1/2
✓ Branch 0 taken 72 times.
✗ Branch 1 not taken.
 72 stack.push_back(input_points_[i]);
163 }
164
165 24 hull_points_ = std::move(stack);
166 return true;
167 }
168
169 24 bool PetersonGrahamScannerSTL::PostProcessingImpl() {
170 24 GetOutput() = static_cast<int>(hull_points_.size());
171 24 return true;
172 }
173
174 ✗ double PetersonGrahamScannerSTL::ComputeOrientation(const Point2D &origin, const Point2D &a, const Point2D &b) {
175 ✗ return CalculateOrientation(origin, a, b);
176 }
177
178 ✗ double PetersonGrahamScannerSTL::ComputeDistanceSq(const Point2D &p1, const Point2D &p2) {
179 ✗ return CalculateSquaredDistance(p1, p2);
180 }
181
182 } // namespace peterson_r_graham_scan_stl
183