у меня есть задача:
Вася нарисовал n секторов на плоскости. Найдите площадь их объединения.

Входные данные

В входных данных находится ноль или более тестов, заканчивающихся концом файла. В первой строке каждого теста находится число число n - количество секторов, нарисованных Васей (1≤n≤500). Следующие n строк содержат 5 чисел: xi, yi, ri, si и αi, где (xi,yi) - центр круга, ri - его радиус, si - угол начала сектора в радианах (измеряется против часовой стрелки, начиная от оси OX), а αi - угол, образующий сектор. xi, yi, ri - целые числа (−100≤xi,yi≤100, 1≤ri≤100), s_i и ai - действительные числа, заданные с точностью до трех знаков после запятой (0≤si,αi≤6). Гарантируется, что сумма всех n не превосходит 500.

Выходные данные

Для каждого теста выведите ответ на задачу. Ответ будет принят системой, если абсолютная или относительная погрешность не превосходит 10^-6.

что не так в моём решении:
#include <bits/stdc++.h>
using namespace std;

const double PI = acos(-1.0);
const double EPS = 1e-9;

// Структура, описывающая сектор
struct Sector {
    double xi, yi;   // Центр сектора
    double ri;       // Радиус сектора
    double si;       // Начальный угол сектора в радианах
    double ai;       // Размах угла сектора в радианах
};

// Функция нормализации угла к диапазону [0, 2π)
double normalize_angle(double theta) {
    theta = fmod(theta, 2.0 * PI);
    if (theta < 0)
        theta += 2.0 * PI;
    return theta;
}

// Функция проверки, лежит ли угол theta внутри сектора [start, start + extent)
bool is_angle_between(double theta, double start, double extent) {
    theta = normalize_angle(theta);
    start = normalize_angle(start);
    double end = normalize_angle(start + extent);
    
    if (extent >= 2.0 * PI - EPS)
        return true;
    
    if (start < end) {
        return (theta >= start - EPS && theta < end - EPS);
    } else { // Сектор оборачивается через 2π
        return (theta >= start - EPS || theta < end - EPS);
    }
}

// Функция объединения перекрывающихся Y-интервалов
vector<pair<double, double>> merge_intervals(vector<pair<double, double>>& intervals) {
    vector<pair<double, double>> merged;
    if (intervals.empty())
        return merged;
    
    // Сортировка интервалов по началу
    sort(intervals.begin(), intervals.end());
    
    double current_start = intervals[0].first;
    double current_end = intervals[0].second;
    
    for (size_t i = 1; i < intervals.size(); ++i){
        if(intervals[i].first <= current_end + EPS){
            // Перекрывающиеся интервалы, обновляем конец
            current_end = max(current_end, intervals[i].second);
        }
        else{
            // Не перекрывается, добавляем текущий интервал и начинаем новый
            merged.emplace_back(current_start, current_end);
            current_start = intervals[i].first;
            current_end = intervals[i].second;
        }
    }
    // Добавляем последний интервал
    merged.emplace_back(current_start, current_end);
    
    return merged;
}

