EXPERIMENTAL work on prototyping the VT3 vector tile spec revision

decode.cpp

@@ -51,14 +51,16 @@ void do_stats(mvt_tile &tile, size_t size, bool compressed, int z, unsigned x, u
 	for (size_t i = 0; i < tile.layers.size(); i++) {
 		state.json_write_string(tile.layers[i].name);
 
-		size_t points = 0, lines = 0, polygons = 0;
+		size_t points = 0, lines = 0, polygons = 0, splines = 0;
 		for (size_t j = 0; j < tile.layers[i].features.size(); j++) {
 			if (tile.layers[i].features[j].type == mvt_point) {
 				points++;
 			} else if (tile.layers[i].features[j].type == mvt_linestring) {
 				lines++;
 			} else if (tile.layers[i].features[j].type == mvt_polygon) {
 				polygons++;
+			} else if (tile.layers[i].features[j].type == mvt_spline) {
+				splines++;
 			}
 		}
 
@@ -73,9 +75,27 @@ void do_stats(mvt_tile &tile, size_t size, bool compressed, int z, unsigned x, u
 		state.json_write_string("polygons");
 		state.json_write_unsigned(polygons);
 
+		state.json_write_string("splines");
+		state.json_write_unsigned(splines);
+
 		state.json_write_string("extent");
 		state.json_write_signed(tile.layers[i].extent);
 
+		if (tile.layers[i].zoom >= 0) {
+			state.json_write_string("zoom");
+			state.json_write_unsigned(tile.layers[i].zoom);
+		}
+
+		if (tile.layers[i].x >= 0) {
+			state.json_write_string("x");
+			state.json_write_unsigned(tile.layers[i].x);
+		}
+
+		if (tile.layers[i].y >= 0) {
+			state.json_write_string("y");
+			state.json_write_unsigned(tile.layers[i].y);
+		}
+
 		state.json_end_hash();
 	}
 
@@ -85,6 +105,21 @@ void do_stats(mvt_tile &tile, size_t size, bool compressed, int z, unsigned x, u
 	state.json_write_newline();
 }
 
+void write_scaling(json_writer &state, mvt_scaling const &scaling) {
+	state.json_write_hash();
+
+	state.json_write_string("offset");
+	state.json_write_unsigned(scaling.offset);
+
+	state.json_write_string("multiplier");
+	state.json_write_number(scaling.multiplier);
+
+	state.json_write_string("base");
+	state.json_write_number(scaling.base);
+
+	state.json_end_hash();
+}
+
 void handle(std::string message, int z, unsigned x, unsigned y, std::set<std::string> const &to_decode, bool pipeline, bool stats, json_writer &state) {
 	mvt_tile tile;
 	bool was_compressed;
@@ -189,6 +224,37 @@ void handle(std::string message, int z, unsigned x, unsigned y, std::set<std::st
 				state.json_write_string("extent");
 				state.json_write_signed(layer.extent);
 
+				if (layer.zoom >= 0) {
+					state.json_write_string("zoom");
+					state.json_write_unsigned(layer.zoom);
+				}
+
+				if (layer.x >= 0) {
+					state.json_write_string("x");
+					state.json_write_unsigned(layer.x);
+				}
+
+				if (layer.y >= 0) {
+					state.json_write_string("y");
+					state.json_write_unsigned(layer.y);
+				}
+
+				if (layer.has_elevation_scaling) {
+					state.json_write_string("elevation_scaling");
+					write_scaling(state, layer.elevation_scaling);
+				}
+
+				if (layer.attribute_scalings.size() != 0) {
+					state.json_write_string("attribute_scalings");
+					state.json_write_array();
+
+					for (size_t i = 0; i < layer.attribute_scalings.size(); i++) {
+						write_scaling(state, layer.attribute_scalings[i]);
+					}
+
+					state.json_end_array();
+				}
+
 				state.json_end_hash();
 
 				state.json_write_string("features");

geobuf.cpp

@@ -78,7 +78,7 @@ serial_val readValue(protozero::pbf_reader &pbf) {
 			break;
 
 		case 6:
-			sv.type = mvt_string;  // stringified JSON
+			sv.type = mvt_hash;  // stringified JSON
 			sv.s = pbf.get_string();
 
 			if (sv.s == "null") {

geojson.cpp

@@ -65,6 +65,11 @@ int serialize_geojson_feature(struct serialization_state *sst, json_object *geom
 		return 0;
 	}
 
+	json_object *attributes = json_hash_get(geometry, "attributes");
+	if (attributes != NULL && attributes->type != JSON_ARRAY) {
+		attributes = NULL;
+	}
+
 	int t;
 	for (t = 0; t < GEOM_TYPES; t++) {
 		if (strcmp(geometry_type->string, geometry_names[t]) == 0) {
@@ -100,6 +105,7 @@ int serialize_geojson_feature(struct serialization_state *sst, json_object *geom
 
 	bool has_id = false;
 	unsigned long long id_value = 0;
+	std::string string_id_value;
 	if (id != NULL) {
 		if (id->type == JSON_NUMBER) {
 			if (id->number >= 0) {
@@ -159,13 +165,17 @@ int serialize_geojson_feature(struct serialization_state *sst, json_object *geom
 			}
 
 			if (!converted) {
-				static bool warned_nan = false;
+				if (id->type == JSON_STRING) {
+					string_id_value = id->string;
+				} else {
+					static bool warned_nan = false;
 
-				if (!warned_nan) {
-					char *s = json_stringify(id);
-					fprintf(stderr, "Warning: Can't represent non-numeric feature ID %s\n", s);
-					free(s);  // stringify
-					warned_nan = true;
+					if (!warned_nan) {
+						char *s = json_stringify(id);
+						fprintf(stderr, "Warning: Can't represent non-numeric feature ID %s\n", s);
+						free(s);  // stringify
+						warned_nan = true;
+					}
 				}
 			}
 		}
@@ -210,14 +220,21 @@ int serialize_geojson_feature(struct serialization_state *sst, json_object *geom
 	}
 
 	drawvec dv;
-	parse_geometry(t, coordinates, dv, VT_MOVETO, sst->fname, sst->line, feature);
+	parse_geometry(t, coordinates, dv, VT_MOVETO, sst->fname, sst->line, feature, false);
+
+	if (attributes != NULL) {
+		drawvec dv2;
+		parse_geometry(t, attributes, dv2, VT_MOVETO, sst->fname, sst->line, feature, true);
+		merge_node_attributes(dv, dv2);
+	}
 
 	serial_feature sf;
 	sf.layer = layer;
 	sf.segment = sst->segment;
 	sf.t = mb_geometry[t];
 	sf.has_id = has_id;
 	sf.id = id_value;
+	sf.string_id = string_id_value;
 	sf.has_tippecanoe_minzoom = (tippecanoe_minzoom != -1);
 	sf.tippecanoe_minzoom = tippecanoe_minzoom;
 	sf.has_tippecanoe_maxzoom = (tippecanoe_maxzoom != -1);

geometry.cpp

@@ -22,7 +22,7 @@
 #include "options.hpp"
 
 static int pnpoly(drawvec &vert, size_t start, size_t nvert, long long testx, long long testy);
-static int clip(double *x0, double *y0, double *x1, double *y1, double xmin, double ymin, double xmax, double ymax);
+static int clip(double *x0, double *y0, double *x1, double *y1, double xmin, double ymin, double xmax, double ymax, bool *changed0, bool *changed1, std::vector<double> *el0, std::vector<double> *el1);
 
 drawvec decode_geometry(FILE *meta, std::atomic<long long> *geompos, int z, unsigned tx, unsigned ty, long long *bbox, unsigned initial_x, unsigned initial_y) {
 	drawvec out;
@@ -37,10 +37,12 @@ drawvec decode_geometry(FILE *meta, std::atomic<long long> *geompos, int z, unsi
 	while (1) {
 		draw d;
 
-		if (!deserialize_byte_io(meta, &d.op, geompos)) {
+		signed char op;
+		if (!deserialize_byte_io(meta, &op, geompos)) {
 			fprintf(stderr, "Internal error: Unexpected end of file in geometry\n");
 			exit(EXIT_FAILURE);
 		}
+		d.op = op & VT_CLOSEPATH;
 		if (d.op == VT_END) {
 			break;
 		}
@@ -77,6 +79,19 @@ drawvec decode_geometry(FILE *meta, std::atomic<long long> *geompos, int z, unsi
 
 			d.x = wwx;
 			d.y = wwy;
+
+			if (op & VT_NODE_3D) {
+				unsigned long long n;
+				deserialize_ulong_long_io(meta, &n, geompos);
+
+				d.elevations.resize(n);
+				for (size_t i = 0; i < n; i++) {
+					deserialize_double_io(meta, &d.elevations[i], geompos);
+				}
+			}
+			if (op & VT_NODE_ATTRIB) {
+				deserialize_string_io(meta, d.attributes, geompos);
+			}
 		}
 
 		out.push_back(d);
@@ -665,20 +680,41 @@ drawvec clip_lines(drawvec &geom, long long minx, long long miny, long long maxx
 		if (i > 0 && (geom[i - 1].op == VT_MOVETO || geom[i - 1].op == VT_LINETO) && geom[i].op == VT_LINETO) {
 			double x1 = geom[i - 1].x;
 			double y1 = geom[i - 1].y;
+			std::vector<double> e1 = geom[i - 1].elevations;
 
 			double x2 = geom[i - 0].x;
 			double y2 = geom[i - 0].y;
+			std::vector<double> e2 = geom[i - 0].elevations;
 
-			int c = clip(&x1, &y1, &x2, &y2, minx, miny, maxx, maxy);
+			bool changed0 = false, changed1 = false;
+			int c = clip(&x1, &y1, &x2, &y2, minx, miny, maxx, maxy, &changed0, &changed1, &e1, &e2);
 
 			if (c > 1) {  // clipped
-				out.push_back(draw(VT_MOVETO, x1, y1));
-				out.push_back(draw(VT_LINETO, x2, y2));
-				out.push_back(draw(VT_MOVETO, geom[i].x, geom[i].y));
+				if (changed0) {
+					out.push_back(draw(VT_MOVETO, x1, y1, e1));
+				} else {
+					draw d = geom[i - 1];
+					d.op = VT_MOVETO;
+					out.push_back(d);
+				}
+
+				if (changed1) {
+					out.push_back(draw(VT_LINETO, x2, y2, e2));
+				} else {
+					draw d = geom[i];
+					d.op = VT_LINETO;
+					out.push_back(d);
+				}
+
+				draw d = geom[i];
+				d.op = VT_MOVETO;
+				out.push_back(d);
 			} else if (c == 1) {  // unchanged
 				out.push_back(geom[i]);
 			} else {  // clipped away entirely
-				out.push_back(draw(VT_MOVETO, geom[i].x, geom[i].y));
+				draw d = geom[i];
+				d.op = VT_MOVETO;
+				out.push_back(d);
 			}
 		} else {
 			out.push_back(geom[i]);
@@ -778,19 +814,22 @@ drawvec impose_tile_boundaries(drawvec &geom, long long extent) {
 		if (i > 0 && geom[i].op == VT_LINETO && (geom[i - 1].op == VT_MOVETO || geom[i - 1].op == VT_LINETO)) {
 			double x1 = geom[i - 1].x;
 			double y1 = geom[i - 1].y;
+			std::vector<double> e1 = geom[i - 1].elevations;
 
 			double x2 = geom[i - 0].x;
 			double y2 = geom[i - 0].y;
+			std::vector<double> e2 = geom[i - 0].elevations;
 
-			int c = clip(&x1, &y1, &x2, &y2, 0, 0, extent, extent);
+			bool changed0 = false, changed1 = false;
+			int c = clip(&x1, &y1, &x2, &y2, 0, 0, extent, extent, &changed0, &changed1, &e1, &e2);
 
 			if (c > 1) {  // clipped
-				if (x1 != geom[i - 1].x || y1 != geom[i - 1].y) {
-					out.push_back(draw(VT_LINETO, x1, y1));
+				if (changed0) {
+					out.push_back(draw(VT_LINETO, x1, y1, e1));
 					out[out.size() - 1].necessary = 1;
 				}
-				if (x2 != geom[i - 0].x || y2 != geom[i - 0].y) {
-					out.push_back(draw(VT_LINETO, x2, y2));
+				if (changed1) {
+					out.push_back(draw(VT_LINETO, x2, y2, e2));
 					out[out.size() - 1].necessary = 1;
 				}
 			}
@@ -1071,7 +1110,7 @@ static int computeOutCode(double x, double y, double xmin, double ymin, double x
 	return code;
 }
 
-static int clip(double *x0, double *y0, double *x1, double *y1, double xmin, double ymin, double xmax, double ymax) {
+static int clip(double *x0, double *y0, double *x1, double *y1, double xmin, double ymin, double xmax, double ymax, bool *changed0, bool *changed1, std::vector<double> *e0, std::vector<double> *e1) {
 	int outcode0 = computeOutCode(*x0, *y0, xmin, ymin, xmax, ymax);
 	int outcode1 = computeOutCode(*x1, *y1, xmin, ymin, xmax, ymax);
 	int accept = 0;
@@ -1087,6 +1126,7 @@ static int clip(double *x0, double *y0, double *x1, double *y1, double xmin, dou
 			// failed both tests, so calculate the line segment to clip
 			// from an outside point to an intersection with clip edge
 			double x = *x0, y = *y0;
+			std::vector<double> e = *e0;
 
 			// At least one endpoint is outside the clip rectangle; pick it.
 			int outcodeOut = outcode0 ? outcode0 : outcode1;
@@ -1096,28 +1136,52 @@ static int clip(double *x0, double *y0, double *x1, double *y1, double xmin, dou
 			if (outcodeOut & TOP) {  // point is above the clip rectangle
 				x = *x0 + (*x1 - *x0) * (ymax - *y0) / (*y1 - *y0);
 				y = ymax;
+
+				e.resize(0);
+				for (size_t i = 0; i < e0->size() && i < e1->size(); i++) {
+					e.push_back((*e0)[i] + ((*e1)[i] - (*e0)[i]) * (ymax - *y0) / (*y1 - *y0));
+				}
 			} else if (outcodeOut & BOTTOM) {  // point is below the clip rectangle
 				x = *x0 + (*x1 - *x0) * (ymin - *y0) / (*y1 - *y0);
 				y = ymin;
+
+				e.resize(0);
+				for (size_t i = 0; i < e0->size() && i < e1->size(); i++) {
+					e.push_back((*e0)[i] + ((*e1)[i] - (*e0)[i]) * (ymin - *y0) / (*y1 - *y0));
+				}
 			} else if (outcodeOut & RIGHT) {  // point is to the right of clip rectangle
 				y = *y0 + (*y1 - *y0) * (xmax - *x0) / (*x1 - *x0);
 				x = xmax;
+
+				e.resize(0);
+				for (size_t i = 0; i < e0->size() && i < e1->size(); i++) {
+					e.push_back((*e0)[i] + ((*e1)[i] - (*e0)[i]) * (xmax - *x0) / (*x1 - *x0));
+				}
 			} else if (outcodeOut & LEFT) {  // point is to the left of clip rectangle
 				y = *y0 + (*y1 - *y0) * (xmin - *x0) / (*x1 - *x0);
 				x = xmin;
+
+				e.resize(0);
+				for (size_t i = 0; i < e0->size() && i < e1->size(); i++) {
+					e.push_back((*e0)[i] + ((*e1)[i] - (*e0)[i]) * (xmin - *x0) / (*x1 - *x0));
+				}
 			}
 
 			// Now we move outside point to intersection point to clip
 			// and get ready for next pass.
 			if (outcodeOut == outcode0) {
 				*x0 = x;
 				*y0 = y;
+				*e0 = e;
 				outcode0 = computeOutCode(*x0, *y0, xmin, ymin, xmax, ymax);
+				*changed0 = 1;
 				changed = 1;
 			} else {
 				*x1 = x;
 				*y1 = y;
+				*e1 = e;
 				outcode1 = computeOutCode(*x1, *y1, xmin, ymin, xmax, ymax);
+				*changed1 = 1;
 				changed = 1;
 			}
 		}