void updateNonClosedRing(LinearRing& ring)
	{
		CoordinateSequence& pts = *(const_cast<CoordinateSequence*>(
			ring.getCoordinatesRO()
					    ));
		Coordinate c = pts[0];
		c.x += 0.0001;
		pts.setAt(c, 0);
	}
Exemple #2
0
/*public*/
EdgeRing*
EdgeRing::findEdgeRingContaining(EdgeRing* testEr,
                                 vector<EdgeRing*>* shellList)
{
    const LinearRing* testRing = testEr->getRingInternal();
    if(! testRing) {
        return nullptr;
    }
    const Envelope* testEnv = testRing->getEnvelopeInternal();
    Coordinate testPt = testRing->getCoordinateN(0);
    EdgeRing* minShell = nullptr;
    const Envelope* minEnv = nullptr;

    typedef std::vector<EdgeRing*> ERList;
    for(ERList::size_type i = 0, e = shellList->size(); i < e; ++i) {
        EdgeRing* tryShell = (*shellList)[i];
        LinearRing* tryRing = tryShell->getRingInternal();
        const Envelope* tryEnv = tryRing->getEnvelopeInternal();
        if(minShell != nullptr) {
            minEnv = minShell->getRingInternal()->getEnvelopeInternal();
        }
        bool isContained = false;

        // the hole envelope cannot equal the shell envelope

        if(tryEnv->equals(testEnv)) {
            continue;
        }

        const CoordinateSequence* tryCoords =
            tryRing->getCoordinatesRO();

        if(tryEnv->contains(testEnv)) {

            // TODO: don't copy testPt !
            testPt = ptNotInList(testRing->getCoordinatesRO(), tryCoords);

            if(PointLocation::isInRing(testPt, tryCoords)) {
                isContained = true;
            }

        }

        // check if this new containing ring is smaller
        // than the current minimum ring
        if(isContained) {
            if(minShell == nullptr || minEnv->contains(tryEnv)) {
                minShell = tryShell;
            }
        }
    }
    return minShell;
}
Exemple #3
0
/*
 *  Returns the area of this <code>Polygon</code>
 *
 * @return the area of the polygon
 */
double
Polygon::getArea() const
{
	double area=0.0;
	area+=fabs(algorithm::CGAlgorithms::signedArea(shell->getCoordinatesRO()));
	for(size_t i=0, n=holes->size(); i<n; ++i)
	{
		LinearRing *lr = static_cast<LinearRing *>((*holes)[i]);
		const CoordinateSequence *h=lr->getCoordinatesRO();
        	area-=fabs(algorithm::CGAlgorithms::signedArea(h));
	}
	return area;
}
bool
QuadtreeNestedRingTester::isNonNested()
{
    buildQuadtree();
    for(size_t i = 0, ni = rings.size(); i < ni; ++i) {
        const LinearRing* innerRing = rings[i];
        const CoordinateSequence* innerRingPts = innerRing->getCoordinatesRO();
        const Envelope* envi = innerRing->getEnvelopeInternal();

        vector<void*> results;
        qt->query(envi, results);
        for(size_t j = 0, nj = results.size(); j < nj; ++j) {
            LinearRing* searchRing = (LinearRing*)results[j];
            const CoordinateSequence* searchRingPts = searchRing->getCoordinatesRO();

            if(innerRing == searchRing) {
                continue;
            }

            const Envelope* e1 = innerRing->getEnvelopeInternal();
            const Envelope* e2 = searchRing->getEnvelopeInternal();
            if(!e1->intersects(e2)) {
                continue;
            }

            const Coordinate* innerRingPt = IsValidOp::findPtNotNode(innerRingPts,
                                            searchRing, graph);

            // Unable to find a ring point not a node of the search ring
            assert(innerRingPt != nullptr);

            bool isInside = PointLocation::isInRing(*innerRingPt, searchRingPts);
            if(isInside) {
                /*
                 * innerRingPt is const just because the input
                 * CoordinateSequence is const. If the input
                 * Polygon survives lifetime of this object
                 * we are safe.
                 */
                nestedPt = const_cast<Coordinate*>(innerRingPt);
                return false;
            }
        }
    }
    return true;
}