Update the nuber of cores acording to the latest GitHub runners state

Qt 5.15 is now the minimal required Qt version.

.appveyor.yml

@@ -0,0 +1,31 @@
+version: 4.2.{build}
+
+configuration:
+  - Release
+
+image:
+  - Visual Studio 2022
+
+environment:
+  VCPKGDIR: C:\tools\vcpkg\installed\x64-windows-static-md-release
+  matrix:
+  - QTDIR: C:\Qt\5.15\msvc2019_64
+  - QTDIR: C:\Qt\6.8\msvc2022_64
+
+install:
+- cmd: |-
+    set PATH=%QTDIR%\bin;%PATH%
+    call "C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Auxiliary\Build\vcvars64.bat
+    vcpkg install zlib:x64-windows-static-md-release
+    copy /y %VCPKGDIR%\lib\zlib.lib %VCPKGDIR%\lib\zlibstatic.lib
+
+build_script:
+- cmd: |-
+    qmake ZLIB=%VCPKGDIR% pbfplugin.pro
+    nmake release
+
+artifacts:
+- path: release\pbf4.dll
+
+cache:
+- C:\tools\vcpkg\installed\

.github/FUNDING.yml

@@ -0,0 +1 @@
+github: tumic0

.github/workflows/android.yml

@@ -0,0 +1,48 @@
+name: Android
+
+on:
+  push:
+    branches:
+      - master
+
+jobs:
+  build:
+    name: QtPBFImagePlugin
+    runs-on: ubuntu-22.04
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: set up JDK 11
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '11'
+      - name: Setup Android SDK
+        uses: android-actions/setup-android@v3
+        with:
+          cmdline-tools-version: 9862592
+      - name: Install android platform, build-tools and ndk
+        run:  ${ANDROID_HOME}/cmdline-tools/latest/bin/sdkmanager --install "platforms;android-33" "build-tools;33.0.0" "ndk;23.1.7779620"
+      - name: Setup NDK path
+        run: echo "ANDROID_NDK_ROOT=${ANDROID_HOME}/ndk/23.1.7779620/" >> $GITHUB_ENV
+      - name: Install Qt (Desktop)
+        uses: jurplel/install-qt-action@v3
+        with:
+          aqtversion: '==3.1.*'
+          version: '6.4.0'
+      - name: Install Qt (Android)
+        uses: jurplel/install-qt-action@v3
+        with:
+          aqtversion: '==3.1.*'
+          version: '6.4.0'
+          target: 'android'
+          arch: 'android_arm64_v8a'
+      - name: Configure build
+        run:  qmake pbfplugin.pro
+      - name: Build project
+        run:  make -j4
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: libplugins_imageformats_libpbf_arm64-v8a.so
+          path: plugins/libplugins_imageformats_libpbf_arm64-v8a.so

.github/workflows/linux.yml

@@ -0,0 +1,25 @@
+name: Linux
+
+on:
+  push:
+    branches:
+      - master
+
+jobs:
+  build:
+    name: QtPBFImagePlugin
+    runs-on: ubuntu-22.04
+    strategy:
+      matrix:
+        config: ['release', 'debug']
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Install dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install qtbase5-dev qtbase5-dev-tools qt5-qmake zlib1g-dev
+      - name: Configure build
+        run: qmake CONFIG+=${{ matrix.config }} pbfplugin.pro
+      - name: Build project
+        run: make -j4

.github/workflows/osx.yml

@@ -0,0 +1,27 @@
+name: OS X
+
+on:
+  push:
+    branches:
+      - master
+
+jobs:
+  build:
+    name: QtPBFImagePlugin
+    runs-on: macos-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Install Qt
+        uses: jurplel/install-qt-action@v4
+        with:
+          version: '6.8.2'
+      - name: Configure build
+        run: qmake pbfplugin.pro QMAKE_APPLE_DEVICE_ARCHS="x86_64h arm64"
+      - name: Build project
+        run: make -j3
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          path: libpbf.dylib
+          name: libpbf.dylib

.gitignore

@@ -0,0 +1,9 @@
+# Object files
+*.o
+
+# Qt stuff
+/.qmake.stash
+moc_*.cpp
+moc_*.h
+qrc_*.cpp
+Makefile*

.travis.yml

@@ -1,23 +0,0 @@
-language: c++
-dist: xenial
-
-os:
-  - linux
-  - osx
-
-env:
-  - QT_SELECT=qt5
-
-before_install:
-  - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then sudo apt-get -qq update; fi
-  - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew update; fi
-
-install:
-  - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew install qt protobuf; fi
-  - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then sudo apt-get install qtbase5-dev qtbase5-dev-tools qt5-qmake libprotobuf-dev protobuf-compiler; fi
-
-script:
-  - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then PATH=/usr/local/opt/qt/bin/:${PATH}; fi
-  - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then qmake PROTOBUF=/usr/local pbfplugin.pro; fi
-  - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then qmake pbfplugin.pro; fi
-  - make

README.md

@@ -7,7 +7,7 @@ displaying raster MBTiles maps or raster XYZ online maps to also display
 PBF(MVT) vector tiles without (almost, see usage) any application modifications.
 
 Standard Mapbox GL Styles are used for styling the maps. Most relevant style
