C++ Segment::contains方法代码示例

    bool intersect(const Segment& s) const
    {
        auto d1 = D(A, B, s.A);
        auto d2 = D(A, B, s.B);

        if ((equals(d1, 0) && contains(s.A)) || (equals(d2, 0) && contains(s.B)))
            return true;

        auto d3 = D(s.A, s.B, A);
        auto d4 = D(s.A, s.B, B);

        if ((equals(d3, 0) && s.contains(A)) || (equals(d4, 0) && s.contains(B)))
            return true;

        return (d1 * d2 < 0) && (d3 * d4 < 0);
    }

int main() {
    int64_t n, x0, y0;
    cin >> n >> x0 >> y0;
    Point p = {x0, y0};
    Segment ray = {p, {inf, y0 + 1}};

    vector<Point> points(n);
    for (int i = 0; i < n; i++) {
        Point p;
        cin >> p.x >> p.y;
        points[i] = p;
    }
    int count = 0;
    bool onBound = false;
    for (int i = 0; i < n; i++) {
        Segment s = {points[i], points[(i + 1) % n]};
        if (s.contains(p)) {
            onBound = true;
            break;
        }
        if (ray.intersects(s)) {
            count++;
        }
    }
    cout << (onBound || count % 2 == 1 ? "YES" : "NO") << endl;

    return 0;
}

bool HexDoc::ReplaceAt(uint64 ToReplaceIndex, uint32 ToReplaceLength, const uint8 *pReplaceWith, uint32 ReplaceWithLength)
{
    if (!CanReplaceAt(ToReplaceIndex, ToReplaceLength, ReplaceWithLength))
        return false;

    if (ToReplaceLength > ReplaceWithLength)
    {
        //! is this a good idea?
        RemoveAt(ToReplaceIndex + ReplaceWithLength, ToReplaceLength - ReplaceWithLength, SUPPRESS_UPDATE);
        ToReplaceLength = ReplaceWithLength;
    }

    // Quick optimization:
    // If affected range is entirely inside one writeable Segment and size doesn't change,
    // just write data.
    //! is this a good idea?
    uint64 segmentStart;
    Segment *ts = GetSegment(ToReplaceIndex, &segmentStart);
    if (ts && ts->type == Segment::MEM && ToReplaceLength == ReplaceWithLength)
    {
        if (ts->contains(ToReplaceIndex, ToReplaceLength, segmentStart))
        {
            memcpy(&ts->pData[ToReplaceIndex - segmentStart], pReplaceWith, ToReplaceLength);
            return true;
        }
    }

    if (!RemoveAt(ToReplaceIndex, ToReplaceLength, SUPPRESS_UPDATE))
        return false;
    if (!InsertAt(ToReplaceIndex, pReplaceWith, ReplaceWithLength, 1, SUPPRESS_UPDATE))
        return false;

/*    THSIZE lengthDiff = (THSIZE)ToReplaceLength - (THSIZE)ReplaceWithLength; // overflow doesn't matter
    for (size_t n = FindModified(ToReplaceIndex, true); n < modRanges.size(); n++)
    {
        ByteRange& tr = modRanges[n];
        if (tr.start > ToReplaceIndex)
            tr.start += lengthDiff;
        tr.end += lengthDiff;
    }*/

    m_iChangeIndex++;
    if (hw)
        hw->OnDataChange(ToReplaceIndex, ToReplaceLength, ReplaceWithLength);
    return true;
}

static void insertIntoSegment(std::vector<Segment *> &seglist, size_t start,
                              size_t end, mtime_t time)
{
    std::vector<Segment *>::iterator segIt;
    for(segIt = seglist.begin(); segIt < seglist.end(); ++segIt)
    {
        Segment *segment = *segIt;
        if(segment->getClassId() == Segment::CLASSID_SEGMENT &&
           segment->contains(end + segment->getOffset()))
        {
            SubSegment *subsegment = new SubSegment(segment,
                                                    start + segment->getOffset(),
                                                    end + segment->getOffset());
            segment->addSubSegment(subsegment);
            segment->startTime.Set(time);
            break;
        }
    }
}

bool HexDoc::RemoveAt(uint64 nIndex, uint64 nSize, int flags /*= 0*/)
{
    if (!(flags & SUPPRESS_UPDATE) && !CanReplaceAt(nIndex, nSize, 0))
        return false;

    m_curSeg = NULL;

    if (nIndex == this->size)
        return nSize == 0;

    int n = FindSegment(nIndex), firstAffected = -1;
    THSIZE base = bases[n];
    const THSIZE removeSize = nSize; // nSize gets modified

    while (nSize)
    {
        Segment* ts = segments[n];
        if (ts->contains(nIndex - 1, base) && ts->contains(nIndex + nSize, base))
        { //---xxx---
            n++;
            Segment* ts2 = ts->RemoveMid(nIndex - base, nSize);
            InsertSegment2(n, nIndex, ts2);
            firstAffected = n + 1; // skip updating the newly inserted segment
            break;
        }
        else if (ts->contains(nIndex - 1, base))
        { // ---xxx
            nSize -= ts->size - (nIndex - base);
            ts->RemoveRight(nIndex - base);
            base += ts->size;
            firstAffected = n;
            n++;
        }
        else if (ts->contains(nIndex + nSize, base))
        { // xxx---
            ts->RemoveLeft(nSize);
            if (firstAffected == -1)
                firstAffected = n + 1;
            break;
        }
        else
        { // xxx
            nSize -= ts->size;
            delete ts;
            RemoveSegment(n);
            if (firstAffected == -1)
                firstAffected = n;
        }
    }

    m_iChangeIndex++;
    if (hw && !(flags & SUPPRESS_UPDATE))
        hw->OnDataChange(nIndex, removeSize, 0);

    if (firstAffected == -1)
        firstAffected = 0;
    for (n = firstAffected; n < (int)bases.size(); n++)
        bases[n] -= removeSize; //! this belongs somewhere else, or at least inside SUPPRESS_UPDATE check.

    this->size -= removeSize;

    return true;
}