EnvelopeVisitor(CoordinateReferenceSystem<P> crs) { this.crs = crs; coordinates = new double[crs.getCoordinateDimension()]; }
private <P extends Position> void readPosition(ByteBuffer byteBuffer, double[] coordinates, CoordinateReferenceSystem<P> crs) { for (int ci = 0; ci < crs.getCoordinateDimension(); ci++) { coordinates[ci] = byteBuffer.getDouble(); } }
/** * Create an instance using the specified coordinates and <code>CoordinateReferenceSystem</code>. * * If the {@code CoordinateReferenceSystem} has coordinate dimension > 2, the Z/M coordinate values will be set to 0 * in the envelope * * @param minC1 minimum first coordinate * @param minC2 minimum second coordinate * @param maxC1 maximum first coordinate * @param maxC2 maximum second coordinate * @param crs the <code>CoordinateReferenceSystem</code> for the coordinates * of the envelope. */ public Envelope(double minC1, double minC2, double maxC1, double maxC2, CoordinateReferenceSystem<P> crs) { if (crs == null) { throw new IllegalArgumentException("Null CRS argument not allowed"); } double[] lowerLeft = new double[crs.getCoordinateDimension()]; double[] upperRight = new double[crs.getCoordinateDimension()]; lowerLeft[0] = minC1 <= maxC1 ? minC1 : maxC1; lowerLeft[1] = minC2 <= maxC2 ? minC2 : maxC2; upperRight[0] = minC1 > maxC1 ? minC1 : maxC1; upperRight[1] = minC2 > maxC2 ? minC2 : maxC2; this.crs = crs; this.lowerLeft = Positions.mkPosition(crs, lowerLeft); this.upperRight = Positions.mkPosition(crs, upperRight); }
public CountingPositionSequenceBuilder(CoordinateReferenceSystem<P> crs) { delegate = PositionSequenceBuilders.variableSized(crs.getPositionClass()); dim = crs.getCoordinateDimension(); }
public static <P extends Position> P positionWithin(Envelope<P> bbox, Random rnd) { P ll = bbox.lowerLeft(); P ur = bbox.upperRight(); CoordinateReferenceSystem<P> crs = bbox.getCoordinateReferenceSystem(); double[] coords = new double[crs.getCoordinateDimension()]; for (int i = 0; i < coords.length; i++) { coords[i] = ll.getCoordinate(i) + (ur.getCoordinate(i) - ll.getCoordinate(i)) * rnd.nextDouble(); } return Positions.mkPosition(crs, coords); } }
private <P extends Position> CoordinateSequence fromCoordinateArray(Coordinate[] coordinates, CoordinateReferenceSystem<P> crs) { PositionSequenceBuilder<P> builder = PositionSequenceBuilders.fixedSized(coordinates.length, crs.getPositionClass()); double[] ordinates = new double[crs.getCoordinateDimension()]; for (Coordinate co : coordinates) { copy(co, ordinates, crs); builder.add(ordinates); } return (CoordinateSequence) builder.toPositionSequence(); }
private <P extends Position> PositionSequence<P> readPositions(int numPos, ByteBuffer byteBuffer, CoordinateReferenceSystem<P> crs) { PositionSequenceBuilder<P> psBuilder = PositionSequenceBuilders.fixedSized(numPos, crs.getPositionClass()); double[] coordinates = new double[crs.getCoordinateDimension()]; for (int i = 0; i < numPos; i++) { readPosition(byteBuffer, coordinates, crs); psBuilder.add(coordinates); } return psBuilder.toPositionSequence(); }
private P interpolate(P p0, P p1, double r) { int dim = getCrs().getCoordinateDimension(); double result[] = new double[dim]; for (int i = 0; i < dim; i++) { result[i] = p0.getCoordinate(i) + r * (p1.getCoordinate(i) - p0.getCoordinate(i)); } return Positions.mkPosition(getCrs(), result); }
static <P extends Position> PositionSequence<P> toSeq(CoordinateReferenceSystem<P> crs, P[] positions) { PositionSequenceBuilder<P> builder = PositionSequenceBuilders.fixedSized(positions.length, crs.getPositionClass()); double[] coords = new double[crs.getCoordinateDimension()]; for (P t : positions) { P pos = Positions.mkPosition(crs, t.toArray(coords)); builder.add(pos); } return builder.toPositionSequence(); }
PositionSequence<?> coordinateRange(IndexRange range) { crs = getCRS(getSrid(), hasZValues(), hasMValues()); PositionSequenceBuilder<?> psBuilder = PositionSequenceBuilders.fixedSized(range.end - range.start, crs.getPositionClass()); double[] coordinates = new double[crs.getCoordinateDimension()]; for (int idx = range.start, i = 0; idx < range.end; idx++, i++) { copyCoordinate(idx, coordinates, crs); psBuilder.add(coordinates); } return psBuilder.toPositionSequence(); }
@SuppressWarnings("unchecked") public <P extends Position> PositionSequence<P> toPositionSequence(CoordinateSequence cs, Class<P> posType, CoordinateReferenceSystem<P> crs) { if (cs instanceof PositionSequence && ((PositionSequence) cs).getPositionClass().equals(posType)) { return (PositionSequence<P>) cs; } Coordinate c = new Coordinate(); double[] psc = new double[crs.getCoordinateDimension()]; Arrays.fill(psc, Double.NaN); PositionSequenceBuilder<P> builder = PositionSequenceBuilders.fixedSized(cs.size(), posType); for (int i = 0; i < cs.size(); i++) { psc[0] = cs.getX(i); psc[1] = cs.getY(i); if (hasVerticalAxis(crs)) { psc[2] = cs.getZ(i); } // transfer measure values to position if (hasMeasureAxis(crs)) { final int idxM = hasVerticalAxis(crs) ? 3 : 2; final double mOrdinate = cs.getM(i); psc[idxM] = mOrdinate; } builder.add(psc); } return builder.toPositionSequence(); }
@Override WktToken numericToken() { CoordinateReferenceSystem<?> crs = getCoordinateReferenceSystem(); int numPoints = countPoints(); //Note that the coords array can be larger than the number of coordinates available in the pointsequence // e.g. when a composite CRS is passed in the decode function for a 2D WKT. // this works because fastReadNumber returns 0 when attempting to read beyond a point delimiter double[] coords = new double[crs.getCoordinateDimension()]; PositionSequenceBuilder<?> psBuilder = PositionSequenceBuilders.fixedSized(numPoints, crs.getPositionClass()); for (int i = 0; i < numPoints; i++) { readPoint(coords); psBuilder.add(coords); skipPointDelimiter(); } return new WktPointSequenceToken(psBuilder.toPositionSequence(), getCoordinateReferenceSystem()); }