private static Geometry<C2D> toPolygon(Envelope env) { final PositionSequence<C2D> ps = PositionSequenceBuilders.fixedSized( 4, C2D.class ) .add( env.lowerLeft().getCoordinate( 0 ), env.lowerLeft().getCoordinate( 1 ) ) .add( env.lowerLeft().getCoordinate( 0 ), env.upperRight().getCoordinate( 1 ) ) .add( env.upperRight().getCoordinate( 0 ), env.upperRight().getCoordinate( 1 ) ) .add( env.lowerLeft().getCoordinate( 0 ), env.lowerLeft().getCoordinate( 1 ) ) .toPositionSequence(); return new Polygon<C2D>( ps, CoordinateReferenceSystems.PROJECTED_2D_METER ); }
@Override public PositionSequence<P> toPositionSequence() { return delegate.toPositionSequence(); }
PositionSequence<P> result() { return builder.toPositionSequence(); } }
/** * Creates an empty Geometry * * @param crs the CoordinateReferenceSystem to use */ protected Geometry(CoordinateReferenceSystem<P> crs) { if (crs == null) throw new IllegalArgumentException("Received null CRS argument"); this.crs = crs; this.positions = PositionSequenceBuilders.fixedSized(0, crs.getPositionClass()).toPositionSequence(); }
private void startNewPointSequenceIfNotEmpty() { if (!sequenceIsEmpty) { positionSequences.add(currentBuilder.toPositionSequence()); currentBuilder = PositionSequenceBuilders.variableSized(this.geometry.getPositionClass()); sequenceIsEmpty = true; } }
public static <P extends Position> PositionSequence<P> collect(Class<P> positionType, P... positions) { PositionSequenceBuilder<P> builder = PositionSequenceBuilders.fixedSized(positions.length, positionType); for(P p : positions) { builder.add(p); } return builder.toPositionSequence(); }
protected <P extends Position> PositionSequence<P> reverse(PositionSequence<P> positions) { PositionSequenceBuilder<P> builder = fixedSized(positions.size(), positions.getPositionClass()); Stack<P> stack = new Stack<P>(); for (P pos : positions) { stack.push(pos); } while (!stack.empty()) { builder.add(stack.pop()); } return builder.toPositionSequence(); }
final PositionSequenceBuilder<P> builder = PositionSequenceBuilders.fixedSized( source.size(), targetPosClass ); if ( source.isEmpty() ) { return builder.toPositionSequence(); return builder.toPositionSequence();
public PositionSequence<P> linearizeCircle() { double angleIncr = acos((c.radius - threshold) / c.radius); PositionSequenceBuilder<P> builder = variableSized((Class<P>) p0.getClass()); double theta0 = angleInDirection(p0); double theta1 = angleInDirection(p1); builder.add(p0); AddPointsBetweenPolarCoordinates(theta0, theta1, p0, p1, angleIncr, builder); builder.add(p1); //TODO -- I'm not sure whether this actually works if the circle defined by the 3 positions is in clockwise direction // AddPointsBetweenPolarCoordinates(theta1, theta0 + 2 * Math.PI, p1, p0, angleIncr, builder, true); AddPointsBetweenPolarCoordinates(theta1, theta0, p1, p0, angleIncr, builder); builder.add(p0); return builder.toPositionSequence(); }
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(); }
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(); }
protected <P extends Position> PositionSequence<P> add(PositionSequence<P> seq1, int seq1Offset, PositionSequence<P> seq2, int seq2Offset) { if (seq1 == null) { return seq2; } if (seq2 == null) { return seq1; } int totalSize = seq1.size() - seq1Offset + seq2.size() - seq2Offset; PositionSequenceBuilder<P> builder = fixedSized(totalSize, seq1.getPositionClass()); CombiningVisitor<P> visitor = new CombiningVisitor<P>(builder); addToBuilder(seq1, seq1Offset, builder, visitor); addToBuilder(seq2, seq2Offset, builder, visitor); return builder.toPositionSequence(); }
/** * Creates a new <code>PositionSequence</code> with positions in reverse order. * * @return */ @Override public PositionSequence<P> reverse() { PositionSequenceBuilder<P> builder = PositionSequenceBuilders.fixedSized(size(), getPositionClass()); double[] coords = new double[getCoordinateDimension()]; for (int i = size() - 1; i >= 0 ; i--) { getCoordinates(i, coords); builder.add(coords); } return builder.toPositionSequence(); }
protected <P extends Position> PositionSequence<P> convertOrdinateArray(Double[] oordinates, SDOGeometry sdoGeom, CoordinateReferenceSystem<P> crs) { final int dim = sdoGeom.getDimension(); int numPos = oordinates.length / dim; PositionSequenceBuilder<P> sequenceBuilder = fixedSized(numPos, crs.getPositionClass()); final int zDim = sdoGeom.getZDimension() - 1; final int lrsDim = sdoGeom.getLRSDimension() - 1; double[] buffer = new double[dim]; for (int posIdx = 0; posIdx < numPos; posIdx++) { int componentIdx = 0; //tracks component in Position buffer[componentIdx] = oordinates[posIdx * dim + componentIdx]; //x componentIdx++; buffer[componentIdx] = oordinates[posIdx * dim + componentIdx]; //y if (zDim > 0) { componentIdx++; /* * Z ordinate can be null! This is valid in ORACLE, but leads to an NPE because of autoboxing. */ Double zOrdinate = oordinates[posIdx * dim + zDim]; buffer[componentIdx] = zOrdinate == null ? Double.NaN : zOrdinate; } if (lrsDim > 0) { componentIdx++; buffer[componentIdx] = oordinates[posIdx * dim + lrsDim]; } sequenceBuilder.add(buffer); } return sequenceBuilder.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()); }
private <T extends C2D & Measured> LineString<T> measure(LineString<T> geometry) { CoordinateReferenceSystem<T> crs = geometry.getCoordinateReferenceSystem(); PositionSequence originalPoints = geometry.getPositions(); PositionSequenceBuilder<T> builder = PositionSequenceBuilders.fixedSized(originalPoints.size(), geometry.getPositionClass()); int mIdx = hasVerticalAxis(crs) ? 3 :2; double[] coordinates = new double[geometry.getCoordinateDimension()]; double[] prevCoordinates = new double[geometry.getCoordinateDimension()]; for (int i = 0; i < originalPoints.size(); i++) { originalPoints.getCoordinates(i, coordinates); if (i > 0) { length += Math.hypot(coordinates[0] - prevCoordinates[0], coordinates[1] - prevCoordinates[1]); } coordinates[mIdx] = length; builder.add(coordinates); prevCoordinates[0] = coordinates[0]; prevCoordinates[1] = coordinates[1]; } return new LineString<T>(builder.toPositionSequence(), crs); }
private <P extends Position> PositionSequence<P> env2Seq(P p0, P p1, boolean asExteriorRing) { Envelope<P> env = new Envelope<P>(p0, p1, (CoordinateReferenceSystem<P>) crs); if (asExteriorRing) { return fixedSized(5, (Class<P>) crs.getPositionClass()) .add(env.lowerLeft()) .add(env.lowerRight()) .add(env.upperRight()) .add(env.upperLeft()) .add(env.lowerLeft()).toPositionSequence(); } else { return fixedSized(5, (Class<P>) crs.getPositionClass()) .add(env.lowerLeft()) .add(env.upperLeft()) .add(env.upperRight()) .add(env.lowerRight()) .add(env.lowerLeft()).toPositionSequence(); } }