bentleyottmann::SweepLine Class Reference

#include <SweepLine.h>

Inheritance diagram for bentleyottmann::SweepLine:

Public Member Functions
	SweepLine ()
void	handleDeletions (Point eventPoint, const DeletionSegmentSet &removing) override
void	handleInsertionsAndCheckForNewCrossings (Point eventPoint, const InsertionSegmentSet &inserting, EventQueueInterface *queue) override
Public Member Functions inherited from bentleyottmann::SweepLineInterface
virtual	~SweepLineInterface ()=default
virtual void	handleDeletions (Point eventPoint, const DeletionSegmentSet &removing)=0
virtual void	handleInsertionsAndCheckForNewCrossings (Point eventPoint, const InsertionSegmentSet &inserting, EventQueueInterface *queue)=0

Friends
struct	SweepLineTestingPeer

Detailed Description

Definition at line 16 of file SweepLine.h.

Constructor & Destructor Documentation

SweepLine()

bentleyottmann::SweepLine::SweepLine

(

)

Definition at line 18 of file SweepLine.cpp.

                     {
    static constexpr Segment LeftSentinel = {{-std::numeric_limits<int32_t>::max(),
                                                     -std::numeric_limits<int32_t>::max()},
                                             {-std::numeric_limits<int32_t>::max(),
                                                     std::numeric_limits<int32_t>::max()}};
    static constexpr Segment RightSentinel = {{std::numeric_limits<int32_t>::max(),
                                                      -std::numeric_limits<int32_t>::max()},
                                              {std::numeric_limits<int32_t>::max(),
                                                      std::numeric_limits<int32_t>::max()}};
 
    fSweepLine.reserve(8);
    fSweepLine.push_back(LeftSentinel);
    fSweepLine.push_back(RightSentinel);
}

Member Function Documentation

handleDeletions()

void bentleyottmann::SweepLine::handleDeletions ( Point  eventPoint, const DeletionSegmentSet &  removing  )

overridevirtual

Implements bentleyottmann::SweepLineInterface.

Definition at line 41 of file SweepLine.cpp.

                                                                                    {
    std::vector<Segment>::iterator newEnd;
    if (removing.empty()) {
        // Remove ending segments
        auto toRemove = [eventPoint](Segment s) {
            return s.lower() == eventPoint;
        };
        newEnd = std::remove_if(fSweepLine.begin(), fSweepLine.end(), toRemove);
    } else {
        // Remove all ending and crossing segments.
        auto toRemove = [eventPoint, &removing](Segment s) {
            return s.lower() == eventPoint || removing.find(s) != removing.end();
        };
        newEnd = std::remove_if(fSweepLine.begin(), fSweepLine.end(), toRemove);
    }
    fSweepLine.erase(newEnd, fSweepLine.end());
}

handleInsertionsAndCheckForNewCrossings()

void bentleyottmann::SweepLine::handleInsertionsAndCheckForNewCrossings ( Point  eventPoint, const InsertionSegmentSet &  inserting, EventQueueInterface *  queue  )

overridevirtual

Implements bentleyottmann::SweepLineInterface.

Definition at line 59 of file SweepLine.cpp.

                                                                                            {
    // The SlopeSegmentSet makes sure that these segments are in the right order for insertion.
    auto comp = [](const Segment& s, Point p) {
        return !point_less_than_segment_in_x(p, s);
    };
 
    const auto rightOfInsertion = std::lower_bound(
            fSweepLine.begin(), fSweepLine.end(), eventPoint, comp);
    SkASSERT(rightOfInsertion != fSweepLine.begin());
    const auto leftOfInsertion = rightOfInsertion - 1;
 
    if (inserting.empty()) {
        // There were deletions, but no insertions, so check if the two segments at the insertion
        // point cross.
        if (auto crossingPoint = intersect(*leftOfInsertion, *rightOfInsertion)) {
            queue->addCrossing(crossingPoint.value(), *leftOfInsertion, *rightOfInsertion);
        }
    } else {
        // Check if the left most inserted segment crosses the segment immediately to the left of
        // the insertion cursor.
        if (auto crossingPoint = intersect(*leftOfInsertion, *inserting.begin())) {
            queue->addCrossing(crossingPoint.value(), *leftOfInsertion, *inserting.begin());
        }
 
        // Check if the right most inserted segment crosses the segment immediately to the right of
        // the insertion cursor.
        if (auto crossingPoint = intersect(*inserting.rbegin(), *rightOfInsertion)) {
            queue->addCrossing(crossingPoint.value(), *inserting.rbegin(), *rightOfInsertion);
        }
 
        // Insert the set in the sweep line.
        fSweepLine.insert(rightOfInsertion, inserting.begin(), inserting.end());
    }
}

Friends And Related Function Documentation

SweepLineTestingPeer

friend struct SweepLineTestingPeer

friend

Definition at line 27 of file SweepLine.h.

---

The documentation for this class was generated from the following files:

• third_party/skia/modules/bentleyottmann/include/SweepLine.h
• third_party/skia/modules/bentleyottmann/src/SweepLine.cpp