55inline std::vector<size_t>
downsampleIndices(
const std::vector<Point>& data,
size_t target_size)
62 if (target_size >= data.size())
64 std::vector<size_t> all_indices;
65 all_indices.reserve(data.size());
66 for (
size_t i = 0; i < data.size(); ++i) { all_indices.push_back(i); }
72 return {0, data.size() - 1};
75 std::vector<size_t> selected_indices;
76 selected_indices.reserve(target_size);
78 const size_t n = data.size();
79 const double bucket_size =
static_cast<double>(n - 2) /
static_cast<double>(target_size - 2);
81 selected_indices.push_back(0);
84 for (
size_t i = 0; i < target_size - 2; ++i)
86 size_t c_start =
static_cast<size_t>(std::floor((i + 1) * bucket_size)) + 1;
87 size_t c_end =
static_cast<size_t>(std::floor((i + 2) * bucket_size)) + 1;
88 c_end = std::min(c_end, n);
89 c_start = std::min(c_start, n);
93 const size_t c_bucket_size = (c_end > c_start) ? (c_end - c_start) : 0;
95 for (
size_t c = c_start; c < c_end; ++c)
101 if (c_bucket_size > 0)
103 avg_cx /=
static_cast<double>(c_bucket_size);
104 avg_cy /=
static_cast<double>(c_bucket_size);
108 avg_cx = data[a_index].x;
109 avg_cy = data[a_index].y;
112 size_t b_start =
static_cast<size_t>(std::floor(i * bucket_size)) + 1;
113 size_t b_end =
static_cast<size_t>(std::floor((i + 1) * bucket_size)) + 1;
114 b_start = std::min(b_start, n - 1);
115 b_end = std::min(b_end, n - 1);
116 if (b_end <= b_start)
118 b_end = std::min(b_start + 1, n - 1);
121 const Point& point_a = data[a_index];
122 double max_area = -1.0;
123 size_t next_a_index = b_start;
125 for (
size_t b = b_start; b < b_end; ++b)
128 0.5 * std::abs(point_a.
x * (data[b].y - avg_cy) + data[b].x * (avg_cy - point_a.
y) +
129 avg_cx * (point_a.
y - data[b].y));
138 selected_indices.push_back(next_a_index);
139 a_index = next_a_index;
142 selected_indices.push_back(n - 1);
143 return selected_indices;
158 size_t min_value_count = 2)
161 std::istringstream iss(line);
162 long long row_index = 0;
163 if (!(iss >> row_index))
170 while (iss >> value) { values_out.push_back(value); }
173 if (values_out.empty() || values_out.size() < min_value_count)
236 const std::vector<size_t>& data_line_positions,
237 const std::vector<size_t>& selected_row_indices)
239 std::vector<bool> keep_data_row(data_line_positions.size(),
false);
240 for (
size_t selected_row_index : selected_row_indices)
242 if (selected_row_index < keep_data_row.size())
244 keep_data_row[selected_row_index] =
true;
248 std::vector<std::string> output_lines;
249 output_lines.reserve(input_lines.size());
251 size_t data_cursor = 0;
252 for (
size_t line_index = 0; line_index < input_lines.size(); ++line_index)
254 if (data_cursor < data_line_positions.size() &&
255 data_line_positions[data_cursor] == line_index)
257 if (keep_data_row[data_cursor])
259 output_lines.push_back(input_lines[line_index]);
265 output_lines.push_back(input_lines[line_index]);
300 size_t min_value_count, XSelector x_selector, YSelector y_selector)
302 std::vector<Point> data_points;
303 std::vector<size_t> data_line_positions;
304 data_points.reserve(input_lines.size());
305 data_line_positions.reserve(input_lines.size());
307 std::vector<double> values;
309 for (
size_t i = 0; i < input_lines.size(); ++i)
314 point.
x =
static_cast<double>(x_selector(values));
315 point.
y =
static_cast<double>(y_selector(values));
316 data_points.push_back(point);
317 data_line_positions.push_back(i);
321 if (data_points.size() <= 2)
328 size_t high = data_points.size();
329 size_t best_size = 2;
333 const size_t mid = low + (high - low) / 2;
335 const std::vector<std::string> candidate =
339 if (candidate_size <= max_bytes)