/** Returns {@code true} if this direct position is equals to the given object. */ @Override public boolean equals(final Object object) { if (object instanceof DirectPosition) { final DirectPosition other = (DirectPosition) object; if (other.getCoordinateReferenceSystem() == null) { return Arrays.equals(ordinates, other.getCoordinate()); } } return false; }
/** * Executes a linear Interpolation between two positions and returns the DirectPosition at the * distance 'par' on this straight line * * <p>This method is NON-ROBUST, e.g. it might suffer by errors caused by the Floating-point * arithmetic * * @param p0 - start position of linear interpolation * @param p1 - end position of linear interpolation * @param par - distance on the straight line, for which to search DirectPosition (from p0 to p1) * @return Position on the straight line at parameter 'par' */ public static DirectPositionImpl linearInterpolate( DirectPosition p0, DirectPosition p1, double par) { // Test ok // 0.0 <= factor <= 1.0 // par = 0 => result = dp0 // par = 1 => result = dp1 double[] coord = AlgoPointND.evaluate(p0.getCoordinates(), p1.getCoordinates(), par); return new DirectPositionImpl(p0.getCoordinateReferenceSystem(), coord); }
/** * Make sure that the specified location uses the same CRS as this one. * * @param location * @throws MismatchedReferenceSystemException if the CRS are incompatible. */ protected void ensureCompatibleReferenceSystem(DirectPosition location) { if (crs != null) { final CoordinateReferenceSystem other = location.getCoordinateReferenceSystem(); if (other != null) { if (!CRS.equalsIgnoreMetadata(crs, other)) { throw new MismatchedReferenceSystemException( Errors.format(ErrorKeys.MISMATCHED_COORDINATE_REFERENCE_SYSTEM)); } } } }
/** Returns a hash value for the given coordinate. */ static int hashCode(final DirectPosition position) { final int dimension = position.getDimension(); int code = 1; for (int i = 0; i < dimension; i++) { final long bits = Double.doubleToLongBits(position.getOrdinate(i)); code = 31 * code + ((int) (bits) ^ (int) (bits >>> 32)); } final CoordinateReferenceSystem crs = position.getCoordinateReferenceSystem(); if (crs != null) { code += crs.hashCode(); } return code; }
/** * Returns {@code true} if the specified object is also a {@linkplain DirectPosition direct * position} with equals {@linkplain #getCoordinate coordinate} and {@linkplain * #getCoordinateReferenceSystem CRS}. * * @param object The object to compare with this position. * @return {@code true} if the given object is equals to this position. */ @Override public boolean equals(final Object object) { if (object instanceof DirectPosition) { final DirectPosition that = (DirectPosition) object; final int dimension = getDimension(); if (dimension == that.getDimension()) { for (int i = 0; i < dimension; i++) { if (!Utilities.equals(this.getOrdinate(i), that.getOrdinate(i))) { return false; } } if (Utilities.equals( this.getCoordinateReferenceSystem(), that.getCoordinateReferenceSystem())) { assert hashCode() == that.hashCode() : this; return true; } } } return false; }