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(); }
@Override public PositionSequenceBuilder<P> add(double... coordinates) { num++; return delegate.add(coordinates); }
PositionSequence<P> result() { return builder.toPositionSequence(); } }
/** * The visit method that is executed for each coordinate. * * @param coordinate the visited coordinate in array representation */ @Override public void visit(double[] coordinate) { this.builder.add(coordinate); }
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(); }
/** * 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(); }
public PositionSequenceBuilder<P> add(P position) { num++; return delegate.add(position); }
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(); }
private void startNewPointSequenceIfNotEmpty() { if (!sequenceIsEmpty) { positionSequences.add(currentBuilder.toPositionSequence()); currentBuilder = PositionSequenceBuilders.variableSized(this.geometry.getPositionClass()); sequenceIsEmpty = true; } }
private P addIfNotEqualLast(P lastPoint, P newPnt) { assert (newPnt != null); if (!newPnt.equals(lastPoint)) { currentBuilder.add(newPnt); lastPoint = newPnt; } return lastPoint; }
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(); }
final PositionSequenceBuilder<P> builder = PositionSequenceBuilders.fixedSized( source.size(), targetPosClass ); if ( source.isEmpty() ) { return builder.toPositionSequence(); return builder.toPositionSequence();
public void visit(Q position) { position.toArray( coords ); builder.add( coords ); } };
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(); } }
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(); }
private <P extends Position> void addToBuilder(PositionSequence<P> seq, int skip, PositionSequenceBuilder<P> builder, CombiningVisitor<P> visitor) { if (skip == 0) { seq.accept(visitor); } else { for (P pos : seq) { if (skip-- <= 0) { builder.add(pos); } } } }
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(); }
PositionSequence<P> last = currentBuilder.toPositionSequence(); if (!last.isEmpty()) { positionSequences.add(last);
buf[2 + i] = buf[2 + i] + incr[i]; builder.add(buf);