public Geometry reverse() { CoordinateSequence seq = (CoordinateSequence) points.clone(); CoordinateSequences.reverse(seq); LinearRing rev = getFactory().createLinearRing(seq); return rev; } }
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; }
/** * Copies a section of a {@link CoordinateSequence} to another {@link CoordinateSequence}. * The sequences must have the same dimension. * * @param src * @param srcPos * @param dest * @param destPos * @param length */ 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 readCoordinateSequenceRing(int size) throws IOException { CoordinateSequence seq = readCoordinateSequence(size); if (isStrict) return seq; if (CoordinateSequences.isRing(seq)) return seq; return CoordinateSequences.ensureValidRing(csFactory, seq); }
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); }
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); }
/** * Reverses the coordinates in a sequence in-place. */ public static void reverse(CoordinateSequence seq) { int last = seq.size() - 1; int mid = last / 2; for (int i = 0; i <= mid; i++) { swap(seq, i, last - i); } }
/** * Ensures that a CoordinateSequence forms a valid ring, * returning a new closed sequence of the correct length if required. * If the input sequence is already a valid ring, it is returned * without modification. * If the input sequence is too short or is not closed, * it is extended with one or more copies of the start point. * * @param fact the CoordinateSequenceFactory to use to create the new sequence * @param seq the sequence to test * @return the original sequence, if it was a valid ring, or a new sequence which is valid. */ public static CoordinateSequence ensureValidRing(CoordinateSequenceFactory fact, CoordinateSequence seq) { int n = seq.size(); // empty sequence is valid if (n == 0) return seq; // too short - make a new one if (n <= 3) return createClosedRing(fact, seq, 4); boolean isClosed = seq.getOrdinate(0, CoordinateSequence.X) == seq.getOrdinate(n-1, CoordinateSequence.X) && seq.getOrdinate(0, CoordinateSequence.Y) == seq.getOrdinate(n-1, CoordinateSequence.Y); if (isClosed) return seq; // make a new closed ring return createClosedRing(fact, seq, n+1); }
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); }
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); }
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); }
/** * Reverses the coordinates in a sequence in-place. */ public static void reverse(CoordinateSequence seq) { int last = seq.size() - 1; int mid = last / 2; for (int i = 0; i <= mid; i++) { swap(seq, i, last - i); } }
/** * Ensures that a CoordinateSequence forms a valid ring, * returning a new closed sequence of the correct length if required. * If the input sequence is already a valid ring, it is returned * without modification. * If the input sequence is too short or is not closed, * it is extended with one or more copies of the start point. * * @param fact the CoordinateSequenceFactory to use to create the new sequence * @param seq the sequence to test * @return the original sequence, if it was a valid ring, or a new sequence which is valid. */ public static CoordinateSequence ensureValidRing(CoordinateSequenceFactory fact, CoordinateSequence seq) { int n = seq.size(); // empty sequence is valid if (n == 0) return seq; // too short - make a new one if (n <= 3) return createClosedRing(fact, seq, 4); boolean isClosed = seq.getOrdinate(0, CoordinateSequence.X) == seq.getOrdinate(n-1, CoordinateSequence.X) && seq.getOrdinate(0, CoordinateSequence.Y) == seq.getOrdinate(n-1, CoordinateSequence.Y); if (isClosed) return seq; // make a new closed ring return createClosedRing(fact, seq, n+1); }
/** * 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 = (CoordinateSequence) points.clone(); CoordinateSequences.reverse(seq); LineString revLine = getFactory().createLineString(seq); return revLine; }
private static CoordinateSequence createClosedRing(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 start point for (int i = n; i < size; i++) copy(seq, 0, newseq, i, 1); return newseq; }
/** * 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); } }
/** * 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 = (CoordinateSequence) points.clone(); CoordinateSequences.reverse(seq); LineString revLine = getFactory().createLineString(seq); return revLine; }
/** * Creates a {@link MultiPoint} using the * points in the given {@link CoordinateSequence}. * A <code>null</code> or empty CoordinateSequence creates an empty MultiPoint. * * @param coordinates a CoordinateSequence (possibly empty), or <code>null</code> * @return a MultiPoint geometry */ public MultiPoint createMultiPoint(CoordinateSequence coordinates) { if (coordinates == null) { return createMultiPoint(new Point[0]); } Point[] points = new Point[coordinates.size()]; for (int i = 0; i < coordinates.size(); i++) { CoordinateSequence ptSeq = getCoordinateSequenceFactory() .create(1, coordinates.getDimension()); CoordinateSequences.copy(coordinates, i, ptSeq, 0, 1); points[i] = createPoint(ptSeq); } return createMultiPoint(points); }
/** * 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; }
private static CoordinateSequence createClosedRing(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 start point for (int i = n; i < size; i++) copy(seq, 0, newseq, i, 1); return newseq; }