nextCoordSeq = geomFactory.getCoordinateSequenceFactory().create(2 + cmdLength, 2); nextCoord = nextCoordSeq.getCoordinate(0); nextCoord.setOrdinate(0, cursor.x); nextCoord.setOrdinate(1, cursor.y); ); nextCoord = nextCoordSeq.getCoordinate(lineToIndex + 1); nextCoord.setOrdinate(0, cursor.x); nextCoord.setOrdinate(1, cursor.y); nextCoord = nextCoordSeq.getCoordinate(nextCoordSeq.size() - 1); nextCoord.setOrdinate(0, nextCoordSeq.getOrdinate(0, 0)); nextCoord.setOrdinate(1, nextCoordSeq.getOrdinate(0, 1)); rings.add(geomFactory.createLinearRing(nextCoordSeq)); return geomFactory.createMultiPolygon(polygons.toArray(new Polygon[polygons.size()]));
@Override public void filter(CoordinateSequence seq, int i) { seq.setOrdinate(i, 0, Math.round(seq.getOrdinate(i, 0))); seq.setOrdinate(i, 1, Math.round(seq.getOrdinate(i, 1))); }
@Override public int hashCode() { CoordinateSequence cs = ls.getCoordinateSequence(); int maxIdx = cs.size() - 1; int x = (int) (cs.getX(0) * 1000000) + (int) (cs.getX(maxIdx) * 1000000); int y = (int) (cs.getY(0) * 1000000) + (int) (cs.getY(maxIdx) * 1000000); return x + y * 101149 + maxIdx * 7883; }
public boolean matchesBackward(CoordinateSequence cs0, CoordinateSequence cs1) { if (cs0.size() != cs1.size()) return false; int maxIdx = cs0.size() - 1; for (int i = 0; i <= maxIdx; i++) if (!cs0.getCoordinate(i).equals(cs1.getCoordinate(maxIdx - i))) return false; return true; }
CoordinateSequence outerRingSeq = makeSequenceValid(polygon.getExteriorRing().getCoordinateSequence(), false, true); if (outerRingSeq.size() == 0 || outerRingSeq.size() < 4) { List<Geometry> list = new ArrayList<>(); if (outerRingSeq.size() > 0) { list.add(makeLineStringValid(polygon.getExteriorRing())); return factory.createPolygon(outerRingSeq); } else { return factory.buildGeometry(list); List<Geometry> degeneratedRings = new ArrayList<>(); for (int i = 0; i < polygon.getNumInteriorRing(); i++) { CoordinateSequence seq = makeSequenceValid(polygon.getInteriorRingN(i).getCoordinateSequence(), false, true); if (seq.size() > 3) { innerRings.add(factory.createLinearRing(seq)); } else if (seq.size() > 1) { degeneratedRings.add(factory.createLineString(seq)); } else if (seq.size() == 1) { degeneratedRings.add(factory.createPoint(seq));
CoordinateSequence sequence = lineString.getCoordinateSequence(); CoordinateSequence sequenceWithoutDuplicates = makeSequenceValid(sequence, false, false); GeometryFactory factory = lineString.getFactory(); if (sequenceWithoutDuplicates.size() == 0) { return factory.createLineString(factory.getCoordinateSequenceFactory().create(0, sequence.getDimension())); } else if (sequenceWithoutDuplicates.size() == 1) { return factory.createLineString(factory.getCoordinateSequenceFactory().create(0, sequence.getDimension())); } else { return factory.createPoint(sequenceWithoutDuplicates);
private static void resolveLineStringSegments(LineString geom, List<Geometry> result) { for (int i = 0; i < geom.getCoordinateSequence().size() - 1; i++) { result.add(geom.getFactory().createLineString(new Coordinate[] { geom.getCoordinateSequence().getCoordinate(i), geom.getCoordinateSequence().getCoordinate(i+1) })); } }
/** * Tests if a linestring is completely contained in the boundary of the target rectangle. * @param line the linestring to test * @return true if the linestring is contained in the boundary */ private boolean isLineStringContainedInBoundary(LineString line) { CoordinateSequence seq = line.getCoordinateSequence(); Coordinate p0 = new Coordinate(); Coordinate p1 = new Coordinate(); for (int i = 0; i < seq.size() - 1; i++) { seq.getCoordinate(i, p0); seq.getCoordinate(i + 1, p1); if (! isLineSegmentContainedInBoundary(p0, p1)) return false; } return true; }
final Ordinates ordinates = new Ordinates(coords.size()); double x0 = coords.getX(0); double y0 = coords.getY(0); boolean prevInside = contained(x0, y0); if (prevInside) { final int size = coords.size(); final double x1 = coords.getX(i); final double y1 = coords.getY(i); double[] clippedSegment = clipSegment(segment); if (clippedSegment != null) { CoordinateSequence cs = csf.create(2, 2); cs.setOrdinate(0, 0, clippedSegment[0]); cs.setOrdinate(0, 1, clippedSegment[1]); cs.setOrdinate(1, 0, clippedSegment[2]); cs.setOrdinate(1, 1, clippedSegment[3]); clipped.add(gf.createLineString(cs)); if (cs0.getOrdinate(0, 0) == cs1.getOrdinate(cs1.size() - 1, 0) && cs0.getOrdinate(0, 1) == cs1.getOrdinate(cs1.size() - 1, 1)) { CoordinateSequence cs = csf.create(cs0.size() + cs1.size() - 1, 2); for (int i = 0; i < cs1.size(); i++) { cs.setOrdinate(i, 0, cs1.getOrdinate(i, 0)); cs.setOrdinate(i, 1, cs1.getOrdinate(i, 1)); for (int i = 1; i < cs0.size(); i++) { cs.setOrdinate(i + cs1.size() - 1, 0, cs0.getOrdinate(i, 0));
final CoordinateSequence coordSeq = geomFactory.getCoordinateSequenceFactory().create(cmdLength, 2); int coordIndex = 0; Coordinate nextCoord; ); nextCoord = coordSeq.getCoordinate(coordIndex++); nextCoord.setOrdinate(0, cursor.x); nextCoord.setOrdinate(1, cursor.y); return coordSeq.size() == 1 ? geomFactory.createPoint(coordSeq) : geomFactory.createMultiPoint(coordSeq);
public String toString() { StringBuffer buf = new StringBuffer(); buf.append("LINESTRING ( "); Coordinate p = new Coordinate(); for (int i = start; i < end; i++) { if (i > start) buf.append(", "); pts.getCoordinate(i, p); buf.append(p.x + " " + p.y); } buf.append(" )"); return buf.toString(); } }
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); }
/** * 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); }
multi = (MultiPolygon) geometry; } else { multi = geometryFactory.createMultiPolygon(new Polygon[] { (Polygon) geometry }); Polygon p; p = (Polygon) multi.getGeometryN(t); allCoords.add(p.getExteriorRing().getCoordinateSequence()); for(int ringN = 0; ringN < p.getNumInteriorRing(); ringN++){ allCoords.add(p.getInteriorRingN(ringN).getCoordinateSequence()); for (int t = 0; t < nrings; t++) { buffer.putInt(count); count = count + coordinates[t].size(); final int seqSize = coords.size(); for(int coordN = 0; coordN < seqSize; coordN++){ buffer.putDouble(coords.getOrdinate(coordN, 0)); buffer.putDouble(coords.getOrdinate(coordN, 1)); CoordinateSequence coords = coordinates[ringN]; final int seqSize = coords.size(); double z; for (int coordN = 0; coordN < seqSize; coordN++) { z = coords.getOrdinate(coordN, 2); if (Double.isNaN(z)) { buffer.putDouble(0.0);
/** * Computes a point which is the average of all coordinates * in a sequence. * If the sequence lies in a single plane, * the computed point also lies in the plane. * * @param seq a coordinate sequence * @return a Coordinate with averaged ordinates */ private Coordinate averagePoint(CoordinateSequence seq) { Coordinate a = new Coordinate(0,0,0); int n = seq.size(); for (int i = 0; i < n; i++) { a.x += seq.getOrdinate(i, CoordinateSequence.X); a.y += seq.getOrdinate(i, CoordinateSequence.Y); a.z += seq.getOrdinate(i, CoordinateSequence.Z); } a.x /= n; a.y /= n; a.z /= n; return a; }
nextCoordSeq = geomFactory.getCoordinateSequenceFactory().create(1 + cmdLength, 2); nextCoord = nextCoordSeq.getCoordinate(0); nextCoord.setOrdinate(0, cursor.x); nextCoord.setOrdinate(1, cursor.y); ); nextCoord = nextCoordSeq.getCoordinate(lineToIndex + 1); nextCoord.setOrdinate(0, cursor.x); nextCoord.setOrdinate(1, cursor.y); geoms.add(geomFactory.createLineString(nextCoordSeq)); return geoms.size() == 1 ? geoms.get(0) : geomFactory.createMultiLineString(geoms.toArray(new LineString[geoms.size()]));
/** * Determines the {@link Location} of a point in a ring. * * @param p * the point to test * @param ring * a coordinate sequence forming a ring * @return the location of the point in the ring */ public static int locatePointInRing(Coordinate p, CoordinateSequence ring) { RayCrossingCounter counter = new RayCrossingCounter(p); Coordinate p1 = new Coordinate(); Coordinate p2 = new Coordinate(); for (int i = 1; i < ring.size(); i++) { ring.getCoordinate(i, p1); ring.getCoordinate(i - 1, p2); counter.countSegment(p1, p2); if (counter.isOnSegment()) return counter.getLocation(); } return counter.getLocation(); }
public Point getPointN(int n) { return getFactory().createPoint(points.getCoordinate(n)); }
/** * Transforms a LinearRing. * The transformation of a LinearRing may result in a coordinate sequence * which does not form a structurally valid ring (i.e. a degnerate ring of 3 or fewer points). * In this case a LineString is returned. * Subclasses may wish to override this method and check for this situation * (e.g. a subclass may choose to eliminate degenerate linear rings) * * @param geom the ring to simplify * @param parent the parent geometry * @return a LinearRing if the transformation resulted in a structurally valid ring * @return a LineString if the transformation caused the LinearRing to collapse to 3 or fewer points */ protected Geometry transformLinearRing(LinearRing geom, Geometry parent) { CoordinateSequence seq = transformCoordinates(geom.getCoordinateSequence(), geom); int seqSize = seq.size(); // ensure a valid LinearRing if (seqSize > 0 && seqSize < 4 && ! preserveType) return factory.createLineString(seq); return factory.createLinearRing(seq); }
private static int checkRepeatedPoints2d(LineString lineString) { int repeatedPoints = 0; final CoordinateSequence coordSeq = lineString.getCoordinateSequence(); Coordinate nextCoord = null, prevCoord; for(int i = 0; i < coordSeq.size(); ++i) { prevCoord = nextCoord; nextCoord = coordSeq.getCoordinate(i); if(nextCoord.equals(prevCoord)) { ++repeatedPoints; } } return repeatedPoints; } }