private CoordinateSequence readCoordinateSequenceRing(int size) throws IOException { CoordinateSequence seq = readCoordinateSequence(size); if (isStrict) return seq; if (CoordinateSequences.isRing(seq)) return seq; return CoordinateSequences.ensureValidRing(csFactory, seq); }
/** * Copies a section of a {@link CoordinateSequence} to another {@link CoordinateSequence}. * The sequences may have different dimensions; * in this case only the common dimensions are copied. * * @param src the sequence to copy from * @param srcPos the position in the source sequence to start copying at * @param dest the sequence to copy to * @param destPos the position in the destination sequence to copy to * @param length the number of coordinates to copy */ public static void copy(CoordinateSequence src, int srcPos, CoordinateSequence dest, int destPos, int length) { for (int i = 0; i < length; i++) { copyCoord(src, srcPos + i, dest, destPos + i); } }
private CoordinateSequence readCoordinateSequenceLineString(int size) throws IOException { CoordinateSequence seq = readCoordinateSequence(size); if (isStrict) return seq; if (seq.size() == 0 || seq.size() >= 2) return seq; return CoordinateSequences.extend(csFactory, seq, 2); }
/** * Shifts the positions of the coordinates until <code>firstCoordinate</code> * is first. * *@param seq the coordinate sequence to rearrange *@param firstCoordinate the coordinate to make first */ public static void scroll(CoordinateSequence seq, Coordinate firstCoordinate) { int i = indexOf(firstCoordinate, seq); if (i <= 0) return; scroll(seq, i); }
/** * 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 */ public static void scroll(CoordinateSequence seq, int indexOfFirstCoordinate) { scroll(seq, indexOfFirstCoordinate, CoordinateSequences.isRing(seq)); }
CoordinateSequences.reverse(revSeq); return revSeq;
private void normalize(LinearRing ring, boolean clockwise) { if (ring.isEmpty()) { return; } CoordinateSequence seq = ring.getCoordinateSequence(); int minCoordinateIndex = CoordinateSequences.minCoordinateIndex(seq, 0, seq.size()-2); CoordinateSequences.scroll(seq, minCoordinateIndex, true); if (Orientation.isCCW(seq) == clockwise) CoordinateSequences.reverse(seq); }
CoordinateSequences.copy(sequence, fromIndex, newSeq, 0, size); return newSeq;
public void testCopyToLargerDim() { PackedCoordinateSequenceFactory csFactory = new PackedCoordinateSequenceFactory(); CoordinateSequence cs2D = createTestSequence(csFactory, 10, 2); CoordinateSequence cs3D = csFactory.create(10, 3); CoordinateSequences.copy(cs2D, 0, cs3D, 0, cs3D.size()); assertTrue(CoordinateSequences.isEqual(cs2D, cs3D)); }
public LinearRing createLinearRing(CoordinateSequence cs) { if (cs.getCoordinate(0).equals(cs.getCoordinate(cs.size() - 1))) return super.createLinearRing(cs); // add a new coordinate to close the ring CoordinateSequenceFactory csFact = getCoordinateSequenceFactory(); CoordinateSequence csNew = csFact.create(cs.size() + 1, cs.getDimension()); CoordinateSequences.copy(cs, 0, csNew, 0, cs.size()); CoordinateSequences.copyCoord(csNew, 0, csNew, csNew.size() - 1); return super.createLinearRing(csNew); }
false); coordSeq = CoordinateSequences.ensureValidRing( gf.getCoordinateSequenceFactory(), coordSeq); ring = gf.createLinearRing(coordSeq);
/** * Returns the index of the minimum coordinate of the whole * coordinate sequence, using the usual lexicographic comparison. * *@param seq the coordinate sequence to search *@return the index of the minimum coordinate in the sequence, found using <code>compareTo</code> *@see Coordinate#compareTo(Object) */ public static int minCoordinateIndex(CoordinateSequence seq) { return minCoordinateIndex(seq, 0, seq.size() - 1); }
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 doTestIndexOf(CoordinateSequenceFactory factory, int dimension) { // arrange CoordinateSequence sequence = createSequenceFromOrdinates(factory, dimension); // act & assert Coordinate[] coordinates = sequence.toCoordinateArray(); for (int i = 0; i < sequence.size(); i++) assertEquals(i, CoordinateSequences.indexOf(coordinates[i], sequence)); }
/** * Reverses a LineString according to the z value. The z of the first point * must be lower than the z of the end point. * * @param lineString * @return */ private static LineString reverse3D(LineString lineString, String order) { CoordinateSequence seq = lineString.getCoordinateSequence(); double startZ = seq.getCoordinate(0).z; double endZ = seq.getCoordinate(seq.size() - 1).z; if (order.equalsIgnoreCase("desc")) { if (!Double.isNaN(startZ) && !Double.isNaN(endZ) && startZ < endZ) { CoordinateSequences.reverse(seq); return FACTORY.createLineString(seq); } } else if (order.equalsIgnoreCase("asc")) { if (!Double.isNaN(startZ) && !Double.isNaN(endZ) && startZ > endZ) { CoordinateSequences.reverse(seq); return FACTORY.createLineString(seq); } } else { throw new IllegalArgumentException("Supported order values are asc or desc."); } return lineString; }
public static CoordinateSequence extend(CoordinateSequenceFactory fact, CoordinateSequence seq, int size) { CoordinateSequence newseq = fact.create(size, seq.getDimension()); int n = seq.size(); copy(seq, 0, newseq, 0, n); // fill remaining coordinates with end point, if it exists if (n > 0) { for (int i = n; i < size; i++) copy(seq, n-1, newseq, i, 1); } return newseq; }
public void testCopyToSmallerDim() { PackedCoordinateSequenceFactory csFactory = new PackedCoordinateSequenceFactory(); CoordinateSequence cs3D = createTestSequence(csFactory, 10, 3); CoordinateSequence cs2D = csFactory.create(10, 2); CoordinateSequences.copy(cs3D, 0, cs2D, 0, cs2D.size()); assertTrue(CoordinateSequences.isEqual(cs2D, cs3D)); }
private static void doTestMinCoordinateIndex(CoordinateSequenceFactory factory, int dimension) { CoordinateSequence sequence = createSequenceFromOrdinates(factory, dimension); if (sequence.size() <= 6) { System.out.println("sequence has a size of " + sequence.size() + ". Execution of this test needs a sequence "+ "with more than 5 coordinates."); return; } int minIndex = sequence.size() / 2; sequence.setOrdinate(minIndex, 0, 5); sequence.setOrdinate(minIndex, 1, 5); assertEquals(minIndex, CoordinateSequences.minCoordinateIndex(sequence)); assertEquals(minIndex, CoordinateSequences.minCoordinateIndex(sequence, 2, sequence.size()-2)); }
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); }
private CoordinateSequence readCoordinateSequenceRing(int size) throws IOException { CoordinateSequence seq = readCoordinateSequence(size); if (isStrict) return seq; if (CoordinateSequences.isRing(seq)) return seq; return CoordinateSequences.ensureValidRing(csFactory, seq); }