/** * Convenience method which provides a standard way of copying {@link CoordinateSequence}s * @param seq the sequence to copy * @return a deep copy of the sequence */ protected final CoordinateSequence copy(CoordinateSequence seq) { return seq.copy(); }
@Override public CoordinateSequence copy() { return new SubSequence(orig.copy(), fromIndex, toIndex); } }
protected LinearRing copyInternal() { return new LinearRing(points.copy(), factory); }
protected LineString copyInternal() { return new LineString(points.copy(), factory); }
protected Point copyInternal() { return new Point(coordinates.copy(), factory); }
public Geometry reverse() { CoordinateSequence seq = points.copy(); CoordinateSequences.reverse(seq); LinearRing rev = getFactory().createLinearRing(seq); return rev; } }
/** * Creates a {@link LineString} whose coordinates are in the reverse * order of this objects * * @return a {@link LineString} with coordinates in the reverse order */ public Geometry reverse() { CoordinateSequence seq = points.copy(); CoordinateSequences.reverse(seq); LineString revLine = getFactory().createLineString(seq); return revLine; }
private static void doTestReverse(CoordinateSequenceFactory factory, int dimension) { // arrange CoordinateSequence sequence = createSequenceFromOrdinates(factory, dimension); CoordinateSequence reversed = sequence.copy(); // act CoordinateSequences.reverse(reversed); // assert for (int i = 0; i < sequence.size(); i++) checkCoordinateAt(sequence, i, reversed, sequence.size() - i - 1, dimension); }
/** * Normalizes a LineString. A normalized linestring * has the first point which is not equal to it's reflected point * less than the reflected point. */ public void normalize() { for (int i = 0; i < points.size() / 2; i++) { int j = points.size() - 1 - i; // skip equal points on both ends if (!points.getCoordinate(i).equals(points.getCoordinate(j))) { if (points.getCoordinate(i).compareTo(points.getCoordinate(j)) > 0) { CoordinateSequence copy = points.copy(); CoordinateSequences.reverse(copy); points = copy; } return; } } }
/** * Shifts the positions of the coordinates until the coordinate at <code>firstCoordinateIndex</code> * is first. * *@param seq the coordinate sequence to rearrange *@param indexOfFirstCoordinate * the index of the coordinate to make first *@param ensureRing * makes sure that {@code} will be a closed ring upon exit */ public static void scroll(CoordinateSequence seq, int indexOfFirstCoordinate, boolean ensureRing) { int i = indexOfFirstCoordinate; if (i <= 0) return; // make a copy of the sequence CoordinateSequence copy = seq.copy(); // test if ring, determine last index int last = ensureRing ? seq.size() - 1: seq.size(); // fill in values for (int j = 0; j < last; j++) { for (int k = 0; k < seq.getDimension(); k++) seq.setOrdinate(j, k, copy.getOrdinate((indexOfFirstCoordinate+j)%last, k)); } // Fix the ring (first == last) if (ensureRing) { for (int k = 0; k < seq.getDimension(); k++) seq.setOrdinate(last, k, seq.getOrdinate(0, k)); } }
private static void doTestScroll(CoordinateSequenceFactory factory, int dimension) { // arrange CoordinateSequence sequence = createCircularString(factory, dimension, new Coordinate(20, 20), 7d, 0.1, 22); CoordinateSequence scrolled = sequence.copy(); // act CoordinateSequences.scroll(scrolled, 12); // assert int io = 12; for (int is = 0; is < scrolled.size() - 1; is++) { checkCoordinateAt(sequence, io, scrolled, is, dimension); io++; io%=scrolled.size(); } }
private static void doTestScrollRing(CoordinateSequenceFactory factory, int dimension) { // arrange //System.out.println("Testing '" + factory.getClass().getSimpleName() + "' with dim=" +dimension ); CoordinateSequence sequence = createCircle(factory, dimension, new Coordinate(10, 10), 9d); CoordinateSequence scrolled = sequence.copy(); // act CoordinateSequences.scroll(scrolled, 12); // assert int io = 12; for (int is = 0; is < scrolled.size() - 1; is++) { checkCoordinateAt(sequence, io, scrolled, is, dimension); io++; io%=scrolled.size()-1; } checkCoordinateAt(scrolled, 0, scrolled, scrolled.size()-1, dimension); }
public void testClone() { CoordinateSequence s1 = CoordinateArraySequenceFactory.instance().create( new Coordinate[] { new Coordinate(1, 2), new Coordinate(3, 4)}); CoordinateSequence s2 = (CoordinateSequence) s1.copy(); assertTrue(s1.getCoordinate(0).equals(s2.getCoordinate(0))); assertTrue(s1.getCoordinate(0) != s2.getCoordinate(0)); }
public void testCloneDimension2() { CoordinateSequence s1 = CoordinateArraySequenceFactory.instance() .create( 2, 2 ); s1.setOrdinate(0, 0, 1); s1.setOrdinate(0, 1, 2); s1.setOrdinate(1, 0, 3); s1.setOrdinate(1, 1, 4); CoordinateSequence s2 = (CoordinateSequence) s1.copy(); assertTrue(s1.getDimension() == s2.getDimension()); assertTrue(s1.getCoordinate(0).equals(s2.getCoordinate(0))); assertTrue(s1.getCoordinate(0) != s2.getCoordinate(0)); } }