/** * Create a new lineString * @return a new {@link LineStringBuilder} */ public static LineStringBuilder newLineString(List<Coordinate> list) { return new LineStringBuilder(list); }
protected XContentBuilder coordinatesArray(XContentBuilder builder, Params params) throws IOException { shell.coordinatesToXcontent(builder, true); for(LineStringBuilder hole : holes) { hole.coordinatesToXcontent(builder, true); } return builder; }
/** * Close the shell of the polygon */ public PolygonBuilder close() { shell.close(); return this; }
@Override public JtsGeometry buildS4J() { Coordinate[] coordinates = this.coordinates.toArray(new Coordinate[this.coordinates.size()]); Geometry geometry; if(wrapdateline) { ArrayList<LineString> strings = decomposeS4J(FACTORY, coordinates, new ArrayList<LineString>()); if(strings.size() == 1) { geometry = strings.get(0); } else { LineString[] linestrings = strings.toArray(new LineString[strings.size()]); geometry = FACTORY.createMultiLineString(linestrings); } } else { geometry = FACTORY.createLineString(coordinates); } return jtsGeometry(geometry); }
double t = intersection(coordinates[i-1], coordinates[i], dateline); if(!Double.isNaN(t)) { Coordinate[] part; part[part.length-1] = Edge.position(coordinates[i-1], coordinates[i], t); coordinates[offset+i-1] = Edge.position(coordinates[i-1], coordinates[i], t); shift(shift, part); offset = i-1; shift = coordinates[i].x > DATELINE ? DATELINE : (coordinates[i].x < -DATELINE ? -DATELINE : 0); } else { part = shift(shift, Arrays.copyOfRange(coordinates, offset, i+1)); offset = i; parts.add(shift(shift, coordinates)); } else if(offset < coordinates.length-1) { Coordinate[] part = Arrays.copyOfRange(coordinates, offset, coordinates.length); parts.add(shift(shift, part));
@Override public Object buildLucene() { if (wrapdateline) { ArrayList<Line> parts = new ArrayList<>(); for (LineStringBuilder line : lines) { LineStringBuilder.decomposeLucene(line.coordinates(false), parts); } if (parts.size() == 1) { return parts.get(0); } return parts.toArray(new Line[parts.size()]); } Line[] linestrings = new Line[lines.size()]; for (int i = 0; i < lines.size(); ++i) { LineStringBuilder lsb = lines.get(i); linestrings[i] = new Line(lsb.coordinates.stream().mapToDouble(c->c.y).toArray(), lsb.coordinates.stream().mapToDouble(c->c.x).toArray()); } return linestrings; }
private static int createEdges(int component, Orientation orientation, LineStringBuilder shell, LineStringBuilder hole, Edge[] edges, int offset, final AtomicBoolean translated) { // inner rings (holes) have an opposite direction than the outer rings // XOR will invert the orientation for outer ring cases (Truth Table:, T/T = F, T/F = T, F/T = T, F/F = F) boolean direction = (component == 0 ^ orientation == Orientation.RIGHT); // set the points array accordingly (shell or hole) Coordinate[] points = (hole != null) ? hole.coordinates(false) : shell.coordinates(false); ring(component, direction, orientation == Orientation.LEFT, points, 0, edges, offset, points.length-1, translated); return points.length-1; }
@Override public JtsGeometry build() { Coordinate[] coordinates = this.coordinates.toArray(new Coordinate[this.coordinates.size()]); Geometry geometry; if(wrapdateline) { ArrayList<LineString> strings = decompose(FACTORY, coordinates, new ArrayList<LineString>()); if(strings.size() == 1) { geometry = strings.get(0); } else { LineString[] linestrings = strings.toArray(new LineString[strings.size()]); geometry = FACTORY.createMultiLineString(linestrings); } } else { geometry = FACTORY.createLineString(coordinates); } return jtsGeometry(geometry); }
@Override public Shape build() { final Geometry geometry; if(wrapdateline) { ArrayList<LineString> parts = new ArrayList<>(); for (LineStringBuilder line : lines) { LineStringBuilder.decompose(FACTORY, line.coordinates(false), parts); } if(parts.size() == 1) { geometry = parts.get(0); } else { LineString[] lineStrings = parts.toArray(new LineString[parts.size()]); geometry = FACTORY.createMultiLineString(lineStrings); } } else { LineString[] lineStrings = new LineString[lines.size()]; Iterator<LineStringBuilder> iterator = lines.iterator(); for (int i = 0; iterator.hasNext(); i++) { lineStrings[i] = FACTORY.createLineString(iterator.next().coordinates(false)); } geometry = FACTORY.createMultiLineString(lineStrings); } return jtsGeometry(geometry); }
static ArrayList<LineString> decomposeS4J(GeometryFactory factory, Coordinate[] coordinates, ArrayList<LineString> strings) { for(Coordinate[] part : decompose(+DATELINE, coordinates)) { for(Coordinate[] line : decompose(-DATELINE, part)) { strings.add(factory.createLineString(line)); } } return strings; }
@Override public JtsGeometry buildS4J() { final Geometry geometry; if(wrapdateline) { ArrayList<LineString> parts = new ArrayList<>(); for (LineStringBuilder line : lines) { LineStringBuilder.decomposeS4J(FACTORY, line.coordinates(false), parts); } if(parts.size() == 1) { geometry = parts.get(0); } else { LineString[] lineStrings = parts.toArray(new LineString[parts.size()]); geometry = FACTORY.createMultiLineString(lineStrings); } } else { LineString[] lineStrings = new LineString[lines.size()]; Iterator<LineStringBuilder> iterator = lines.iterator(); for (int i = 0; iterator.hasNext(); i++) { lineStrings[i] = FACTORY.createLineString(iterator.next().coordinates(false)); } geometry = FACTORY.createMultiLineString(lineStrings); } return jtsGeometry(geometry); }
@Override public int numDimensions() { if (shell == null) { throw new IllegalStateException("unable to get number of dimensions, " + "Polygon has not yet been initialized"); } return shell.numDimensions(); }
double t = intersection(coordinates[i-1], coordinates[i], dateline); if(!Double.isNaN(t)) { Coordinate[] part; part[part.length-1] = Edge.position(coordinates[i-1], coordinates[i], t); coordinates[offset+i-1] = Edge.position(coordinates[i-1], coordinates[i], t); shift(shift, part); offset = i-1; shift = coordinates[i].x > DATELINE ? DATELINE : (coordinates[i].x < -DATELINE ? -DATELINE : 0); } else { part = shift(shift, Arrays.copyOfRange(coordinates, offset, i+1)); offset = i; parts.add(shift(shift, coordinates)); } else if(offset < coordinates.length-1) { Coordinate[] part = Arrays.copyOfRange(coordinates, offset, coordinates.length); parts.add(shift(shift, part));
public Coordinate[][] coordinates() { Coordinate[][] result = new Coordinate[lines.size()][]; for (int i = 0; i < result.length; i++) { result[i] = lines.get(i).coordinates(false); } return result; }
@Override public Shape build() { Coordinate[] coordinates = this.coordinates.toArray(new Coordinate[this.coordinates.size()]); Geometry geometry; if(wrapdateline) { ArrayList<LineString> strings = decompose(FACTORY, coordinates, new ArrayList<LineString>()); if(strings.size() == 1) { geometry = strings.get(0); } else { LineString[] linestrings = strings.toArray(new LineString[strings.size()]); geometry = FACTORY.createMultiLineString(linestrings); } } else { geometry = FACTORY.createLineString(coordinates); } return jtsGeometry(geometry); }
@Override public JtsGeometry build() { final Geometry geometry; if(wrapdateline) { ArrayList<LineString> parts = new ArrayList<>(); for (LineStringBuilder line : lines) { LineStringBuilder.decompose(FACTORY, line.coordinates(false), parts); } if(parts.size() == 1) { geometry = parts.get(0); } else { LineString[] lineStrings = parts.toArray(new LineString[parts.size()]); geometry = FACTORY.createMultiLineString(lineStrings); } } else { LineString[] lineStrings = new LineString[lines.size()]; Iterator<LineStringBuilder> iterator = lines.iterator(); for (int i = 0; iterator.hasNext(); i++) { lineStrings[i] = FACTORY.createLineString(iterator.next().coordinates(false)); } geometry = FACTORY.createMultiLineString(lineStrings); } return jtsGeometry(geometry); }
@Override public void writeTo(StreamOutput out) throws IOException { out.writeVInt(lines.size()); for (LineStringBuilder line : lines) { line.writeTo(out); } }
static ArrayList<Line> decomposeLucene(Coordinate[] coordinates, ArrayList<Line> lines) { for (Coordinate[] part : decompose(+DATELINE, coordinates)) { for (Coordinate[] line : decompose(-DATELINE, part)) { lines.add(new Line(Arrays.stream(line).mapToDouble(i->normalizeLat(i.y)).toArray(), Arrays.stream(line).mapToDouble(i->normalizeLon(i.x)).toArray())); } } return lines; }
public int numDimensions() { if (lines == null || lines.isEmpty()) { throw new IllegalStateException("unable to get number of dimensions, " + "LineStrings have not yet been initialized"); } return lines.get(0).numDimensions(); }