kopia lustrzana https://github.com/onthegomap/planetiler
1264 wiersze
42 KiB
Java
1264 wiersze
42 KiB
Java
/* ****************************************************************
|
|
* Licensed to the Apache Software Foundation (ASF) under one
|
|
* or more contributor license agreements. See the NOTICE file
|
|
* distributed with this work for additional information
|
|
* regarding copyright ownership. The ASF licenses this file
|
|
* to you under the Apache License, Version 2.0 (the
|
|
* "License"); you may not use this file except in compliance
|
|
* with the License. You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing,
|
|
* software distributed under the License is distributed on an
|
|
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
|
* KIND, either express or implied. See the License for the
|
|
* specific language governing permissions and limitations
|
|
* under the License.
|
|
****************************************************************/
|
|
package com.onthegomap.planetiler;
|
|
|
|
import com.carrotsearch.hppc.IntArrayList;
|
|
import com.google.common.primitives.Ints;
|
|
import com.google.protobuf.InvalidProtocolBufferException;
|
|
import com.onthegomap.planetiler.collection.FeatureGroup;
|
|
import com.onthegomap.planetiler.geo.GeoUtils;
|
|
import com.onthegomap.planetiler.geo.GeometryException;
|
|
import com.onthegomap.planetiler.geo.GeometryType;
|
|
import com.onthegomap.planetiler.geo.MutableCoordinateSequence;
|
|
import com.onthegomap.planetiler.util.Hilbert;
|
|
import com.onthegomap.planetiler.util.LayerAttrStats;
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.HashMap;
|
|
import java.util.LinkedHashMap;
|
|
import java.util.List;
|
|
import java.util.Locale;
|
|
import java.util.Map;
|
|
import java.util.TreeMap;
|
|
import java.util.function.Consumer;
|
|
import java.util.stream.Collectors;
|
|
import java.util.stream.Stream;
|
|
import javax.annotation.concurrent.NotThreadSafe;
|
|
import org.locationtech.jts.algorithm.Orientation;
|
|
import org.locationtech.jts.geom.Coordinate;
|
|
import org.locationtech.jts.geom.CoordinateSequence;
|
|
import org.locationtech.jts.geom.CoordinateXY;
|
|
import org.locationtech.jts.geom.Geometry;
|
|
import org.locationtech.jts.geom.GeometryFactory;
|
|
import org.locationtech.jts.geom.LineString;
|
|
import org.locationtech.jts.geom.LinearRing;
|
|
import org.locationtech.jts.geom.MultiLineString;
|
|
import org.locationtech.jts.geom.MultiPoint;
|
|
import org.locationtech.jts.geom.MultiPolygon;
|
|
import org.locationtech.jts.geom.Point;
|
|
import org.locationtech.jts.geom.Polygon;
|
|
import org.locationtech.jts.geom.Puntal;
|
|
import org.locationtech.jts.geom.impl.CoordinateArraySequence;
|
|
import org.locationtech.jts.geom.impl.PackedCoordinateSequence;
|
|
import org.slf4j.Logger;
|
|
import org.slf4j.LoggerFactory;
|
|
import vector_tile.VectorTileProto;
|
|
|
|
/**
|
|
* Encodes a single output tile containing JTS {@link Geometry} features into the compact binary Mapbox Vector Tile
|
|
* format.
|
|
* <p>
|
|
* This class is copied from <a href=
|
|
* "https://github.com/ElectronicChartCentre/java-vector-tile/blob/master/src/main/java/no/ecc/vectortile/VectorTileEncoder.java">VectorTileEncoder.java</a>
|
|
* and <a href=
|
|
* "https://github.com/ElectronicChartCentre/java-vector-tile/blob/master/src/main/java/no/ecc/vectortile/VectorTileDecoder.java">VectorTileDecoder.java</a>
|
|
* and modified to decouple geometry encoding from vector tile encoding so that encoded commands can be stored in the
|
|
* sorted feature map prior to encoding vector tiles. The internals are also refactored to improve performance by using
|
|
* hppc primitive collections.
|
|
*
|
|
* @see <a href="https://github.com/mapbox/vector-tile-spec/tree/master/2.1">Mapbox Vector Tile Specification</a>
|
|
*/
|
|
@NotThreadSafe
|
|
public class VectorTile {
|
|
public static final long NO_FEATURE_ID = 0;
|
|
|
|
private static final Logger LOGGER = LoggerFactory.getLogger(VectorTile.class);
|
|
|
|
// TODO make these configurable
|
|
private static final int EXTENT = 4096;
|
|
private static final double SIZE = 256d;
|
|
// use a treemap to ensure that layers are encoded in a consistent order
|
|
private final Map<String, Layer> layers = new TreeMap<>();
|
|
private LayerAttrStats.Updater.ForZoom layerStatsTracker = LayerAttrStats.Updater.ForZoom.NOOP;
|
|
|
|
private static int[] getCommands(Geometry input, int scale) {
|
|
var encoder = new CommandEncoder(scale);
|
|
encoder.accept(input);
|
|
return encoder.result.toArray();
|
|
}
|
|
|
|
/**
|
|
* Scales a geometry down by a factor of {@code 2^scale} without materializing an intermediate JTS geometry and
|
|
* returns the encoded result.
|
|
*/
|
|
private static int[] unscale(int[] commands, int scale, GeometryType geomType) {
|
|
IntArrayList result = new IntArrayList();
|
|
int geometryCount = commands.length;
|
|
int length = 0;
|
|
int command = 0;
|
|
int i = 0;
|
|
int inX = 0, inY = 0;
|
|
int outX = 0, outY = 0;
|
|
int startX = 0, startY = 0;
|
|
double scaleFactor = Math.pow(2, -scale);
|
|
int lengthIdx = 0;
|
|
int moveToIdx = 0;
|
|
int pointsInShape = 0;
|
|
boolean first = true;
|
|
while (i < geometryCount) {
|
|
if (length <= 0) {
|
|
length = commands[i++];
|
|
lengthIdx = result.size();
|
|
result.add(length);
|
|
command = length & ((1 << 3) - 1);
|
|
length = length >> 3;
|
|
}
|
|
|
|
if (length > 0) {
|
|
if (command == Command.MOVE_TO.value) {
|
|
// degenerate geometry, remove it from output entirely
|
|
if (!first && pointsInShape < geomType.minPoints()) {
|
|
int prevCommand = result.get(lengthIdx);
|
|
result.elementsCount = moveToIdx;
|
|
result.add(prevCommand);
|
|
// reset deltas
|
|
outX = startX;
|
|
outY = startY;
|
|
}
|
|
// keep track of size of next shape...
|
|
pointsInShape = 0;
|
|
startX = outX;
|
|
startY = outY;
|
|
moveToIdx = result.size() - 1;
|
|
}
|
|
first = false;
|
|
if (command == Command.CLOSE_PATH.value) {
|
|
pointsInShape++;
|
|
length--;
|
|
continue;
|
|
}
|
|
|
|
int dx = commands[i++];
|
|
int dy = commands[i++];
|
|
|
|
length--;
|
|
|
|
dx = zigZagDecode(dx);
|
|
dy = zigZagDecode(dy);
|
|
|
|
inX = inX + dx;
|
|
inY = inY + dy;
|
|
|
|
int nextX = (int) Math.round(inX * scaleFactor);
|
|
int nextY = (int) Math.round(inY * scaleFactor);
|
|
|
|
if (nextX == outX && nextY == outY && command == Command.LINE_TO.value) {
|
|
int commandLength = result.get(lengthIdx) - 8;
|
|
if (commandLength < 8) {
|
|
// get rid of lineto section if empty
|
|
result.elementsCount = lengthIdx;
|
|
} else {
|
|
result.set(lengthIdx, commandLength);
|
|
}
|
|
} else {
|
|
pointsInShape++;
|
|
int dxOut = nextX - outX;
|
|
int dyOut = nextY - outY;
|
|
result.add(
|
|
zigZagEncode(dxOut),
|
|
zigZagEncode(dyOut)
|
|
);
|
|
outX = nextX;
|
|
outY = nextY;
|
|
}
|
|
}
|
|
}
|
|
// degenerate geometry, remove it from output entirely
|
|
if (pointsInShape < geomType.minPoints()) {
|
|
result.elementsCount = moveToIdx;
|
|
}
|
|
return result.toArray();
|
|
}
|
|
|
|
static int zigZagEncode(int n) {
|
|
// https://developers.google.com/protocol-buffers/docs/encoding#types
|
|
return (n << 1) ^ (n >> 31);
|
|
}
|
|
|
|
private static int zigZagDecode(int n) {
|
|
// https://developers.google.com/protocol-buffers/docs/encoding#types
|
|
return ((n >> 1) ^ (-(n & 1)));
|
|
}
|
|
|
|
private static Geometry decodeCommands(GeometryType geomType, int[] commands, int scale) throws GeometryException {
|
|
try {
|
|
GeometryFactory gf = GeoUtils.JTS_FACTORY;
|
|
double SCALE = (EXTENT << scale) / SIZE;
|
|
int x = 0;
|
|
int y = 0;
|
|
|
|
List<MutableCoordinateSequence> allCoordSeqs = new ArrayList<>();
|
|
MutableCoordinateSequence currentCoordSeq = null;
|
|
|
|
int geometryCount = commands.length;
|
|
int length = 0;
|
|
int command = 0;
|
|
int i = 0;
|
|
while (i < geometryCount) {
|
|
|
|
if (length <= 0) {
|
|
length = commands[i++];
|
|
command = length & ((1 << 3) - 1);
|
|
length = length >> 3;
|
|
assert geomType != GeometryType.POINT || i == 1 : "Invalid multipoint, command found at index %d, expected 0"
|
|
.formatted(i);
|
|
assert geomType != GeometryType.POINT ||
|
|
(length * 2 + 1 == geometryCount) : "Invalid multipoint: int[%d] length=%d".formatted(geometryCount,
|
|
length);
|
|
}
|
|
|
|
if (length > 0) {
|
|
|
|
if (command == Command.MOVE_TO.value) {
|
|
currentCoordSeq = new MutableCoordinateSequence();
|
|
allCoordSeqs.add(currentCoordSeq);
|
|
} else {
|
|
assert currentCoordSeq != null;
|
|
}
|
|
|
|
if (command == Command.CLOSE_PATH.value) {
|
|
if (geomType != GeometryType.POINT && !currentCoordSeq.isEmpty()) {
|
|
currentCoordSeq.closeRing();
|
|
}
|
|
length--;
|
|
continue;
|
|
}
|
|
|
|
int dx = commands[i++];
|
|
int dy = commands[i++];
|
|
|
|
length--;
|
|
|
|
dx = zigZagDecode(dx);
|
|
dy = zigZagDecode(dy);
|
|
|
|
x = x + dx;
|
|
y = y + dy;
|
|
|
|
currentCoordSeq.forceAddPoint(x / SCALE, y / SCALE);
|
|
}
|
|
|
|
}
|
|
|
|
Geometry geometry = null;
|
|
boolean outerCCW = false;
|
|
|
|
switch (geomType) {
|
|
case LINE -> {
|
|
List<LineString> lineStrings = new ArrayList<>(allCoordSeqs.size());
|
|
for (MutableCoordinateSequence coordSeq : allCoordSeqs) {
|
|
if (coordSeq.size() <= 1) {
|
|
continue;
|
|
}
|
|
lineStrings.add(gf.createLineString(coordSeq));
|
|
}
|
|
if (lineStrings.size() == 1) {
|
|
geometry = lineStrings.getFirst();
|
|
} else if (lineStrings.size() > 1) {
|
|
geometry = gf.createMultiLineString(lineStrings.toArray(new LineString[0]));
|
|
}
|
|
}
|
|
case POINT -> {
|
|
CoordinateSequence cs = new PackedCoordinateSequence.Double(allCoordSeqs.size(), 2, 0);
|
|
for (int j = 0; j < allCoordSeqs.size(); j++) {
|
|
MutableCoordinateSequence coordSeq = allCoordSeqs.get(j);
|
|
cs.setOrdinate(j, 0, coordSeq.getX(0));
|
|
cs.setOrdinate(j, 1, coordSeq.getY(0));
|
|
}
|
|
if (cs.size() == 1) {
|
|
geometry = gf.createPoint(cs);
|
|
} else if (cs.size() > 1) {
|
|
geometry = gf.createMultiPoint(cs);
|
|
}
|
|
}
|
|
case POLYGON -> {
|
|
List<List<LinearRing>> polygonRings = new ArrayList<>();
|
|
List<LinearRing> ringsForCurrentPolygon = new ArrayList<>();
|
|
boolean first = true;
|
|
for (MutableCoordinateSequence coordSeq : allCoordSeqs) {
|
|
// skip hole with too few coordinates
|
|
if (ringsForCurrentPolygon.size() > 0 && coordSeq.size() < 2) {
|
|
continue;
|
|
}
|
|
LinearRing ring = gf.createLinearRing(coordSeq);
|
|
boolean ccw = Orientation.isCCW(coordSeq);
|
|
if (first) {
|
|
first = false;
|
|
outerCCW = ccw;
|
|
assert outerCCW : "outer ring is not counter-clockwise";
|
|
}
|
|
if (ccw == outerCCW) {
|
|
ringsForCurrentPolygon = new ArrayList<>();
|
|
polygonRings.add(ringsForCurrentPolygon);
|
|
}
|
|
ringsForCurrentPolygon.add(ring);
|
|
}
|
|
List<Polygon> polygons = new ArrayList<>();
|
|
for (List<LinearRing> rings : polygonRings) {
|
|
LinearRing shell = rings.getFirst();
|
|
LinearRing[] holes = rings.subList(1, rings.size()).toArray(new LinearRing[rings.size() - 1]);
|
|
polygons.add(gf.createPolygon(shell, holes));
|
|
}
|
|
if (polygons.size() == 1) {
|
|
geometry = polygons.getFirst();
|
|
}
|
|
if (polygons.size() > 1) {
|
|
geometry = gf.createMultiPolygon(GeometryFactory.toPolygonArray(polygons));
|
|
}
|
|
}
|
|
default -> {
|
|
}
|
|
}
|
|
|
|
if (geometry == null) {
|
|
geometry = GeoUtils.EMPTY_GEOMETRY;
|
|
}
|
|
|
|
return geometry;
|
|
} catch (IllegalArgumentException e) {
|
|
throw new GeometryException("decode_vector_tile", "Unable to decode geometry", e);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Parses a binary-encoded vector tile protobuf into a list of features.
|
|
* <p>
|
|
* Does not decode geometries, but clients can call {@link VectorGeometry#decode()} to decode a JTS {@link Geometry}
|
|
* if needed.
|
|
* <p>
|
|
* If {@code encoded} is compressed, clients must decompress it first.
|
|
*
|
|
* @param encoded encoded vector tile protobuf
|
|
* @return list of features on that tile
|
|
* @throws IllegalStateException if decoding fails
|
|
* @throws IndexOutOfBoundsException if a tag's key or value refers to an index that does not exist in the keys/values
|
|
* array for a layer
|
|
*/
|
|
public static List<Feature> decode(byte[] encoded) {
|
|
try {
|
|
VectorTileProto.Tile tile = VectorTileProto.Tile.parseFrom(encoded);
|
|
List<Feature> features = new ArrayList<>();
|
|
for (VectorTileProto.Tile.Layer layer : tile.getLayersList()) {
|
|
String layerName = layer.getName();
|
|
assert layer.getExtent() == 4096;
|
|
List<String> keys = layer.getKeysList();
|
|
List<Object> values = new ArrayList<>();
|
|
|
|
for (VectorTileProto.Tile.Value value : layer.getValuesList()) {
|
|
if (value.hasBoolValue()) {
|
|
values.add(value.getBoolValue());
|
|
} else if (value.hasDoubleValue()) {
|
|
values.add(value.getDoubleValue());
|
|
} else if (value.hasFloatValue()) {
|
|
values.add(value.getFloatValue());
|
|
} else if (value.hasIntValue()) {
|
|
values.add(value.getIntValue());
|
|
} else if (value.hasSintValue()) {
|
|
values.add(value.getSintValue());
|
|
} else if (value.hasUintValue()) {
|
|
values.add(value.getUintValue());
|
|
} else if (value.hasStringValue()) {
|
|
values.add(value.getStringValue());
|
|
} else {
|
|
values.add(null);
|
|
}
|
|
}
|
|
|
|
for (VectorTileProto.Tile.Feature feature : layer.getFeaturesList()) {
|
|
int tagsCount = feature.getTagsCount();
|
|
Map<String, Object> attrs = HashMap.newHashMap(tagsCount / 2);
|
|
int tagIdx = 0;
|
|
while (tagIdx < feature.getTagsCount()) {
|
|
String key = keys.get(feature.getTags(tagIdx++));
|
|
Object value = values.get(feature.getTags(tagIdx++));
|
|
attrs.put(key, value);
|
|
}
|
|
features.add(new Feature(
|
|
layerName,
|
|
feature.getId(),
|
|
new VectorGeometry(Ints.toArray(feature.getGeometryList()), GeometryType.valueOf(feature.getType()), 0),
|
|
attrs
|
|
));
|
|
}
|
|
}
|
|
return features;
|
|
} catch (InvalidProtocolBufferException e) {
|
|
throw new IllegalStateException(e);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Encodes a JTS geometry according to
|
|
* <a href="https://github.com/mapbox/vector-tile-spec/tree/master/2.1#43-geometry-encoding">Geometry Encoding
|
|
* Specification</a>.
|
|
*
|
|
* @param geometry the JTS geometry to encoded
|
|
* @return the geometry type and command array for the encoded geometry
|
|
*/
|
|
public static VectorGeometry encodeGeometry(Geometry geometry) {
|
|
return encodeGeometry(geometry, 0);
|
|
}
|
|
|
|
public static VectorGeometry encodeGeometry(Geometry geometry, int scale) {
|
|
return new VectorGeometry(getCommands(geometry, scale), GeometryType.typeOf(geometry), scale);
|
|
}
|
|
|
|
/**
|
|
* Returns a new {@link VectorGeometryMerger} that combines encoded geometries of the same type into a merged
|
|
* multipoint, multilinestring, or multipolygon.
|
|
*/
|
|
public static VectorGeometryMerger newMerger(GeometryType geometryType) {
|
|
return new VectorGeometryMerger(geometryType);
|
|
}
|
|
|
|
/**
|
|
* Returns the hilbert index of the zig-zag-encoded first point of {@code geometry}.
|
|
* <p>
|
|
* This can be useful for sorting geometries to minimize encoded vector tile geometry command size since smaller
|
|
* offsets take fewer bytes using protobuf varint encoding.
|
|
*/
|
|
public static int hilbertIndex(Geometry geometry) {
|
|
Coordinate coord = geometry.getCoordinate();
|
|
int x = zigZagEncode((int) Math.round(coord.x * 4096 / 256));
|
|
int y = zigZagEncode((int) Math.round(coord.y * 4096 / 256));
|
|
return Hilbert.hilbertXYToIndex(15, x, y);
|
|
}
|
|
|
|
/**
|
|
* Returns the number of internal geometries in this feature including points/lines/polygons inside multigeometries.
|
|
*/
|
|
public static int countGeometries(VectorTileProto.Tile.Feature feature) {
|
|
int result = 0;
|
|
int idx = 0;
|
|
int geomCount = feature.getGeometryCount();
|
|
while (idx < geomCount) {
|
|
int length = feature.getGeometry(idx);
|
|
int command = length & ((1 << 3) - 1);
|
|
length = length >> 3;
|
|
if (command == Command.MOVE_TO.value) {
|
|
result += length;
|
|
}
|
|
idx += 1;
|
|
if (command != Command.CLOSE_PATH.value) {
|
|
idx += length * 2;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Adds features in a layer to this tile.
|
|
*
|
|
* @param layerName name of the layer in this tile to add the features to
|
|
* @param features features to add to the tile
|
|
* @return this encoder for chaining
|
|
*/
|
|
public VectorTile addLayerFeatures(String layerName, List<Feature> features) {
|
|
if (features.isEmpty()) {
|
|
return this;
|
|
}
|
|
Layer layer = layers.get(layerName);
|
|
if (layer == null) {
|
|
layer = new Layer();
|
|
layers.put(layerName, layer);
|
|
}
|
|
var statsTracker = layerStatsTracker.forLayer(layerName);
|
|
|
|
for (Feature inFeature : features) {
|
|
if (inFeature != null && inFeature.geometry().commands().length > 0) {
|
|
EncodedFeature outFeature = new EncodedFeature(inFeature);
|
|
|
|
for (Map.Entry<String, ?> e : inFeature.attrs().entrySet()) {
|
|
// skip attribute without value
|
|
if (e.getValue() != null) {
|
|
String key = e.getKey();
|
|
Object value = e.getValue();
|
|
outFeature.tags.add(layer.key(key));
|
|
outFeature.tags.add(layer.value(value));
|
|
statsTracker.accept(key, value);
|
|
}
|
|
}
|
|
|
|
layer.encodedFeatures.add(outFeature);
|
|
}
|
|
}
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Returns a vector tile protobuf object with all features in this tile.
|
|
*/
|
|
public VectorTileProto.Tile toProto() {
|
|
VectorTileProto.Tile.Builder tile = VectorTileProto.Tile.newBuilder();
|
|
for (Map.Entry<String, Layer> e : layers.entrySet()) {
|
|
String layerName = e.getKey();
|
|
Layer layer = e.getValue();
|
|
|
|
VectorTileProto.Tile.Layer.Builder tileLayer = VectorTileProto.Tile.Layer.newBuilder()
|
|
.setVersion(2)
|
|
.setName(layerName)
|
|
.setExtent(EXTENT)
|
|
.addAllKeys(layer.keys());
|
|
|
|
for (Object value : layer.values()) {
|
|
VectorTileProto.Tile.Value.Builder tileValue = VectorTileProto.Tile.Value.newBuilder();
|
|
switch (value) {
|
|
case String stringValue -> tileValue.setStringValue(stringValue);
|
|
case Integer intValue -> tileValue.setSintValue(intValue);
|
|
case Long longValue -> tileValue.setSintValue(longValue);
|
|
case Float floatValue -> tileValue.setFloatValue(floatValue);
|
|
case Double doubleValue -> tileValue.setDoubleValue(doubleValue);
|
|
case Boolean booleanValue -> tileValue.setBoolValue(booleanValue);
|
|
case Object other -> tileValue.setStringValue(other.toString());
|
|
}
|
|
tileLayer.addValues(tileValue.build());
|
|
}
|
|
|
|
for (EncodedFeature feature : layer.encodedFeatures) {
|
|
VectorTileProto.Tile.Feature.Builder featureBuilder = VectorTileProto.Tile.Feature.newBuilder()
|
|
.addAllTags(Ints.asList(feature.tags.toArray()))
|
|
.setType(feature.geometry().geomType().asProtobufType())
|
|
.addAllGeometry(Ints.asList(feature.geometry().commands()));
|
|
|
|
if (feature.id != NO_FEATURE_ID) {
|
|
featureBuilder.setId(feature.id);
|
|
}
|
|
|
|
tileLayer.addFeatures(featureBuilder.build());
|
|
}
|
|
|
|
tile.addLayers(tileLayer.build());
|
|
}
|
|
return tile.build();
|
|
}
|
|
|
|
/**
|
|
* Creates a vector tile protobuf with all features in this tile and serializes it as a byte array.
|
|
* <p>
|
|
* Does not compress the result.
|
|
*/
|
|
public byte[] encode() {
|
|
return toProto().toByteArray();
|
|
}
|
|
|
|
/**
|
|
* Returns true if this tile contains only polygon fills.
|
|
*/
|
|
public boolean containsOnlyFills() {
|
|
return containsOnlyFillsOrEdges(false);
|
|
}
|
|
|
|
/**
|
|
* Returns true if this tile contains only polygon fills or horizontal/vertical edges that are likely to be repeated
|
|
* across tiles.
|
|
*/
|
|
public boolean containsOnlyFillsOrEdges() {
|
|
return containsOnlyFillsOrEdges(true);
|
|
}
|
|
|
|
private boolean containsOnlyFillsOrEdges(boolean allowEdges) {
|
|
boolean empty = true;
|
|
for (var layer : layers.values()) {
|
|
for (var feature : layer.encodedFeatures) {
|
|
empty = false;
|
|
if (!feature.geometry.isFillOrEdge(allowEdges)) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return !empty;
|
|
}
|
|
|
|
/**
|
|
* Determine whether a tile is likely to be a duplicate of some other tile hence it makes sense to calculate a hash
|
|
* for it.
|
|
* <p>
|
|
* Deduplication code is aiming for a balance between filtering-out all duplicates and not spending too much CPU on
|
|
* hash calculations: calculating hashes for all tiles costs too much CPU, not calculating hashes at all means
|
|
* generating archives which are too big. This method is responsible for achieving that balance.
|
|
* <p>
|
|
* Current understanding is, that for the whole planet, there are 267m total tiles and 38m unique tiles. The
|
|
* {@link #containsOnlyFillsOrEdges()} heuristic catches >99.9% of repeated tiles and cuts down the number of tile
|
|
* hashes we need to track by 98% (38m to 735k). So it is considered a good tradeoff.
|
|
*
|
|
* @return {@code true} if the tile might have duplicates hence we want to calculate a hash for it
|
|
*/
|
|
public boolean likelyToBeDuplicated() {
|
|
return layers.values().stream().allMatch(v -> v.encodedFeatures.isEmpty()) || containsOnlyFillsOrEdges();
|
|
}
|
|
|
|
/**
|
|
* Call back to {@code layerStats} as vector tile features are being encoded in
|
|
* {@link #addLayerFeatures(String, List)} to track attribute types present on features in each layer, for example to
|
|
* emit in tilejson metadata stats.
|
|
*/
|
|
public void trackLayerStats(LayerAttrStats.Updater.ForZoom layerStats) {
|
|
this.layerStatsTracker = layerStats;
|
|
}
|
|
|
|
enum Command {
|
|
MOVE_TO(1),
|
|
LINE_TO(2),
|
|
CLOSE_PATH(7);
|
|
|
|
final int value;
|
|
|
|
Command(int value) {
|
|
this.value = value;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Utility that combines encoded geometries of the same type into a merged multipoint, multilinestring, or
|
|
* multipolygon.
|
|
*/
|
|
public static class VectorGeometryMerger implements Consumer<VectorGeometry> {
|
|
// For the most part this just concatenates the individual command arrays together
|
|
// EXCEPT we need to adjust the first coordinate of each subsequent linestring to
|
|
// be an offset from the end of the previous linestring.
|
|
// AND we need to combine all multipoint "move to" commands into one at the start of
|
|
// the sequence
|
|
|
|
private final GeometryType geometryType;
|
|
private final IntArrayList result = new IntArrayList();
|
|
private int overallX = 0;
|
|
private int overallY = 0;
|
|
|
|
private VectorGeometryMerger(GeometryType geometryType) {
|
|
this.geometryType = geometryType;
|
|
}
|
|
|
|
@Override
|
|
public void accept(VectorGeometry vectorGeometry) {
|
|
if (vectorGeometry.geomType != geometryType) {
|
|
throw new IllegalArgumentException(
|
|
"Cannot merge a " + vectorGeometry.geomType.name().toLowerCase(Locale.ROOT) + " geometry into a multi" +
|
|
vectorGeometry.geomType.name().toLowerCase(Locale.ROOT));
|
|
}
|
|
if (vectorGeometry.isEmpty()) {
|
|
return;
|
|
}
|
|
var commands = vectorGeometry.unscale().commands();
|
|
int x = 0;
|
|
int y = 0;
|
|
|
|
int geometryCount = commands.length;
|
|
int length = 0;
|
|
int command = 0;
|
|
int i = 0;
|
|
|
|
result.ensureCapacity(result.elementsCount + commands.length);
|
|
// and multipoints will end up with only one command ("move to" with length=# points)
|
|
if (geometryType != GeometryType.POINT || result.isEmpty()) {
|
|
result.add(commands[0]);
|
|
}
|
|
result.add(zigZagEncode(zigZagDecode(commands[1]) - overallX));
|
|
result.add(zigZagEncode(zigZagDecode(commands[2]) - overallY));
|
|
if (commands.length > 3) {
|
|
result.add(commands, 3, commands.length - 3);
|
|
}
|
|
|
|
while (i < geometryCount) {
|
|
if (length <= 0) {
|
|
length = commands[i++];
|
|
command = length & ((1 << 3) - 1);
|
|
length = length >> 3;
|
|
}
|
|
|
|
if (length > 0) {
|
|
length--;
|
|
if (command != Command.CLOSE_PATH.value) {
|
|
x += zigZagDecode(commands[i++]);
|
|
y += zigZagDecode(commands[i++]);
|
|
}
|
|
}
|
|
}
|
|
overallX = x;
|
|
overallY = y;
|
|
}
|
|
|
|
/** Returns the merged multi-geometry. */
|
|
public VectorGeometry finish() {
|
|
// set the correct "move to" length for multipoints based on how many points were actually added
|
|
if (geometryType == GeometryType.POINT) {
|
|
result.buffer[0] = Command.MOVE_TO.value | (((result.size() - 1) / 2) << 3);
|
|
}
|
|
return new VectorGeometry(result.toArray(), geometryType, 0);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* A vector geometry encoded as a list of commands according to the
|
|
* <a href="https://github.com/mapbox/vector-tile-spec/tree/master/2.1#43-geometry-encoding">vector tile
|
|
* specification</a>.
|
|
* <p>
|
|
* To encode extra precision in intermediate feature geometries, the geometry contained in {@code commands} is scaled
|
|
* to a tile extent of {@code EXTENT * 2^scale}, so when the {@code scale == 0} the extent is {@link #EXTENT} and when
|
|
* {@code scale == 2} the extent is 4x{@link #EXTENT}. Geometries must be scaled back to 0 using {@link #unscale()}
|
|
* before outputting to the archive.
|
|
*/
|
|
public record VectorGeometry(int[] commands, GeometryType geomType, int scale) {
|
|
|
|
private static final int LEFT = 1;
|
|
private static final int RIGHT = 1 << 1;
|
|
private static final int TOP = 1 << 2;
|
|
private static final int BOTTOM = 1 << 3;
|
|
private static final int INSIDE = 0;
|
|
private static final int ALL = TOP | LEFT | RIGHT | BOTTOM;
|
|
private static final VectorGeometry EMPTY_POINT = new VectorGeometry(new int[0], GeometryType.POINT, 0);
|
|
|
|
public VectorGeometry {
|
|
if (scale < 0) {
|
|
throw new IllegalArgumentException("scale can not be less than 0, got: " + scale);
|
|
}
|
|
}
|
|
|
|
private static int getSide(int x, int y, int extent) {
|
|
int result = INSIDE;
|
|
if (x < 0) {
|
|
result |= LEFT;
|
|
} else if (x > extent) {
|
|
result |= RIGHT;
|
|
}
|
|
if (y < 0) {
|
|
result |= TOP;
|
|
} else if (y > extent) {
|
|
result |= BOTTOM;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private static boolean slanted(int x1, int y1, int x2, int y2) {
|
|
return x1 != x2 && y1 != y2;
|
|
}
|
|
|
|
private static boolean segmentCrossesTile(int x1, int y1, int x2, int y2, int extent) {
|
|
return (y1 >= 0 || y2 >= 0) &&
|
|
(y1 <= extent || y2 <= extent) &&
|
|
(x1 >= 0 || x2 >= 0) &&
|
|
(x1 <= extent || x2 <= extent);
|
|
}
|
|
|
|
private static boolean isSegmentInvalid(boolean allowEdges, int x1, int y1, int x2, int y2, int extent) {
|
|
boolean crossesTile = segmentCrossesTile(x1, y1, x2, y2, extent);
|
|
if (allowEdges) {
|
|
return crossesTile && slanted(x1, y1, x2, y2);
|
|
} else {
|
|
return crossesTile;
|
|
}
|
|
}
|
|
|
|
|
|
private static boolean visitedEnoughSides(boolean allowEdges, int sides) {
|
|
if (allowEdges) {
|
|
return ((sides & LEFT) > 0 && (sides & RIGHT) > 0) || ((sides & TOP) > 0 && (sides & BOTTOM) > 0);
|
|
} else {
|
|
return sides == ALL;
|
|
}
|
|
}
|
|
|
|
/** Converts an encoded geometry back to a JTS geometry. */
|
|
public Geometry decode() throws GeometryException {
|
|
return decodeCommands(geomType, commands, scale);
|
|
}
|
|
|
|
/** Returns this encoded geometry, scaled back to 0, so it is safe to emit to archive output. */
|
|
public VectorGeometry unscale() {
|
|
return scale == 0 ? this : new VectorGeometry(VectorTile.unscale(commands, scale, geomType), geomType, 0);
|
|
}
|
|
|
|
@Override
|
|
public boolean equals(Object o) {
|
|
if (this == o) {
|
|
return true;
|
|
}
|
|
if (o == null || getClass() != o.getClass()) {
|
|
return false;
|
|
}
|
|
|
|
VectorGeometry that = (VectorGeometry) o;
|
|
|
|
if (geomType != that.geomType) {
|
|
return false;
|
|
}
|
|
return Arrays.equals(commands, that.commands);
|
|
}
|
|
|
|
@Override
|
|
public int hashCode() {
|
|
int result = Arrays.hashCode(commands);
|
|
result = 31 * result + geomType.hashCode();
|
|
return result;
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
return "VectorGeometry[" +
|
|
"commands=int[" + commands.length +
|
|
"], geomType=" + geomType +
|
|
" (" + geomType.asByte() + ")]";
|
|
}
|
|
|
|
/** Returns true if the encoded geometry is a polygon fill. */
|
|
public boolean isFill() {
|
|
return isFillOrEdge(false);
|
|
}
|
|
|
|
/**
|
|
* Returns true if the encoded geometry is a polygon fill, rectangle edge, or part of a horizontal/vertical line
|
|
* that is likely to be repeated across tiles.
|
|
*/
|
|
public boolean isFillOrEdge() {
|
|
return isFillOrEdge(true);
|
|
}
|
|
|
|
/**
|
|
* Returns true if the encoded geometry is a polygon fill, or if {@code allowEdges == true} then also a rectangle
|
|
* edge, or part of a horizontal/vertical line that is likely to be repeated across tiles.
|
|
*/
|
|
public boolean isFillOrEdge(boolean allowEdges) {
|
|
if (geomType != GeometryType.POLYGON && (!allowEdges || geomType != GeometryType.LINE)) {
|
|
return false;
|
|
}
|
|
|
|
boolean isLine = geomType == GeometryType.LINE;
|
|
|
|
int extent = EXTENT << scale;
|
|
int visited = INSIDE;
|
|
int firstX = 0;
|
|
int firstY = 0;
|
|
int x = 0;
|
|
int y = 0;
|
|
|
|
int geometryCount = commands.length;
|
|
int length = 0;
|
|
int command = 0;
|
|
int i = 0;
|
|
while (i < geometryCount) {
|
|
|
|
if (length <= 0) {
|
|
length = commands[i++];
|
|
command = length & ((1 << 3) - 1);
|
|
length = length >> 3;
|
|
if (isLine && length > 2) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (length > 0) {
|
|
if (command == Command.CLOSE_PATH.value) {
|
|
if (isSegmentInvalid(allowEdges, x, y, firstX, firstY, extent) ||
|
|
!visitedEnoughSides(allowEdges, visited)) {
|
|
return false;
|
|
}
|
|
length--;
|
|
continue;
|
|
}
|
|
|
|
int dx = commands[i++];
|
|
int dy = commands[i++];
|
|
|
|
length--;
|
|
|
|
dx = zigZagDecode(dx);
|
|
dy = zigZagDecode(dy);
|
|
|
|
int nextX = x + dx;
|
|
int nextY = y + dy;
|
|
|
|
if (command == Command.MOVE_TO.value) {
|
|
firstX = nextX;
|
|
firstY = nextY;
|
|
if ((visited = getSide(firstX, firstY, extent)) == INSIDE) {
|
|
return false;
|
|
}
|
|
} else {
|
|
if (isSegmentInvalid(allowEdges, x, y, nextX, nextY, extent)) {
|
|
return false;
|
|
}
|
|
visited |= getSide(nextX, nextY, extent);
|
|
}
|
|
y = nextY;
|
|
x = nextX;
|
|
}
|
|
|
|
}
|
|
|
|
return visitedEnoughSides(allowEdges, visited);
|
|
}
|
|
|
|
/** Returns true if there are no commands in this geometry. */
|
|
public boolean isEmpty() {
|
|
return commands.length == 0;
|
|
}
|
|
|
|
/**
|
|
* If this is a point, returns an empty geometry if more than {@code buffer} pixels outside the tile bounds, or if
|
|
* it is a multipoint than removes all points outside the buffer.
|
|
*/
|
|
public VectorGeometry filterPointsOutsideBuffer(double buffer) {
|
|
if (geomType != GeometryType.POINT) {
|
|
return this;
|
|
}
|
|
IntArrayList result = null;
|
|
|
|
int extent = (EXTENT << scale);
|
|
int bufferInt = (int) Math.ceil(buffer * extent / 256);
|
|
int min = -bufferInt;
|
|
int max = extent + bufferInt;
|
|
|
|
int x = 0;
|
|
int y = 0;
|
|
int lastX = 0;
|
|
int lastY = 0;
|
|
|
|
int geometryCount = commands.length;
|
|
int length = 0;
|
|
int i = 0;
|
|
|
|
while (i < geometryCount) {
|
|
if (length <= 0) {
|
|
length = commands[i++] >> 3;
|
|
assert i <= 1 : "Bad index " + i;
|
|
}
|
|
|
|
if (length > 0) {
|
|
length--;
|
|
x += zigZagDecode(commands[i++]);
|
|
y += zigZagDecode(commands[i++]);
|
|
if (x < min || y < min || x > max || y > max) {
|
|
if (result == null) {
|
|
// short-circuit the common case of only a single point that gets filtered-out
|
|
if (commands.length == 3) {
|
|
return EMPTY_POINT;
|
|
}
|
|
result = new IntArrayList(commands.length);
|
|
result.add(commands, 0, i - 2);
|
|
}
|
|
} else {
|
|
if (result != null) {
|
|
result.add(zigZagEncode(x - lastX), zigZagEncode(y - lastY));
|
|
}
|
|
lastX = x;
|
|
lastY = y;
|
|
}
|
|
}
|
|
}
|
|
if (result != null) {
|
|
if (result.size() < 3) {
|
|
result.elementsCount = 0;
|
|
} else {
|
|
result.set(0, Command.MOVE_TO.value | (((result.size() - 1) / 2) << 3));
|
|
}
|
|
|
|
return new VectorGeometry(result.toArray(), geomType, scale);
|
|
} else {
|
|
return this;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the hilbert index of the zig-zag-encoded first point of this feature.
|
|
* <p>
|
|
* This can be useful for sorting geometries to minimize encoded vector tile geometry command size since smaller
|
|
* offsets take fewer bytes using protobuf varint encoding.
|
|
*/
|
|
public int hilbertIndex() {
|
|
if (commands.length < 3) {
|
|
return 0;
|
|
}
|
|
int x = commands[1];
|
|
int y = commands[2];
|
|
return Hilbert.hilbertXYToIndex(15, x >> scale, y >> scale);
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns the coordinate of the first point in this geometry in tile pixel coordinates from (0,0) at the top left
|
|
* to (256,256) at the bottom right.
|
|
*/
|
|
public CoordinateXY firstCoordinate() {
|
|
if (commands.length < 3) {
|
|
return null;
|
|
}
|
|
double factor = 1 << scale;
|
|
double x = zigZagDecode(commands[1]) * SIZE / EXTENT / factor;
|
|
double y = zigZagDecode(commands[2]) * SIZE / EXTENT / factor;
|
|
return new CoordinateXY(x, y);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* A feature in a vector tile.
|
|
*
|
|
* @param layer the layer the feature was in
|
|
* @param id the feature ID
|
|
* @param geometry the encoded feature geometry (decode using {@link VectorGeometry#decode()})
|
|
* @param attrs tags for the feature to output
|
|
* @param group grouping key used to limit point density or {@link #NO_GROUP} if not in a group. NOTE: this is only
|
|
* populated when this feature was deserialized from {@link FeatureGroup}, not when parsed from a tile
|
|
* since vector tile schema does not encode group.
|
|
*/
|
|
public record Feature(
|
|
String layer,
|
|
long id,
|
|
VectorGeometry geometry,
|
|
Map<String, Object> attrs,
|
|
long group
|
|
) {
|
|
|
|
public static final long NO_GROUP = Long.MIN_VALUE;
|
|
|
|
public Feature(
|
|
String layer,
|
|
long id,
|
|
VectorGeometry geometry,
|
|
Map<String, Object> attrs
|
|
) {
|
|
this(layer, id, geometry, attrs, NO_GROUP);
|
|
}
|
|
|
|
public boolean hasGroup() {
|
|
return group != NO_GROUP;
|
|
}
|
|
|
|
/**
|
|
* Encodes {@code newGeometry} and returns a copy of this feature with {@code geometry} replaced with the encoded
|
|
* new geometry.
|
|
*/
|
|
public Feature copyWithNewGeometry(Geometry newGeometry) {
|
|
return copyWithNewGeometry(encodeGeometry(newGeometry));
|
|
}
|
|
|
|
/**
|
|
* Returns a copy of this feature with {@code geometry} replaced with {@code newGeometry}.
|
|
*/
|
|
public Feature copyWithNewGeometry(VectorGeometry newGeometry) {
|
|
return newGeometry == geometry ? this : new Feature(
|
|
layer,
|
|
id,
|
|
newGeometry,
|
|
attrs,
|
|
group
|
|
);
|
|
}
|
|
|
|
/** Returns a copy of this feature with {@code extraAttrs} added to {@code attrs}. */
|
|
public Feature copyWithExtraAttrs(Map<String, Object> extraAttrs) {
|
|
return new Feature(
|
|
layer,
|
|
id,
|
|
geometry,
|
|
Stream.concat(attrs.entrySet().stream(), extraAttrs.entrySet().stream())
|
|
.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)),
|
|
group
|
|
);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Encodes a geometry as a sequence of integers according to the
|
|
* <a href="https://github.com/mapbox/vector-tile-spec/tree/master/2.1#43-geometry-encoding">Geometry * Encoding
|
|
* Specification</a>.
|
|
*/
|
|
private static class CommandEncoder {
|
|
|
|
final IntArrayList result = new IntArrayList();
|
|
private final double SCALE;
|
|
// Initial points use absolute locations, then subsequent points in a geometry use offsets so
|
|
// need to keep track of previous x/y location during the encoding.
|
|
int x = 0, y = 0;
|
|
|
|
CommandEncoder(int scale) {
|
|
this.SCALE = (EXTENT << scale) / SIZE;
|
|
}
|
|
|
|
static boolean shouldClosePath(Geometry geometry) {
|
|
return (geometry instanceof Polygon) || (geometry instanceof LinearRing);
|
|
}
|
|
|
|
static int commandAndLength(Command command, int repeat) {
|
|
return repeat << 3 | command.value;
|
|
}
|
|
|
|
void accept(Geometry geometry) {
|
|
switch (geometry) {
|
|
case MultiLineString multiLineString -> {
|
|
for (int i = 0; i < multiLineString.getNumGeometries(); i++) {
|
|
encode(((LineString) multiLineString.getGeometryN(i)).getCoordinateSequence(), false, GeometryType.LINE);
|
|
}
|
|
}
|
|
case Polygon polygon -> {
|
|
LineString exteriorRing = polygon.getExteriorRing();
|
|
encode(exteriorRing.getCoordinateSequence(), true, GeometryType.POLYGON);
|
|
for (int i = 0; i < polygon.getNumInteriorRing(); i++) {
|
|
LineString interiorRing = polygon.getInteriorRingN(i);
|
|
encode(interiorRing.getCoordinateSequence(), true, GeometryType.LINE);
|
|
}
|
|
}
|
|
case MultiPolygon multiPolygon -> {
|
|
for (int i = 0; i < multiPolygon.getNumGeometries(); i++) {
|
|
accept(multiPolygon.getGeometryN(i));
|
|
}
|
|
}
|
|
case LineString lineString ->
|
|
encode(lineString.getCoordinateSequence(), shouldClosePath(geometry), GeometryType.LINE);
|
|
case Point point -> encode(point.getCoordinateSequence(), false, GeometryType.POINT);
|
|
case Puntal ignored -> encode(new CoordinateArraySequence(geometry.getCoordinates()), shouldClosePath(geometry),
|
|
geometry instanceof MultiPoint, GeometryType.POINT);
|
|
case null -> LOGGER.warn("Null geometry type");
|
|
default -> LOGGER.warn("Unrecognized geometry type: " + geometry.getGeometryType());
|
|
}
|
|
}
|
|
|
|
void encode(CoordinateSequence cs, boolean closePathAtEnd, GeometryType geomType) {
|
|
encode(cs, closePathAtEnd, false, geomType);
|
|
}
|
|
|
|
void encode(CoordinateSequence cs, boolean closePathAtEnd, boolean multiPoint, GeometryType geomType) {
|
|
if (cs.size() == 0) {
|
|
throw new IllegalArgumentException("empty geometry");
|
|
}
|
|
|
|
int startIdx = result.size();
|
|
int numPoints = 0;
|
|
int lineToIndex = 0;
|
|
int lineToLength = 0;
|
|
int startX = x;
|
|
int startY = y;
|
|
|
|
for (int i = 0; i < cs.size(); i++) {
|
|
|
|
double cx = cs.getX(i);
|
|
double cy = cs.getY(i);
|
|
|
|
if (i == 0) {
|
|
result.add(commandAndLength(Command.MOVE_TO, multiPoint ? cs.size() : 1));
|
|
}
|
|
|
|
int _x = (int) Math.round(cx * SCALE);
|
|
int _y = (int) Math.round(cy * SCALE);
|
|
|
|
// prevent point equal to the previous
|
|
if (i > 0 && _x == x && _y == y && !multiPoint) {
|
|
lineToLength--;
|
|
continue;
|
|
}
|
|
|
|
// prevent double closing
|
|
if (closePathAtEnd && cs.size() > 1 && i == (cs.size() - 1) && cs.getX(0) == cx && cs.getY(0) == cy) {
|
|
lineToLength--;
|
|
continue;
|
|
}
|
|
|
|
// delta, then zigzag
|
|
result.add(zigZagEncode(_x - x));
|
|
result.add(zigZagEncode(_y - y));
|
|
numPoints++;
|
|
|
|
x = _x;
|
|
y = _y;
|
|
|
|
if (i == 0 && cs.size() > 1 && !multiPoint) {
|
|
// can length be too long?
|
|
lineToIndex = result.size();
|
|
lineToLength = cs.size() - 1;
|
|
result.add(commandAndLength(Command.LINE_TO, lineToLength));
|
|
}
|
|
|
|
}
|
|
|
|
// update LineTo length
|
|
if (lineToIndex > 0) {
|
|
if (lineToLength == 0) {
|
|
// remove empty LineTo
|
|
result.remove(lineToIndex);
|
|
} else {
|
|
// update LineTo with new length
|
|
result.set(lineToIndex, commandAndLength(Command.LINE_TO, lineToLength));
|
|
}
|
|
}
|
|
|
|
if (closePathAtEnd) {
|
|
result.add(commandAndLength(Command.CLOSE_PATH, 1));
|
|
numPoints++;
|
|
}
|
|
|
|
// degenerate geometry, skip emitting
|
|
if (numPoints < geomType.minPoints()) {
|
|
result.elementsCount = startIdx;
|
|
// reset deltas
|
|
x = startX;
|
|
y = startY;
|
|
}
|
|
}
|
|
}
|
|
|
|
private record EncodedFeature(IntArrayList tags, long id, VectorGeometry geometry) {
|
|
|
|
EncodedFeature(Feature in) {
|
|
this(new IntArrayList(), in.id(), in.geometry());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Holds all features in an output layer of this tile, along with the index of each tag key/value so that features can
|
|
* store each key/value as a pair of integers.
|
|
*/
|
|
private static final class Layer {
|
|
|
|
final List<EncodedFeature> encodedFeatures = new ArrayList<>();
|
|
final Map<String, Integer> keys = new LinkedHashMap<>();
|
|
final Map<Object, Integer> values = new LinkedHashMap<>();
|
|
|
|
List<String> keys() {
|
|
return new ArrayList<>(keys.keySet());
|
|
}
|
|
|
|
List<Object> values() {
|
|
return new ArrayList<>(values.keySet());
|
|
}
|
|
|
|
/** Returns the ID associated with {@code key} or adds a new one if not present. */
|
|
Integer key(String key) {
|
|
Integer i = keys.get(key);
|
|
if (i == null) {
|
|
i = keys.size();
|
|
keys.put(key, i);
|
|
}
|
|
return i;
|
|
}
|
|
|
|
/** Returns the ID associated with {@code value} or adds a new one if not present. */
|
|
Integer value(Object value) {
|
|
Integer i = values.get(value);
|
|
if (i == null) {
|
|
i = values.size();
|
|
values.put(value, i);
|
|
}
|
|
return i;
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
return "Layer{" + encodedFeatures.size() + "}";
|
|
}
|
|
}
|
|
}
|