Obszary spójne współosiowych prostokątów

Muszę wyznaczyć spójne obszary złożone z prostokątów współosiowych (o równoległych do osi o podanym dolnym lewym i górnym prawym rogu), wyliczyć ile mają dziur i jaką mają powierzchnie. Spójne obszary to obszary złożone z prostokątów nachodzących na siebie lub dotykających siebie krawędziami (prostokąty, które mają wspólny tylko jeden wierzchołek wspólny nie tworzą jednego obszaru spójnego). Spójne obszary mam wyświetlić zostawiając przechodząc po krawędziach zostawiając obszar po lewej stronie i wypisując długość krawędzi, + dla skrętu w prawo, - dla skrętu w lewo i .0 dla końca (dziury również w ten sposób muszę pokazać zostawiając dziurę po prawej stronie).

Najpierw z prostokątów wyznaczam pionowe odcinki otwierające i zamykające i sortuje je:

if (empty())
    {
        return;
    }
    vector<Segment> Segments;
    for(RectangleList::const_iterator it = this->begin(), int R = 0; it != this->end(); ++it, R++)
    {
        Segments.push_back(Segment(it->GetX(), it->GetZ(), it->GetY(), R, true));
        Segments.push_back(Segment(it->GetX(), it->GetZ(), it->GetT(), R, false));
    }
    sort(Segments.begin(), Segments.end());

Odcinki mają być sortowane według rosnącej współrzędnej X, a jeśli mają taką samą to według rosnącej współrzędnej Y dolnego wierzchołka:

inline bool operator< (Segment &s) const
        {
            return (X < s.X) || (Y == s.Y && GetStart() < s.GetStart()) || (Y == s.Y && GetStart() == s.GetStart() &&
                    GetEnd() == s.GetEnd());
        } 

Odcinki mają być sortowane według rosnącej współrzędnej X, a jeśli mają taką samą to według rosnącej współrzędnej Y dolnego wierzchołka:

inline bool operator< (Segment &s) const
        {
            return (X < s.X) || (Y == s.Y && GetStart() < s.GetStart()) || (Y == s.Y && GetStart() == s.GetStart() &&
                    GetEnd() == s.GetEnd());
        }

W ten sposób umiem wyznaczyć punkty rozpoczęcia i zakończenia "sum" odcinków (odcinków złożonych z nachodzących na siebie odcinków) na każdej linii, czyli wierzchołki obszarów spójnych bez uwzględnienia otwarcia prostokątów (vector<vector<Point>> Points - wektor pionowych linii, które są wektorami punktów na tych liniach):

 bool ConnectedSegmentIsEnded = true;
    int X, Y, i = 0, j = 0, Start;
    vector<vector<Point>> Points;
    list<OpenRectangle> OpenRectangles;
    list<OpenRectangle>::iterator or = OpenRectangles.begin();
    vector<SimpleSegment> OpenLine;
        for(vector<Segment>::iterator it = Segments.begin(); it != Segments.end(); ++it)
    {
        if (it->Ends)
        {
            while (or->GetStart() != it->GetStart())
            {
            }
            for (;or->GetEnd() >= it->GetEnd(); or++)
            {
                if (or->Decrease() == 0)
                {
                    OpenRectangles.erase(or);
                }
            }
        }
        if (or->GetStart() < it->GetStart())
        {
        }
        for(;or->GetEnd() < it->GetEnd(); or++)
        {
            it->Decrease();
        }
        if (!ConnectedSegmentIsNotEnded)
        {
            if (it->GetX() == X)
            {
                if (it->GetStart() > Y)
                {
                    Points[0].push_back(Point(X, it->GetY));
                }
                else
                {
                    if (it->GetEnd() > Y)
                    {
                        Y = it->GetEnd();
                       
                    }
                    else
                    {
                        Points.push_back(Point(X, it->GetY));
                    }
                    continue;
                }
            }
            else
            {
                i++;
            }
        }
        X = it->GetX();
        Points.push_back(Vector());
        Start = it->GetStart();
        Points[i].push_back(Point(X, Start));
       
        Y = it->GetEnd();
        OpenRectangles.push_back(OpenRectangle(Start, X, it->GetRectangle());
        ConnectedSegmentIsEnded = false;
    }
    Points.push_back(Point(X, Y);

Znalezienie wierzchołków obszaru spójnego chciałbym zrobić przez omiatanie od lewej do prawej mając pionowe linie z odcinkami z ilością otwarć, ale nie weim jak to zaimplementować. To by było coś w stylu:

 for(vector<Segment>::iterator it = Segments.begin(); it != Segments.end(); ++it)
    {
if (it->Ends)
        {
            while (or->GetStart() != it->GetStart())
            {
            }
            for (;or->GetEnd() >= it->GetEnd(); or++)
            {
                if (or->Decrease() == 0)
                {
                    OpenRectangles.erase(or);
                }
            }
        }
        if (or->GetStart() < it->GetStart())
        {
        }
        for(;or->GetEnd() < it->GetEnd(); or++)
        {
            or->Increase();
        }
        } 

Jak wyznaczyć obszary spójne mając prostokąty o lewym dolnym rogu (GetX(), GetY()) i prawym górnym rogu (GetZ(), GetT())? Jak poprawnie wyznaczyć wierzchołki obszarów spójnych dla każdej pionowej linii mając posortowane pionowe krawędzie prostokątów o dolnej współrzędnej Y GetStart(), górnej Y GetEnd(), współrzędnej X GetX() i numerze prostokąta GetRectangle() (to czy jest to odcinek rozpoczynający prostokąt czy kończący można sprawdzić za pomocą Begins())? Proszę o pomoc.