// Функция получения Y-диапазонов, покрытых сектором на заданной вертикальной полосе x_mid
vector<pair<double, double>> get_sector_y_coverage(const Sector& sector, double x_mid){
    vector<pair<double, double>> intervals;
    
    double dx = x_mid - sector.xi;
    
    // Проверяем, входит ли x_mid в горизонтальный диапазон сектора
    if(abs(dx) > sector.ri + EPS )
        return intervals;
    
    double dy_max_sq = sector.ri * sector.ri - dx * dx;
    if(dy_max_sq < -EPS )
        return intervals;
    
    double dy_max = sqrt(max(dy_max_sq, 0.0));
    
    double y_min_circle = sector.yi - dy_max;
    double y_max_circle = sector.yi + dy_max;
    
    // Особый случай, когда вертикальная полоса проходит через центр сектора по оси X
    if(abs(dx) < EPS ){
        bool includes_upper = is_angle_between(PI/2.0, sector.si, sector.ai);
        bool includes_lower = is_angle_between(3.0*PI/2.0, sector.si, sector.ai);
        
        if(includes_upper && includes_lower){
            // Сектор охватывает весь вертикальный отрезок
            intervals.emplace_back(y_min_circle, y_max_circle);
        }
        else if(includes_upper){
            // Охватывает только верхнюю часть
            intervals.emplace_back(sector.yi, y_max_circle);
        }
        else if(includes_lower){
            // Охватывает только нижнюю часть
            intervals.emplace_back(y_min_circle, sector.yi);
        }
        // Иначе, не охватывает вертикальный отрезок
        return intervals;
    }
    
    // Общий случай: dx != 0
    double s_i = sector.si;
    double a_i = sector.ai;
    
    double theta_start = normalize_angle(s_i);
    double theta_end = normalize_angle(s_i + a_i);
    
    double y0, y1;
    
    // Вычисляем y0: y-координата пересечения сектора с вертикальной полосой на начальном угле
    if(abs(cos(theta_start)) < EPS){
        // Угол близок к π/2 или 3π/2, вертикальная линия
        y0 = sector.yi + dy_max; // Верхняя граница
    }
    else{
        y0 = sector.yi + dx * tan(theta_start);
    }
    
    // Вычисляем y1: y-координата пересечения сектора с вертикальной полосой на конечном угле
    if(abs(cos(theta_end)) < EPS ){
        y1 = sector.yi + dy_max; // Верхняя граница
    }
    else{
        y1 = sector.yi + dx * tan(theta_end);
    }
    
    // Ограничиваем y0 и y1 границами круга
    y0 = min(max(y0, y_min_circle), y_max_circle);
    y1 = min(max(y1, y_min_circle), y_max_circle);
    
    if(a_i >= PI - EPS ){
        // Если размах угла сектора >= π, покрытие от 0 до y_max_circle
        // Это соответствует верхней половине круга для сектора от 0 до π
        intervals.emplace_back(sector.yi, y_max_circle);
    }
    else{
        // Если размах угла сектора < π, покрытие между y0 и y1
        double y_low = min(y0, y1);
        double y_high = max(y0, y1);
        if(y_low < y_high - EPS){
            intervals.emplace_back(y_low, y_high);
        }
    }
    
    return intervals;
}

int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    
    int n;
    cout << fixed << setprecision(6); // Устанавливаем точность вывода
    
    while(cin >> n){
        vector<Sector> sectors(n);
        for(int i=0; i<n; i++){
            cin >> sectors[i].xi >> sectors[i].yi >> sectors[i].ri >> sectors[i].si >> sectors[i].ai;
        }
        
        vector<double> x_events;
        for(auto &sector : sectors){
            // Левая и правая границы сектора по оси X
            x_events.emplace_back(sector.xi - sector.ri);
            x_events.emplace_back(sector.xi + sector.ri);
            
            // Проекции начального и конечного углов сектора на ось X
            double angle_start = normalize_angle(sector.si);
            double angle_end = normalize_angle(sector.si + sector.ai);
            double x_proj_start = sector.xi + sector.ri * cos(angle_start);
            double x_proj_end = sector.xi + sector.ri * cos(angle_end);
            x_events.emplace_back(x_proj_start);
            x_events.emplace_back(x_proj_end);
        }
        
        // Сортировка и удаление дубликатов
        sort(x_events.begin(), x_events.end());
        x_events.erase(unique(x_events.begin(), x_events.end(), [&](double a, double b)-> bool{
            return abs(a -b) < EPS;
        }), x_events.end());
        
        double total_area = 0.0;
        
        // Обработка каждой вертикальной полосы
        for(int i=0; i <(int)x_events.size()-1; i++){
            double x_left =x_events[i];
            double x_right=x_events[i+1];
            
            if(x_right -x_left < EPS )
                continue; // Пропускаем слишком узкие полосы
            
            double x_mid = (x_left +x_right)/2.0;
            vector<pair<double, double>> y_coverage;
            
            // Сбор всех Y-диапазонов, покрытых секторами на текущей полосе
            for(auto &sector : sectors){
                auto interval = get_sector_y_coverage(sector, x_mid);
                for(auto &[a, b] : interval){
                    y_coverage.emplace_back(a, b);
                }
            }
            
            if(y_coverage.empty())
                continue; // Нет покрытия на этой полосе
            
            // Объединение перекрывающихся Y-интервалов
            auto merged = merge_intervals(y_coverage);
            
            double coverage =0.0;
            for(auto &[a, b] : merged){
                coverage += (b -a);
            }
            
            // Добавление площади текущей полосы к общей площади
            total_area += (x_right -x_left) * coverage;
        }
        
        // Вывод общей площади с точностью до 6 знаков после запятой
        cout << fixed << setprecision(6) << total_area << "\n";
    }
}