How to use

intersects

method

in

org.geotools.geometry.jts.ReferencedEnvelope3D

/**
 * Check if the point <code>p</code> overlaps (lies inside) the region of this <code>Envelope
 * </code>.
 *
 * @param p the <code>Coordinate</code> to be tested
 * @return <code>true</code> if the point overlaps this <code>Envelope</code>
 */
public boolean intersects(Coordinate p) {
  return intersects(p.x, p.y, p.z);
}

/**
 * @deprecated Use #intersects instead. In the future, #overlaps may be changed to be a true
 *     overlap check; that is, whether the intersection is two-dimensional.
 */
public boolean overlaps(ReferencedEnvelope3D other) {
  return intersects(other);
}

/** @deprecated Use #intersects instead. */
public boolean overlaps(double x, double y, double z) {
  return intersects(x, y, z);
}

/** @deprecated Use #intersects instead. */
public boolean overlaps(Coordinate p) {
  return intersects(p);
}

/**
 * Check if the point <code>(x, y)</code> overlaps (lies inside) the region of this <code>
 * Envelope</code>.
 *
 * @param x the x-ordinate of the point
 * @param y the y-ordinate of the point
 * @param z the z-ordinate of the point
 * @return <code>true</code> if the point overlaps this <code>Envelope</code>
 */
public boolean intersects(double x, double y, double z) {
  if (isNull()) return false;
  return intersects(x, y) && !(z > maxz || z < minz);
}

/** Check if this bounding box intersects the provided bounds. */
public boolean intersects(final BoundingBox3D bbox) {
  ensureCompatibleReferenceSystem(bbox);
  return intersects(getJTSEnvelope(bbox));
}

public boolean evaluate(Object feature) {
  Geometry other = Converters.convert(property.evaluate(feature), Geometry.class);
  if (other == null) return false;
  return get3DEnvelope(other).intersects(envelope);
}

assertFalse(envelope.intersects(1.0, 2.0, 3.0));
assertTrue(envelope.intersects(x_ave, y_ave, z_ave));
assertTrue(envelope.intersects(x_min, y_min, z_min));
assertTrue(envelope.intersects(x_max, y_max, z_max));
assertFalse(envelope.intersects(-x_ave, -y_ave, -z_ave));
assertFalse(envelope.intersects(x_min - delta, y_ave, z_ave));
assertFalse(envelope.intersects(x_max + delta, y_ave, z_ave));
assertFalse(envelope.intersects(x_ave, y_min - delta, z_ave));
assertFalse(envelope.intersects(x_ave, y_max + delta, z_ave));
assertFalse(envelope.intersects(x_ave, y_ave, z_min - delta));
assertFalse(envelope.intersects(x_ave, y_ave, z_max + delta));

/**
 * Computes the distance between this and another <code>Envelope</code>. The distance between
 * overlapping Envelopes is 0. Otherwise, the distance is the Euclidean distance between the
 * closest points.
 */
public double distance(ReferencedEnvelope3D env) {
  if (intersects(env)) return 0;
  double dx = 0.0;
  if (getMaxX() < env.getMinX()) dx = env.getMinX() - getMaxX();
  else if (getMinX() > env.getMaxX()) dx = getMinX() - env.getMaxX();
  double dy = 0.0;
  if (getMaxY() < env.getMinY()) dy = env.getMinY() - getMaxY();
  else if (getMinY() > env.getMaxY()) dy = getMinY() - env.getMaxY();
  double dz = 0.0;
  if (maxz < env.minz) dz = env.minz - maxz;
  else if (minz > env.maxz) dz = minz - env.maxz;
  // if either is zero, the envelopes overlap either vertically or
  // horizontally
  if (dx == 0.0 && dz == 0) return dy;
  if (dy == 0.0 && dz == 0) return dx;
  if (dx == 0 && dy == 0) return dz;
  return Math.sqrt(dx * dx + dy * dy + dz * dz);
}

/**
 * Computes the intersection of two {@link Envelope}s.
 *
 * @param env the envelope to intersect with
 * @return a new Envelope representing the intersection of the envelopes (this will be the null
 *     envelope if either argument is null, or they do not intersect
 */
public ReferencedEnvelope3D intersection(ReferencedEnvelope3D env) {
  ensureCompatibleReferenceSystem(env);
  if (isNull() || env.isNull() || !intersects(env)) return new ReferencedEnvelope3D();
  double intMinX = getMinX() > env.getMinX() ? getMinX() : env.getMinX();
  double intMinY = getMinY() > env.getMinY() ? getMinY() : env.getMinY();
  double intMinZ = minz > env.minz ? minz : env.minz;
  double intMaxX = getMaxX() < env.getMaxX() ? getMaxX() : env.getMaxX();
  double intMaxY = getMaxY() < env.getMaxY() ? getMaxY() : env.getMaxY();
  double intMaxZ = maxz < env.maxz ? maxz : env.maxz;
  return new ReferencedEnvelope3D(
      intMinX,
      intMaxX,
      intMinY,
      intMaxY,
      intMinZ,
      intMaxZ,
      env.getCoordinateReferenceSystem());
}