protected Double[] convertPositionSequence(PositionSequence<?> coordinates) { int dim = coordinates.getCoordinateDimension(); if (dim > 4) { throw new IllegalArgumentException("Dim parameter value cannot be greater than 4"); } final Double[] converted = new Double[coordinates.size() * dim]; LLAPositionVisitor visitor = new ToArrayVisitor(converted); coordinates.accept(visitor); return converted; }
private <P extends Position> boolean testPointSequenceEquality(PositionSequence<P> first, PositionSequence<P> second) { if (!first.getPositionClass().equals(second.getPositionClass())) return false; double[] c1 = new double[first.getCoordinateDimension()]; double[] c2 = new double[second.getCoordinateDimension()]; for (int idx = 0; idx < first.size(); idx++) { first.getCoordinates(idx, c1); second.getCoordinates(idx, c2); if(!this.positionEquality.equals(c1, c2)) return false; } return true; }
@Override public <P extends Position> boolean equals(PositionSequence<P> first, PositionSequence<P> second) { if (first == second) return true; if (first == null || second == null) return false; if (first.isEmpty() && second.isEmpty()) return true; if (first.size() != second.size()) return false; return testPointSequenceEquality(first, second); }
final Class<P> targetPosClass) { PositionFactory<P> factory = Positions.getFactoryFor( targetPosClass ); final PositionSequenceBuilder<P> builder = PositionSequenceBuilders.fixedSized( source.size(), targetPosClass ); if ( source.isEmpty() ) { return builder.toPositionSequence(); source.getCoordinateDimension(), factory.getCoordinateDimension() )]; source.accept( visitor ); return builder.toPositionSequence();
protected void writePoints(PositionSequence<P> points, int coordinateDimension, ByteBuffer output) { double[] coordinates = new double[coordinateDimension]; for (int i = 0; i < points.size(); i++) { points.getCoordinates(i, coordinates); writePoint(coordinates, output); } }
@Override public P next() { double[] coordinates = new double[sequence.getCoordinateDimension()]; if (hasNext()){ sequence.getCoordinates(index++, coordinates); return Positions.mkPosition(sequence.getPositionClass(), coordinates); } throw new NoSuchElementException(); }
private <P extends Position> void addPointList(PositionSequence<P> points) { addStartList(); double[] coords = new double[points.getCoordinateDimension()]; for (int i = 0; i < points.size(); i++) { if (i > 0) { addDelimiter(); } points.getCoordinates(i, coords); addPoint(coords); } addEndList(); }
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(); }
/** * Determines whether the specified {@code PositionSequence} is counter-clockwise. * <p/> * <p>Only the first three positions, are inspected to determine whether the sequence is counter-clockwise. * In case are less than three positions in the sequence, the method returns true.</p> * * @param positions a {@code PositionSequence} * @return true if the positions in the specified sequence are counter-clockwise, or if the sequence contains * less than three elements. */ public static boolean isCounterClockwise(PositionSequence<?> positions) { if (positions.size() < 3) return true; Position p0 = positions.getPositionN(0); Position p1 = positions.getPositionN(1); double det = 0; int positionsSize = positions.size(); int i = 2; while(i < positionsSize && det == 0) { Position p2 = positions.getPositionN(i); det = deltaDeterminant(p0, p1, p2); i++; } if (det == 0) { throw new IllegalArgumentException("Positions are collinear in 2D"); } return det > 0; }
private static <C extends Position> PositionFactory<C> extractFactory(PositionSequence<C>[] children) { if (children == null) { throw new IllegalArgumentException("Null or empty children array not allowed."); } else { PositionFactory<C> factory = null; for (PositionSequence<C> seq : children) { if (seq.isEmpty()) continue; if (seq == null) { throw new IllegalArgumentException("No null entries allowed in children array."); } else { if (factory != null && !factory.equals(seq.getPositionFactory())) { throw new IllegalArgumentException("All child sequences must have the same Coordinate Reference System"); } factory = seq.getPositionFactory(); } } return factory; } }
public Class<P> getPositionClass() { return !getPositions().isEmpty() ? getPositions().getPositionClass() : this.crs.getPositionClass(); }
@Override public void accept(PositionVisitor<P> visitor) { for (PositionSequence<P> child : getChildren()) { child.accept(visitor); } }
/** * Returns the <code>Position</code> of this <code>Point</code>. * * @return the <code>Position</code> of this <code>Point</code>. */ public P getPosition() { return getPositions().getPositionN(0) ; }
/** * Creates a new <code>PositionSequence</code> with positions in reverse order. * * @return */ @Override public PositionSequence<P> reverse() { PositionSequence<P>[] childrenCopy = this.getChildren(); for (int i = 0; i < childrenCopy.length; i++){ childrenCopy[i] = childrenCopy[i].reverse(); } reverseInPlace(childrenCopy); return new NestedPositionSequence<P>(childrenCopy); }
/** * Tests whether this <code>Geometry</code> corresponds to the empty set. * * @return true if this <code>Geometry</code> corresponds to the empty set, false otherwise. */ public boolean isEmpty() { return this.getPositions().isEmpty(); }
/** * set currentChildIterator to the iterator of the next child, if this child has no more elements and a next child exists. */ private void advanceChildIterator() { while (childIndex < children.length && (currentChildIterator == null || !currentChildIterator.hasNext())) { currentChildIterator = children[childIndex++].iterator(); } }
/** * Returns the coordinate dimension of this <code>Geometry</code> * <p/> * <p>The coordinate dimension is the number of components in the coordinates of the points in * this <code>Geometry</code>. </p> * * @return the coordinate dimension */ public int getCoordinateDimension() { return getPositions().getCoordinateDimension(); }
@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 public void getCoordinates(int position, double[] coordinates) { int childOffset = position; for (PositionSequence<P> child : getChildren()) { if (childOffset < child.size()) { child.getCoordinates(childOffset, coordinates); return; } else { childOffset -= child.size(); } } throw new ArrayIndexOutOfBoundsException(String.format("Index %d not found in collection of size %d", position, size())); }