How to use

intersects

method

in

com.vividsolutions.jts.geom.Geometry

/**
 * Default implementation.
 */
public boolean intersects(Geometry g)
{
 return baseGeom.intersects(g);
}
 

/**
 * Tests whether this geometry is disjoint from the argument geometry.
 * <p>
 * The <code>disjoint</code> predicate has the following equivalent definitions:
 * <ul>
 * <li>The two geometries have no point in common
 * <li>The DE-9IM Intersection Matrix for the two geometries matches 
 * <code>[FF*FF****]</code>
 * <li><code>! g.intersects(this) = true</code>
 * <br>(<code>disjoint</code> is the inverse of <code>intersects</code>)
 * </ul>
 *
 *@param  g  the <code>Geometry</code> with which to compare this <code>Geometry</code>
 *@return        <code>true</code> if the two <code>Geometry</code>s are
 *      disjoint
 *
 * @see Geometry#intersects
 */
public boolean disjoint(Geometry g) {
 return ! intersects(g);
}

for (NamedArea area : intersects) {
  Geometry polygon = area.getPolygon();
  if (!polygon.intersects(startPoint))
    continue;
  Geometry lineParts = line.intersection(polygon);

 static List findIntersecting(Collection targetGeoms, Geometry queryGeom)
 {
    List result = new ArrayList();
    for (Iterator it = targetGeoms.iterator(); it.hasNext(); ) {
      Geometry test = (Geometry) it.next();
      if (test.intersects(queryGeom)) {
        result.add(test);
      }
    }
   return result;
 }
}

MultiPolygon polygon = area.toJTSMultiPolygon();
if (!(polygon.intersects(startPoint) || polygon.getBoundary()
    .intersects(startPoint)))
  continue;
Geometry lineParts = line.intersection(polygon);

static public boolean intersects(Geometry arg0,Geometry arg1)
{
   if (arg0 == null || arg1 == null) return false;
   Geometry _this = arg0;
   return _this.intersects(arg1);
}

/**
 * Default implementation.
 */
public boolean intersects(Geometry g)
{
 return baseGeom.intersects(g);
}
 

  private boolean geoMatch(Geometry left, Geometry right)
  {
    //log.warn("Check "+left.toText()+" with "+right.toText());
    return considerBoundaryIntersection ? left.intersects(right) : left.covers(right);
  }
}

  public boolean match(Geometry spatialObject, Geometry queryWindow)
  {
    if (considerBoundaryIntersection) {
      if (queryWindow.intersects(spatialObject)) { return true; }
    }
    else {
      if (queryWindow.covers(spatialObject)) { return true; }
    }
    return false;
  }
}

  private boolean geoMatch(Geometry left, Geometry right)
  {
    //log.warn("Check "+left.toText()+" with "+right.toText());
    return considerBoundaryIntersection ? left.intersects(right) : left.covers(right);
  }
}

  public boolean match(Geometry spatialObject, Geometry queryWindow)
  {
    if (considerBoundaryIntersection) {
      if (queryWindow.intersects(spatialObject)) { return true; }
    }
    else {
      if (queryWindow.covers(spatialObject)) { return true; }
    }
    return false;
  }
}

/**
 * Helper method for {@link #intersects(Geometry, Geometry) intersects(Geometry, Geometry)}
 */
private static boolean intersects(GeometryCollection gc, Geometry g) {
  final int size=gc.getNumGeometries();
  for (int i = 0; i < size; i++) {
    Geometry g1 = (Geometry)gc.getGeometryN(i);
    if( g1.intersects(g) )
      return true;
  }
  return false;
}

public static Boolean intersects(GeometryType geom1, GeometryType geom2) throws FunctionExecutionException {
  Geometry g1 = getGeometry(geom1);
  Geometry g2 = getGeometry(geom2);
  return g1.intersects(g2);
}

public static Boolean intersects(GeometryType geom1, GeometryType geom2) throws FunctionExecutionException {
  Geometry g1 = getGeometry(geom1);
  Geometry g2 = getGeometry(geom2);
  return g1.intersects(g2);
}

 @Override
 public Item item(final QueryContext qc, final InputInfo ii) throws QueryException {
  return Bln.get(checkGeo(0, qc).intersects(checkGeo(1, qc)));
 }
}

protected boolean basicEvaluate(Geometry left, Geometry right) {
  Envelope envLeft = left.getEnvelopeInternal();
  Envelope envRight = right.getEnvelopeInternal();
  if (envRight.intersects(envLeft)) {
    return left.intersects(right);
  } else {
    return false;
  }
  // Note that this is a pretty permissive logic
  // if the type has somehow been mis-set (can't happen externally)
  // then true is returned in all cases
}

protected final boolean basicEvaluate(Geometry left, Geometry right) {
  Envelope envLeft = left.getEnvelopeInternal();
  Envelope envRight = right.getEnvelopeInternal();
  return envRight.intersects(envLeft) && left.intersects(right);
}

public static boolean boundingBoxIntersects(
    GeometryType geom1, GeometryType geom2) throws FunctionExecutionException {
  Geometry g1 = getGeometry(geom1);
  Geometry g2 = getGeometry(geom2);
  return g1.getEnvelope().intersects(g2.getEnvelope());
}

public static boolean boundingBoxIntersects(
    GeometryType geom1, GeometryType geom2) throws FunctionExecutionException {
  Geometry g1 = getGeometry(geom1);
  Geometry g2 = getGeometry(geom2);
  return g1.getEnvelope().intersects(g2.getEnvelope());
}

public boolean evaluate(Object feature) {
  if (feature instanceof Feature && !validate((Feature)feature))
    return false;
  
  Geometry left = getLeftGeometry(feature);
  Geometry right = getRightGeometry(feature);
  
  Envelope envLeft = left.getEnvelopeInternal();
  Envelope envRight = right.getEnvelopeInternal();
  
  if(envRight.intersects(envLeft))
    return left.intersects(right);
  else
    return false;
}