bool
RectangleIntersects::intersects(const geom::Geometry& geom)
{
if (!rectEnv.intersects(geom.getEnvelopeInternal()))
return false;
// test envelope relationships
EnvelopeIntersectsVisitor visitor(rectEnv);
visitor.applyTo(geom);
if (visitor.intersects()) return true;
// test if any rectangle corner is contained in the target
ContainsPointVisitor ecpVisitor(rectangle);
ecpVisitor.applyTo(geom);
if (ecpVisitor.containsPoint())
return true;
// test if any lines intersect
LineIntersectsVisitor liVisitor(rectangle);
liVisitor.applyTo(geom);
if (liVisitor.intersects())
return true;
return false;
}
void visit(const geom::Geometry &geom)
{
using GEOMETRY::algorithm::locate::SimplePointInAreaLocator;
const geom::Polygon *poly;
if ( !(poly=dynamic_cast<const geom::Polygon *>(&geom)) ) {
return;
}
const geom::Envelope &elementEnv = *(geom.getEnvelopeInternal());
if ( !rectEnv.intersects(elementEnv) ) {
return;
}
// test each corner of rectangle for inclusion
for (int i=0; i<4; i++)
{
const geom::Coordinate &rectPt=rectSeq.getAt(i);
if ( !elementEnv.contains(rectPt) ) {
continue;
}
// check rect point in poly (rect is known not to
// touch polygon at this point)
if ( SimplePointInAreaLocator::containsPointInPolygon(rectPt, poly) )
{
containsPointVar=true;
return;
}
}
}
/*public static*/
double
GeometrySnapper::computeSizeBasedSnapTolerance(const geom::Geometry& g)
{
const Envelope* env = g.getEnvelopeInternal();
double minDimension = (std::min)(env->getHeight(), env->getWidth());
double snapTol = minDimension * snapPrecisionFactor;
return snapTol;
}
void visit(const geom::Geometry &geom)
{
const geom::Envelope &elementEnv = *(geom.getEnvelopeInternal());
if (! rectEnv.intersects(elementEnv) ) {
return;
}
// check if general relate algorithm should be used,
// since it's faster for large inputs
if (geom.getNumPoints() > RectangleIntersects::MAXIMUM_SCAN_SEGMENT_COUNT)
{
intersectsVar = rectangle.relate(geom)->isIntersects();
return;
}
// if small enough, test for segment intersection directly
computeSegmentIntersection(geom);
}
/**
* Reports whether it can be concluded that an intersection occurs,
* or whether further testing is required.
*
* @return <code>true</code> if an intersection must occur
* <code>false</code> if no conclusion can be made
*/
void visit(const geom::Geometry &element)
{
const geom::Envelope &elementEnv = *(element.getEnvelopeInternal());
// disjoint
if ( ! rectEnv.intersects(elementEnv) ) {
return;
}
// fully contained - must intersect
if ( rectEnv.contains(elementEnv) ) {
intersectsVar = true;
return;
}
/*
* Since the envelopes intersect and the test element is
* connected, if the test envelope is completely bisected by
* an edge of the rectangle the element and the rectangle
* must touch (This is basically an application of the
* Jordan Curve Theorem). The alternative situation
* is that the test envelope is "on a corner" of the
* rectangle envelope, i.e. is not completely bisected.
* In this case it is not possible to make a conclusion
* about the presence of an intersection.
*/
if (elementEnv.getMinX() >= rectEnv.getMinX()
&& elementEnv.getMaxX() <= rectEnv.getMaxX())
{
intersectsVar=true;
return;
}
if (elementEnv.getMinY() >= rectEnv.getMinY()
&& elementEnv.getMaxY() <= rectEnv.getMaxY())
{
intersectsVar = true;
return;
}
}