-features used by [Maputnik](http://editor.openmaptiles.org) are supported.
+features used by [Maputnik](https://maputnik.github.io/editor) are supported.
 A default fallback style (OSM-Liberty) for OpenMapTiles is part of the plugin.
 
 "Plain" PBF files as well as gzip compressed files (as used in MBTiles) are
@@ -18,29 +18,48 @@ to fit the styles and available data (OpenMapTiles, Mapbox tiles).
 Due to a major design flaw in the Mapbox vector tiles specification - the zoom
 is not part of the PBF data - the plugin can not be used "as is", but passing
 the zoom level is necessary. This is done by exploiting the optional *format*
-parameter of the QImage constructor or the QImage::fromData() or
-QPixmap::loadFromData() functions. The zoom number is passed as ASCII string
+parameter of the QImage constructor or the *QImage::loadFromData()* or
+*QPixmap::loadFromData()* functions. The zoom number is passed as ASCII string
 to the functions:
 ```cpp
-QPixmap pm;
-pm.loadFromData(tileData, QString::number(zoom).toLatin1());
+QImage img;
+img.loadFromData(data, QByteArray::number(zoom));
 ```
-The plugin supports vector scaling using QImageReader's setScaledSize() method,
+
+For a complete code sample see the [pbf2png](https://github.com/tumic0/pbf2png)
+conversion utility.
+
+### HiDPI
+The plugin supports vector scaling using QImageReader's *setScaledSize()* method,
 so when used like in the following example:
 ```cpp
-QImageReader reader(file, QString::number(zoom).toLatin1());
+QImage img;
+QImageReader reader(file, QByteArray::number(zoom));
 reader.setScaledSize(QSize(1024, 1024));
-reader.read(&image);
+reader.read(&img);
 ```
 you will get 1024x1024px tiles with a pixel ratio of 2 (= HiDPI tiles).
 
+### Overzoom
+Since version 3 of the plugin tile overzoom is supported. If you set *format*
+to `$zoom;$overzoom`:
+```cpp
+QImage img;
+QByteArray fmt(QByteArray::number(zoom) + ';' + QByteArray::number(overzoom));
+img.loadFromData(data, fmt);
+```
+you will get (512<<overzoom)x(512<<overzoom)px tiles with a pixel ratio of 1.
+When overzoom is combined with setScaledSize(), the base size is the overzoomed
+tile size.
+
 ## Styles
 The map style is loaded from the
 [$AppDataLocation](http://doc.qt.io/qt-5/qstandardpaths.html)/style/style.json
 file on plugin load. If the style uses a sprite, the sprite JSON file must
 be named `sprite.json` and the sprite image `sprite.png` and both files must be
 placed in the same directory as the style itself. *A style compatible with the
-tiles data schema (Mapbox, OpenMapTiles, Tilezen) must be used.*
+tiles data schema (Mapbox, OpenMapTiles, Tilezen, Ordnance Survey, Esri, ...)
+must be used.*
 
 For a list of "ready to use" styles see the
 [QtPBFImagePlugin-styles](https://github.com/tumic0/QtPBFImagePlugin-styles)
@@ -48,48 +67,45 @@ repository.
 
 ## Build
 ### Requirements
-* Qt >= 5.4 (5.6 for HiDPI support)
-* Google Protocol Buffers (protobuf-lite)
+* Qt5 >= 5.15 or Qt6
 * Zlib
 
 ### Build steps
-#### Linux
+#### Linux, OS X and Android
 ```shell
 qmake pbfplugin.pro
 make
 ```
 #### Windows
 ```shell
-qmake PROTOBUF=path/to/protobuf ZLIB=path/to/zlib pbfplugin.pro
+qmake ZLIB=path/to/zlib pbfplugin.pro
 nmake
 ```
-#### OS X
-```shell
-qmake PROTOBUF=path/to/protobuf pbfplugin.pro
-make
-```
 
 ## Install
 Copy the plugin to the system Qt image plugins path to make it work. You may
-also set the QT_PLUGIN_PATH system variable before starting the application. For
-Linux, there are RPM and DEB [packages](https://build.opensuse.org/project/show/home:tumic:QtPBFImagePlugin)
+also set the QT_PLUGIN_PATH system variable before starting the application.
+For Linux, there are RPM and DEB [packages](https://build.opensuse.org/project/show/home:tumic:QtPBFImagePlugin)
 for most common distros available on OBS.
 
 ## Limitations
-* Only data that is part of the PBF file is displayed. External layers defined in the
-style are ignored.
-* Text PBF features must have a unique id (OpenMapTiles >= v3.7) for the text layout
-algorithm to work properly.
-* Expressions are not supported in the styles, only property functions are implemented.
+* Only data that is part of the PBF file is displayed. External layers defined
+in the style are ignored.
+* Text PBF features must have a unique id (OpenMapTiles >= v3.7) for the text
+layout algorithm to work properly. Additionally, the tile buffer must be large
+enough to contain all neighboring text features overlapping to the tile bounds
+(only data from the tile itself can be drawn to the resulting image).
+* Expressions are not supported in the styles, only property functions are
+implemented.
 
 ## Changelog
-[Changelog](https://build.opensuse.org/package/view_file/home:tumic:QtPBFImagePlugin/QtPBFImagePlugin/libqt5-qtpbfimageformat.changes)
+[Changelog](https://build.opensuse.org/projects/home:tumic:QtPBFImagePlugin/packages/QtPBFImagePlugin/files/qt6-qtpbfimageformat.changes)
 
 ## Status
 A picture is worth a thousand words.
 #### OpenMapTiles
 
-* Data: [MapTiler](https://github.com/tumic0/GPXSee-maps/blob/master/World/MapTiler.tpl)
+* Data: [MapTiler](https://github.com/tumic0/GPXSee-maps/blob/master/World/MapTiler-OpenMapTiles.tpl)
 * Style: [OSM-liberty](https://github.com/tumic0/QtPBFImagePlugin-styles/blob/master/OpenMapTiles/osm-liberty/style.json)
 
 ![osm-liberty 5](https://tumic0.github.io/QtPBFImagePlugin/images/osm-liberty-5.png)

pbfplugin.pro

@@ -2,12 +2,10 @@ TARGET  = pbf
 TEMPLATE = lib
 CONFIG += plugin
 QT += gui
+VERSION = 4.2
 
-PROTOS = protobuf/vector_tile.proto
-include(protobuf/vector_tile.pri)
-
-INCLUDEPATH += ./protobuf
 HEADERS += src/pbfhandler.h \
+    src/data.h \
     src/pbfplugin.h \
     src/gzip.h \
     src/pbf.h \
@@ -20,9 +18,9 @@ HEADERS += src/pbfhandler.h \
     src/textpointitem.h \
     src/font.h \
     src/textitem.h \
-    src/sprites.h \
-    src/config.h
+    src/sprites.h
 SOURCES += src/pbfplugin.cpp \
+    src/data.cpp \
     src/pbfhandler.cpp \
     src/gzip.cpp \
     src/pbf.cpp \
@@ -39,21 +37,27 @@ RESOURCES += pbfplugin.qrc
 
 DEFINES += QT_NO_DEPRECATED_WARNINGS
 
-unix:!macx{
-    LIBS += -lprotobuf-lite \
-        -lz
+unix:!macx:!android {
+    LIBS += -lz
+
+    target.path += $$[QT_INSTALL_PLUGINS]/imageformats
+    INSTALLS += target
 }
 win32 {
-    INCLUDEPATH += $$PROTOBUF/include \
-        $$ZLIB/include
-    LIBS += $$PROTOBUF/lib/libprotobuf-lite.lib \
-        $$ZLIB/lib/zlibstatic.lib
+    INCLUDEPATH += $$ZLIB/include
+    LIBS += $$ZLIB/lib/zlibstatic.lib
+
+    QMAKE_TARGET_PRODUCT = QtPBFImagePlugin
+    QMAKE_TARGET_DESCRIPTION = Qt $$QT_VERSION MVT/PBF image plugin
+    QMAKE_TARGET_COPYRIGHT = Copyright (c) 2018-2025 Martin Tuma
 }
 macx {
-    INCLUDEPATH += $$PROTOBUF/include
-    LIBS += $$PROTOBUF/lib/libprotobuf-lite.a \
-        -lz
+    LIBS += -lz
 }
+android {
+    LIBS += -lz
 
-target.path += $$[QT_INSTALL_PLUGINS]/imageformats
-INSTALLS += target
+    top_builddir=$$shadowed($$PWD)
+    DESTDIR = $$top_builddir/plugins
+    TARGET = $$qt5LibraryTarget(libpbf, "plugins/imageformats/")
+}

protobuf/vector_tile.pri

@@ -1,17 +0,0 @@
-INCLUDEPATH += $$PWD
-DEPENDPATH  += $$PWD
-
-protobuf_decl.name = protobuf headers
-protobuf_decl.input = PROTOS
-protobuf_decl.output = ${QMAKE_FILE_IN_PATH}/${QMAKE_FILE_BASE}.pb.h
-protobuf_decl.commands = protoc --cpp_out=${QMAKE_FILE_IN_PATH} --proto_path=${QMAKE_FILE_IN_PATH} ${QMAKE_FILE_NAME}
-protobuf_decl.variable_out = HEADERS
-QMAKE_EXTRA_COMPILERS += protobuf_decl
-
-protobuf_impl.name = protobuf sources
-protobuf_impl.input = PROTOS
-protobuf_impl.output = ${QMAKE_FILE_IN_PATH}/${QMAKE_FILE_BASE}.pb.cc
-protobuf_impl.depends = ${QMAKE_FILE_IN_PATH}/${QMAKE_FILE_BASE}.pb.h
-protobuf_impl.commands = $$escape_expand(\n)
-protobuf_impl.variable_out = SOURCES
-QMAKE_EXTRA_COMPILERS += protobuf_impl

protobuf/vector_tile.proto

@@ -1,78 +0,0 @@
-package vector_tile;
-
-option optimize_for = LITE_RUNTIME;
-
-message Tile {
-
-        // GeomType is described in section 4.3.4 of the specification
-        enum GeomType {
-             UNKNOWN = 0;
-             POINT = 1;
-             LINESTRING = 2;
-             POLYGON = 3;
-        }
-
-        // Variant type encoding
-        // The use of values is described in section 4.1 of the specification
-        message Value {
-                // Exactly one of these values must be present in a valid message
-                optional string string_value = 1;
-                optional float float_value = 2;
-                optional double double_value = 3;
-                optional int64 int_value = 4;
-                optional uint64 uint_value = 5;
-                optional sint64 sint_value = 6;
-                optional bool bool_value = 7;
-
-                extensions 8 to max;
-        }
-
-        // Features are described in section 4.2 of the specification
-        message Feature {
-                optional uint64 id = 1 [ default = 0 ];
-
-                // Tags of this feature are encoded as repeated pairs of
-                // integers.
-                // A detailed description of tags is located in sections
-                // 4.2 and 4.4 of the specification
-                repeated uint32 tags = 2 [ packed = true ];
-
-                // The type of geometry stored in this feature.
-                optional GeomType type = 3 [ default = UNKNOWN ];
-
-                // Contains a stream of commands and parameters (vertices).
-                // A detailed description on geometry encoding is located in 
-                // section 4.3 of the specification.
-                repeated uint32 geometry = 4 [ packed = true ];
-        }
-
-        // Layers are described in section 4.1 of the specification
-        message Layer {
-                // Any compliant implementation must first read the version
-                // number encoded in this message and choose the correct
-                // implementation for this version number before proceeding to
-                // decode other parts of this message.
-                required uint32 version = 15 [ default = 1 ];
-
-                required string name = 1;
-
-                // The actual features in this tile.
-                repeated Feature features = 2;
-
-                // Dictionary encoding for keys
-                repeated string keys = 3;
-
-                // Dictionary encoding for values
-                repeated Value values = 4;
-
-                // Although this is an "optional" field it is required by the specification.
-                // See https://github.com/mapbox/vector-tile-spec/issues/47
-                optional uint32 extent = 5 [ default = 4096 ];
-
-                extensions 16 to max;
-        }
-
-        repeated Layer layers = 3;
-
-        extensions 16 to 8191;
-}

src/config.h

@@ -1,10 +0,0 @@
-#ifndef CONFIG_H
-#define CONFIG_H
-
-#include <QtGlobal>
-
-#if QT_VERSION >= QT_VERSION_CHECK(5, 6, 0)
-#define ENABLE_HIDPI
-#endif // QT >= 5.6
-
-#endif // CONFIG_H

src/data.cpp

@@ -0,0 +1,354 @@
+#include "data.h"
+
+#define TYPE(tag) (tag & 0x07)
+#define FIELD(tag) (tag >> 3)
+
+#define VARINT 0
+#define I64    1
+#define LEN    2
+#define I32    5
+
+struct CTX
+{
+	CTX(const QByteArray &ba)
+	  : bp(ba.constData()), be(bp + ba.size()), tag(0) {}
+
+	const char *bp;
+	const char *be;
+	quint32 tag;
+};
+
+static inline qint64 zigzag64decode(quint64 value)
+{
+	return static_cast<qint64>((value >> 1u) ^ static_cast<quint64>(
+	  -static_cast<qint64>(value & 1u)));
+}
+
+template<typename T>
+static bool varint(CTX &ctx, T &val)
+{
+	unsigned int shift = 0;
+	val = 0;
+
+	while (ctx.bp < ctx.be) {
+		val |= ((quint8)*ctx.bp & 0x7F) << shift;
+		shift += 7;
+		if (!((quint8)*ctx.bp++ & 0x80))
+			return true;
+	}
+
+	return false;
+}
+
+static bool length(CTX &ctx, qint32 &val)
+{
+	if (TYPE(ctx.tag) != LEN)
+		return false;
+
+	if (!varint(ctx, val))
+		return false;
+
+	return (val >= 0);
+}
+
+static bool str(CTX &ctx, QByteArray &val)
+{
+	qint32 len;
+
+	if (!length(ctx, len))
+		return false;
+	if (ctx.bp + len > ctx.be)
+		return false;
+
+/* In Qt5 the (later) conversion to QString is broken when the QByteArray is
+   not nul terminated so we have to use the "deep copy" constructor that
+   nul-terminates the byte array when it is created. */
+#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
+	val = QByteArray(ctx.bp, len);
+#else
+	val = QByteArray::fromRawData(ctx.bp, len);
+#endif
+	ctx.bp += len;
+
+	return true;
+}
+
+static bool dbl(CTX &ctx, double &val)
+{
+	if (TYPE(ctx.tag) != I64)
+		return false;
+	if (ctx.bp + sizeof(val) > ctx.be)
+		return false;
+
+	memcpy(&val, ctx.bp, sizeof(val));
+	ctx.bp += sizeof(val);
+
+	return true;
+}
+
+static bool flt(CTX &ctx, float &val)
+{
+	if (TYPE(ctx.tag) != I32)
+		return false;
+	if (ctx.bp + sizeof(val) > ctx.be)
+		return false;
+
+	memcpy(&val, ctx.bp, sizeof(val));
+	ctx.bp += sizeof(val);
+
+	return true;
+}
+
+static bool packed(CTX &ctx, QVector<quint32> &vals)
+{
+	quint32 v;
+
+	if (TYPE(ctx.tag) == LEN) {
+		qint32 len;
+		if (!varint(ctx, len) || len < 0)
+			return false;
+		const char *ee = ctx.bp + len;
+		if (ee > ctx.be)
+			return false;
+		while (ctx.bp < ee) {
+			if (!varint(ctx, v))
+				return false;
+			vals.append(v);
+		}
+		return (ctx.bp == ee);
+	} else if (TYPE(ctx.tag) == VARINT) {
+		if (!varint(ctx, v))
+			return false;
+		vals.append(v);
+		return true;
+	} else
+		return false;
+}
+
+static bool skip(CTX &ctx)
+{
+	qint32 len = 0;
+
+	switch (TYPE(ctx.tag)) {
+		case VARINT:
+			return varint(ctx, len);
+		case I64:
+			len = 8;
+			break;
+		case LEN:
+			if (!varint(ctx, len) || len < 0)
+				return false;
+			break;
+		case I32:
+			len = 4;
+			break;
+		default:
+			return false;
+	}
+
+	if (ctx.bp + len > ctx.be)
+		return false;
+	ctx.bp += len;
+
+	return true;
+}
+
+static bool value(CTX &ctx, QVariant &val)
+{
+	QByteArray ba;
+	quint64 num;
+	double dnum;
+	float fnum;
+	qint32 len;
+
+	if (!length(ctx, len))
+		return false;
+
+	const char *ee = ctx.bp + len;
+	if (ee > ctx.be)
+		return false;
+
+	while (ctx.bp < ee) {
+		if (!varint(ctx, ctx.tag))
+			return false;
+
+		switch (FIELD(ctx.tag)) {
+			case 1:
+				if (!str(ctx, ba))
+					return false;
+				val = QVariant(ba);
+				break;
+			case 2:
+				if (!flt(ctx, fnum))
+					return false;
+				val = QVariant(fnum);
+				break;
+			case 3:
+				if (!dbl(ctx, dnum))
+					return false;
+				val = QVariant(dnum);
+				break;
+			case 4:
+				if (TYPE(ctx.tag) != VARINT)
+					return false;
+				if (!varint(ctx, num))
+					return false;
+				val = QVariant(static_cast<qint64>(num));
+				break;
+			case 5:
+				if (TYPE(ctx.tag) != VARINT)
+					return false;
+				if (!varint(ctx, num))
+					return false;
+				val = QVariant(num);
+				break;
+			case 6:
+				if (TYPE(ctx.tag) != VARINT)
+					return false;
+				if (!varint(ctx, num))
+					return false;
+				val = QVariant(zigzag64decode(num));
+				break;
+			case 7:
+				if (TYPE(ctx.tag) != VARINT)
+					return false;
+				if (!varint(ctx, num))
+					return false;
+				val = QVariant(num ? true : false);
+				break;
+			default:
+				if (!skip(ctx))
+					return false;
+		}
+	}
+
+	return (ctx.bp == ee);
+}
+
+static bool feature(CTX &ctx, Data::Feature &f)
+{
+	qint32 len;
+	quint32 e;
+
+	if (!length(ctx, len))
+		return false;
+
+	const char *ee = ctx.bp + len;
+	if (ee > ctx.be)
+		return false;
+
+	while (ctx.bp < ee) {
+		if (!varint(ctx, ctx.tag))
+			return false;
+
+		switch (FIELD(ctx.tag)) {
+			case 1:
+				if (TYPE(ctx.tag) != VARINT)
+					return false;
+				if (!varint(ctx, f.id))
+					return false;
+				break;
+			case 2:
+				if (!packed(ctx, f.tags))
+					return false;
+				break;
+			case 3:
+				if (TYPE(ctx.tag) != VARINT)
+					return false;
+				if (!varint(ctx, e))
+					return false;
+				if (e > Data::GeomType::POLYGON)
+					return false;
+				f.type = static_cast<Data::GeomType>(e);
+				break;
+			case 4:
+				if (!packed(ctx, f.geometry))
+					return false;
+				break;
+			default:
+				if (!skip(ctx))
+					return false;
+		}
+	}
+
+	return (ctx.bp == ee);
+}
+
+static bool layer(CTX &ctx, Data::Layer &l)
+{
+	qint32 len;
+
+	if (!length(ctx, len))
+		return false;
+
+	const char *ee = ctx.bp + len;
+	if (ee > ctx.be)
+		return false;
+
+	while (ctx.bp < ee) {
+		if (!varint(ctx, ctx.tag))
+			return false;
+
+		switch (FIELD(ctx.tag)) {
+			case 1:
+				if (!str(ctx, l.name))
+					return false;
+				break;
+			case 2:
+				l.features.append(Data::Feature());
+				if (!feature(ctx, l.features.last()))
+					return false;
+				break;
+			case 3:
+				l.keys.append(QByteArray());
+				if (!str(ctx, l.keys.last()))
+					return false;
+				break;
+			case 4:
+				l.values.append(QVariant());
+				if (!value(ctx, l.values.last()))
+					return false;
+				break;
+			case 5:
+				if (TYPE(ctx.tag) != VARINT)
+					return false;
+				if (!varint(ctx, l.extent))
+					return false;
+				break;
+			case 15:
+				if (TYPE(ctx.tag) != VARINT)
+					return false;
+				if (!varint(ctx, l.version))
+					return false;
+				break;
+			default:
+				if (!skip(ctx))
+					return false;
+		}
+	}
+
+	return (ctx.bp == ee);
+}
+
+bool Data::load(const QByteArray &ba)
+{
+	CTX ctx(ba);
+
+	while (ctx.bp < ctx.be) {
+		if (!varint(ctx, ctx.tag))
+			return false;
+
+		switch (FIELD(ctx.tag)) {
+			case 3:
+				_layers.append(Layer());
+				if (!layer(ctx, _layers.last()))
+					return false;
+				break;
+			default:
+				if (!skip(ctx))
+					return false;
+		}
+	}
+
+	return (ctx.bp == ctx.be);
+}

src/data.h

@@ -0,0 +1,47 @@
+#ifndef DATA_H
+#define DATA_H
+
+#include <QByteArray>
+#include <QVector>
+#include <QVariant>
+
+class Data
+{
+public:
+	enum GeomType {
+		UNKNOWN = 0,
+		POINT = 1,
+		LINESTRING = 2,
+		POLYGON = 3
+	};
+
+	struct Feature
+	{
+		Feature() : id(0), type(UNKNOWN) {}
+
+		quint64 id;
+		QVector<quint32> tags;
+		GeomType type;
+		QVector<quint32> geometry;
+	};
+
+	struct Layer
+	{
+		Layer() : version(1), extent(4096) {}
+
+		quint32 version;
+		QByteArray name;
+		QVector<Feature> features;
+		QVector<QByteArray> keys;
+		QVector<QVariant> values;
+		quint32 extent;
+	};
+
+	bool load(const QByteArray &ba);
+	const QVector<Layer> &layers() const {return _layers;}
+
+private:
+	QVector<Layer> _layers;
+};
+
+#endif // DATA_H

src/function.cpp

@@ -34,10 +34,14 @@ static QColor interpolate(const QPair<qreal, QColor> &p0,
 	  ? progress / difference
 	  : (pow(base, progress) - 1) / (pow(base, difference) - 1);
 
-
+#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
 	qreal p0h, p0s, p0l, p0a;
-	p0.second.getHslF(&p0h, &p0s, &p0l, &p0a);
 	qreal p1h, p1s, p1l, p1a;
+#else // QT6
+	float p0h, p0s, p0l, p0a;
+	float p1h, p1s, p1l, p1a;
+#endif // QT6
+	p0.second.getHslF(&p0h, &p0s, &p0l, &p0a);
 	p1.second.getHslF(&p1h, &p1s, &p1l, &p1a);
 
 	/* Qt returns a hue of -1 for achromatic colors. We convert it to a hue of 1

src/function.h

@@ -6,6 +6,7 @@
 #include <QColor>
 #include <QPair>
 #include <QString>
+#include <QJsonValue>
 
 class QJsonObject;
 

src/gzip.cpp

@@ -6,7 +6,7 @@
 
 QByteArray Gzip::uncompress(QIODevice *device, int limit)
 {
-	int ret;
+	int ret = Z_STREAM_END;
 	z_stream strm;
 	unsigned char in[CHUNK];
 	unsigned char out[CHUNK];

src/pbf.cpp

@@ -4,7 +4,6 @@
 #define LINE_TO    2
 #define CLOSE_PATH 7
 
-
 static inline qint32 zigzag32decode(quint32 value)
 {
 	return static_cast<qint32>((value >> 1u) ^ static_cast<quint32>(
@@ -16,37 +15,17 @@ static inline QPoint parameters(quint32 v1, quint32 v2)
 	return QPoint(zigzag32decode(v1), zigzag32decode(v2));
 }
 
-static QVariant value(const vector_tile::Tile_Value &val)
-{
-	if (val.has_bool_value())
-		return QVariant(val.bool_value());
-	else if (val.has_int_value())
-		return QVariant((qlonglong)val.int_value());
-	else if (val.has_sint_value())
-		return QVariant((qlonglong)val.sint_value());
-	else if (val.has_uint_value())
-		return QVariant((qulonglong)val.uint_value());
-	else if (val.has_float_value())
-		return QVariant(val.float_value());
-	else if (val.has_double_value())
-		return QVariant(val.double_value());
-	else if (val.has_string_value())
-		return QVariant(QString::fromStdString(val.string_value()));
-	else
-		return QVariant();
-}
-
-const QVariant *PBF::Feature::value(const QString &key) const
+const QVariant *PBF::Feature::value(const QByteArray &key) const
 {
 	const KeyHash &keys(_layer->keys());
 	KeyHash::const_iterator it(keys.find(key));
 	if (it == keys.constEnd())
 		return 0;
 
-	google::protobuf::uint32 index = *it;
-	for (int i = 0; i < _data->tags_size(); i = i + 2)
-		if (_data->tags(i) == index)
-			return &(_layer->values().at(_data->tags(i+1)));
+	quint32 index = *it;
+	for (int i = 0; i < _data->tags.size(); i = i + 2)
+		if (_data->tags.at(i) == index)
+			return &(_layer->values().at(_data->tags.at(i+1)));
 
 	return 0;
 }
@@ -56,15 +35,15 @@ QPainterPath PBF::Feature::path(const QSizeF &factor) const
 	QPoint cursor;
 	QPainterPath path;
 
-	for (int i = 0; i < _data->geometry_size(); i++) {
-		quint32 g = _data->geometry(i);
+	for (int i = 0; i < _data->geometry.size(); i++) {
+		quint32 g = _data->geometry.at(i);
 		unsigned cmdId = g & 0x7;
 		unsigned cmdCount = g >> 3;
 
 		if (cmdId == MOVE_TO) {
 			for (unsigned j = 0; j < cmdCount; j++) {
-				QPoint offset = parameters(_data->geometry(i+1),
-				  _data->geometry(i+2));
+				QPoint offset = parameters(_data->geometry.at(i+1),
+				  _data->geometry.at(i+2));
 				i += 2;
 				cursor += offset;
 				path.moveTo(QPointF(cursor.x() * factor.width(),
@@ -72,8 +51,8 @@ QPainterPath PBF::Feature::path(const QSizeF &factor) const
 			}
 		} else if (cmdId == LINE_TO) {
 			for (unsigned j = 0; j < cmdCount; j++) {
-				QPoint offset = parameters(_data->geometry(i+1),
-				  _data->geometry(i+2));
+				QPoint offset = parameters(_data->geometry.at(i+1),
+				  _data->geometry.at(i+2));
 				i += 2;
 				cursor += offset;
 				path.lineTo(QPointF(cursor.x() * factor.width(),
@@ -88,32 +67,27 @@ QPainterPath PBF::Feature::path(const QSizeF &factor) const
 	return path;
 }
 
-PBF::Layer::Layer(const vector_tile::Tile_Layer *data) : _data(data)
+PBF::Layer::Layer(const Data::Layer *layer) : _data(layer)
 {
-	_keys.reserve(data->keys_size());
-	for (int i = 0; i < data->keys_size(); i++)
-		_keys.insert(QString::fromStdString(data->keys(i)), i);
-	_values.reserve(data->values_size());
-	for (int i = 0; i < data->values_size(); i++)
-		_values.append(value(data->values(i)));
+	_keys.reserve(layer->keys.size());
+	for (int i = 0; i < layer->keys.size(); i++)
+		_keys.insert(layer->keys.at(i), i);
 
-	_features.reserve(data->features_size());
-	for (int i = 0; i < data->features_size(); i++)
-		_features.append(Feature(&(data->features(i)), this));
-	qSort(_features.begin(), _features.end());
+	_features.reserve(layer->features.size());
+	for (int i = 0; i < layer->features.size(); i++)
+		_features.append(Feature(&(layer->features.at(i)), this));
+	std::sort(_features.begin(), _features.end());
 }
 
-PBF::PBF(const vector_tile::Tile &tile)
+PBF::PBF(const Data &data)
 {
-	for (int i = 0; i <  tile.layers_size(); i++) {
-		const vector_tile::Tile_Layer &layer = tile.layers(i);
-		_layers.insert(QString::fromStdString(layer.name()), new Layer(&layer));
+	for (int i = 0; i <  data.layers().size(); i++) {
+		const Data::Layer &layer = data.layers().at(i);
+		_layers.insert(layer.name, new Layer(&layer));
 	}
 }
 
 PBF::~PBF()
 {
-	for (QHash<QString, Layer*>::iterator it = _layers.begin();
-	  it != _layers.end(); it++)
-		delete *it;
+	qDeleteAll(_layers);
 }

src/pbf.h

@@ -5,10 +5,10 @@
 #include <QVector>
 #include <QHash>
 #include <QPainterPath>
-#include "vector_tile.pb.h"
+#include "data.h"
 
 
-typedef QHash<QString, google::protobuf::uint32> KeyHash;
+typedef QHash<QByteArray, quint32> KeyHash;
 
 class PBF
 {
@@ -19,17 +19,17 @@ public:
 	{
 	public:
 		Feature() : _data(0), _layer(0) {}
-		Feature(const vector_tile::Tile_Feature *data, const Layer *layer)
+		Feature(const Data::Feature *data, const Layer *layer)
 		  : _data(data), _layer(layer) {}
 
-		const QVariant *value(const QString &key) const;
-		vector_tile::Tile_GeomType type() const {return _data->type();}
+		const QVariant *value(const QByteArray &key) const;
+		Data::GeomType type() const {return _data->type;}
 		QPainterPath path(const QSizeF &factor) const;
 
 		friend bool operator<(const Feature &f1, const Feature &f2);
 
 	private:
-		const vector_tile::Tile_Feature *_data;
+		const Data::Feature *_data;
 		const Layer *_layer;
 	};
 
@@ -37,31 +37,30 @@ public:
 	{
 	public:
 
-		Layer(const vector_tile::Tile_Layer *data);
+		Layer(const Data::Layer *layer);
 
 		const QVector<Feature> &features() const {return _features;}
-		const QVector<QVariant> &values() const {return _values;}
+		const QVector<QVariant> &values() const {return _data->values;}
 		const KeyHash &keys() const {return _keys;}
-		const vector_tile::Tile_Layer *data() const {return _data;}
+		const Data::Layer *data() const {return _data;}
 
 	private:
-		const vector_tile::Tile_Layer *_data;
+		const Data::Layer *_data;
 		QVector<Feature> _features;
-		QVector<QVariant> _values;
 		KeyHash _keys;
 	};
 
 
-	PBF(const vector_tile::Tile &tile);
+	PBF(const Data &data);
 	~PBF();
 
-	const QHash<QString, Layer*> &layers() const {return _layers;}
+	const QHash<QByteArray, Layer*> &layers() const {return _layers;}
 
 private:
-	QHash<QString, Layer*> _layers;
+	QHash<QByteArray, Layer*> _layers;
 };
 
 inline bool operator<(const PBF::Feature &f1, const PBF::Feature &f2)
-  {return f1._data->id() < f2._data->id();}
+  {return f1._data->id < f2._data->id;}
 
 #endif // PBF_H

src/pbfhandler.cpp

@@ -3,6 +3,7 @@
 #include <QtEndian>
 #include <QDebug>
 #include "gzip.h"
+#include "data.h"
 #include "tile.h"
 #include "style.h"
 #include "pbfhandler.h"
@@ -73,22 +74,25 @@ bool PBFHandler::read(QImage *image)
 		}
 	} else if (isPlainPBF(magic))
 		ba = device()->readAll();
-	vector_tile::Tile data;
-	if (!data.ParseFromArray(ba.constData(), ba.size())) {
+	Data data;
+	if (!data.load(ba)) {
 		qCritical() << "Invalid PBF data";
 		return false;
 	}
 
-	bool ok;
-	int zoom = format().toInt(&ok);
+	QList<QByteArray> list(format().split(';'));
+	int zoom = list.size() ? list.first().toInt() : 0;
+	int overzoom = (list.size() > 1) ? list.at(1).toInt() : 0;
+
+	QSize scaledSize(_scaledSize.isValid()
+	  ? _scaledSize : QSize(TILE_SIZE, TILE_SIZE));
+	QSize size(scaledSize.width()<<overzoom,
+	  scaledSize.height()<<overzoom);
+	QPointF scale((qreal)scaledSize.width() / TILE_SIZE,
+	  (qreal)scaledSize.height() / TILE_SIZE);
 
-	QSize size = _scaledSize.isValid()
-	  ? _scaledSize : QSize(TILE_SIZE, TILE_SIZE);
-	QPointF scale = _scaledSize.isValid()
-	  ? QPointF((qreal)_scaledSize.width() / TILE_SIZE,
-		(qreal)_scaledSize.height() / TILE_SIZE) : QPointF(1.0, 1.0);
 	*image = QImage(size, QImage::Format_ARGB32_Premultiplied);
-	Tile tile(image, ok ? zoom : -1, scale);
+	Tile tile(image, zoom, scale);
 
 	_style->render(data, tile);
 

src/pbfhandler.h

@@ -11,7 +11,7 @@ class Style;
 class PBFHandler : public QImageIOHandler
 {
 public:
-	PBFHandler(const Style *style) : _style(style) {}
+	PBFHandler(Style *style) : _style(style) {}
 	~PBFHandler() {}
 
 	bool canRead() const;
@@ -24,7 +24,7 @@ public:
 	static bool canRead(QIODevice *device);
 
 private:
-	const Style *_style;
+	Style *_style;
 	QSize _scaledSize;
 };
 

src/sprites.cpp

@@ -4,22 +4,28 @@
 #include <QDebug>
 #include "sprites.h"
 
-
-/*
-	Loading the sprites atlas image must be deferred until all image plugins
-	are loaded, otherwise reading the image will cause a deadlock!
-*/
-static const QImage *atlas(const QString &fileName)
+static QImage sdf2img(const QImage &sdf, const QColor &color)
 {
-	static QImage *img = new QImage(fileName);
+	QImage img(sdf.convertToFormat(QImage::Format_ARGB32));
+	quint32 argb = color.rgba();
+	uchar *bits = img.bits();
+	int bpl = img.bytesPerLine();
+
+	for (int y = 0; y < img.height(); y++) {
+		for (int x = 0; x < img.width(); x++) {
+			quint32 *pixel =  (quint32*)(bits + y * bpl + x * 4);
+			*pixel = ((*pixel >> 24) < 192) ? 0 : argb;
+		}
+	}
+
 	return img;
 }
 
 Sprites::Sprite::Sprite(const QJsonObject &json)
+  : _pixelRatio(1.0), _sdf(false)
 {
 	int x, y, width, height;
 
-
 	if (json.contains("x") && json["x"].isDouble())
 		x = json["x"].toInt();
 	else
@@ -39,17 +45,14 @@ Sprites::Sprite::Sprite(const QJsonObject &json)
 
 	_rect = QRect(x, y, width, height);
 
-
 	if (json.contains("pixelRatio") && json["pixelRatio"].isDouble())
 		_pixelRatio = json["pixelRatio"].toDouble();
-	else
-		_pixelRatio = 1.0;
+	if (json.contains("sdf") && json["sdf"].isBool())
+		_sdf = json["sdf"].toBool();
 }
 
 bool Sprites::load(const QString &jsonFile, const QString &imageFile)
 {
-	_imageFile = imageFile;
-
 	QFile file(jsonFile);
 	if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
 		qCritical() << jsonFile << ": error opening file";
@@ -78,27 +81,60 @@ bool Sprites::load(const QString &jsonFile, const QString &imageFile)
 			qWarning() << it.key() << ": invalid sprite definition";
 	}
 
+	// Loading the sprites atlas image must be deferred until all image plugins
+	// are loaded, otherwise reading the image will cause a deadlock in Qt!
+	_imageFile = imageFile;
+
 	return true;
 }
 
-QImage Sprites::icon(const QString &name) const
+QImage Sprites::sprite(const Sprite &sprite, const QColor &color, qreal scale)
 {
-	if (_imageFile.isEmpty())
+	_lock.lock();
+	if (_init <= 0) {
+		if (_init < 0) {
+			_lock.unlock();
+			return QImage();
+		}
+
+		_img = QImage(_imageFile);
+		if (_img.isNull()) {
+			qWarning() << _imageFile << ": invalid sprite atlas image";
+			_init = -1;
+			_lock.unlock();
+			return QImage();
+		}
+
+		_init = 1;
+	}
+	_lock.unlock();
+
+	if (!_img.rect().contains(sprite.rect()))
 		return QImage();
 
-	const QImage *img = atlas(_imageFile);
-	if (img->isNull())
+	QImage img(_img.copy(sprite.rect()));
+	img.setDevicePixelRatio(sprite.pixelRatio());
+
+	if (sprite.sdf()) {
+		if (scale != 1.0) {
+			QSize size(img.size().width() * scale, img.size().height() * scale);
+			QImage simg(img.scaled(size, Qt::IgnoreAspectRatio,
+			  Qt::SmoothTransformation));
+			return sdf2img(simg, color);
+		} else
+			return sdf2img(img, color);
+	} else
+		return img;
+}
+
+QImage Sprites::icon(const QString &name, const QColor &color, qreal size)
+{
+	if (name.isNull())
 		return QImage();
 
-	QMap<QString, Sprite>::const_iterator it = _sprites.find(name);
+	QMap<QString, Sprite>::const_iterator it = _sprites.constFind(name);
 	if (it == _sprites.constEnd())
 		return QImage();
 
-	if (!img->rect().contains(it->rect()))
-		return QImage();
-
-	QImage ret(img->copy(it->rect()));
-	ret.setDevicePixelRatio(it->pixelRatio());
-
-	return ret;
+	return sprite(*it, color, size);
 }

src/sprites.h

@@ -5,16 +5,19 @@
 #include <QMap>
 #include <QImage>
 #include <QString>
+#include <QMutex>
 
 class QJsonObject;
 
 class Sprites
 {
 public:
+	Sprites() : _init(0) {}
 	bool load(const QString &jsonFile, const QString &imageFile);
 
 	bool isNull() const {return _imageFile.isNull();}
-	QImage icon(const QString &name) const;
+	QImage icon(const QString &name, const QColor &color = Qt::black,
+	  qreal size = 1.0);
 
 private:
 	class Sprite {
@@ -23,14 +26,21 @@ private:
 
 		const QRect &rect() const {return _rect;}
 		qreal pixelRatio() const {return _pixelRatio;}
+		bool sdf() const {return _sdf;}
 
 	private:
 		QRect _rect;
 		qreal _pixelRatio;
+		bool _sdf;
 	};
 
+	QImage sprite(const Sprite &sprite, const QColor &color, qreal scale);
+
 	QMap<QString, Sprite> _sprites;
+	QImage _img;
+	QMutex _lock;
 	QString _imageFile;
+	int _init;
 };
 
 #endif // SPRITES_H

src/style.cpp

@@ -5,25 +5,39 @@
 #include <QJsonArray>
 #include <QFileInfo>
 #include <QDir>
+#include <QRegularExpression>
 #include <QDebug>
 #include "text.h"
-#include "color.h"
 #include "font.h"
 #include "tile.h"
 #include "pbf.h"
 #include "style.h"
 
 
-static vector_tile::Tile_GeomType geometryType(const QString &str)
+static Data::GeomType geometryType(const QString &str)
 {
 	if (str == "Point")
-		return vector_tile::Tile_GeomType_POINT;
+		return Data::GeomType::POINT;
 	else if (str == "LineString")
-		return vector_tile::Tile_GeomType_LINESTRING;
+		return Data::GeomType::LINESTRING;
 	else if (str == "Polygon")
-		return vector_tile::Tile_GeomType_POLYGON;
+		return Data::GeomType::POLYGON;
 	else
-		return vector_tile::Tile_GeomType_UNKNOWN;
+		return Data::GeomType::UNKNOWN;
+}
+
+static QVariant variant(const QJsonValue &val)
+{
+	switch (val.type()) {
+		case QJsonValue::String:
+			return QVariant(val.toString().toUtf8());
+		case QJsonValue::Double:
+		case QJsonValue::Bool:
+			return val.toVariant();
+		default:
+			qWarning() << val << ": invalid filter value";
+			return QVariant();
+	}
 }
 
 Style::Layer::Filter::Filter(const QJsonArray &json)
@@ -35,50 +49,50 @@ Style::Layer::Filter::Filter(const QJsonArray &json)
 	if (json.isEmpty())
 		INVALID_FILTER(json);
 
-	QString type = json.at(0).toString();
+	QString type(json.at(0).toString());
 
 	if (type == "==") {
 		if (json.size() != 3)
 			INVALID_FILTER(json);
 		if (json.at(1).toString() == "$type") {
 			_type = GeometryType;
-			_kv = QPair<QString, QVariant>(QString(),
+			_kv = QPair<QByteArray, QVariant>(QByteArray(),
 			  QVariant(geometryType(json.at(2).toString())));
 		} else {
 			_type = EQ;
-			_kv = QPair<QString, QVariant>(json.at(1).toString(),
-			  json.at(2).toVariant());
+			_kv = QPair<QByteArray, QVariant>(json.at(1).toString().toUtf8(),
+			  variant(json.at(2)));
 		}
 	} else if (type == "!=") {
 		if (json.size() != 3)
 			INVALID_FILTER(json);
 		_type = NE;
-		_kv = QPair<QString, QVariant>(json.at(1).toString(),
-		  json.at(2).toVariant());
+		_kv = QPair<QByteArray, QVariant>(json.at(1).toString().toUtf8(),
+		  variant(json.at(2)));
 	} else if (type == "<") {
 		if (json.size() != 3)
 			INVALID_FILTER(json);
 		_type = LT;
-		_kv = QPair<QString, QVariant>(json.at(1).toString(),
-		  json.at(2).toVariant());
+		_kv = QPair<QByteArray, QVariant>(json.at(1).toString().toUtf8(),
+		  variant(json.at(2)));
 	} else if (type == "<=") {
 		if (json.size() != 3)
 			INVALID_FILTER(json);
 		_type = LE;
-		_kv = QPair<QString, QVariant>(json.at(1).toString(),
-		  json.at(2).toVariant());
+		_kv = QPair<QByteArray, QVariant>(json.at(1).toString().toUtf8(),
+		  variant(json.at(2)));
 	} else if (type == ">") {
 		if (json.size() != 3)
 			INVALID_FILTER(json);
 		_type = GT;
-		_kv = QPair<QString, QVariant>(json.at(1).toString(),
-		  json.at(2).toVariant());
+		_kv = QPair<QByteArray, QVariant>(json.at(1).toString().toUtf8(),
+		  variant(json.at(2)));
 	} else if (type == ">=") {
 		if (json.size() != 3)
 			INVALID_FILTER(json);
 		_type = GE;
-		_kv = QPair<QString, QVariant>(json.at(1).toString(),
-		  json.at(2).toVariant());
+		_kv = QPair<QByteArray, QVariant>(json.at(1).toString().toUtf8(),
+		  variant(json.at(2)));
 	} else if (type == "all") {
 		_type = All;
 		for (int i = 1; i < json.size(); i++)
@@ -91,28 +105,32 @@ Style::Layer::Filter::Filter(const QJsonArray &json)
 		if (json.size() < 3)
 			INVALID_FILTER(json);
 		_type = In;
-		_kv = QPair<QString, QVariant>(json.at(1).toString(), QVariant());
+		_kv = QPair<QByteArray, QVariant>(json.at(1).toString().toUtf8(),
+		  QVariant());
 		for (int i = 2; i < json.size(); i++)
-			_set.insert(json.at(i).toString());
+			_set.insert(json.at(i).toString().toUtf8());
 	}  else if (type == "!in") {
 		if (json.size() < 3)
 			INVALID_FILTER(json);
 		_type = In;
 		_not = true;
-		_kv = QPair<QString, QVariant>(json.at(1).toString(), QVariant());
+		_kv = QPair<QByteArray, QVariant>(json.at(1).toString().toUtf8(),
+		  QVariant());
 		for (int i = 2; i < json.size(); i++)
-			_set.insert(json.at(i).toString());
+			_set.insert(json.at(i).toString().toUtf8());
 	} else if (type == "has") {
 		if (json.size() < 2)
 			INVALID_FILTER(json);
 		_type = Has;
-		_kv = QPair<QString, QVariant>(json.at(1).toString(), QVariant());
+		_kv = QPair<QByteArray, QVariant>(json.at(1).toString().toUtf8(),
+		  QVariant());
 	} else if (type == "!has") {
 		if (json.size() < 2)
 			INVALID_FILTER(json);
 		_type = Has;
 		_not = true;
-		_kv = QPair<QString, QVariant>(json.at(1).toString(), QVariant());
+		_kv = QPair<QByteArray, QVariant>(json.at(1).toString().toUtf8(),
+		  QVariant());
 	} else
 		INVALID_FILTER(json);
 }
@@ -138,27 +156,51 @@ bool Style::Layer::Filter::match(const PBF::Feature &feature) const
 			if (!(v = feature.value(_kv.first)))
 				return false;
 			else
+#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
 				return *v > _kv.second;
+#else // QT6
+				return (QVariant::compare(*v, _kv.second)
+				  == QPartialOrdering::Greater);
+#endif // QT6
 		case GE:
-			if (!(v = feature.value(_kv.first)))
+			{if (!(v = feature.value(_kv.first)))
 				return false;
-			else
+			else {
+#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
 				return *v >= _kv.second;
+#else // QT6
+				QPartialOrdering res = QVariant::compare(*v, _kv.second);
+				return (res == QPartialOrdering::Greater
+				  || res == QPartialOrdering::Equivalent);
+#endif // QT6
+			}}
 		case LT:
 			if (!(v = feature.value(_kv.first)))
 				return false;
 			else
+#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
 				return *v < _kv.second;
+#else // QT6
+				return (QVariant::compare(*v, _kv.second)
+				  == QPartialOrdering::Less);
+#endif // QT6
 		case LE:
-			if (!(v = feature.value(_kv.first)))
+			{if (!(v = feature.value(_kv.first)))
 				return false;
-			else
+			else {
+#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
 				return *v <= _kv.second;
+#else // QT6
+				QPartialOrdering res = QVariant::compare(*v, _kv.second);
+				return (res == QPartialOrdering::Less
+				  || res == QPartialOrdering::Equivalent);
+#endif // QT6
+			}}
 		case In:
 			if (!(v = feature.value(_kv.first)))
 				return _not;
 			else
-				return _set.contains((*v).toString()) ^ _not;
+				return _set.contains((*v).toByteArray()) ^ _not;
 		case Has:
 			return (feature.value(_kv.first) ? true : false) ^ _not;
 		case All:
@@ -180,19 +222,19 @@ bool Style::Layer::Filter::match(const PBF::Feature &feature) const
 
 QString Style::Layer::Template::value(int zoom, const PBF::Feature &feature) const
 {
-	QRegExp rx = QRegExp("\\{[^\\}]*\\}");
+	static QRegularExpression rx("\\{[^\\}]*\\}");
 	QString text(_field.value(zoom));
+	QRegularExpressionMatchIterator it = rx.globalMatch(text);
 	QStringList keys;
-	int pos = 0;
 
-	while ((pos = rx.indexIn(text, pos)) != -1) {
-		QString match = rx.capturedTexts().first();
-		keys.append(match.mid(1, match.size() - 2));
-		pos += rx.matchedLength();
+	while (it.hasNext()) {
+		QRegularExpressionMatch match = it.next();
+		QString val = match.captured(0);
+		keys.append(val.mid(1, val.size() - 2));
 	}
 	for (int i = 0; i < keys.size(); i++) {
 		const QString &key = keys.at(i);
-		const QVariant *val = feature.value(key);
+		const QVariant *val = feature.value(key.toUtf8());
 		text.replace(QString("{%1}").arg(key), val ? val->toString() : "");
 	}
 
@@ -233,6 +275,9 @@ Style::Layer::Paint::Paint(const QJsonObject &json)
 	_textHaloColor = FunctionC(json["text-halo-color"], QColor());
 	_textHaloWidth = FunctionF(json["text-halo-width"]);
 	_textHaloBlur = FunctionF(json["text-halo-blur"]);
+
+	// icon
+	_iconColor = FunctionC(json["icon-color"]);
 }
 
 QPen Style::Layer::Paint::pen(Type type, int zoom) const
@@ -268,7 +313,7 @@ QPen Style::Layer::Paint::pen(Type type, int zoom) const
 	return pen;
 }
 
-QBrush Style::Layer::Paint::brush(Type type, int zoom, const Sprites &sprites)
+QBrush Style::Layer::Paint::brush(Type type, int zoom, Sprites &sprites)
   const
 {
 	QColor color;
@@ -345,9 +390,16 @@ Style::Layer::Layout::Layout(const QJsonObject &json)
 
 	// icon
 	_icon = Template(FunctionS(json["icon-image"]));
+	_iconSize = FunctionF(json["icon-size"]);
 
 	// symbol
 	_symbolPlacement = FunctionS(json["symbol-placement"]);
+
+	// visibility
+	if (json.contains("visibility") && json["visibility"].isString())
+		_visible = !(json["visibility"].toString() == "none");
+	else
+		_visible = true;
 }
 
 QFont Style::Layer::Layout::font(int zoom) const
@@ -452,7 +504,7 @@ Style::Layer::Layer(const QJsonObject &json)
 		_type = Symbol;
 
 	// source-layer
-	_sourceLayer = json["source-layer"].toString();
+	_sourceLayer = json["source-layer"].toString().toUtf8();
 
 	// zooms
 	if (json.contains("minzoom") && json["minzoom"].isDouble())
@@ -481,7 +533,7 @@ bool Style::Layer::match(int zoom, const PBF::Feature &feature) const
 	return _filter.match(feature);
 }
 
-void Style::Layer::setPathPainter(Tile &tile, const Sprites &sprites) const
+void Style::Layer::setPathPainter(Tile &tile, Sprites &sprites) const
 {
 	QPainter &p = tile.painter();
 	int zoom = tile.zoom();
@@ -514,14 +566,18 @@ void Style::Layer::setTextProperties(Tile &tile) const
 }
 
 void Style::Layer::addSymbol(Tile &tile, const QPainterPath &path,
-  const PBF::Feature &feature, const Sprites &sprites) const
+  const PBF::Feature &feature, Sprites &sprites) const
 {
-	QString text = _layout.text(tile.zoom(), feature);
-	if (text.isEmpty())
+	QString text(_layout.text(tile.zoom(), feature));
+	QString icon(_layout.icon(tile.zoom(), feature));
+	QColor color(_paint.iconColor(tile.zoom()));
+	qreal size(_layout.iconSize(tile.zoom()));
+	QImage img(sprites.icon(icon, color, size));
+
+	if (text.isEmpty() && img.isNull())
 		return;
 
-	QString icon = _layout.icon(tile.zoom(), feature);
-	tile.text().addLabel(text, sprites.icon(icon), path);
+	tile.text().addLabel(text, img, path);
 }
 
 static bool loadSprites(const QDir &styleDir, const QString &json,
@@ -534,7 +590,7 @@ static bool loadSprites(const QDir &styleDir, const QString &json,
 		if (QFileInfo::exists(spritesImg))
 			return sprites.load(spritesJSON, spritesImg);
 		else {
-			qCritical() << spritesImg << ": no such file";
+			qWarning() << spritesImg << ": no such file";
 			return false;
 		}
 	}
@@ -567,27 +623,20 @@ bool Style::load(const QString &fileName)
 				_layers.append(Layer(layers[i].toObject()));
 	}
 
-	QDir styleDir = QFileInfo(fileName).absoluteDir();
+	QDir styleDir(QFileInfo(fileName).absoluteDir());
 	loadSprites(styleDir, "sprite.json", "sprite.png", _sprites);
-#ifdef ENABLE_HIDPI
 	loadSprites(styleDir, "sprite@2x.json", "sprite@2x.png", _sprites2x);
-#endif // ENABLE_HIDPI
 
 	return true;
 }
 
-const Sprites &Style::sprites(const QPointF &scale) const
+Sprites &Style::sprites(const QPointF &scale)
 {
-#ifdef ENABLE_HIDPI
 	return (scale.x() > 1.0 || scale.y() > 1.0)
 	  && !_sprites2x.isNull() ? _sprites2x : _sprites;
-#else // ENABLE_HIDPI
-	Q_UNUSED(scale);
-	return _sprites;
-#endif // ENABLE_HIDPI
 }
 
-void Style::setupLayer(Tile &tile, const Layer &layer) const
+void Style::setupLayer(Tile &tile, const Layer &layer)
 {
 	if (layer.isSymbol())
 		layer.setTextProperties(tile);
@@ -595,7 +644,7 @@ void Style::setupLayer(Tile &tile, const Layer &layer) const
 		layer.setPathPainter(tile, sprites(tile.scale()));
 }
 
-void Style::drawBackground(Tile &tile) const
+void Style::drawBackground(Tile &tile)
 {
 	QRectF rect(QPointF(0, 0), QSizeF(tile.size().width() / tile.scale().x(),
 	  tile.size().height() / tile.scale().y()));
@@ -610,13 +659,10 @@ void Style::drawBackground(Tile &tile) const
 		_layers.first().setPathPainter(tile, _sprites);
 		tile.painter().drawPath(path);
 	}
-
-	//tile.painter().setPen(Qt::red);
-	//tile.painter().drawRect(rect);
 }
 
 void Style::drawFeature(const PBF::Feature &feature, const Layer &layer,
-  Tile &tile, const QSizeF &factor) const
+  Tile &tile, const QSizeF &factor)
 {
 	if (!layer.match(tile.zoom(), feature))
 		return;
@@ -632,14 +678,17 @@ void Style::drawFeature(const PBF::Feature &feature, const Layer &layer,
 }
 
 void Style::drawLayer(const PBF::Layer &pbfLayer, const Layer &styleLayer,
-  Tile &tile) const
+  Tile &tile)
 {
-	if (pbfLayer.data()->version() > 2)
+	if (pbfLayer.data()->version > 2)
+		return;
+
+	if (!styleLayer.isVisible())
 		return;
 
 	QSizeF factor(tile.size().width() / tile.scale().x() /
-	  (qreal)pbfLayer.data()->extent(), tile.size().height() / tile.scale().y()
-	  / (qreal)pbfLayer.data()->extent());
+	  (qreal)pbfLayer.data()->extent, tile.size().height() / tile.scale().y()
+	  / (qreal)pbfLayer.data()->extent);
 
 	tile.painter().save();
 	setupLayer(tile, styleLayer);
@@ -648,12 +697,12 @@ void Style::drawLayer(const PBF::Layer &pbfLayer, const Layer &styleLayer,
 	tile.painter().restore();
 }
 
-void Style::render(const PBF &data, Tile &tile) const
+void Style::render(const PBF &data, Tile &tile)
 {
 	drawBackground(tile);
 
 	for (int i = 0; i < _layers.size(); i++) {
-		QHash<QString, PBF::Layer*>::const_iterator it = data.layers().find(
+		QHash<QByteArray, PBF::Layer*>::const_iterator it = data.layers().find(
 		  _layers.at(i).sourceLayer());
 		if (it == data.layers().constEnd())
 			continue;
@@ -662,4 +711,11 @@ void Style::render(const PBF &data, Tile &tile) const
 	}
 
 	tile.text().render(&tile.painter());
+
+	//QRectF rect(QPointF(0, 0), QSizeF(tile.size().width() / tile.scale().x(),
+	//  tile.size().height() / tile.scale().y()));
+	//tile.painter().setPen(Qt::red);
+	//tile.painter().setBrush(Qt::NoBrush);
+	//tile.painter().setRenderHint(QPainter::Antialiasing, false);
+	//tile.painter().drawRect(rect);
 }

src/style.h

@@ -12,7 +12,6 @@
 #include <QBrush>
 #include <QFont>
 #include "pbf.h"
-#include "config.h"
 #include "text.h"
 #include "function.h"
 #include "sprites.h"
@@ -30,7 +29,7 @@ public:
 	Style(QObject *parent = 0) : QObject(parent) {}
 
 	bool load(const QString &fileName);
-	void render(const PBF &data, Tile &tile) const;
+	void render(const PBF &data, Tile &tile);
 
 private:
 	class Layer {
@@ -38,16 +37,17 @@ private:
 		Layer() : _type(Unknown), _minZoom(0), _maxZoom(24) {}
 		Layer(const QJsonObject &json);
 
-		const QString &sourceLayer() const {return _sourceLayer;}
+		const QByteArray &sourceLayer() const {return _sourceLayer;}
 		bool isPath() const {return (_type == Line || _type == Fill);}
 		bool isBackground() const {return (_type == Background);}
 		bool isSymbol() const {return (_type == Symbol);}
+		bool isVisible() const {return (_layout.visible());}
 
 		bool match(int zoom, const PBF::Feature &feature) const;
-		void setPathPainter(Tile &tile, const Sprites &sprites) const;
+		void setPathPainter(Tile &tile, Sprites &sprites) const;
 		void setTextProperties(Tile &tile) const;
 		void addSymbol(Tile &tile, const QPainterPath &path,
-		  const PBF::Feature &feature, const Sprites &sprites) const;
+		  const PBF::Feature &feature, Sprites &sprites) const;
 
 	private:
 		enum Type {
@@ -74,8 +74,8 @@ private:
 
 			Type _type;
 			bool _not;
-			QSet<QString> _set;
-			QPair<QString, QVariant> _kv;
+			QSet<QByteArray> _set;
+			QPair<QByteArray, QVariant> _kv;
 			QVector<Filter> _filters;
 		};
 
@@ -92,7 +92,7 @@ private:
 		class Layout {
 		public:
 			Layout() : _textSize(16), _textMaxWidth(10), _textMaxAngle(45),
-			  _font("Open Sans") {}
+			  _font("Open Sans"), _visible(true) {}
 			Layout(const QJsonObject &json);
 
 			qreal maxTextWidth(int zoom) const
@@ -103,18 +103,22 @@ private:
 			  {return _text.value(zoom, feature).trimmed();}
 			QString icon(int zoom, const PBF::Feature &feature) const
 			  {return _icon.value(zoom, feature);}
+			qreal iconSize(int zoom) const
+			  {return _iconSize.value(zoom);}
 			QFont font(int zoom) const;
 			Qt::PenCapStyle lineCap(int zoom) const;
 			Qt::PenJoinStyle lineJoin(int zoom) const;
 			Text::Anchor textAnchor(int zoom) const;
 			Text::SymbolPlacement symbolPlacement(int zoom) const;
 			Text::RotationAlignment textRotationAlignment(int zoom) const;
+			bool visible() const {return _visible;}
 
 		private:
 			QFont::Capitalization textTransform(int zoom) const;
 
 			Template _text;
 			Template _icon;
+			FunctionF _iconSize;
 			FunctionF _textSize;
 			FunctionF _textMaxWidth;
 			FunctionF _textMaxAngle;
@@ -125,6 +129,7 @@ private:
 			FunctionS _symbolPlacement;
 			FunctionS _textRotationAlignment;
 			QFont _font;
+			bool _visible;
 		};
 
 		class Paint {
@@ -133,13 +138,15 @@ private:
 			Paint(const QJsonObject &json);
 
 			QPen pen(Layer::Type type, int zoom) const;
-			QBrush brush(Layer::Type type, int zoom, const Sprites &sprites)
+			QBrush brush(Layer::Type type, int zoom, Sprites &sprites)
 			  const;
 			qreal opacity(Layer::Type type, int zoom) const;
 			bool antialias(Layer::Type type, int zoom) const;
 			Text::Halo halo(int zoom) const
 			  {return Text::Halo(_textHaloColor.value(zoom),
 			  _textHaloWidth.value(zoom), _textHaloBlur.value(zoom));}
+			QColor iconColor(int zoom) const
+			  {return _iconColor.value(zoom);}
 
 		private:
 			FunctionC _textColor;
@@ -148,6 +155,7 @@ private:
 			FunctionC _fillColor;
 			FunctionC _fillOutlineColor;
 			FunctionC _backgroundColor;
+			FunctionC _iconColor;
 			FunctionF _fillOpacity;
 			FunctionF _lineOpacity;
 			FunctionF _lineWidth;
@@ -159,27 +167,24 @@ private:
 		};
 
 		Type _type;
-		QString _sourceLayer;
+		QByteArray _sourceLayer;
 		int _minZoom, _maxZoom;
 		Filter _filter;
 		Layout _layout;
 		Paint _paint;
 	};
 
-	const Sprites &sprites(const QPointF &scale) const;
+	Sprites &sprites(const QPointF &scale);
 
-	void drawBackground(Tile &tile) const;
-	void setupLayer(Tile &tile, const Layer &layer) const;
+	void drawBackground(Tile &tile);
+	void setupLayer(Tile &tile, const Layer &layer);
 	void drawFeature(const PBF::Feature &feature, const Layer &layer,
-	  Tile &tile, const QSizeF &factor) const;
+	  Tile &tile, const QSizeF &factor);
 	void drawLayer(const PBF::Layer &pbfLayer, const Layer &styleLayer,
-	  Tile &tile) const;
+	  Tile &tile);
 
 	QVector<Layer> _layers;
-	Sprites _sprites;
-#ifdef ENABLE_HIDPI
-	Sprites _sprites2x;
-#endif // QT >= 5.6
+	Sprites _sprites, _sprites2x;
 };
 
 #endif // STYLE_H

src/text.cpp

@@ -9,21 +9,15 @@
 
 Text::~Text()
 {
-	for (int i = 0; i < _items.size(); i++)
-		delete _items[i];
+	qDeleteAll(_items);
 }
 
 void Text::render(QPainter *painter) const
 {
-	QSet<QString> set;
-
 	for (int i = 0; i < _items.size(); i++) {
 		const TextItem *ti = _items.at(i);
-		if (ti->isVisible() && _sceneRect.intersects(ti->boundingRect())
-		  && !set.contains(ti->text())) {
+		if (ti->isVisible() && _sceneRect.intersects(ti->boundingRect()))
 			ti->paint(painter);
-			set.insert(ti->text());
-		}
 	}
 }
 
@@ -52,6 +46,8 @@ void Text::addLabel(const QString &text, const QImage &icon,
 	} else {
 		switch (_placement) {
 			case Line:
+				if (text.isEmpty())
+					return;
 				ti = new TextPathItem(text, path, _font, _maxAngle, _sceneRect);
 				break;
 			case LineCenter:
@@ -74,7 +70,7 @@ void Text::addLabel(const QString &text, const QImage &icon,
 	ti->setHalo(_halo);
 	addItem(ti);
 
-	QList<TextItem*> ci = collidingItems(ti);
+	QList<TextItem*> ci(collidingItems(ti));
 	for (int i = 0; i < ci.size(); i++)
 		ci[i]->setVisible(false);
 }

src/textitem.cpp

@@ -21,14 +21,14 @@ qreal TextItem::avgCharWidth() const
 		ratio = 1.0;
 	// Greek & Cyrilic
 	else if (cp >= 0x03FF && cp <= 0x04FF) {
-		ratio = (_font.capitalization() == QFont::AllUppercase) ? 0.80 : 0.73;
+		ratio = (_font.capitalization() == QFont::AllUppercase) ? 0.80 : 0.70;
 		if (_font.bold())
 			ratio *= 1.1;
 		if (_font.italic())
 			ratio *= 0.9;
 	// The rest (Latin scripts, Arabic, ...)
 	} else {
-		ratio = (_font.capitalization() == QFont::AllUppercase) ? 0.75 : 0.63;
+		ratio = (_font.capitalization() == QFont::AllUppercase) ? 0.75 : 0.60;
 		if (_font.bold())
 			ratio *= 1.1;
 		if (_font.italic())

src/textpathitem.cpp

@@ -2,42 +2,95 @@
 #include <QPainter>
 #include "textpathitem.h"
 
-
-static bool intersection(const QLineF &line, const QRectF &rect,
-  QPointF *p)
+static void swap(const QLineF &line, QPointF *p1, QPointF *p2)
 {
-	if (line.intersect(QLineF(rect.topLeft(), rect.topRight()), p)
+
+	QPointF lp1(line.p1());
+	QPointF lp2(line.p2());
+
+	if ((lp1.rx() < lp2.rx() && p1->rx() > p2->rx())
+	  || (lp1.ry() < lp2.ry() && p1->ry() > p2->ry())
+	  || (lp1.rx() > lp2.rx() && p1->rx() < p2->rx())
+	  || (lp1.ry() > lp2.ry() && p1->ry() < p2->ry())) {
+		QPointF tmp(*p2);
+		*p2 = *p1;
+		*p1 = tmp;
+	}
+}
+
+static bool intersection(const QLineF &line, const QRectF &rect, QPointF *p1,
+  QPointF *p2)
+{
+	QPointF *p = p1;
+
+	if (line.intersects(QLineF(rect.topLeft(), rect.topRight()), p)
+	  == QLineF::BoundedIntersection)
+		p = p2;
+	if (line.intersects(QLineF(rect.topLeft(), rect.bottomLeft()), p)
+	  == QLineF::BoundedIntersection) {
+		if (p == p2) {
+			swap(line, p1, p2);
+			return true;
+		}
+		p = p2;
+	}
+	if (line.intersects(QLineF(rect.bottomRight(), rect.bottomLeft()), p)
+	  == QLineF::BoundedIntersection) {
+		if (p == p2) {
+			swap(line, p1, p2);
+			return true;
+		}
+		p = p2;
+	}
+	if (line.intersects(QLineF(rect.bottomRight(), rect.topRight()), p)
+	  == QLineF::BoundedIntersection) {
+		if (p == p2) {
+			swap(line, p1, p2);
+			return true;
+		}
+	}
+
+	Q_ASSERT(p != p2);
+
+	return false;
+}
+
+static bool intersection(const QLineF &line, const QRectF &rect, QPointF *p)
+{
+	if (line.intersects(QLineF(rect.topLeft(), rect.topRight()), p)
 	  == QLineF::BoundedIntersection)
 		return true;
-	if (line.intersect(QLineF(rect.topLeft(), rect.bottomLeft()), p)
+	if (line.intersects(QLineF(rect.topLeft(), rect.bottomLeft()), p)
 	  == QLineF::BoundedIntersection)
 		return true;
-	if (line.intersect(QLineF(rect.bottomRight(), rect.bottomLeft()), p)
+	if (line.intersects(QLineF(rect.bottomRight(), rect.bottomLeft()), p)
 	  == QLineF::BoundedIntersection)
 		return true;
-	if (line.intersect(QLineF(rect.bottomRight(), rect.topRight()), p)
+	if (line.intersects(QLineF(rect.bottomRight(), rect.topRight()), p)
 	  == QLineF::BoundedIntersection)
 		return true;
 
 	return false;
 }
 
-static QPainterPath subpath(const QList<QLineF> &lines, int start, int end,
+static QPainterPath subpath(const QPolygonF &path, int start, int end,
   qreal cut)
 {
 	qreal ss = 0, es = 0;
 	int si = start, ei = end;
 
-	for (int i = start; i <= end; i++) {
-		qreal len = lines.at(i).length();
+	for (int i = start; i < end; i++) {
+		QLineF l(path.at(i), path.at(i+1));
+		qreal len = l.length();
 		if (ss + len < cut / 2) {
 			ss += len;
 			si++;
 		} else
 			break;
 	}
-	for (int i = end; i >= start; i--) {
-		qreal len = lines.at(i).length();
+	for (int i = end; i > start; i--) {
+		QLineF l(path.at(i), path.at(i-1));
+		qreal len = l.length();
 		if (es + len < cut / 2) {
 			es += len;
 			ei--;
@@ -45,82 +98,117 @@ static QPainterPath subpath(const QList<QLineF> &lines, int start, int end,
 			break;
 	}
 
-	QLineF sl(lines.at(si).p2(), lines.at(si).p1());
+	QLineF sl(path.at(si+1), path.at(si));
 	sl.setLength(sl.length() - (cut / 2 - ss));
-	QLineF el(lines.at(ei));
+	QLineF el(path.at(ei-1), path.at(ei));
 	el.setLength(el.length() - (cut / 2 - es));
 
 	QPainterPath p(sl.p2());
-	for (int i = si; i <= ei; i++)
-		p.lineTo(lines.at(i).p2());
-	p.setElementPositionAt(p.elementCount() - 1, el.p2().x(), el.p2().y());
+	for (int i = si + 1; i < ei; i++)
+		p.lineTo(path.at(i));
+	p.lineTo(el.p2());
 
 	return p;
 }
 
-static QList<QLineF> lineString(const QPainterPath &path,
-  const QRectF &boundingRect)
+static QList<QPolygonF> polyLines(const QPainterPath &path, const QRectF &rect)
 {
-	QList<QLineF> lines;
-	int start = 0, end = path.elementCount() - 1;
-	QPointF p;
+	QList<QPolygonF> lines;
+	QPolygonF line;
+	bool lastIn = rect.contains(path.elementAt(0));
 
-	for (int i = 0; i < path.elementCount(); i++) {
-		if (boundingRect.contains(path.elementAt(i))) {
-			start = i;
-			break;
-		}
-	}
-	for (int i = path.elementCount() - 1; i >= 0; i--) {
-		if (boundingRect.contains(path.elementAt(i))) {
-			end = i;
-			break;
+	for (int i = 1; i < path.elementCount(); i++) {
+		if (rect.contains(path.elementAt(i))) {
+			if (lastIn) {
+				if (line.isEmpty())
+					line.append(path.elementAt(i-1));
+				line.append(path.elementAt(i));
+			} else {
+				QPointF p;
+				QLineF l(path.elementAt(i-1), path.elementAt(i));
+
+				if (intersection(l, rect, &p))
+					line.append(p);
+				line.append(path.elementAt(i));
+			}
+
+			lastIn = true;
+		} else {
+			QLineF l(path.elementAt(i-1), path.elementAt(i));
+
+			if (lastIn) {
+				QPointF p;
+				if (line.isEmpty())
+					line.append(path.elementAt(i-1));
+				if (intersection(l, rect, &p))
+					line.append(p);
+				lines.append(line);
+				line.clear();
+			} else {
+				QPointF p1, p2;
+				if (intersection(l, rect, &p1, &p2)) {
+					line.append(p1);
+					line.append(p2);
+					lines.append(line);
+					line.clear();
+				}
+			}
+
+			lastIn = false;
 		}
 	}
 
-	if (start > 0) {
-		QLineF l(path.elementAt(start-1), path.elementAt(start));
-		if (intersection(l, boundingRect, &p))
-			lines.append(QLineF(p, path.elementAt(start)));
-	}
-	for (int i = start + 1; i <= end; i++)
-		lines.append(QLineF(path.elementAt(i-1), path.elementAt(i)));
-	if (end < path.elementCount() - 1) {
-		QLineF l(path.elementAt(end), path.elementAt(end+1));
-		if (intersection(l, boundingRect, &p))
-			lines.append(QLineF(path.elementAt(end), p));
-	}
+	if (!line.isEmpty())
+		lines.append(line);
 
 	return lines;
 }
 
+static qreal diff(qreal a1, qreal a2)
+{
+	qreal d = qAbs(a1 - a2);
+	return (d > 180) ? 360 - d : d;
+}
+
 static QPainterPath textPath(const QPainterPath &path, qreal textWidth,
   qreal maxAngle, qreal charWidth, const QRectF &tileRect)
 {
-	QList<QLineF> lines(lineString(path, tileRect));
-	qreal length = 0;
-	qreal angle = lines.first().angle();
-	int last = 0;
+	if (path.isEmpty())
+		return QPainterPath();
+
+	QList<QPolygonF> lines(polyLines(path, tileRect));
 
 	for (int i = 0; i < lines.size(); i++) {
-		qreal sl = lines.at(i).length();
-		qreal a = lines.at(i).angle();
+		const QPolygonF &pl = lines.at(i);
+		qreal angle = 0, length = 0;
+		int last = 0;
 
-		if (!tileRect.contains(lines.at(i).p2()) || sl < charWidth
-		  || qAbs(angle - a) > maxAngle) {
-			if (length > textWidth)
-				return subpath(lines, last, i - 1, length - textWidth);
-			last = i;
-			length = 0;
-		} else
-			length += sl;
+		for (int j = 1; j < pl.size(); j ++) {
+			QLineF l(pl.at(j-1), pl.at(j));
+			qreal sl = l.length();
+			qreal a = l.angle();
 
-		angle = a;
+			if (sl < charWidth) {
+				if (length > textWidth)
+					return subpath(pl, last, j - 1, length - textWidth);
+				last = j;
+				length = 0;
+			} else if (j > 1 && diff(angle, a) > maxAngle) {
+				if (length > textWidth)
+					return subpath(pl, last, j - 1, length - textWidth);
+				last = j - 1;
+				length = sl;
+			} else
+				length += sl;
+
+			angle = a;
+		}
+
+		if (length > textWidth)
+			return subpath(pl, last, pl.size() - 1, length - textWidth);
 	}
 
-	return (length > textWidth)
-	  ? subpath(lines, last, lines.size() - 1, length - textWidth)
-	  : QPainterPath();
+	return QPainterPath();
 }
 
 static bool reverse(const QPainterPath &path)
@@ -155,11 +243,8 @@ TextPathItem::TextPathItem(const QString &text, const QPainterPath &path,
 
 void TextPathItem::paint(QPainter *painter) const
 {
-	//painter->setPen(Qt::red);
-	//painter->drawPath(_shape);
-
 	QFontMetrics fm(font());
-	int textWidth = fm.width(text());
+	int textWidth = fm.boundingRect(text()).width();
 
 	qreal factor = (textWidth) / qMax(_path.length(), (qreal)textWidth);
 	qreal percent = (1.0 - factor) / 2.0;
@@ -186,7 +271,7 @@ void TextPathItem::paint(QPainter *painter) const
 			painter->drawText(QPoint(1, fm.descent()), text().at(i));
 			painter->setTransform(t);
 
-			int width = fm.charWidth(text(), i);
+			int width = fm.horizontalAdvance(text().at(i));
 			percent += ((qreal)width / (qreal)textWidth) * factor;
 		}
 
@@ -203,7 +288,12 @@ void TextPathItem::paint(QPainter *painter) const
 		painter->drawText(QPoint(0, fm.descent()), text().at(i));
 		painter->setTransform(t);
 
-		int width = fm.charWidth(text(), i);
+		int width = fm.horizontalAdvance(text().at(i));
 		percent += ((qreal)width / (qreal)textWidth) * factor;
 	}
+
+	//painter->setBrush(Qt::NoBrush);
+	//painter->setPen(Qt::red);
+	//painter->setRenderHint(QPainter::Antialiasing, false);
+	//painter->drawPath(_shape);
 }

src/textpointitem.cpp

@@ -1,7 +1,6 @@
 #include <QPainter>
 #include <QtMath>
 #include <QStaticText>
-#include "config.h"
 #include "textpointitem.h"
 
 
@@ -50,16 +49,10 @@ QRectF TextPointItem::fuzzyBoundingRect() const
 	return QRectF(0, 0, width, lines * fs * 1.6);
 }
 
-
 QRectF TextPointItem::moveTextRect(const QRectF &rect) const
 {
-#ifdef ENABLE_HIDPI
 	QRectF iconRect = _icon.isNull() ? QRectF()
 	  : QRectF(QPointF(0, 0), QSizeF(_icon.size()) / _icon.devicePixelRatioF());
-#else // ENABLE_HIDPI
-	QRectF iconRect = _icon.isNull() ? QRectF() : QRectF(QPointF(0, 0),
-	  QSizeF(_icon.size()));
-#endif // ENABLE_HIDPI
 	QRectF textRect(rect);
 
 	switch (_anchor) {
@@ -92,16 +85,12 @@ TextPointItem::TextPointItem(const QString &text, const QPointF &pos,
   : TextItem(text, font), _pos(pos), _icon(icon), _maxWidth(maxWidth),
   _anchor(anchor)
 {
-	_textRect = fuzzyBoundingRect();
+	_textRect = text.isEmpty() ? QRectF() : fuzzyBoundingRect();
 	_boundingRect = moveTextRect(_textRect);
 
 	if (!_icon.isNull()) {
-#ifdef ENABLE_HIDPI
 		QRectF iconRect(QPointF(0, 0), QSizeF(_icon.size())
 		  / _icon.devicePixelRatioF());
-#else // ENABLE_HIDPI
-		QRectF iconRect(QPointF(0, 0), QSizeF(_icon.size()));
-#endif // ENABLE_HIDPI
 		iconRect.moveCenter(pos);
 		_boundingRect |= iconRect;
 	}
@@ -127,14 +116,9 @@ void TextPointItem::paint(QPainter *painter) const
 
 	if (!_icon.isNull()) {
 		textRect = moveTextRect(painter->boundingRect(_textRect, FLAGS, text()));
-#ifdef ENABLE_HIDPI
 		painter->drawImage(_pos - QPointF(_icon.width()
 		  / _icon.devicePixelRatioF() / 2, _icon.height()
 		  / _icon.devicePixelRatioF() / 2), _icon);
-#else // ENABLE_HIDPI
-		painter->drawImage(_pos - QPointF(_icon.width() / 2,
-		  _icon.height() / 2), _icon);
-#endif // ENABLE_HIDPI
 	} else
 		textRect = _boundingRect;
 

src/tile.h

@@ -11,7 +11,10 @@ public:
 	  : _zoom(zoom), _size(img->size()), _scale(scale),
 	  _text(QSize(img->size().width() / scale.x(),
 	  img->size().height() / scale.y())), _painter(img)
-	  {_painter.scale(scale.x(), scale.y());}
+	{
+		img->fill(Qt::transparent);
+		_painter.scale(scale.x(), scale.y());
+	}
 
 	int zoom() const {return _zoom;}
 	const QSize &size() const {return _size;}

style/style.json

@@ -2265,7 +2265,6 @@
       "source": "openmaptiles",
       "source-layer": "building",
       "minzoom": 13,
-      "maxzoom": 14,
       "layout": {
         "visibility": "visible"
       },
@@ -4059,4 +4058,4 @@
     }
   ],
   "id": "osm-liberty"
-}
+}