/** * Copies a coordinate of a {@link CoordinateSequence} to another {@link CoordinateSequence}. * The sequences must have the same dimension. * * @param src * @param srcPos * @param dest * @param destPos */ public static void copyCoord(CoordinateSequence src, int srcPos, CoordinateSequence dest, int destPos) { for (int dim = 0; dim < src.getDimension(); dim++) { dest.setOrdinate(destPos, dim, src.getOrdinate(srcPos, dim)); } }
/** * Creates a new sequence based on a deep copy of the given {@link CoordinateSequence}. * The coordinate dimension is set to equal the dimension of the input. * * @param coordSeq the coordinate sequence that will be copied. */ public CoordinateArraySequence(CoordinateSequence coordSeq) { if (coordSeq != null) { dimension = coordSeq.getDimension(); coordinates = new Coordinate[coordSeq.size()]; } else coordinates = new Coordinate[0]; for (int i = 0; i < coordinates.length; i++) { coordinates[i] = coordSeq.getCoordinateCopy(i); } }
int size2 = s2.size(); int dim1 = s1.getDimension(); int dim2 = s2.getDimension();
private CoordinateSequence readCoordinateSequence(int size) throws IOException { CoordinateSequence seq = csFactory.create(size, inputDimension); int targetDim = seq.getDimension(); if (targetDim > inputDimension) targetDim = inputDimension; for (int i = 0; i < size; i++) { readCoordinate(); for (int j = 0; j < targetDim; j++) { seq.setOrdinate(i, j, ordValues[j]); } } return seq; }
/** * Appends the i'th coordinate from the sequence to the writer * * @param seq the <code>CoordinateSequence</code> to process * @param i the index of the coordinate to write * @param writer the output writer to append to */ private void appendCoordinate(CoordinateSequence seq, int i, Writer writer) throws IOException { writer.write(writeNumber(seq.getX(i)) + " " + writeNumber(seq.getY(i))); if (outputDimension >= 3 && seq.getDimension() >= 3) { double z = seq.getOrdinate(i, 3); if (! Double.isNaN(z)) { writer.write(" "); writer.write(writeNumber(z)); } } }
dim = cs.getDimension(); // max dim
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; }
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; }
/** * Swaps two coordinates in a sequence. * * @param seq * @param i * @param j */ public static void swap(CoordinateSequence seq, int i, int j) { if (i == j) return; for (int dim = 0; dim < seq.getDimension(); dim++) { double tmp = seq.getOrdinate(i, dim); seq.setOrdinate(i, dim, seq.getOrdinate(j, dim)); seq.setOrdinate(j, dim, tmp); } }
/** * 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); }
private void writeCoordinate(CoordinateSequence seq, int index, OutStream os) throws IOException { ByteOrderValues.putDouble(seq.getX(index), buf, byteOrder); os.write(buf, 8); ByteOrderValues.putDouble(seq.getY(index), buf, byteOrder); os.write(buf, 8); // only write 3rd dim if caller has requested it for this writer if (outputDimension >= 3) { // if 3rd dim is requested, only write it if the CoordinateSequence provides it double ordVal = Coordinate.NULL_ORDINATE; if (seq.getDimension() >= 3) ordVal = seq.getOrdinate(index, 2); ByteOrderValues.putDouble(ordVal, buf, byteOrder); os.write(buf, 8); } } }
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 void gatherDim4(CoordinateSequence cs, Map<Coordinate, Double> map) { if (cs.getDimension() == 4) { for (int i = 0; i < cs.size(); i++) { map.put(cs.getCoordinate(i), cs.getOrdinate(i, 3)); } } }
private void gatherDim4(CoordinateSequence cs, Map<Coordinate, Double> map) { if (cs.getDimension() == 4) { for (int i = 0; i < cs.size(); i++) { map.put(cs.getCoordinate(i), cs.getOrdinate(i, 3)); } } }
public void filter(CoordinateSequence coordinates, int index) { for (int i = 0; i < coordinates.getDimension(); i++) { double ordinate = coordinates.getOrdinate(index, i); double preciseOrdinate = precision.makePrecise(ordinate); coordinates.setOrdinate(index, i, preciseOrdinate); } }
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; }
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; }
protected void write(Encoder output, CoordinateSequence coordseq) throws IOException { int dim = coordseq.getDimension(); // if(dim>2) { // throw new IllegalArgumentException("only supports 2d geometry now ("+dim+")"); // } for (int i = 0; i < coordseq.size(); i++) { output.write(coordseq.getOrdinate(i, 0), coordseq.getOrdinate(i, 1)); } }
@Test public void Empty2dTest() { assertEquals(2, FloatPackedCoordinateSequence.EMPTY_2D.getDimension() ); assertEquals(0, FloatPackedCoordinateSequence.EMPTY_2D.size() ); }
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); }