@Override public boolean hasNext() { return index < this.sequence.size(); }
/** * Constructs a <code>LineString</code> from the specified positions * and <code>ProjectedGeometryOperations</code> implementation. * * @param positions the {@code PositionSequence} that determines this geometry * @throws IllegalArgumentException if the passed <code>PointSequence</code> is non-empty and of size < 2 */ public LineString(PositionSequence<P> positions, CoordinateReferenceSystem<P> crs) { super(positions, crs); if (positions.size() != 0 && positions.size() < 2) { throw new IllegalArgumentException("Require at least two points for a linestring"); } }
private int calculateSize() { int size = 0; for (PositionSequence<P> child : getChildren()) { size += child.size(); } return size; }
/** * Returns the number of positions in the <code>PositionSequence</code> of this <code>Geometry</code>. * * @return the number of positions in the <code>PositionSequence</code> of this <code>Geometry</code>. */ public int getNumPositions() { return getPositions().size(); }
@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())); }
@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); }
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(); }
protected void encodePoints(SqlServerGeometry nativeGeom, PositionSequence<?> coordinates) { nativeGeom.setNumberOfPoints( coordinates.size() ); nativeGeom.allocateMValueArray(); nativeGeom.allocateZValueArray(); for ( int i = 0; i < coordinates.size(); i++ ) { setCoordinate( nativeGeom, i, coordinates); } }
public static <P extends Position> MultiPoint<P> mkMultiPoint(PositionSequence<P> positions, CoordinateReferenceSystem<P> crs) { final List<Point<P>> points = new ArrayList<>(positions.size()); positions.forEach(p -> points.add( mkPoint(p, crs)) ); return mkMultiPoint(points); }
@Override protected void encodePoints(SqlServerGeometry nativeGeom, PositionSequence<?> coordinates) { super.encodePoints( nativeGeom, coordinates ); if ( coordinates.size() == 2 ) { nativeGeom.setIsSingleLineSegment(); } }
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); } }
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; }
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(); }
/** * Returns the position at the specified index in the <code>PositionSequence</code> of this <code>Geometry</code>. * * @param index the position in the <code>PositionSequence</code> (first point is at index 0). * @return the position at the specified index in the <code>PositionSequence</code> of this <code>Geometry</code>. */ public P getPositionN(int index) { if (index >= getPositions().size()) { throw new IndexOutOfBoundsException(); } double[] coords = new double[getCoordinateDimension()]; getPositions().getCoordinates(index, coords); return Positions.mkPosition(getCoordinateReferenceSystem(), coords); }
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; }
/** * Gets the CoordinateSequence corresponding to a compound element. * * @param idxFirst the first sub-element of the compound element * @param idxLast the last sub-element of the compound element * @param sdoGeom the SDOGeometry that holds the compound element. * @return */ protected <P extends Position> PositionSequence<P> getCompoundCSeq(int idxFirst, int idxLast, SDOGeometry sdoGeom) { PositionSequence<P> cs = null; for (int i = idxFirst; i <= idxLast; i++) { // pop off the last element as it is added with the next // coordinate sequence if (cs != null && cs.size() > 0) { cs = add(cs, 0, getElementCSeq(i, sdoGeom, (i < idxLast), (CoordinateReferenceSystem<P>) crs), 1); } else { cs = add(cs, getElementCSeq(i, sdoGeom, (i < idxLast), (CoordinateReferenceSystem<P>) crs)); } } return cs; }
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(); }
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); }
@Override @SuppressWarnings("unchecked") Geometry<?> internalDecode(SDOGeometry sdoGeom) { CoordinateReferenceSystem<?> crs = getCoordinateReferenceSystem(sdoGeom); final Double[] ordinates = sdoGeom.getOrdinates().getOrdinateArray(); PositionSequence<? extends Position> positions = convertOrdinateArray(ordinates, sdoGeom, crs); Point[] pnts = new Point[positions.size()]; int i = 0; for (Position p : positions) { pnts[i++] = new Point(p, crs); } return new MultiPoint(pnts); } }
/** * Linearizes arcs and circles. * * @return linearized interpolation of arcs or circle */ protected <P extends Position> PositionSequence<P> linearize(PositionSequence<P> positions, boolean entireCirlce) { PositionSequence<P> result = null; int idx = 0; while (idx < positions.size() - 2) { //only iterate if we have at least three more points P p0 = positions.getPositionN(idx++); P p1 = positions.getPositionN(idx++); P p2 = positions.getPositionN(idx); //dont' increment, we repeat next iteration from this index CircularArcLinearizer<P> linearizer = new CircularArcLinearizer<P>(p0, p1, p2, LINEARIZER_EPSILON); PositionSequence<P> ps; if (entireCirlce) { ps = linearizer.linearizeCircle(); } else { ps = linearizer.linearize(); } // if this is not the first arcsegment, the first linearized // point is already in linearizedArc, so disregard this. if (result == null) { // this is the first iteration result = ps; } else { result = add(result, 0, ps, 1); } } return result; }