adding tesseract in the repository

for all the treadmills

.github/workflows/main.yml

@@ -54,11 +54,10 @@ jobs:
           path: "src/MSIX-Toolkit/"
           ref: b82af826d29e93e4c85d34fad8a405b6c49905e7
 
-      - uses: msys2/setup-msys2@v2
-        with:
-          install: mingw-w64-x86_64-toolchain
-          msystem: mingw64
-          release: false
+#      - name: Check folders
+#        shell: pwsh
+#        run: |
+#          Get-ChildItem -Path D:\a\_temp\ -Recurse -ErrorAction SilentlyContinue -Force
 
       - name: Setup cmake
         uses: jwlawson/actions-setup-cmake@v1.9
@@ -109,332 +108,3 @@ jobs:
           name: windows-binary
           path: src/debug/output
 
-#  window-steam-build:
-#    runs-on: windows-latest
-#
-#    steps:
-#      - uses: actions/checkout@v2
-#      - name: Checkout submodule repo
-#        uses: actions/checkout@v2
-#        with:
-#          repository: bluetiger9/SmtpClient-for-Qt
-#          path: "src/smtpclient/"
-#          ref: 3fa4a0fe5797070339422cf18b5e9ed8dcb91f9c
-#
-#      - uses: actions/checkout@v2
-#      - name: Checkout submodule repo
-#        uses: actions/checkout@v2
-#        with:
-#          repository: cagnulein/qmdnsengine
-#          path: "src/qmdnsengine/"
-#          ref: "zwift"
-#
-#      - uses: msys2/setup-msys2@v2
-#        with:
-#          install: mingw-w64-x86_64-toolchain
-#          msystem: mingw64
-#          release: false
-#
-#      - name: Setup cmake
-#        uses: jwlawson/actions-setup-cmake@v1.9
-#        with:
-#          cmake-version: '3.20.x'
-#
-#      - name: Install Qt
-#        uses: jurplel/install-qt-action@v2
-#        with:
-#          version: '5.15.2'
-#          host: 'windows'
-#          modules: 'qtnetworkauth qtcharts'
-#          target: "desktop"
-#          arch: win64_mingw81
-#          dir: "${{github.workspace}}/qt/"
-#          install-deps: "true"
-#
-#      - name: Build
-#        run: |
-#            qmake
-#            cd src
-#            echo "#define STRAVA_SECRET_KEY ${{ secrets.strava_secret_key }}" > secret.h
-#            echo "#define SMTP_USERNAME ${{ secrets.smtp_username }}" >> secret.h
-#            echo "#define SMTP_PASSWORD ${{ secrets.smtp_password }}" >> secret.h
-#            echo "#define SMTP_SERVER ${{ secrets.smtp_server }}" >> secret.h
-#            echo "#define STEAM_STORE" >> secret.h
-#            cd ..
-#            make -j8
-#            cd src/debug
-#            mkdir output
-#            mkdir appx
-#            cp qdomyos-zwift.exe output/
-#            cd output
-#            windeployqt --qmldir ../../ qdomyos-zwift.exe
-#            cp "${{github.workspace}}/qt/Qt/5.15.2/mingw81_64/bin/libwinpthread-1.dll" .
-#            cp "${{github.workspace}}/qt/Qt/5.15.2/mingw81_64/bin/libgcc_s_seh-1.dll" .
-#            cp "${{github.workspace}}/qt/Qt/5.15.2/mingw81_64/bin/libstdc++-6.dll" .
-#
-#      - uses: game-ci/steam-deploy@v1
-#        with:
-#          username: ${{ secrets.STEAM_USERNAME }}
-#          password: ${{ secrets.STEAM_PASSWORD }}
-#          configVdf: ${{ secrets.STEAM_CONFIG_VDF}}
-#          ssfnFileName: ${{ secrets.STEAM_SSFN_FILE_NAME }}
-#          ssfnFileContents: ${{ secrets.STEAM_SSFN_FILE_CONTENTS }}
-#          appId: 2267200
-#          buildDescription: 2.12
-#          rootPath: src/debug/output
-#          depot1Path: ./
-#          #depot2Path: StandaloneLinux64
-#          releaseBranch: prerelease
-
-  # This workflow contains a single job called "build"
-  linux-x86-build:
-    # The type of runner that the job will run on
-    runs-on: ubuntu-latest
-
-    # Steps represent a sequence of tasks that will be executed as part of the job
-    steps:
-#      - name: Cache Qt Linux Desktop
-#        id: cache-qt-linux-desktop
-#        uses: actions/cache@v1
-#        with:
-#          path: '${{ github.workspace }}/output/linux-desktop/'
-#          key: ${{ runner.os }}-QtCache-Linux-Desktop
-
-#      - name: Cache Qt Linux Android
-#        id: cache-qt-android
-#        uses: actions/cache@v1
-#        with:
-#          path: '${{ github.workspace }}/output/android/'
-#          key: ${{ runner.os }}-QtCache-Android
-
-      - name: Xvfb install and run
-        run: |
-          sudo apt-get install -y xvfb
-          Xvfb -ac ${{ env.DISPLAY }} -screen 0 1280x780x24 &
-
-      # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
-      - uses: actions/checkout@v2
-      - name: Checkout submodule repo
-        uses: actions/checkout@v2
-        with:
-          repository: bluetiger9/SmtpClient-for-Qt
-          path: "src/smtpclient/"
-          ref: 3fa4a0fe5797070339422cf18b5e9ed8dcb91f9c
-
-      - uses: actions/checkout@v2
-      - name: Checkout submodule repo
-        uses: actions/checkout@v2
-        with:
-          repository: cagnulein/qmdnsengine
-          path: "src/qmdnsengine/"
-          ref: "zwift"
-
-      - uses: actions/checkout@v2
-      - name: Checkout submodule repo
-        uses: actions/checkout@v2
-        with:
-          repository: google/googletest
-          path: "tst/googletest/"
-          ref: "release-1.12.1"
-
-      - name: Install packages required to run QZ inside workflow
-        run: sudo apt update -y && sudo apt-get install -y qtbase5-dev qtchooser qt5-qmake qtbase5-dev-tools qtquickcontrols2-5-dev libqt5bluetooth5 libqt5widgets5 libqt5positioning5 libqt5xml5 qtconnectivity5-dev qtpositioning5-dev libqt5charts5-dev libqt5charts5 libqt5networkauth5-dev libqt5websockets5* libxcb-randr0-dev libxcb-xtest0-dev libxcb-xinerama0-dev libxcb-shape0-dev libxcb-xkb-dev
-
-      - name: Install Qt
-        uses: jurplel/install-qt-action@v2
-        with:
-          version: '5.15.2'
-          host: 'linux'
-          modules: 'qtnetworkauth qtcharts'
-
-      - name: Compile Linux Desktop
-        run: qmake; make -j8
-
-      - name: Archive linux-desktop binary
-        uses: actions/upload-artifact@v2
-        with:
-          name: linux-desktop-binary
-          path: src/qdomyos-zwift         
-
-      - name: Test
-        run: cd tst; GTEST_OUTPUT=xml:test-results/ GTEST_COLOR=1 ./qdomyos-zwift-tests; cd ..
-
-      - name: Upload test results
-        uses: actions/upload-artifact@v2
-        if: failure()
-        with:
-          name: test_results_xml
-          path: tst/test-results/**/*.xml               
-
-#      - name: Test Peloton API
-#        if: github.event_name == 'push' || github.event_name == 'schedule'
-#        run: cd /home/runner/work/qdomyos-zwift/qdomyos-zwift/src/; ./qdomyos-zwift -test-peloton -peloton-username ${{ secrets.peloton_username }} -peloton-password ${{ secrets.peloton_password }}
-#        timeout-minutes: 2
-
-#      - name: Test Home Fitness Buddy API
-#        run: cd /home/runner/work/qdomyos-zwift/qdomyos-zwift/src/; ./qdomyos-zwift -test-hfb
-#        timeout-minutes: 2
-
-#      - uses: actions/checkout@v2
-#        with:
-#          repository: nttld/setup-ndk
-#          path: setup-ndk
-      # The packages.json in nttld/setup-ndk has already been updated,
-      # https://github.com/nttld/setup-ndk/commit/831db5b02a0f0cab80614619efe461a3dcc140e6
-      # but `dist/*` has not been rebuilt yet. Build it.
-      # https://github.com/nttld/setup-ndk/tree/main/dist
-#      - name: Locally rebuilt setup-ndk
-#        run: |
-#          npm -prefix ./setup-ndk install
-#          npm -prefix ./setup-ndk run all
-      # Install using locally rebuilt setup-ndk
-#      - name: Setup Android NDK r21d
-#        uses: ./setup-ndk
-      #- uses: nttld/setup-ndk@v1
-#        with:
-#          ndk-version: r21d
-
-# waiting github.com/jurplel/install-qt-action/issues/63
-#      - name: Install Qt Android
-#        uses: jurplel/install-qt-action@v2
-#        with:
-#          version: '5.12.9'
-#          host: 'linux'
-#          target: 'android'
-#          arch: 'android_armv7'
-#          modules: 'qtcharts debug_info'
-#          dir: '${{ github.workspace }}/output/android/'
-#          cached: ${{ steps.cache-qt-android.outputs.cache-hit }}
-
-#      - name: Compile Android
-#        run: cd src; qmake; make -j4
-
-#      - name: Install Qt MacOS
-#        uses: jurplel/install-qt-action@v2
-#        with:
-#          version: '5.12.9'
-#          host: 'mac'
-#          target: 'desktop'
-#          modules: 'qtcharts debug_info'
-#          dir: '${{ github.workspace }}/output/macos/'
-
-#      - name: Compile MacOS
-#        run: cd src; qmake; make -j4
-
-
-  # This workflow contains a single job called "build"
-  android-build:
-    # The type of runner that the job will run on
-    runs-on: ubuntu-latest
-
-    # Steps represent a sequence of tasks that will be executed as part of the job
-    steps:
-#      - name: Cache Qt Linux Desktop
-#        id: cache-qt-linux-desktop
-#        uses: actions/cache@v1
-#        with:
-#          path: '${{ github.workspace }}/output/linux-desktop/'
-#          key: ${{ runner.os }}-QtCache-Linux-Desktop
-
-#      - name: Cache Qt Linux Android
-#        id: cache-qt-android
-#        uses: actions/cache@v1
-#        with:
-#          path: '${{ github.workspace }}/output/android/'
-#          key: ${{ runner.os }}-QtCache-Android
-
-      - name: Xvfb install and run
-        run: |
-          sudo apt-get install -y xvfb
-          Xvfb -ac ${{ env.DISPLAY }} -screen 0 1280x780x24 &
-
-      # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
-      - uses: actions/checkout@v2
-      - name: Checkout submodule repo
-        uses: actions/checkout@v2
-        with:
-          repository: bluetiger9/SmtpClient-for-Qt
-          path: "src/smtpclient/"
-          ref: 3fa4a0fe5797070339422cf18b5e9ed8dcb91f9c
-
-      - uses: actions/checkout@v2
-      - name: Checkout submodule repo
-        uses: actions/checkout@v2
-        with:
-          repository: cagnulein/qmdnsengine
-          path: "src/qmdnsengine/"
-          ref: "zwift"
-
-      - uses: actions/checkout@v2
-      - name: Checkout submodule repo
-        uses: actions/checkout@v2
-        with:
-          repository: google/googletest
-          path: "tst/googletest/"
-          ref: "release-1.12.1"
-
-      - name: Install packages required to run QZ inside workflow
-        run: sudo apt update -y && sudo apt-get install -y qtbase5-dev qtchooser qt5-qmake qtbase5-dev-tools qtquickcontrols2-5-dev libqt5bluetooth5 libqt5widgets5 libqt5positioning5 libqt5xml5 qtconnectivity5-dev qtpositioning5-dev libqt5charts5-dev libqt5charts5 libqt5networkauth5-dev libqt5websockets5* libxcb-randr0-dev libxcb-xtest0-dev libxcb-xinerama0-dev libxcb-shape0-dev libxcb-xkb-dev
-
-#      - name: Test Peloton API
-#        if: github.event_name == 'push' || github.event_name == 'schedule'
-#        run: cd /home/runner/work/qdomyos-zwift/qdomyos-zwift/src/; ./qdomyos-zwift -test-peloton -peloton-username ${{ secrets.peloton_username }} -peloton-password ${{ secrets.peloton_password }}
-#        timeout-minutes: 2
-
-#      - name: Test Home Fitness Buddy API
-#        run: cd /home/runner/work/qdomyos-zwift/qdomyos-zwift/src/; ./qdomyos-zwift -test-hfb
-#        timeout-minutes: 2
-
-#      - uses: actions/checkout@v2
-#        with:
-#          repository: nttld/setup-ndk
-#          path: setup-ndk
-      # The packages.json in nttld/setup-ndk has already been updated,
-      # https://github.com/nttld/setup-ndk/commit/831db5b02a0f0cab80614619efe461a3dcc140e6
-      # but `dist/*` has not been rebuilt yet. Build it.
-      # https://github.com/nttld/setup-ndk/tree/main/dist
-#      - name: Locally rebuilt setup-ndk
-#        run: |
-#          npm -prefix ./setup-ndk install
-#          npm -prefix ./setup-ndk run all
-      # Install using locally rebuilt setup-ndk
-#      - name: Setup Android NDK r21d
-#        uses: ./setup-ndk
-      #- uses: nttld/setup-ndk@v1
-#        with:
-#          ndk-version: r21d
-
-# waiting github.com/jurplel/install-qt-action/issues/63
-      - name: Install Qt Android
-        uses: jurplel/install-qt-action@v2
-        with:
-          version: '5.15.2'
-          host: 'linux'
-          target: 'android'
-          arch: 'android'
-          modules: 'qtcharts  qtnetworkauth'
-          dir: '${{ github.workspace }}/output/android/'
-
-      - name: Install Java
-        uses: actions/setup-java@v3
-        with:
-          distribution: 'temurin' # See 'Supported distributions' for available options
-          java-version: '11'
-
-      - name: Set Android NDK 21 && build
-        run: |
-          # Install NDK 21 after GitHub update
-          # https://github.com/actions/virtual-environments/issues/5595
-          ANDROID_ROOT="/usr/local/lib/android"
-          ANDROID_SDK_ROOT="${ANDROID_ROOT}/sdk"
-          SDKMANAGER="${ANDROID_SDK_ROOT}/cmdline-tools/latest/bin/sdkmanager"
-          echo "y" | $SDKMANAGER "ndk;21.4.7075529"
-          export ANDROID_NDK="${ANDROID_SDK_ROOT}/ndk-bundle"
-          export ANDROID_NDK_ROOT="${ANDROID_NDK}"
-
-          ln -sfn $ANDROID_SDK_ROOT/ndk/21.4.7075529 $ANDROID_NDK
-          rm -rf /usr/local/lib/android/sdk/ndk/25.1.8937393
-          qmake -spec android-clang 'ANDROID_ABIS=armeabi-v7a arm64-v8a x86 x86_64' 'ANDROID_NDK_ROOT=/usr/local/lib/android/sdk/ndk/21.4.7075529' && make -j4 && make INSTALL_ROOT=${{ github.workspace }}/output/android/ install
-
-      - name: Build APK (not usable for production due to unpatched QT library)
-        run: cd src; androiddeployqt --input android-qdomyos-zwift-deployment-settings.json --output ${{ github.workspace }}/output/android/ --android-platform android-31 --gradle --aab

src/Computrainer.cpp

@@ -632,6 +632,7 @@ void Computrainer::run() {
 
         /* time to shut up shop */
         if (!(curstatus & CT_RUNNING)) {
+            qDebug() << "time to shut up shop";
             // time to stop!
             closePort(); // need to release that file handle!!
             quit(0);
@@ -639,12 +640,14 @@ void Computrainer::run() {
         }
 
         if ((curstatus & CT_PAUSED) && isDeviceOpen == true) {
+            qDebug() << "(curstatus & CT_PAUSED) && isDeviceOpen == true";
             closePort();
             isDeviceOpen = false;
 
         } else if (!(curstatus & CT_PAUSED) && (curstatus & CT_RUNNING) && isDeviceOpen == false) {
-
+            qDebug() << "!(curstatus & CT_PAUSED) && (curstatus & CT_RUNNING) && isDeviceOpen == false";
             if (openPort()) {
+                qDebug() << "quit(2)";
                 quit(2);
                 return; // open failed!
             }
@@ -653,6 +656,7 @@ void Computrainer::run() {
             // send first command to get computrainer ready
             prepareCommand(curmode, curmode == CT_ERGOMODE ? curload : curgradient);
             if (sendCommand(curmode) == -1) {
+                qDebug() << "quit(4)";
                 // send failed - ouch!
                 closePort(); // need to release that file handle!!
                 quit(4);
@@ -671,6 +675,7 @@ void Computrainer::run() {
 
             prepareCommand(curmode, curmode == CT_ERGOMODE ? curload : curgradient);
             if (sendCommand(curmode) == -1) {
+                qDebug() << "quit(4)";
                 // send failed - ouch!
                 closePort(); // need to release that file handle!!
                 quit(4);
@@ -744,9 +749,9 @@ int Computrainer::readMessage() {
     }
 
 #ifdef Q_OS_ANDROID
-    qDebug() << cleanFrame << QByteArray((const char*)buf, 7).toHex(' ');
+    qDebug() << cleanFrame << QByteArray((const char *)buf, 7).toHex(' ');
 
-    if(!cleanFrame)
+    if (!cleanFrame)
         return 0;
 #endif
 

src/android/AndroidManifest.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0"?>
-<manifest package="org.cagnulen.qdomyoszwift" xmlns:android="http://schemas.android.com/apk/res/android" xmlns:tools="http://schemas.android.com/tools" android:versionName="2.13.18" android:versionCode="523" android:installLocation="auto">
+<manifest package="org.cagnulen.qdomyoszwift" xmlns:android="http://schemas.android.com/apk/res/android" xmlns:tools="http://schemas.android.com/tools" android:versionName="2.13.21" android:versionCode="526" android:installLocation="auto">
 <!-- The following comment will be replaced upon deployment with default permissions based on the dependencies of the application.
           Remove the comment if you do not require these default permissions. -->
 			<!-- %%INSERT_PERMISSIONS -->

src/bluetooth.cpp

@@ -1503,6 +1503,23 @@ void bluetooth::deviceDiscovered(const QBluetoothDeviceInfo &device) {
                         &bluetooth::connectedAndDiscovered);
                 mepanelBike->deviceDiscovered(b);
                 this->startTemplateManagers(mepanelBike);
+            } else if ((b.name().toUpper().startsWith(QStringLiteral("SCHWINN 170/270"))) && !schwinn170Bike &&
+                       filter) {
+                this->setLastBluetoothDevice(b);
+                this->stopDiscovery();
+                schwinn170Bike =
+                    new schwinn170bike(noWriteResistance, noHeartService, bikeResistanceOffset, bikeResistanceGain);
+                // stateFileRead();
+                emit deviceConnected(b);
+                connect(schwinn170Bike, &bluetoothdevice::connectedAndDiscovered, this,
+                        &bluetooth::connectedAndDiscovered);
+                // connect(echelonConnectSport, SIGNAL(disconnected()), this, SLOT(restart()));
+                connect(schwinn170Bike, &schwinn170bike::debug, this, &bluetooth::debug);
+                // connect(echelonConnectSport, SIGNAL(speedChanged(double)), this, SLOT(speedChanged(double)));
+                // connect(echelonConnectSport, SIGNAL(inclinationChanged(double)), this,
+                // SLOT(inclinationChanged(double)));
+                schwinn170Bike->deviceDiscovered(b);
+                this->startTemplateManagers(schwinn170Bike);
             } else if ((b.name().toUpper().startsWith(QStringLiteral("IC BIKE")) ||
                         (b.name().toUpper().startsWith(QStringLiteral("C7-")) && b.name().length() != 17) ||
                         b.name().toUpper().startsWith(QStringLiteral("C9/C10"))) &&
@@ -2637,6 +2654,11 @@ void bluetooth::restart() {
         delete schwinnIC4Bike;
         schwinnIC4Bike = nullptr;
     }
+    if (schwinn170Bike) {
+
+        delete schwinn170Bike;
+        schwinn170Bike = nullptr;
+    }
     if (sportsTechBike) {
 
         delete sportsTechBike;
@@ -2906,6 +2928,8 @@ bluetoothdevice *bluetooth::device() {
         return mcfBike;
     } else if (schwinnIC4Bike) {
         return schwinnIC4Bike;
+    } else if (schwinn170Bike) {
+        return schwinn170Bike;
     } else if (sportsTechBike) {
         return sportsTechBike;
     } else if (sportsPlusBike) {

src/bluetooth.h

@@ -83,6 +83,7 @@
 #include "proformtreadmill.h"
 #include "proformwifibike.h"
 #include "proformwifitreadmill.h"
+#include "schwinn170bike.h"
 #include "schwinnic4bike.h"
 #include "signalhandler.h"
 #include "skandikawiribike.h"
@@ -206,6 +207,7 @@ class bluetooth : public QObject, public SignalHandler {
     solebike *soleBike = nullptr;
     soleelliptical *soleElliptical = nullptr;
     solef80treadmill *soleF80 = nullptr;
+    schwinn170bike *schwinn170Bike = nullptr;
     chronobike *chronoBike = nullptr;
     fitplusbike *fitPlusBike = nullptr;
     echelonrower *echelonRower = nullptr;

src/eslinkertreadmill.cpp

@@ -101,7 +101,7 @@ void eslinkertreadmill::forceSpeed(double requestSpeed) {
 
         writeCharacteristic(display, sizeof(display),
                             QStringLiteral("forceSpeed speed=") + QString::number(requestSpeed), false, true);
-    } else if(treadmill_type == COSTAWAY) {
+    } else if (treadmill_type == COSTAWAY) {
         // CheckSum 8 Xor
         uint8_t display[] = {0xa9, 0xa0, 0x03, 0x02, 0x00, 0x00, 0x00};
         display[4] = requestSpeed * 10;
@@ -152,7 +152,9 @@ void eslinkertreadmill::update() {
             updateDisplay(elapsed.value());
         }
 
-        if (treadmill_type == TYPE::RHYTHM_FUN || treadmill_type == TYPE::YPOO_MINI_CHANGE || treadmill_type == TYPE::COSTAWAY) { //
+        if (treadmill_type == TYPE::RHYTHM_FUN || treadmill_type == TYPE::YPOO_MINI_CHANGE ||
+            treadmill_type == TYPE::COSTAWAY) {
+
             if (requestSpeed != -1) {
                 if (requestSpeed != currentSpeed().value() && requestSpeed >= 0 && requestSpeed <= 22) {
                     emit debug(QStringLiteral("writing speed ") + QString::number(requestSpeed));
@@ -341,7 +343,7 @@ void eslinkertreadmill::characteristicChanged(const QLowEnergyCharacteristic &ch
 
     if ((newValue.length() != 17 && (treadmill_type == RHYTHM_FUN || treadmill_type == YPOO_MINI_CHANGE)))
         return;
-    else if(newValue.length() != 5 && treadmill_type == COSTAWAY)
+    else if (newValue.length() != 5 && treadmill_type == COSTAWAY)
         return;
 
     if (treadmill_type == RHYTHM_FUN || treadmill_type == YPOO_MINI_CHANGE) {
@@ -380,7 +382,7 @@ void eslinkertreadmill::characteristicChanged(const QLowEnergyCharacteristic &ch
             lastSpeed = speed;
             lastInclination = incline;
         }
-    } else if(treadmill_type == COSTAWAY) {
+    } else if (treadmill_type == COSTAWAY) {
         const double miles = 1.60934;
         Speed = newValue.at(3) * miles;
         Inclination = 0; // this treadmill doesn't have inclination

src/inner_templates/floating/floating.htm

@@ -741,7 +741,7 @@
           $('.distance-value').html("<b>" + odometer.toFixed(2) + "</b>");
           $('.rowremainingtime-value').html("<b>" + row_remaining_time_h.toString().padStart(2, "0") + ":" + row_remaining_time_m.toString().padStart(2, "0") + ":" + row_remaining_time_s.toString().padStart(2, "0") + "</b>");
           $('.elapsed-value').html("<b>" + elapsed_h.toString().padStart(2, "0") + ":" + elapsed_m.toString().padStart(2, "0") + ":" + elapsed_s.toString().padStart(2, "0") + "</b>");
-          
+			 $('gears-value').html("<b>" + gears.toFixed(0) + "</b>");
           if(pace_s.toString() === "-1" || (pace_s.toString() === "0" && pace_m.toString() === "0"))
             $('.pace-value').html("<b>N/A</b>");
           else
@@ -775,4 +775,4 @@
   </script>
 </body>
 
-</html>
+</html>

src/main.qml

@@ -665,7 +665,7 @@ ApplicationWindow {
             }
 
             ItemDelegate {
-                text: "version 2.13.18"
+                text: "version 2.13.21"
                 width: parent.width
             }
 				FileDialog {

src/qdomyos-zwift.pri

@@ -32,6 +32,7 @@ QML_IMPORT_PATH =
 QML_DESIGNER_IMPORT_PATH =
 
 win32:QMAKE_LFLAGS_DEBUG += -static-libstdc++ -static-libgcc
+win32:LIBS += -lgdi32 -lUser32
 QMAKE_LFLAGS_RELEASE += -s
 QMAKE_CXXFLAGS += -fno-sized-deallocation
 unix:android: {
@@ -47,6 +48,10 @@ macx {
 }
 INCLUDEPATH += qmdnsengine/src/include
 
+#tesseract
+win32:INCLUDEPATH += windows/tesseract/include windows/leptonica/include
+win32:LIBS += -llept -ltesseract -Lwindows/tesseract/lib -Lwindows/leptonica/lib
+
 # The following define makes your compiler emit warnings if you use
 # any Qt feature that has been marked deprecated (the exact warnings
 # depend on your compiler). Please consult the documentation of the
@@ -67,6 +72,8 @@ SOURCES += \
     $$PWD/androidadblog.cpp \
    $$PWD/apexbike.cpp \
    $$PWD/pelotonbike.cpp \
+   $$PWD/qtesseract.cpp \
+   $$PWD/schwinn170bike.cpp \
    $$PWD/wahookickrheadwind.cpp \
    $$PWD/ziprotreadmill.cpp \
    Computrainer.cpp \
@@ -264,6 +271,8 @@ HEADERS += \
    $$PWD/apexbike.h \
     $$PWD/discoveryoptions.h \
    $$PWD/pelotonbike.h \
+   $$PWD/qtesseract.h \
+   $$PWD/schwinn170bike.h \
    $$PWD/wahookickrheadwind.h \
    $$PWD/ziprotreadmill.h \
    Computrainer.h \
@@ -770,4 +779,4 @@ INCLUDEPATH += purchasing/inapp
 
 WINRT_MANIFEST = AppxManifest.xml
 
-VERSION = 2.13.18
+VERSION = 2.13.21

src/qtesseract.cpp

@@ -0,0 +1,167 @@
+#include "qtesseract.h"
+#ifdef Q_OS_WIN
+
+#include <Windows.h>
+#include <fstream>
+#include <iostream>
+
+int WriteBitmapFile(PBITMAPFILEHEADER pFileHeader, PBITMAPINFOHEADER pInfoHeader, PBYTE pImageData,
+                    DWORD dwImageDataSize) {
+    /*
+    The format of a .bmp file is:
+    1) File header
+    2) Info header
+    3) Raw bytes (representing the pixels)
+    (https://en.wikipedia.org/wiki/BMP_file_format)
+    */
+
+    std::ofstream fout;
+    fout.open("temp.bmp", std::ios::out | std::ios::binary);
+
+    if (!fout) {
+        printf("ofstream::open failed (err %d)\n", GetLastError());
+        return 1;
+    }
+
+    fout.write((char *)(pFileHeader), sizeof(BITMAPFILEHEADER));
+    fout.write((char *)(pInfoHeader), sizeof(BITMAPINFOHEADER));
+    fout.write((char *)(pImageData), dwImageDataSize);
+    fout.close();
+
+    return 0;
+}
+
+int SaveFromBitmapInfo(PBITMAPINFO pBitmapInfo) {
+    // This program currently doesn't support other types of compression
+    if (pBitmapInfo->bmiHeader.biCompression != BI_RGB) {
+        printf("[!] Bitmap compression is different from BI_RGB\n");
+        return 0;
+    }
+
+    BITMAPFILEHEADER bmfh = {0};
+
+    bmfh.bfType = 0x4D42;                                                 // BMP magic
+    bmfh.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER); // 14 and 40 bytes respectively
+    bmfh.bfSize = bmfh.bfOffBits + pBitmapInfo->bmiHeader.biWidth * pBitmapInfo->bmiHeader.biHeight *
+                                       pBitmapInfo->bmiHeader.biBitCount / 8;
+
+    return WriteBitmapFile(&bmfh, &pBitmapInfo->bmiHeader, (PBYTE)&pBitmapInfo->bmiColors,
+                           bmfh.bfSize - bmfh.bfOffBits);
+}
+
+int SaveBitmapFromClipboard() {
+    HANDLE hGlobal = NULL;
+    int rv = 1;
+
+    if (!IsClipboardFormatAvailable(CF_DIB)) {
+        printf("[!] CF_DIB is not an avialable format\n");
+        return 1;
+    }
+    printf("[*] BITMAPINFO format is available\n");
+
+    if (!OpenClipboard(NULL)) {
+        printf("[!] OpenClipboard failed (err %d)\n", GetLastError());
+        return 1;
+    }
+
+    hGlobal = GetClipboardData(CF_DIB);
+    if (hGlobal == NULL) {
+        printf("[!] GetClipboardData failed (err %d)\n", GetLastError());
+        return 1;
+    }
+
+    PBITMAPINFO pClipboardData = (PBITMAPINFO)GlobalLock(hGlobal);
+    if (pClipboardData == NULL) {
+        printf("[!] GlobalLock failed (err %d)\n", GetLastError());
+        return 1;
+    }
+
+    rv = SaveFromBitmapInfo(pClipboardData);
+
+    GlobalUnlock(hGlobal);
+    if (!CloseClipboard()) {
+        printf("[!] CloseClipboard failed (err %d)\n", GetLastError());
+        return 1;
+    }
+
+    return rv;
+}
+
+void qtesseract::captureWindow() {
+
+    RECT rc;
+    HWND hwnd = ::FindWindow(0, TEXT("Zwift")); //::FindWindow(0,_T("ScreenCapture (Running) - Microsoft
+                                                //:Visual Studio"));//::FindWindow(0, _T("Calculator"));//=
+                                                //:FindWindow("Notepad", NULL);    //You get the ideal?
+    if (hwnd == NULL) {
+        return;
+    }
+    GetClientRect(hwnd, &rc);
+
+    // create
+    HDC hdcScreen = GetDC(NULL);
+    HDC hdc = CreateCompatibleDC(hdcScreen);
+    HBITMAP hbmp = CreateCompatibleBitmap(hdcScreen, rc.right - rc.left, rc.bottom - rc.top);
+    SelectObject(hdc, hbmp);
+
+    // Print to memory hdc
+    PrintWindow(hwnd, hdc, PW_CLIENTONLY);
+
+    // copy to clipboard
+    OpenClipboard(NULL);
+    EmptyClipboard();
+    SetClipboardData(CF_BITMAP, hbmp);
+    CloseClipboard();
+
+    SaveBitmapFromClipboard();
+
+    tesseract::TessBaseAPI *api = new tesseract::TessBaseAPI();
+    // Initialize tesseract-ocr with English, without specifying tessdata path
+    if (api->Init(NULL, "eng")) {
+        fprintf(stderr, "Could not initialize tesseract.\n");
+        exit(1);
+    }
+    // Open input image with leptonica library
+    Pix *image = pixRead("temp.bmp");
+    api->SetImage(image);
+    // Set lstm_choice_mode to alternative symbol choices per character, bbox is at word level.
+    api->SetVariable("lstm_choice_mode", "2");
+    api->Recognize(0);
+    tesseract::PageIteratorLevel level = tesseract::RIL_WORD;
+    tesseract::ResultIterator *res_it = api->GetIterator();
+    // Get confidence level for alternative symbol choices. Code is based on
+    // https://github.com/tesseract-ocr/tesseract/blob/a7a729f6c315e751764b72ea945da961638effc5/src/api/hocrrenderer.cpp#L325-L344
+    std::vector<std::vector<std::pair<const char *, float>>> *choiceMap = nullptr;
+    if (res_it != 0) {
+        do {
+            const char *word;
+            float conf;
+            int x1, y1, x2, y2, tcnt = 1, gcnt = 1, wcnt = 0;
+            res_it->BoundingBox(level, &x1, &y1, &x2, &y2);
+            choiceMap = res_it->GetBestLSTMSymbolChoices();
+            for (auto timestep : *choiceMap) {
+                if (timestep.size() > 0) {
+                    for (auto &j : timestep) {
+                        conf = int(j.second * 100);
+                        word = j.first;
+                        printf("%d  symbol: '%s';  \tconf: %.2f; BoundingBox: %d,%d,%d,%d;\n", wcnt, word, conf, x1, y1,
+                               x2, y2);
+                        gcnt++;
+                    }
+                    tcnt++;
+                }
+                wcnt++;
+                printf("\n");
+            }
+        } while (res_it->Next(level));
+    }
+    // Destroy used object and release memory
+    api->End();
+    pixDestroy(&image);
+
+    // release
+    DeleteDC(hdc);
+    DeleteObject(hbmp);
+    ReleaseDC(NULL, hdcScreen);
+}
+#endif

src/qtesseract.h

@@ -0,0 +1,32 @@
+#ifndef QTESSERACT_H
+#define QTESSERACT_H
+
+#include <QApplication>
+
+#ifdef Q_OS_WIN
+
+#include <QQmlContext>
+#include <QStyleFactory>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "bluetooth.h"
+#include "mainwindow.h"
+#include <QDir>
+#include <QGuiApplication>
+#include <QOperatingSystemVersion>
+#include <QQmlApplicationEngine>
+#include <QSettings>
+#include <QStandardPaths>
+
+#include <leptonica/allheaders.h>
+#include <tesseract/baseapi.h>
+
+class qtesseract {
+  public:
+    static void captureWindow();
+
+  private:
+};
+#endif
+#endif // QTESSERACT_H

src/qzsettings.cpp

@@ -641,8 +641,10 @@ const QString QZSettings::sole_treadmill_inclination_fast = QStringLiteral("sole
 const QString QZSettings::zwift_ocr = QStringLiteral("zwift_ocr");
 const QString QZSettings::fit_file_saved_on_quit = QStringLiteral("fit_file_saved_on_quit");
 const QString QZSettings::gem_module_inclination = QStringLiteral("gem_module_inclination");
+const QString QZSettings::treadmill_simulate_inclination_with_speed =
+    QStringLiteral("treadmill_simulate_inclination_with_speed");
 
-const uint32_t allSettingsCount = 536;
+const uint32_t allSettingsCount = 537;
 QVariant allSettings[allSettingsCount][2] = {
     {QZSettings::cryptoKeySettingsProfiles, QZSettings::default_cryptoKeySettingsProfiles},
     {QZSettings::bluetooth_no_reconnection, QZSettings::default_bluetooth_no_reconnection},
@@ -1183,6 +1185,8 @@ QVariant allSettings[allSettingsCount][2] = {
     {QZSettings::zwift_ocr, QZSettings::default_zwift_ocr},
     {QZSettings::fit_file_saved_on_quit, QZSettings::default_fit_file_saved_on_quit},
     {QZSettings::gem_module_inclination, QZSettings::default_gem_module_inclination},
+    {QZSettings::treadmill_simulate_inclination_with_speed,
+     QZSettings::default_treadmill_simulate_inclination_with_speed},
 };
 
 void QZSettings::qDebugAllSettings(bool showDefaults) {

src/qzsettings.h

@@ -1803,6 +1803,9 @@ class QZSettings {
     static const QString gem_module_inclination;
     static constexpr bool default_gem_module_inclination = false;
 
+    static const QString treadmill_simulate_inclination_with_speed;
+    static constexpr bool default_treadmill_simulate_inclination_with_speed = false;
+
     /**
      * @brief Write the QSettings values using the constants from this namespace.
      * @param showDefaults Optionally indicates if the default should be shown with the key.

src/schwinn170bike.cpp

@@ -0,0 +1,591 @@
+#include "schwinn170bike.h"
+
+#include "ios/lockscreen.h"
+#include "virtualbike.h"
+#include <QBluetoothLocalDevice>
+#include <QDateTime>
+#include <QFile>
+#include <QMetaEnum>
+#include <QSettings>
+
+#include <QThread>
+#include <math.h>
+#ifdef Q_OS_ANDROID
+#include <QLowEnergyConnectionParameters>
+#endif
+#include "keepawakehelper.h"
+#include <chrono>
+
+using namespace std::chrono_literals;
+
+schwinn170bike::schwinn170bike(bool noWriteResistance, bool noHeartService, uint8_t bikeResistanceOffset,
+                               double bikeResistanceGain) {
+    m_watt.setType(metric::METRIC_WATT);
+    Speed.setType(metric::METRIC_SPEED);
+    refresh = new QTimer(this);
+    this->noWriteResistance = noWriteResistance;
+    this->noHeartService = noHeartService;
+    this->bikeResistanceGain = bikeResistanceGain;
+    this->bikeResistanceOffset = bikeResistanceOffset;
+    initDone = false;
+    connect(refresh, &QTimer::timeout, this, &schwinn170bike::update);
+    refresh->start(200ms);
+}
+
+void schwinn170bike::writeCharacteristic(QLowEnergyService *service, QLowEnergyCharacteristic characteristic,
+                                         uint8_t *data, uint8_t data_len, QString info, bool disable_log,
+                                         bool wait_for_response) {
+    QEventLoop loop;
+    QTimer timeout;
+    if (wait_for_response) {
+        connect(service, SIGNAL(characteristicChanged(QLowEnergyCharacteristic, QByteArray)), &loop, SLOT(quit()));
+        timeout.singleShot(300, &loop, SLOT(quit()));
+    } else {
+        connect(service, SIGNAL(characteristicWritten(QLowEnergyCharacteristic, QByteArray)), &loop, SLOT(quit()));
+        timeout.singleShot(300, &loop, SLOT(quit()));
+    }
+
+    service->writeCharacteristic(characteristic, QByteArray((const char *)data, data_len));
+
+    if (!disable_log)
+        debug(" >> " + QByteArray((const char *)data, data_len).toHex(' ') + " // " + info);
+
+    loop.exec();
+}
+
+void schwinn170bike::update() {
+    if (m_control->state() == QLowEnergyController::UnconnectedState) {
+
+        emit disconnected();
+        return;
+    }
+
+    if (initRequest) {
+
+        initRequest = false;
+    } else {
+
+        update_metrics(false, watts());
+
+        // updating the treadmill console every second
+        if (sec1Update++ == (500 / refresh->interval())) {
+
+            sec1Update = 0;
+            // updateDisplay(elapsed);
+        }
+
+        if (requestResistance != -1) {
+            if (requestResistance > max_resistance)
+                requestResistance = max_resistance;
+            else if (requestResistance == 0) {
+                requestResistance = 1;
+            }
+
+            if (requestResistance != currentResistance().value()) {
+                emit debug(QStringLiteral("writing resistance ") + QString::number(requestResistance));
+
+                // forceResistance(requestResistance);
+            }
+            requestResistance = -1;
+        }
+        if (requestStart != -1) {
+            emit debug(QStringLiteral("starting..."));
+
+            // btinit();
+
+            requestStart = -1;
+            emit bikeStarted();
+        }
+        if (requestStop != -1) {
+            emit debug(QStringLiteral("stopping..."));
+
+            // writeCharacteristic(initDataF0C800B8, sizeof(initDataF0C800B8), "stop tape");
+            requestStop = -1;
+        }
+    }
+}
+
+void schwinn170bike::serviceDiscovered(const QBluetoothUuid &gatt) {
+    emit debug(QStringLiteral("serviceDiscovered ") + gatt.toString());
+}
+
+void schwinn170bike::characteristicChanged(const QLowEnergyCharacteristic &characteristic, const QByteArray &newValue) {
+    double heart = 0.0;
+
+    // qDebug() << "characteristicChanged" << characteristic.uuid() << newValue << newValue.length();
+    Q_UNUSED(characteristic);
+    QSettings settings;
+    QString heartRateBeltName =
+        settings.value(QZSettings::heart_rate_belt_name, QZSettings::default_heart_rate_belt_name).toString();
+
+    qDebug() << QStringLiteral(" << ") << newValue.toHex(' ') << characteristic.uuid();
+
+    if (newValue.length() == 20) {
+        Resistance = newValue.at(18);
+
+        emit resistanceRead(Resistance.value());
+        return;
+    }
+
+    if (newValue.length() != 14)
+        return;
+
+    lastPacket = newValue;
+
+    m_watt = ((double)(((uint16_t)((uint8_t)newValue.at(7)) << 8) | (uint16_t)((uint8_t)newValue.at(6)))) / 100.0;
+    emit debug(QStringLiteral("Current Watt: ") + QString::number(m_watt.value()));
+
+    emit debug(QStringLiteral("Current Cadence: ") + QString::number(Cadence.value()));
+
+    if (!settings.value(QZSettings::speed_power_based, QZSettings::default_speed_power_based).toBool()) {
+        Speed = ((double)(((uint16_t)((uint8_t)newValue.at(4)) << 8) | (uint16_t)((uint8_t)newValue.at(3)))) / 100.0;
+    } else {
+        Speed = metric::calculateSpeedFromPower(
+            watts(), Inclination.value(), Speed.value(),
+            fabs(QDateTime::currentDateTime().msecsTo(Speed.lastChanged()) / 1000.0), this->speedLimit());
+    }
+    emit debug(QStringLiteral("Current Speed: ") + QString::number(Speed.value()));
+
+    Distance += ((Speed.value() / 3600000.0) *
+                 ((double)lastRefreshCharacteristicChanged.msecsTo(QDateTime::currentDateTime())));
+
+    emit debug(QStringLiteral("Current Distance: ") + QString::number(Distance.value()));
+
+    if (watts())
+        KCal += ((((0.048 * ((double)watts()) + 1.19) *
+                   settings.value(QZSettings::weight, QZSettings::default_weight).toFloat() * 3.5) /
+                  200.0) /
+                 (60000.0 / ((double)lastRefreshCharacteristicChanged.msecsTo(
+                                QDateTime::currentDateTime())))); //(( (0.048* Output in watts +1.19) * body weight in
+                                                                  // kg * 3.5) / 200 ) / 60
+
+    emit debug(QStringLiteral("Current KCal: ") + QString::number(KCal.value()));
+
+#ifdef Q_OS_ANDROID
+    if (settings.value(QZSettings::ant_heart, QZSettings::default_ant_heart).toBool())
+        Heart = (uint8_t)KeepAwakeHelper::heart();
+    else
+#endif
+    {
+    }
+
+    if (Cadence.value() > 0) {
+
+        CrankRevs++;
+        LastCrankEventTime += (uint16_t)(1024.0 / (((double)(Cadence.value())) / 60.0));
+    }
+
+    // if we change this, also change the wattsFromResistance function. We can create a standard function in order to
+    // have all the costants in one place (I WANT MORE TIME!!!)
+    double ac = 0.01243107769;
+    double bc = 1.145964912;
+    double cc = -23.50977444;
+
+    double ar = 0.1469553975;
+    double br = -5.841344538;
+    double cr = 97.62165482;
+
+    double res =
+        (((sqrt(pow(br, 2.0) -
+                4.0 * ar *
+                    (cr - (m_watt.value() * 132.0 / (ac * pow(Cadence.value(), 2.0) + bc * Cadence.value() + cc)))) -
+           br) /
+          (2.0 * ar)) *
+         settings.value(QZSettings::peloton_gain, QZSettings::default_peloton_gain).toDouble()) +
+        settings.value(QZSettings::peloton_offset, QZSettings::default_peloton_offset).toDouble();
+
+    double resistance;
+    if (isnan(res)) {
+        res = 0;
+    }
+    if (settings.value(QZSettings::schwinn_bike_resistance, QZSettings::default_schwinn_bike_resistance).toBool())
+        resistance = pelotonToBikeResistance(res);
+    else
+        resistance = res;
+    if (qFabs(resistance - Resistance.value()) >=
+        (double)settings.value(QZSettings::schwinn_resistance_smooth, QZSettings::default_schwinn_resistance_smooth)
+            .toInt()) {
+        m_pelotonResistance = res;
+    } else {
+        // to calculate correctly the averages
+        m_pelotonResistance = m_pelotonResistance.value();
+
+        qDebug() << QStringLiteral("resistance not updated cause to schwinn_resistance_smooth setting");
+    }
+
+    lastRefreshCharacteristicChanged = QDateTime::currentDateTime();
+
+    if (heartRateBeltName.startsWith(QStringLiteral("Disabled"))) {
+        if (heart == 0.0) {
+
+#ifdef Q_OS_IOS
+#ifndef IO_UNDER_QT
+            lockscreen h;
+            long appleWatchHeartRate = h.heartRate();
+            h.setKcal(KCal.value());
+            h.setDistance(Distance.value());
+            Heart = appleWatchHeartRate;
+            debug("Current Heart from Apple Watch: " + QString::number(appleWatchHeartRate));
+#endif
+#endif
+        } else {
+
+            Heart = heart;
+        }
+    }
+
+#ifdef Q_OS_IOS
+#ifndef IO_UNDER_QT
+    bool cadence = settings.value(QZSettings::bike_cadence_sensor, QZSettings::default_bike_cadence_sensor).toBool();
+    bool ios_peloton_workaround =
+        settings.value(QZSettings::ios_peloton_workaround, QZSettings::default_ios_peloton_workaround).toBool();
+    if (ios_peloton_workaround && cadence && h && firstStateChanged) {
+
+        h->virtualbike_setCadence(currentCrankRevolutions(), lastCrankEventTime());
+        h->virtualbike_setHeartRate((uint8_t)metrics_override_heartrate());
+    }
+#endif
+#endif
+
+    emit debug(QStringLiteral("Current Calculated Resistance: ") + QString::number(Resistance.value()));
+    emit debug(QStringLiteral("Current CrankRevs: ") + QString::number(CrankRevs));
+    emit debug(QStringLiteral("Last CrankEventTime: ") + QString::number(LastCrankEventTime));
+
+    if (m_control->error() != QLowEnergyController::NoError) {
+        qDebug() << QStringLiteral("QLowEnergyController ERROR!!") << m_control->errorString();
+    }
+}
+
+void schwinn170bike::stateChanged(QLowEnergyService::ServiceState state) {
+    QSettings settings;
+    QMetaEnum metaEnum = QMetaEnum::fromType<QLowEnergyService::ServiceState>();
+    emit debug(QStringLiteral("BTLE stateChanged ") + QString::fromLocal8Bit(metaEnum.valueToKey(state)));
+
+    for (QLowEnergyService *s : qAsConst(gattCommunicationChannelService)) {
+        qDebug() << QStringLiteral("stateChanged") << s->serviceUuid() << s->state();
+        if (s->state() != QLowEnergyService::ServiceDiscovered && s->state() != QLowEnergyService::InvalidService) {
+            qDebug() << QStringLiteral("not all services discovered");
+            return;
+        }
+    }
+
+    if (state != QLowEnergyService::ServiceState::ServiceDiscovered) {
+        qDebug() << QStringLiteral("ignoring this state");
+        return;
+    }
+
+    qDebug() << QStringLiteral("all services discovered!");
+
+    for (QLowEnergyService *s : qAsConst(gattCommunicationChannelService)) {
+        if (s->state() == QLowEnergyService::ServiceDiscovered) {
+            // establish hook into notifications
+            connect(s, &QLowEnergyService::characteristicChanged, this, &schwinn170bike::characteristicChanged);
+            connect(s, &QLowEnergyService::characteristicWritten, this, &schwinn170bike::characteristicWritten);
+            connect(s, &QLowEnergyService::characteristicRead, this, &schwinn170bike::characteristicRead);
+            connect(
+                s, static_cast<void (QLowEnergyService::*)(QLowEnergyService::ServiceError)>(&QLowEnergyService::error),
+                this, &schwinn170bike::errorService);
+            connect(s, &QLowEnergyService::descriptorWritten, this, &schwinn170bike::descriptorWritten);
+            connect(s, &QLowEnergyService::descriptorRead, this, &schwinn170bike::descriptorRead);
+
+            qDebug() << s->serviceUuid() << QStringLiteral("connected!");
+
+            auto characteristics_list = s->characteristics();
+            for (const QLowEnergyCharacteristic &c : qAsConst(characteristics_list)) {
+                qDebug() << QStringLiteral("char uuid") << c.uuid() << QStringLiteral("handle") << c.handle();
+                auto descriptors_list = c.descriptors();
+                for (const QLowEnergyDescriptor &d : qAsConst(descriptors_list)) {
+                    qDebug() << QStringLiteral("descriptor uuid") << d.uuid() << QStringLiteral("handle") << d.handle();
+                }
+
+                if ((c.properties() & QLowEnergyCharacteristic::Notify) == QLowEnergyCharacteristic::Notify) {
+                    QByteArray descriptor;
+                    descriptor.append((char)0x01);
+                    descriptor.append((char)0x00);
+                    if (c.descriptor(QBluetoothUuid::ClientCharacteristicConfiguration).isValid()) {
+                        s->writeDescriptor(c.descriptor(QBluetoothUuid::ClientCharacteristicConfiguration), descriptor);
+                    } else {
+                        qDebug() << QStringLiteral("ClientCharacteristicConfiguration") << c.uuid()
+                                 << c.descriptor(QBluetoothUuid::ClientCharacteristicConfiguration).uuid()
+                                 << c.descriptor(QBluetoothUuid::ClientCharacteristicConfiguration).handle()
+                                 << QStringLiteral(" is not valid");
+                    }
+
+                    qDebug() << s->serviceUuid() << c.uuid() << QStringLiteral("notification subscribed!");
+                } else if ((c.properties() & QLowEnergyCharacteristic::Indicate) ==
+                           QLowEnergyCharacteristic::Indicate) {
+                    QByteArray descriptor;
+                    descriptor.append((char)0x02);
+                    descriptor.append((char)0x00);
+                    if (c.descriptor(QBluetoothUuid::ClientCharacteristicConfiguration).isValid()) {
+                        s->writeDescriptor(c.descriptor(QBluetoothUuid::ClientCharacteristicConfiguration), descriptor);
+                    } else {
+                        qDebug() << QStringLiteral("ClientCharacteristicConfiguration") << c.uuid()
+                                 << c.descriptor(QBluetoothUuid::ClientCharacteristicConfiguration).uuid()
+                                 << c.descriptor(QBluetoothUuid::ClientCharacteristicConfiguration).handle()
+                                 << QStringLiteral(" is not valid");
+                    }
+
+                    qDebug() << s->serviceUuid() << c.uuid() << QStringLiteral("indication subscribed!");
+                } else if ((c.properties() & QLowEnergyCharacteristic::Read) == QLowEnergyCharacteristic::Read) {
+                    // s->readCharacteristic(c);
+                    // qDebug() << s->serviceUuid() << c.uuid() << "reading!";
+                } else if ((c.properties() & QLowEnergyCharacteristic::Write) == QLowEnergyCharacteristic::Write &&
+                           (c.uuid() == QBluetoothUuid(QStringLiteral("5ec4e520-9804-11e3-b4b9-0002a5d5c51b")) ||
+                            c.uuid() == QBluetoothUuid(QStringLiteral("1717b3c0-9803-11e3-90e1-0002a5d5c51b")))) {
+                    qDebug() << s->serviceUuid() << c.uuid() << "writing!";
+                    uint8_t init[] = {0x07, 0x01, 0xd3, 0x00, 0x1f, 0x05, 0x01};
+                    writeCharacteristic(s, c, init, sizeof(init), "init");
+                } else if ((c.properties() & QLowEnergyCharacteristic::WriteNoResponse) ==
+                           QLowEnergyCharacteristic::WriteNoResponse) {
+                    qDebug() << s->serviceUuid() << c.uuid() << "writing!";
+                    uint8_t init[] = {0x07, 0x01, 0xd3, 0x00, 0x1f, 0x05, 0x01};
+                    writeCharacteristic(s, c, init, sizeof(init), "init");
+                }
+            }
+        }
+    }
+
+    // ******************************************* virtual bike init *************************************
+    if (!firstStateChanged && !virtualBike
+#ifdef Q_OS_IOS
+#ifndef IO_UNDER_QT
+        && !h
+#endif
+#endif
+    ) {
+        QSettings settings;
+        bool virtual_device_enabled =
+            settings.value(QZSettings::virtual_device_enabled, QZSettings::default_virtual_device_enabled).toBool();
+#ifdef Q_OS_IOS
+#ifndef IO_UNDER_QT
+        bool cadence =
+            settings.value(QZSettings::bike_cadence_sensor, QZSettings::default_bike_cadence_sensor).toBool();
+        bool ios_peloton_workaround =
+            settings.value(QZSettings::ios_peloton_workaround, QZSettings::default_ios_peloton_workaround).toBool();
+        if (ios_peloton_workaround && cadence) {
+            qDebug() << "ios_peloton_workaround activated!";
+            h = new lockscreen();
+            h->virtualbike_ios();
+        } else
+#endif
+#endif
+            if (virtual_device_enabled) {
+            emit debug(QStringLiteral("creating virtual bike interface..."));
+            virtualBike =
+                new virtualbike(this, noWriteResistance, noHeartService, bikeResistanceOffset, bikeResistanceGain);
+            // connect(virtualBike,&virtualbike::debug ,this,&ftmsbike::debug);
+            connect(virtualBike, &virtualbike::changeInclination, this, &schwinn170bike::changeInclination);
+        }
+    }
+    firstStateChanged = 1;
+    // ********************************************************************************************************
+}
+
+void schwinn170bike::descriptorWritten(const QLowEnergyDescriptor &descriptor, const QByteArray &newValue) {
+    emit debug(QStringLiteral("descriptorWritten ") + descriptor.name() + QStringLiteral(" ") + newValue.toHex(' '));
+
+    initRequest = true;
+    emit connectedAndDiscovered();
+}
+
+void schwinn170bike::descriptorRead(const QLowEnergyDescriptor &descriptor, const QByteArray &newValue) {
+    qDebug() << QStringLiteral("descriptorRead ") << descriptor.name() << descriptor.uuid() << newValue.toHex(' ');
+}
+
+void schwinn170bike::characteristicWritten(const QLowEnergyCharacteristic &characteristic, const QByteArray &newValue) {
+
+    Q_UNUSED(characteristic);
+    emit debug(QStringLiteral("characteristicWritten ") + newValue.toHex(' '));
+}
+
+void schwinn170bike::characteristicRead(const QLowEnergyCharacteristic &characteristic, const QByteArray &newValue) {
+    qDebug() << QStringLiteral("characteristicRead ") << characteristic.uuid() << newValue.toHex(' ');
+}
+
+void schwinn170bike::serviceScanDone(void) {
+    emit debug(QStringLiteral("serviceScanDone"));
+
+    initRequest = false;
+    auto services_list = m_control->services();
+    for (const QBluetoothUuid &s : qAsConst(services_list)) {
+        gattCommunicationChannelService.append(m_control->createServiceObject(s));
+        connect(gattCommunicationChannelService.constLast(), &QLowEnergyService::stateChanged, this,
+                &schwinn170bike::stateChanged);
+        gattCommunicationChannelService.constLast()->discoverDetails();
+    }
+}
+
+void schwinn170bike::errorService(QLowEnergyService::ServiceError err) {
+
+    QMetaEnum metaEnum = QMetaEnum::fromType<QLowEnergyService::ServiceError>();
+    emit debug(QStringLiteral("schwinn170bike::errorService") + QString::fromLocal8Bit(metaEnum.valueToKey(err)) +
+               m_control->errorString());
+}
+
+void schwinn170bike::error(QLowEnergyController::Error err) {
+
+    QMetaEnum metaEnum = QMetaEnum::fromType<QLowEnergyController::Error>();
+    emit debug(QStringLiteral("schwinn170bike::error") + QString::fromLocal8Bit(metaEnum.valueToKey(err)) +
+               m_control->errorString());
+}
+
+void schwinn170bike::deviceDiscovered(const QBluetoothDeviceInfo &device) {
+    emit debug(QStringLiteral("Found new device: ") + device.name() + QStringLiteral(" (") +
+               device.address().toString() + ')');
+    {
+        bluetoothDevice = device;
+
+        m_control = QLowEnergyController::createCentral(bluetoothDevice, this);
+        connect(m_control, &QLowEnergyController::serviceDiscovered, this, &schwinn170bike::serviceDiscovered);
+        connect(m_control, &QLowEnergyController::discoveryFinished, this, &schwinn170bike::serviceScanDone);
+        connect(m_control,
+                static_cast<void (QLowEnergyController::*)(QLowEnergyController::Error)>(&QLowEnergyController::error),
+                this, &schwinn170bike::error);
+        connect(m_control, &QLowEnergyController::stateChanged, this, &schwinn170bike::controllerStateChanged);
+
+        connect(m_control,
+                static_cast<void (QLowEnergyController::*)(QLowEnergyController::Error)>(&QLowEnergyController::error),
+                this, [this](QLowEnergyController::Error error) {
+                    Q_UNUSED(error);
+                    Q_UNUSED(this);
+                    emit debug(QStringLiteral("Cannot connect to remote device."));
+                    emit disconnected();
+                });
+        connect(m_control, &QLowEnergyController::connected, this, [this]() {
+            Q_UNUSED(this);
+            emit debug(QStringLiteral("Controller connected. Search services..."));
+            m_control->discoverServices();
+        });
+        connect(m_control, &QLowEnergyController::disconnected, this, [this]() {
+            Q_UNUSED(this);
+            emit debug(QStringLiteral("LowEnergy controller disconnected"));
+            emit disconnected();
+        });
+
+        // Connect
+        m_control->connectToDevice();
+        return;
+    }
+}
+
+bool schwinn170bike::connected() {
+    if (!m_control) {
+
+        return false;
+    }
+    return m_control->state() == QLowEnergyController::DiscoveredState;
+}
+
+void *schwinn170bike::VirtualBike() { return virtualBike; }
+
+void *schwinn170bike::VirtualDevice() { return VirtualBike(); }
+
+uint16_t schwinn170bike::watts() {
+    if (currentCadence().value() == 0) {
+        return 0;
+    }
+
+    return m_watt.value();
+}
+
+void schwinn170bike::controllerStateChanged(QLowEnergyController::ControllerState state) {
+    qDebug() << QStringLiteral("controllerStateChanged") << state;
+    if (state == QLowEnergyController::UnconnectedState && m_control) {
+        qDebug() << QStringLiteral("trying to connect back again...");
+
+        initDone = false;
+        m_control->connectToDevice();
+    }
+}
+
+resistance_t schwinn170bike::pelotonToBikeResistance(int pelotonResistance) {
+    QSettings settings;
+    bool schwinn_bike_resistance_v2 =
+        settings.value(QZSettings::schwinn_bike_resistance_v2, QZSettings::default_schwinn_bike_resistance_v2).toBool();
+    if (!schwinn_bike_resistance_v2) {
+        if (pelotonResistance > 54)
+            return pelotonResistance;
+        if (pelotonResistance < 26)
+            return pelotonResistance / 5;
+
+        // y = 0,04x2 - 1,32x + 11,8
+        return ((0.04 * pow(pelotonResistance, 2)) - (1.32 * pelotonResistance) + 11.8);
+    } else {
+        if (pelotonResistance > 20)
+            return (((double)pelotonResistance - 20.0) * 1.25);
+        else
+            return 1;
+    }
+}
+
+uint16_t schwinn170bike::wattsFromResistance(double resistance) {
+    QSettings settings;
+
+    double ac = 0.01243107769;
+    double bc = 1.145964912;
+    double cc = -23.50977444;
+
+    double ar = 0.1469553975;
+    double br = -5.841344538;
+    double cr = 97.62165482;
+
+    for (uint16_t i = 1; i < 2000; i += 5) {
+        double res =
+            (((sqrt(pow(br, 2.0) -
+                    4.0 * ar *
+                        (cr - ((double)i * 132.0 / (ac * pow(Cadence.value(), 2.0) + bc * Cadence.value() + cc)))) -
+               br) /
+              (2.0 * ar)) *
+             settings.value(QZSettings::peloton_gain, QZSettings::default_peloton_gain).toDouble()) +
+            settings.value(QZSettings::peloton_offset, QZSettings::default_peloton_offset).toDouble();
+
+        if (!isnan(res) && res >= resistance) {
+            return i;
+        }
+    }
+
+    return 0;
+}
+
+void schwinn170bike::resistanceFromFTMSAccessory(resistance_t res) {
+    ResistanceFromFTMSAccessory = res;
+    qDebug() << QStringLiteral("resistanceFromFTMSAccessory") << res;
+}
+
+/*
+uint8_t schwinn170bike::resistanceFromPowerRequest(uint16_t power) {
+    qDebug() << QStringLiteral("resistanceFromPowerRequest") << Cadence.value() << power;
+
+if (Cadence.value() == 0)
+    return 1;
+
+for (int i = 1; i < max_resistance; i++) {
+    if (wattsFromResistance(i) <= power && wattsFromResistance(i + 1) >= power) {
+        resistance_t res = pelotonToBikeResistance(i);
+        qDebug() << QStringLiteral("resistanceFromPowerRequest") << wattsFromResistance(i)
+                 << wattsFromResistance(i + 1) << QStringLiteral("power=") << power << QStringLiteral("res=")
+                 << res;
+        // if the SS2K didn't send resistance at all or
+        // only if the resistance requested is higher and the current wattage is lower than the target
+        // only if the resistance requested is lower and the current wattage is higher than the target
+        // the main issue about schwinn is that the formula to get the wattage from the resistance is not so good
+        // so we need to put some constraint in the ERG mode
+        if (ResistanceFromFTMSAccessory.value() == 0 ||
+            ((power > m_watt.value() && res > (resistance_t)ResistanceFromFTMSAccessory.value()) ||
+             ((power < m_watt.value() && res < (resistance_t)ResistanceFromFTMSAccessory.value())))) {
+            return res;
+        } else {
+            if (power > m_watt.value())
+                return ResistanceFromFTMSAccessory.value() + 1;
+            else
+                return ResistanceFromFTMSAccessory.value() - 1;
+        }
+    }
+}
+if (power < wattsFromResistance(1))
+    return 1;
+else
+    return 1;
+}
+*/

src/schwinn170bike.h

@@ -0,0 +1,109 @@
+#ifndef SCHWINN170BIKE_H
+#define SCHWINN170BIKE_H
+
+#include <QtBluetooth/qlowenergyadvertisingdata.h>
+#include <QtBluetooth/qlowenergyadvertisingparameters.h>
+#include <QtBluetooth/qlowenergycharacteristic.h>
+#include <QtBluetooth/qlowenergycharacteristicdata.h>
+#include <QtBluetooth/qlowenergycontroller.h>
+#include <QtBluetooth/qlowenergydescriptordata.h>
+#include <QtBluetooth/qlowenergyservice.h>
+#include <QtBluetooth/qlowenergyservicedata.h>
+//#include <QtBluetooth/private/qlowenergycontrollerbase_p.h>
+//#include <QtBluetooth/private/qlowenergyserviceprivate_p.h>
+#include <QBluetoothDeviceDiscoveryAgent>
+#include <QtCore/qbytearray.h>
+
+#ifndef Q_OS_ANDROID
+#include <QtCore/qcoreapplication.h>
+#else
+#include <QtGui/qguiapplication.h>
+#endif
+#include <QtCore/qlist.h>
+#include <QtCore/qmutex.h>
+#include <QtCore/qscopedpointer.h>
+#include <QtCore/qtimer.h>
+
+#include <QDateTime>
+#include <QObject>
+#include <QString>
+
+#include "bike.h"
+#include "virtualbike.h"
+
+#ifdef Q_OS_IOS
+#include "ios/lockscreen.h"
+#endif
+
+class schwinn170bike : public bike {
+    Q_OBJECT
+  public:
+    schwinn170bike(bool noWriteResistance, bool noHeartService, uint8_t bikeResistanceOffset,
+                   double bikeResistanceGain);
+    resistance_t pelotonToBikeResistance(int pelotonResistance);
+    bool ergManagedBySS2K() { return true; }
+    resistance_t maxResistance() { return max_resistance; }
+    bool connected();
+
+    void *VirtualBike();
+    void *VirtualDevice();
+
+  private:
+    void writeCharacteristic(QLowEnergyService *service, QLowEnergyCharacteristic characteristic, uint8_t *data,
+                             uint8_t data_len, QString info, bool disable_log = false, bool wait_for_response = false);
+    uint16_t wattsFromResistance(double resistance);
+    void startDiscover();
+    uint16_t watts();
+
+    QTimer *refresh;
+    virtualbike *virtualBike = nullptr;
+
+    QList<QLowEnergyService *> gattCommunicationChannelService;
+
+    uint8_t sec1Update = 0;
+    QByteArray lastPacket;
+    QDateTime lastRefreshCharacteristicChanged = QDateTime::currentDateTime();
+    uint8_t firstStateChanged = 0;
+
+    bool initDone = false;
+    bool initRequest = false;
+
+    bool noWriteResistance = false;
+    bool noHeartService = false;
+
+    const resistance_t max_resistance = 100;
+    uint8_t bikeResistanceOffset = 4;
+    double bikeResistanceGain = 1.0;
+
+    metric ResistanceFromFTMSAccessory;
+
+#ifdef Q_OS_IOS
+    lockscreen *h = 0;
+#endif
+
+  signals:
+    void disconnected();
+    void debug(QString string);
+
+  public slots:
+    void deviceDiscovered(const QBluetoothDeviceInfo &device);
+    void resistanceFromFTMSAccessory(resistance_t res);
+
+  private slots:
+
+    void characteristicChanged(const QLowEnergyCharacteristic &characteristic, const QByteArray &newValue);
+    void characteristicWritten(const QLowEnergyCharacteristic &characteristic, const QByteArray &newValue);
+    void descriptorWritten(const QLowEnergyDescriptor &descriptor, const QByteArray &newValue);
+    void characteristicRead(const QLowEnergyCharacteristic &characteristic, const QByteArray &newValue);
+    void descriptorRead(const QLowEnergyDescriptor &descriptor, const QByteArray &newValue);
+    void stateChanged(QLowEnergyService::ServiceState state);
+    void controllerStateChanged(QLowEnergyController::ControllerState state);
+
+    void serviceDiscovered(const QBluetoothUuid &gatt);
+    void serviceScanDone(void);
+    void update();
+    void error(QLowEnergyController::Error err);
+    void errorService(QLowEnergyService::ServiceError);
+};
+
+#endif // SCHWINN170BIKE_H

src/settings.qml

@@ -741,6 +741,9 @@ import Qt.labs.settings 1.0
 
             // from version 2.13.18
             property bool gem_module_inclination: false
+
+            // from version 2.13.19
+            property bool treadmill_simulate_inclination_with_speed: false
         }
 
         function paddingZeros(text, limit) {
@@ -4599,6 +4602,33 @@ import Qt.labs.settings 1.0
                     color: Material.color(Material.Lime)
                 }
 
+                SwitchDelegate {
+                    text: qsTr("Simulate Inclinatin with Speed")
+                    spacing: 0
+                    bottomPadding: 0
+                    topPadding: 0
+                    rightPadding: 0
+                    leftPadding: 0
+                    clip: false
+                    checked: settings.treadmill_simulate_inclination_with_speed
+                    Layout.alignment: Qt.AlignLeft | Qt.AlignTop
+                    Layout.fillWidth: true
+                    onClicked: settings.treadmill_simulate_inclination_with_speed = checked
+                }
+
+                Label {
+                    text: qsTr("For treadmills without inclination: turning this on and QZ will transform inclination requests into speed changes.")
+                    font.bold: true
+                    font.italic: true
+                    font.pixelSize: 9
+                    textFormat: Text.PlainText
+                    wrapMode: Text.WordWrap
+                    verticalAlignment: Text.AlignVCenter
+                    Layout.alignment: Qt.AlignLeft | Qt.AlignTop
+                    Layout.fillWidth: true
+                    color: Material.color(Material.Lime)
+                }
+
                 Label {
                     text: qsTr("Expand the bars to the right to display the options under this setting. Select your specific model (if it is listed) and leave all other settings on default. If you encounter problems or have a question about settings for your specific equipment with QZ, click here to open a support ticket on GitHub or ask the QZ community on the QZ Facebook Group.")
                     font.bold: true
@@ -5309,7 +5339,7 @@ import Qt.labs.settings 1.0
                             Layout.alignment: Qt.AlignLeft | Qt.AlignTop
                             Layout.fillWidth: true
                             onClicked: settings.eslinker_costaway = checked
-                        }
+                        }                        
                     }
                 }
 

src/skandikawiribike.cpp

@@ -248,7 +248,7 @@ void skandikawiribike::characteristicChanged(const QLowEnergyCharacteristic &cha
     {
         if (heartRateBeltName.startsWith(QStringLiteral("Disabled"))) {
             if (X2000) {
-                Heart = convertHexToDec(newValue.at(8));
+                Heart = newValue.at(8);
             } else {
                 Heart = 0;
             }

src/trainprogram.cpp

@@ -8,6 +8,8 @@
 #include "androidactivityresultreceiver.h"
 #include "keepawakehelper.h"
 #include <QAndroidJniObject>
+#elif defined Q_OS_WIN
+#include "qtesseract.h"
 #endif
 
 using namespace std::chrono_literals;
@@ -443,9 +445,9 @@ void trainprogram::scheduler() {
         // in case no workout has been selected
         // Zwift OCR
 
-#ifdef Q_OS_ANDROID
         if (settings.value(QZSettings::zwift_ocr, QZSettings::default_zwift_ocr).toBool() && bluetoothManager &&
             bluetoothManager->device() && bluetoothManager->device()->deviceType() == bluetoothdevice::TREADMILL) {
+#ifdef Q_OS_ANDROID
             QAndroidJniObject text = QAndroidJniObject::callStaticObjectMethod<jstring>(
                 "org/cagnulen/qdomyoszwift/ScreenCaptureService", "getLastText");
             QString t = text.toString();
@@ -470,16 +472,19 @@ void trainprogram::scheduler() {
                         qDebug() << ss[0] << ss[1];
                         QString inc = ss[1].replace("Rect(", "").replace(")", "");
                         if (inc.split(",").length() > 2) {
+                            static int zwift_ocr_prev_inc = 0;
                             int w_minbound = w * 0.93;
                             int h_minbound = h * 0.08;
                             int h_maxbound = h * 0.15;
                             int x = inc.split(",").at(0).toInt();
                             int y = inc.split(",").at(2).toInt();
-                            qDebug() << x << w_minbound << h_maxbound << y << h_minbound;
+                            qDebug() << x << w_minbound << h_maxbound << y << h_minbound << zwift_ocr_prev_inc;
                             if (x > w_minbound && y < h_maxbound && y > h_minbound) {
                                 ss[0] = ss[0].replace("%", "");
                                 ss[0] = ss[0].replace("O", "0");
-                                bluetoothManager->device()->changeInclination(ss[0].toInt(), ss[0].toInt());
+                                if (zwift_ocr_prev_inc == ss[0].toInt())
+                                    bluetoothManager->device()->changeInclination(ss[0].toInt(), ss[0].toInt());
+                                zwift_ocr_prev_inc = ss[0].toInt();
                             }
                         }
                     }
@@ -489,8 +494,10 @@ void trainprogram::scheduler() {
                 qDebug() << QStringLiteral("ZWIFT OCR IGNORING") << packageName << t;
             }
         }
+#else
+            qtesseract::captureWindow();
+        }
 #endif
-
         return;
     }
 

src/treadmill.cpp

@@ -40,6 +40,8 @@ void treadmill::update_metrics(bool watt_calc, const double watts) {
     bool power_as_treadmill =
         settings.value(QZSettings::power_sensor_as_treadmill, QZSettings::default_power_sensor_as_treadmill).toBool();
 
+    simulateInclinationWithSpeed();
+
     if (settings.value(QZSettings::power_sensor_name, QZSettings::default_power_sensor_name)
                 .toString()
                 .startsWith(QStringLiteral("Disabled")) == false &&
@@ -93,7 +95,7 @@ uint16_t treadmill::wattsCalc(double weight, double speed, double inclination) {
     return watts;
 }
 
-uint16_t treadmill::watts(double weight) {    
+uint16_t treadmill::watts(double weight) {
     uint16_t watts = wattsCalc(weight, currentSpeed().value(), currentInclination().value());
     m_watt.setValue(watts);
     return m_watt.value();
@@ -190,8 +192,14 @@ double treadmill::treadmillInclinationOverrideReverse(double Inclination) {
 double treadmill::treadmillInclinationOverride(double Inclination) {
     QSettings settings;
 
-    double treadmill_inclination_ovveride_gain = settings.value(QZSettings::treadmill_inclination_ovveride_gain, QZSettings::default_treadmill_inclination_ovveride_gain).toDouble();
-    double treadmill_inclination_ovveride_offset = settings.value(QZSettings::treadmill_inclination_ovveride_offset, QZSettings::default_treadmill_inclination_ovveride_offset).toDouble();
+    double treadmill_inclination_ovveride_gain = settings
+                                                     .value(QZSettings::treadmill_inclination_ovveride_gain,
+                                                            QZSettings::default_treadmill_inclination_ovveride_gain)
+                                                     .toDouble();
+    double treadmill_inclination_ovveride_offset = settings
+                                                       .value(QZSettings::treadmill_inclination_ovveride_offset,
+                                                              QZSettings::default_treadmill_inclination_ovveride_offset)
+                                                       .toDouble();
 
     Inclination = Inclination * treadmill_inclination_ovveride_gain;
     Inclination = Inclination + treadmill_inclination_ovveride_offset;
@@ -353,3 +361,29 @@ void treadmill::cadenceFromAppleWatch() {
 #endif
 #endif
 }
+
+bool treadmill::simulateInclinationWithSpeed() {
+    QSettings settings;
+    bool treadmill_simulate_inclination_with_speed =
+        settings
+            .value(QZSettings::treadmill_simulate_inclination_with_speed,
+                   QZSettings::default_treadmill_simulate_inclination_with_speed)
+            .toBool();
+    double w = settings.value(QZSettings::weight, QZSettings::default_weight).toFloat();
+    if (treadmill_simulate_inclination_with_speed) {
+        if (requestInclination != -100) {
+            qDebug() << QStringLiteral("treadmill_simulate_inclination_with_speed enabled!") << requestInclination
+                     << requestSpeed << m_lastRawSpeedRequested;
+            if (requestSpeed != -1) {
+                requestSpeed =
+                    wattsCalc(w, requestSpeed, requestInclination) * requestSpeed / wattsCalc(w, requestSpeed, 0);
+            } else if (m_lastRawSpeedRequested != -1) {
+                requestSpeed = wattsCalc(w, m_lastRawSpeedRequested, requestInclination) * m_lastRawSpeedRequested /
+                               wattsCalc(w, m_lastRawSpeedRequested, 0);
+            }
+        }
+        requestInclination = -100;
+        return true;
+    }
+    return false;
+}

src/treadmill.h

@@ -72,6 +72,9 @@ class treadmill : public bluetoothdevice {
     double m_lastRawSpeedRequested = -1;
     double m_lastRawInclinationRequested = -100;
     bool instantaneousStrideLengthCMAvailableFromDevice = false;
+
+  private:
+    bool simulateInclinationWithSpeed();
 };
 
 #endif // TREADMILL_H

src/windows/leptonica/include/leptonica/alltypes.h

@@ -0,0 +1,68 @@
+/*====================================================================*
+ -  Copyright (C) 2001 Leptonica.  All rights reserved.
+ -
+ -  Redistribution and use in source and binary forms, with or without
+ -  modification, are permitted provided that the following conditions
+ -  are met:
+ -  1. Redistributions of source code must retain the above copyright
+ -     notice, this list of conditions and the following disclaimer.
+ -  2. Redistributions in binary form must reproduce the above
+ -     copyright notice, this list of conditions and the following
+ -     disclaimer in the documentation and/or other materials
+ -     provided with the distribution.
+ -
+ -  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ -  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ -  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ -  A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ANY
+ -  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ -  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ -  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ -  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ -  OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ -  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ -  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *====================================================================*/
+
+#ifndef  LEPTONICA_ALLTYPES_H
+#define  LEPTONICA_ALLTYPES_H
+
+    /* Standard */
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+
+    /* General and configuration defs */
+#include "endianness.h"
+#include "environ.h"
+
+    /* Generic and non-image-specific containers */
+#include "array.h"
+#include "bbuffer.h"
+#include "hashmap.h"
+#include "heap.h"
+#include "list.h"
+#include "ptra.h"
+#include "queue.h"
+#include "rbtree.h"
+#include "stack.h"
+
+    /* Imaging */
+#include "arrayaccess.h"
+#include "bmf.h"
+#include "ccbord.h"
+#include "colorfill.h"
+#include "dewarp.h"
+#include "gplot.h"
+#include "imageio.h"
+#include "jbclass.h"
+#include "morph.h"
+#include "pix.h"
+#include "recog.h"
+#include "regutils.h"
+#include "stringcode.h"
+#include "sudoku.h"
+#include "watershed.h"
+
+
+#endif /* LEPTONICA_ALLTYPES_H */

src/windows/leptonica/include/leptonica/array.h

@@ -0,0 +1,109 @@
+/*====================================================================*
+ -  Copyright (C) 2001 Leptonica.  All rights reserved.
+ -
+ -  Redistribution and use in source and binary forms, with or without
+ -  modification, are permitted provided that the following conditions
+ -  are met:
+ -  1. Redistributions of source code must retain the above copyright
+ -     notice, this list of conditions and the following disclaimer.
+ -  2. Redistributions in binary form must reproduce the above
+ -     copyright notice, this list of conditions and the following
+ -     disclaimer in the documentation and/or other materials
+ -     provided with the distribution.
+ -
+ -  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ -  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ -  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ -  A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ANY
+ -  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ -  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ -  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ -  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ -  OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ -  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ -  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *====================================================================*/
+
+#ifndef  LEPTONICA_ARRAY_H
+#define  LEPTONICA_ARRAY_H
+
+/*!
+ * \file array.h
+ *
+ * <pre>
+ *  This file has typedefs for the following array structs:
+ *      struct Numa          array of floats
+ *      struct Numaa
+ *      struct L_Dna         array of doubles
+ *      struct L_Dnaa
+ *      struct L_Dnahash
+ *      struct Sarray        array of C-strings
+ *      struct L_Bytea       array of bytes
+ *
+ *  It contains definitions for:
+ *      Numa interpolation flags
+ *      Numa border flags
+ *      Numa data type conversion to string
+ *
+ *  Here are the non-image-related arrays in leptonica:
+ *  * Numa, L_Dna, L_Ptra, Sarray:
+ *    These have most of the typical operations of vectors, such as add,
+ *    insert, remove and replace.
+ *  * Numaa, L_Dnaa, L_Ptraa:
+ *    These are arrays of float, double and generic pointer arrays.
+ *  * L_Bytea:
+ *    This is an array of bytes, analogous to a C++ string.
+ *  * L_Dnahash:
+ *    This is a simple hashing for integers, used in the jbig2 classifier.
+ * </pre>
+ */
+
+
+/*------------------------------------------------------------------------*
+ *                             Array Structs                              *
+ *------------------------------------------------------------------------*/
+    /*! Number array: an array of floats */
+typedef struct Numa  NUMA;
+
+    /*! Array of number arrays */
+typedef struct Numaa  NUMAA;
+
+    /*! Double number array: an array of doubles */
+typedef struct L_Dna  L_DNA;
+
+    /*! Array of double number arrays */
+typedef struct L_Dnaa  L_DNAA;
+
+    /*! Array of double number arrays, used as a simple hash */
+typedef struct L_DnaHash L_DNAHASH;
+
+    /*! String array: an array of C strings */
+typedef struct Sarray SARRAY;
+
+    /*! Byte array (analogous to C++ "string") */
+typedef struct L_Bytea L_BYTEA;
+
+
+/*------------------------------------------------------------------------*
+ *                              Array flags                               *
+ *------------------------------------------------------------------------*/
+/*! Numa Interpolation */
+enum {
+    L_LINEAR_INTERP = 1,        /*!< linear     */
+    L_QUADRATIC_INTERP = 2      /*!< quadratic  */
+};
+
+/*! Numa Border Adding */
+enum {
+    L_CONTINUED_BORDER = 1,    /*!< extended with same value                  */
+    L_SLOPE_BORDER = 2,        /*!< extended with constant normal derivative  */
+    L_MIRRORED_BORDER = 3      /*!< mirrored                                  */
+};
+
+/*! Numa Data Conversion */
+enum {
+    L_INTEGER_VALUE = 1,        /*!< convert to integer  */
+    L_FLOAT_VALUE = 2           /*!< convert to float    */
+};
+
+#endif  /* LEPTONICA_ARRAY_H */

src/windows/leptonica/include/leptonica/array_internal.h

@@ -0,0 +1,135 @@
+/*====================================================================*
+ -  Copyright (C) 2001 Leptonica.  All rights reserved.
+ -
+ -  Redistribution and use in source and binary forms, with or without
+ -  modification, are permitted provided that the following conditions
+ -  are met:
+ -  1. Redistributions of source code must retain the above copyright
+ -     notice, this list of conditions and the following disclaimer.
+ -  2. Redistributions in binary form must reproduce the above
+ -     copyright notice, this list of conditions and the following
+ -     disclaimer in the documentation and/or other materials
+ -     provided with the distribution.
+ -
+ -  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ -  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ -  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ -  A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ANY
+ -  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ -  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ -  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ -  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ -  OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ -  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ -  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *====================================================================*/
+
+#ifndef  LEPTONICA_ARRAY_INTERNAL_H
+#define  LEPTONICA_ARRAY_INTERNAL_H
+
+/*!
+ * \file array_internal.h
+ *
+ * <pre>
+ *  Contains the following structs:
+ *      struct Numa          array of floats
+ *      struct Numaa
+ *      struct L_Dna         array of doubles
+ *      struct L_Dnaa
+ *      struct L_Dnahash
+ *      struct Sarray        array of C-strings
+ *      struct L_Bytea       array of bytes
+ *
+ *  This file can be #included after allheaders.h in source files that
+ *  require direct access to the internal data fields in these structs.
+ *
+ *  Here are the non-image-related arrays in leptonica:
+ *  * Numa, L_Dna, L_Ptra, Sarray:
+ *    These have most of the typical operations of vectors, such as add,
+ *    insert, remove and replace.
+ *  * Numaa, L_Dnaa, L_Ptraa:
+ *    These are arrays of float, double and generic pointer arrays.
+ *  * L_Bytea:
+ *    This is an array of bytes, analogous to a C++ string.
+ *  * L_Dnahash:
+ *    This is a simple hashing for integers, used in the jbig2 classifier.
+ * </pre>
+ */
+
+
+/*------------------------------------------------------------------------*
+ *                             Array Structs                              *
+ *------------------------------------------------------------------------*/
+/*! Numa version for serialization */
+#define  NUMA_VERSION_NUMBER     1
+
+    /*! Number array: an array of floats */
+struct Numa
+{
+    l_int32          nalloc;    /*!< size of allocated number array      */
+    l_int32          n;         /*!< number of numbers saved             */
+    l_atomic         refcount;  /*!< reference count (1 if no clones)    */
+    l_float32        startx;    /*!< x value assigned to array[0]        */
+    l_float32        delx;      /*!< change in x value as i --> i + 1    */
+    l_float32       *array;     /*!< number array                        */
+};
+
+    /*! Array of number arrays */
+struct Numaa
+{
+    l_int32          nalloc;    /*!< size of allocated ptr array          */
+    l_int32          n;         /*!< number of Numa saved                 */
+    struct Numa    **numa;      /*!< array of Numa                        */
+};
+
+/*! Dna version for serialization */
+#define  DNA_VERSION_NUMBER     1
+
+    /*! Double number array: an array of doubles */
+struct L_Dna
+{
+    l_int32          nalloc;    /*!< size of allocated number array      */
+    l_int32          n;         /*!< number of numbers saved             */
+    l_atomic         refcount;  /*!< reference count (1 if no clones)    */
+    l_float64        startx;    /*!< x value assigned to array[0]        */
+    l_float64        delx;      /*!< change in x value as i --> i + 1    */
+    l_float64       *array;     /*!< number array                        */
+};
+
+    /*! Array of double number arrays */
+struct L_Dnaa
+{
+    l_int32          nalloc;    /*!< size of allocated ptr array          */
+    l_int32          n;         /*!< number of L_Dna saved                */
+    struct L_Dna   **dna;       /*!< array of L_Dna                       */
+};
+
+struct L_DnaHash
+{
+    l_int32          nbuckets;
+    l_int32          initsize;   /*!< initial size of each dna that is made  */
+    struct L_Dna   **dna;        /*!< array of L_Dna                       */
+};
+
+/*! Sarray version for serialization */
+#define  SARRAY_VERSION_NUMBER     1
+
+    /*! String array: an array of C strings */
+struct Sarray
+{
+    l_int32          nalloc;    /*!< size of allocated ptr array         */
+    l_int32          n;         /*!< number of strings allocated         */
+    l_atomic         refcount;  /*!< reference count (1 if no clones)    */
+    char           **array;     /*!< string array                        */
+};
+
+    /*! Byte array (analogous to C++ "string") */
+struct L_Bytea
+{
+    size_t           nalloc;    /*!< number of bytes allocated in data array  */
+    size_t           size;      /*!< number of bytes presently used           */
+    l_atomic         refcount;  /*!< reference count (1 if no clones)         */
+    l_uint8         *data;      /*!< data array                               */
+};
+
+#endif  /* LEPTONICA_ARRAY_INTERNAL_H */

src/windows/leptonica/include/leptonica/arrayaccess.h

@@ -0,0 +1,270 @@
+/*====================================================================*
+ -  Copyright (C) 2001 Leptonica.  All rights reserved.
+ -
+ -  Redistribution and use in source and binary forms, with or without
+ -  modification, are permitted provided that the following conditions
+ -  are met:
+ -  1. Redistributions of source code must retain the above copyright
+ -     notice, this list of conditions and the following disclaimer.
+ -  2. Redistributions in binary form must reproduce the above
+ -     copyright notice, this list of conditions and the following
+ -     disclaimer in the documentation and/or other materials
+ -     provided with the distribution.
+ -
+ -  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ -  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ -  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ -  A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ANY
+ -  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ -  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ -  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ -  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ -  OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ -  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ -  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *====================================================================*/
+
+#ifndef  LEPTONICA_ARRAY_ACCESS_H
+#define  LEPTONICA_ARRAY_ACCESS_H
+
+/*!
+ * \file arrayaccess.h
+ *
+ * <pre>
+ *  1, 2, 4, 8, 16 and 32 bit data access within an array of 32-bit words
+ *
+ *  This is used primarily to access 1, 2, 4, 8, 16 and 32 bit pixels
+ *  in a line of image data, represented as an array of 32-bit words.
+ *
+ *     pdata:  pointer to first 32-bit word in the array
+ *     n:      index of the pixel in the array
+ *
+ *  Function calls for these accessors are defined in arrayaccess.c.
+ *
+ *  However, for efficiency we use the inline macros for all accesses.
+ *  Even though the 2 and 4 bit set* accessors are more complicated,
+ *  they are about 10% faster than the function calls.
+ *
+ *  The 32 bit access is just a cast and ptr arithmetic.  We include
+ *  it so that the input ptr can be void*.
+ *
+ *  At the end of this file is code for invoking the function calls
+ *  instead of inlining.
+ *
+ *  The macro SET_DATA_BIT_VAL(pdata, n, val) is a bit slower than
+ *      if (val == 0)
+ *          CLEAR_DATA_BIT(pdata, n);
+ *      else
+ *          SET_DATA_BIT(pdata, n);
+ *
+ *  Some compilers complain when the SET macros are surrounded by
+ *  parentheses, because parens require an evaluation and it is not
+ *  defined for SET macros.  If SET_DATA_QBIT were defined as a
+ *  compound macro, in analogy to l_setDataQbit(), it requires
+ *  surrounding braces:
+ * \code
+ *     #define  SET_DATA_QBIT(pdata, n, val) \
+ *        {l_uint32 *_TEMP_WORD_PTR_; \
+ *         _TEMP_WORD_PTR_ = (l_uint32 *)(pdata) + ((n) >> 3); \
+ *         *_TEMP_WORD_PTR_ &= ~(0xf0000000 >> (4 * ((n) & 7))); \
+ *         *_TEMP_WORD_PTR_ |= (((val) & 15) << (28 - 4 * ((n) & 7)));}
+ * \endcode
+ *  but if used in an if/else
+ * \code
+ *      if (x)
+ *         SET_DATA_QBIT(...);
+ *      else
+ *         ...
+ * \endcode
+ *  the compiler sees
+ * \code
+ *      if (x)
+ *         {......};
+ *      else
+ *         ...
+ * \endcode
+ *  The semicolon comes after the brace and will not compile.
+ *  This can be fixed in the call by either omitting the semicolon
+ *  or requiring another set of braces around SET_DATA_QBIT(), but
+ *  both these options break compatibility with current code, and
+ *  require special attention by anyone using the macros.
+ *
+ *  There are (at least) two ways to fix this in the macro definitions,
+ *  suggested by Dave Bryan.
+ *  (1) Surround the braces in the macro above with
+ *         do {....} while(0)
+ *      Then the semicolon just terminates the expression.
+ *  (2) Reduce the blocks to a single expression; e.g,
+ *         *((l_uint32 *)(pdata) + ((n) >> 3)) = \
+ *           *((l_uint32 *)(pdata) + ((n) >> 3)) \
+ *           & ~(0xf0000000 >> (4 * ((n) & 7))) \
+ *           | (((val) & 15) << (28 - 4 * ((n) & 7)))
+ *      This appears to cause redundant computation, but the compiler
+ *      should evaluate the common subexpression only once.
+ *  All these methods have the same performance, giving about 300M
+ *  SET_DATA_QBIT operations per second on a fast 64 bit system.
+ *  Using the function calls instead of the macros results in about 250M
+ *  SET_DATA_QBIT operations per second, a performance hit of nearly 20%.
+ * </pre>
+ */
+
+#define  USE_INLINE_ACCESSORS    1
+
+#if USE_INLINE_ACCESSORS
+
+    /*=============================================================*/
+    /*                Faster: use in line accessors                */
+    /*=============================================================*/
+
+    /*--------------------------------------------------*
+     *                     1 bit access                 *
+     *--------------------------------------------------*/
+/*! 1 bit access - get */
+#define  GET_DATA_BIT(pdata, n) \
+    ((*((const l_uint32 *)(pdata) + ((n) >> 5)) >> (31 - ((n) & 31))) & 1)
+
+/*! 1 bit access - set */
+#define  SET_DATA_BIT(pdata, n) \
+    *((l_uint32 *)(pdata) + ((n) >> 5)) |= (0x80000000 >> ((n) & 31))
+
+/*! 1 bit access - clear */
+#define  CLEAR_DATA_BIT(pdata, n) \
+    *((l_uint32 *)(pdata) + ((n) >> 5)) &= ~(0x80000000 >> ((n) & 31))
+
+/*! 1 bit access - set value (0 or 1) */
+#define  SET_DATA_BIT_VAL(pdata, n, val) \
+     *((l_uint32 *)(pdata) + ((n) >> 5)) = \
+        ((*((l_uint32 *)(pdata) + ((n) >> 5)) \
+        & (~(0x80000000 >> ((n) & 31)))) \
+        | ((l_uint32)(val) << (31 - ((n) & 31))))
+
+    /*--------------------------------------------------*
+     *                     2 bit access                 *
+     *--------------------------------------------------*/
+/*! 2 bit access - get */
+#define  GET_DATA_DIBIT(pdata, n) \
+    ((*((const l_uint32 *)(pdata) + ((n) >> 4)) >> (2 * (15 - ((n) & 15)))) & 3)
+
+/*! 2 bit access - set value (0 ... 3) */
+#define  SET_DATA_DIBIT(pdata, n, val) \
+     *((l_uint32 *)(pdata) + ((n) >> 4)) = \
+        ((*((l_uint32 *)(pdata) + ((n) >> 4)) \
+        & (~(0xc0000000 >> (2 * ((n) & 15))))) \
+        | ((l_uint32)((val) & 3) << (30 - 2 * ((n) & 15))))
+
+/*! 2 bit access - clear */
+#define  CLEAR_DATA_DIBIT(pdata, n) \
+    *((l_uint32 *)(pdata) + ((n) >> 4)) &= ~(0xc0000000 >> (2 * ((n) & 15)))
+
+
+    /*--------------------------------------------------*
+     *                     4 bit access                 *
+     *--------------------------------------------------*/
+/*! 4 bit access - get */
+#define  GET_DATA_QBIT(pdata, n) \
+     ((*((const l_uint32 *)(pdata) + ((n) >> 3)) >> (4 * (7 - ((n) & 7)))) & 0xf)
+
+/*! 4 bit access - set value (0 ... 15) */
+#define  SET_DATA_QBIT(pdata, n, val) \
+     *((l_uint32 *)(pdata) + ((n) >> 3)) = \
+        ((*((l_uint32 *)(pdata) + ((n) >> 3)) \
+        & (~(0xf0000000 >> (4 * ((n) & 7))))) \
+        | ((l_uint32)((val) & 15) << (28 - 4 * ((n) & 7))))
+
+/*! 4 bit access - clear */
+#define  CLEAR_DATA_QBIT(pdata, n) \
+    *((l_uint32 *)(pdata) + ((n) >> 3)) &= ~(0xf0000000 >> (4 * ((n) & 7)))
+
+
+    /*--------------------------------------------------*
+     *                     8 bit access                 *
+     *--------------------------------------------------*/
+#ifdef  L_BIG_ENDIAN
+/*! 8 bit access - get */
+#define  GET_DATA_BYTE(pdata, n) \
+             (*((const l_uint8 *)(pdata) + (n)))
+#else  /* L_LITTLE_ENDIAN */
+/*! 8 bit access - get */
+#define  GET_DATA_BYTE(pdata, n) \
+             (*(l_uint8 *)((l_uintptr_t)((const l_uint8 *)(pdata) + (n)) ^ 3))
+#endif  /* L_BIG_ENDIAN */
+
+#ifdef  L_BIG_ENDIAN
+/*! 8 bit access - set value (0 ... 255) */
+#define  SET_DATA_BYTE(pdata, n, val) \
+             *((l_uint8 *)(pdata) + (n)) = (val)
+#else  /* L_LITTLE_ENDIAN */
+/*! 8 bit access - set value (0 ... 255) */
+#define  SET_DATA_BYTE(pdata, n, val) \
+             *(l_uint8 *)((l_uintptr_t)((l_uint8 *)(pdata) + (n)) ^ 3) = (val)
+#endif  /* L_BIG_ENDIAN */
+
+
+    /*--------------------------------------------------*
+     *                    16 bit access                 *
+     *--------------------------------------------------*/
+#ifdef  L_BIG_ENDIAN
+/*! 16 bit access - get */
+#define  GET_DATA_TWO_BYTES(pdata, n) \
+             (*((const l_uint16 *)(pdata) + (n)))
+#else  /* L_LITTLE_ENDIAN */
+/*! 16 bit access - get */
+#define  GET_DATA_TWO_BYTES(pdata, n) \
+             (*(l_uint16 *)((l_uintptr_t)((const l_uint16 *)(pdata) + (n)) ^ 2))
+#endif  /* L_BIG_ENDIAN */
+
+#ifdef  L_BIG_ENDIAN
+/*! 16 bit access - set value (0 ... 65535) */
+#define  SET_DATA_TWO_BYTES(pdata, n, val) \
+             *((l_uint16 *)(pdata) + (n)) = (val)
+#else  /* L_LITTLE_ENDIAN */
+/*! 16 bit access - set value (0 ... 65535) */
+#define  SET_DATA_TWO_BYTES(pdata, n, val) \
+             *(l_uint16 *)((l_uintptr_t)((l_uint16 *)(pdata) + (n)) ^ 2) = (val)
+#endif  /* L_BIG_ENDIAN */
+
+
+    /*--------------------------------------------------*
+     *                    32 bit access                 *
+     *--------------------------------------------------*/
+/*! 32 bit access - get */
+#define  GET_DATA_FOUR_BYTES(pdata, n) \
+             (*((const l_uint32 *)(pdata) + (n)))
+
+/*! 32 bit access - set (0 ... 4294967295) */
+#define  SET_DATA_FOUR_BYTES(pdata, n, val) \
+             *((l_uint32 *)(pdata) + (n)) = (val)
+
+
+#else
+
+    /*=============================================================*/
+    /*         Slower: use function calls for all accessors        */
+    /*=============================================================*/
+
+#define  GET_DATA_BIT(pdata, n)               l_getDataBit(pdata, n)
+#define  SET_DATA_BIT(pdata, n)               l_setDataBit(pdata, n)
+#define  CLEAR_DATA_BIT(pdata, n)             l_clearDataBit(pdata, n)
+#define  SET_DATA_BIT_VAL(pdata, n, val)      l_setDataBitVal(pdata, n, val)
+
+#define  GET_DATA_DIBIT(pdata, n)             l_getDataDibit(pdata, n)
+#define  SET_DATA_DIBIT(pdata, n, val)        l_setDataDibit(pdata, n, val)
+#define  CLEAR_DATA_DIBIT(pdata, n)           l_clearDataDibit(pdata, n)
+
+#define  GET_DATA_QBIT(pdata, n)              l_getDataQbit(pdata, n)
+#define  SET_DATA_QBIT(pdata, n, val)         l_setDataQbit(pdata, n, val)
+#define  CLEAR_DATA_QBIT(pdata, n)            l_clearDataQbit(pdata, n)
+
+#define  GET_DATA_BYTE(pdata, n)              l_getDataByte(pdata, n)
+#define  SET_DATA_BYTE(pdata, n, val)         l_setDataByte(pdata, n, val)
+
+#define  GET_DATA_TWO_BYTES(pdata, n)         l_getDataTwoBytes(pdata, n)
+#define  SET_DATA_TWO_BYTES(pdata, n, val)    l_setDataTwoBytes(pdata, n, val)
+
+#define  GET_DATA_FOUR_BYTES(pdata, n)         l_getDataFourBytes(pdata, n)
+#define  SET_DATA_FOUR_BYTES(pdata, n, val)    l_setDataFourBytes(pdata, n, val)
+
+#endif  /* USE_INLINE_ACCESSORS */
+
+
+#endif /* LEPTONICA_ARRAY_ACCESS_H */

src/windows/leptonica/include/leptonica/bbuffer.h

@@ -0,0 +1,60 @@
+/*====================================================================*
+ -  Copyright (C) 2001 Leptonica.  All rights reserved.
+ -
+ -  Redistribution and use in source and binary forms, with or without
+ -  modification, are permitted provided that the following conditions
+ -  are met:
+ -  1. Redistributions of source code must retain the above copyright
+ -     notice, this list of conditions and the following disclaimer.
+ -  2. Redistributions in binary form must reproduce the above
+ -     copyright notice, this list of conditions and the following
+ -     disclaimer in the documentation and/or other materials
+ -     provided with the distribution.
+ -
+ -  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ -  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ -  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ -  A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ANY
+ -  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ -  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ -  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ -  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ -  OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ -  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ -  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *====================================================================*/
+
+#ifndef  LEPTONICA_BBUFFER_H
+#define  LEPTONICA_BBUFFER_H
+
+/*!
+ * \file bbuffer.h
+ *
+ * <pre>
+ *      Expandable byte buffer for reading data in from memory and
+ *      writing data out to other memory.
+ *
+ *      This implements a queue of bytes, so data read in is put
+ *      on the "back" of the queue (i.e., the end of the byte array)
+ *      and data written out is taken from the "front" of the queue
+ *      (i.e., from an index marker "nwritten" that is initially set at
+ *      the beginning of the array.)  As usual with expandable
+ *      arrays, we keep the size of the allocated array and the
+ *      number of bytes that have been read into the array.
+ *
+ *      For implementation details, see bbuffer.c.
+ * </pre>
+ */
+
+/*! Expandable byte buffer for memory read/write operations */
+struct L_ByteBuffer
+{
+    l_int32      nalloc;       /*!< size of allocated byte array            */
+    l_int32      n;            /*!< number of bytes read into to the array  */
+    l_int32      nwritten;     /*!< number of bytes written from the array  */
+    l_uint8     *array;        /*!< byte array                              */
+};
+typedef struct L_ByteBuffer L_BBUFFER;
+
+
+#endif  /* LEPTONICA_BBUFFER_H */

src/windows/leptonica/include/leptonica/bilateral.h

@@ -0,0 +1,136 @@
+/*====================================================================*
+ -  Copyright (C) 2001 Leptonica.  All rights reserved.
+ -
+ -  Redistribution and use in source and binary forms, with or without
+ -  modification, are permitted provided that the following conditions
+ -  are met:
+ -  1. Redistributions of source code must retain the above copyright
+ -     notice, this list of conditions and the following disclaimer.
+ -  2. Redistributions in binary form must reproduce the above
+ -     copyright notice, this list of conditions and the following
+ -     disclaimer in the documentation and/or other materials
+ -     provided with the distribution.
+ -
+ -  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ -  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ -  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ -  A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ANY
+ -  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ -  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ -  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ -  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ -  OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ -  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ -  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *====================================================================*/
+
+#ifndef  LEPTONICA_BILATERAL_H
+#define  LEPTONICA_BILATERAL_H
+
+/*!
+ * \file bilateral.h
+ *
+ * <pre>
+ *  Contains the following struct
+ *      struct L_Bilateral
+ *
+ *
+ *  For a tutorial introduction to bilateral filters, which apply a
+ *  gaussian blur to smooth parts of the image while preserving edges, see
+ *    http://people.csail.mit.edu/sparis/bf_course/slides/03_definition_bf.pdf
+ *
+ *  We give an implementation of a bilateral filtering algorithm given in:
+ *    "Real-Time O(1) Bilateral Filtering," by Yang, Tan and Ahuja, CVPR 2009
+ *  which is at:
+ *    http://vision.ai.uiuc.edu/~qyang6/publications/cvpr-09-qingxiong-yang.pdf
+ *  This is based on an earlier algorithm by Sylvain Paris and Frédo Durand:
+ *    http://people.csail.mit.edu/sparis/publi/2006/eccv/
+ *               Paris_06_Fast_Approximation.pdf
+ *
+ *  The kernel of the filter is a product of a spatial gaussian and a
+ *  monotonically decreasing function of the difference in intensity
+ *  between the source pixel and the neighboring pixel.  The intensity
+ *  part of the filter gives higher influence for pixels with intensities
+ *  that are near to the source pixel, and the spatial part of the
+ *  filter gives higher weight to pixels that are near the source pixel.
+ *  This combination smooths in relatively uniform regions, while
+ *  maintaining edges.
+ *
+ *  The advantage of the appoach of Yang et al is that it is separable,
+ *  so the computation time is linear in the gaussian filter size.
+ *  Furthermore, it is possible to do much of the computation as a reduced
+ *  scale, which gives a good approximation to the full resolution version
+ *  but greatly speeds it up.
+ *
+ *  The bilateral filtered value at x is:
+ *
+ *            sum[y in N(x)]: spatial(|y - x|) * range(|I(x) - I(y)|) * I(y)
+ *    I'(x) = --------------------------------------------------------------
+ *            sum[y in N(x)]: spatial(|y - x|) * range(|I(x) - I(y)|)
+ *
+ *  where I() is the input image, I'() is the filtered image, N(x) is the
+ *  set of pixels around x in the filter support, and spatial() and range()
+ *  are gaussian functions:
+ *          spatial(x) = exp(-x^2 / (2 * s_s^2))
+ *          range(x) = exp(-x^2 / (2 * s_r^2))
+ *  and s_s and s_r and the standard deviations of the two gaussians.
+ *
+ *  Yang et al use a separable approximation to this, by defining a set
+ *  of related but separable functions J(k,x), that we call Principal
+ *  Bilateral Components (PBC):
+ *
+ *             sum[y in N(x)]: spatial(|y - x|) * range(|k - I(y)|) * I(y)
+ *    J(k,x) = -----------------------------------------------------------
+ *             sum[y in N(x)]: spatial(|y - x|) * range(|k - I(y)|)
+ *
+ *  which are computed quickly for a set of n values k[p], p = 0 ... n-1.
+ *  Then each output pixel is found using a linear interpolation:
+ *
+ *    I'(x) = (1 - q) * J(k[p],x) + q * J(k[p+1],x)
+ *
+ *  where J(k[p],x) and J(k[p+1],x) are PBC for which
+ *    k[p] <= I(x) and k[p+1] >= I(x), and
+ *    q = (I(x) - k[p]) / (k[p+1] - k[p]).
+ *
+ *  We can also subsample I(x), create subsampled versions of J(k,x),
+ *  which are then interpolated between for I'(x).
+ *
+ *  We generate 'pixsc', by optionally downscaling the input image
+ *  (using area mapping by the factor 'reduction'), and then adding
+ *  a mirrored border to avoid boundary cases.  This is then used
+ *  to compute 'ncomps' PBCs.
+ *
+ *  The 'spatial_stdev' is also downscaled by 'reduction'.  The size
+ *  of the 'spatial' array is 4 * (reduced 'spatial_stdev') + 1.
+ *  The size of the 'range' array is 256.
+ * </pre>
+ */
+
+
+/*------------------------------------------------------------------------*
+ *                          Bilateral filter                              *
+ *------------------------------------------------------------------------*/
+
+/*! Bilateral filter */
+struct L_Bilateral
+{
+    struct Pix     *pixs;           /*!< clone of source pix                 */
+    struct Pix     *pixsc;          /*!< downscaled pix with mirrored border */
+    l_int32         reduction;      /*!< 1, 2 or 4x for intermediates        */
+    l_float32       spatial_stdev;  /*!< stdev of spatial gaussian           */
+    l_float32       range_stdev;    /*!< stdev of range gaussian             */
+    l_float32      *spatial;        /*!< 1D gaussian spatial kernel          */
+    l_float32      *range;          /*!< one-sided gaussian range kernel     */
+    l_int32         minval;         /*!< min value in 8 bpp pix              */
+    l_int32         maxval;         /*!< max value in 8 bpp pix              */
+    l_int32         ncomps;         /*!< number of intermediate results      */
+    l_int32        *nc;             /*!< set of k values (size ncomps)       */
+    l_int32        *kindex;         /*!< mapping from intensity to lower k   */
+    l_float32      *kfract;         /*!< mapping from intensity to fract k   */
+    struct Pixa    *pixac;          /*!< intermediate result images (PBC)    */
+    l_uint32     ***lineset;        /*!< lineptrs for pixac                  */
+};
+typedef struct L_Bilateral  L_BILATERAL;
+
+
+#endif  /* LEPTONICA_BILATERAL_H */

src/windows/leptonica/include/leptonica/bmf.h

@@ -0,0 +1,64 @@
+/*====================================================================*
+ -  Copyright (C) 2001 Leptonica.  All rights reserved.
+ -
+ -  Redistribution and use in source and binary forms, with or without
+ -  modification, are permitted provided that the following conditions
+ -  are met:
+ -  1. Redistributions of source code must retain the above copyright
+ -     notice, this list of conditions and the following disclaimer.
+ -  2. Redistributions in binary form must reproduce the above
+ -     copyright notice, this list of conditions and the following
+ -     disclaimer in the documentation and/or other materials
+ -     provided with the distribution.
+ -
+ -  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ -  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ -  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ -  A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ANY
+ -  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ -  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ -  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ -  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ -  OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ -  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ -  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *====================================================================*/
+
+#ifndef  LEPTONICA_BMF_H
+#define  LEPTONICA_BMF_H
+
+/*!
+ * \file bmf.h
+ *
+ *     Simple data structure to hold bitmap fonts and related data
+ */
+
+    /*! Constants for deciding when text block is divided into paragraphs */
+/*! Split Text */
+enum {
+    SPLIT_ON_LEADING_WHITE = 1,    /*!< tab or space at beginning of line   */
+    SPLIT_ON_BLANK_LINE    = 2,    /*!< newline with optional white space   */
+    SPLIT_ON_BOTH          = 3     /*!< leading white space or newline      */
+};
+
+
+/*! Data structure to hold bitmap fonts and related data */
+struct L_Bmf
+{
+    struct Pixa  *pixa;        /*!< pixa of bitmaps for 93 characters        */
+    l_int32       size;        /*!< font size (in points at 300 ppi)         */
+    char         *directory;   /*!< directory containing font bitmaps        */
+    l_int32       baseline1;   /*!< baseline offset for ascii 33 - 57        */
+    l_int32       baseline2;   /*!< baseline offset for ascii 58 - 91        */
+    l_int32       baseline3;   /*!< baseline offset for ascii 93 - 126       */
+    l_int32       lineheight;  /*!< max height of line of chars              */
+    l_int32       kernwidth;   /*!< pixel dist between char bitmaps          */
+    l_int32       spacewidth;  /*!< pixel dist between word bitmaps          */
+    l_int32       vertlinesep; /*!< extra vertical space between text lines  */
+    l_int32      *fonttab;     /*!< table mapping ascii --> font index       */
+    l_int32      *baselinetab; /*!< table mapping ascii --> baseline offset  */
+    l_int32      *widthtab;    /*!< table mapping ascii --> char width       */
+};
+typedef struct L_Bmf L_BMF;
+
+#endif  /* LEPTONICA_BMF_H */

src/windows/leptonica/include/leptonica/bmfdata.h

@@ -0,0 +1,636 @@
+/*====================================================================*
+ -  Copyright (C) 2001 Leptonica.  All rights reserved.
+ -
+ -  Redistribution and use in source and binary forms, with or without
+ -  modification, are permitted provided that the following conditions
+ -  are met:
+ -  1. Redistributions of source code must retain the above copyright
+ -     notice, this list of conditions and the following disclaimer.
+ -  2. Redistributions in binary form must reproduce the above
+ -     copyright notice, this list of conditions and the following
+ -     disclaimer in the documentation and/or other materials
+ -     provided with the distribution.
+ -
+ -  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ -  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ -  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ -  A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ANY
+ -  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ -  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ -  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ -  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ -  OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ -  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ -  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *====================================================================*/
+
+/*!
+ * \file bmfdata.h
+ *
+ * <pre>
+ *  This file contains data for constructing the bitmap fonts.
+ *
+ *  The fontdata string holds all 9 sets of bitmap fonts in a base64
+ *  encoding of a pixacomp representation of the tiff compressed images.
+ *  It was generated by prog/genfonts and pasted in.  This allows
+ *  the use of the bitmap fonts for image labelling without accessing
+ *  stored versions of either the tiff images for each set, or the pixa
+ *  of the 95 printable character images that was derived from the tiff image.
+ *
+ *  In use, to get the bmf for a specific font size, from the encoded
+ *  string in this file, call
+ *      bmfCreate(NULL, fontsize);
+ * </pre>
+ */
+
+#ifndef  LEPTONICA_BMFDATA_H
+#define  LEPTONICA_BMFDATA_H
+
+#define  NUM_FONTS  9
+static const char  *inputfonts[] = {"chars-4.tif", "chars-6.tif",
+                                    "chars-8.tif", "chars-10.tif",
+                                    "chars-12.tif", "chars-14.tif",
+                                    "chars-16.tif", "chars-18.tif",
+                                    "chars-20.tif"};
+static const char  *outputfonts[] = {"chars-4.pa", "chars-6.pa",
+                                     "chars-8.pa", "chars-10.pa",
+                                     "chars-12.pa", "chars-14.pa",
+                                     "chars-16.pa", "chars-18.pa",
+                                     "chars-20.pa"};
+static const l_int32  baselines[NUM_FONTS][3] = {{11, 12, 12}, {18, 18, 18},
+                                                 {24, 24, 24}, {30, 30, 30},
+                                                 {36, 36, 36}, {42, 42, 42},
+                                                 {48, 48, 48}, {54, 54, 54},
+                                                 {60, 60, 60}};
+
+static const char  fontdata_4[] =
+    "SUkqACYFAAAmoHICP///////////////////////kFcchgc45Bgc45AgcgxBY5DY5DY5Agcg"
+    "jkM45A8GocgxBA8M45BfCGgchhzOQxZBiNe/CDQRT6RQ+k4QV6BHcgvBBjCC+KoSjQI7wjj/"
+    "16I+EUPTpV0rI4LilVtAjjyPuR58jg3CRd6dJkcDMCj+v//qlVsMgQPVY6vugih9Lr/8RCF+"
+    "OqUUK6C/fHFV9RStf8MulG10fKcN6X+lXOBg+GexX71wxSPCf4/+kE0uR5zE0rtfCFg3oIp0"
+    "R+GF5DSmQaMS/oG1xen0X2wyh8WXwoI46VPt/kNYcf9J4h/pUHB///2H+t+lkCByDj/r9ZBX"
+    "H1BAtUr7u/IEOQanrS0eByO16tpVaSWtaEVsNiG66WrBgg05wM4bCYNWDCWIiDCER6HGhERE"
+    "RER3ZHBfXjaSQ7iOP/////////////////////////////////////////////////////+Q"
+    "JgK95DIDRZAjCDccgRMhn4g5yC9CD0IL+QxhuIfCCYQTC4IJhBiyLBB7J4QX4gvQgxxBehBi"
+    "yGDkPhdkEw1kPZY5cEHck5BIJOQc9aI+wjE7DL7RdsMu2GXoZehGDYaDCDQaDSCDQdIOGEEX"
+    "bDLzCLthl5ojzkeL0NMJhNNbVoJ6kclXuggyOGfugnw3vugv/0u+9IN7pBvdJ//brT3VtdLy"
+    "B4NxyGsOPRnv9R7xx3/9L+EU/3/f4jj/t+3TdDvkFZyC7hYdKkCCKHQI76SW/pD/6XCKdAin"
+    "29L9L6/9eEUOrD0kv8IIMNKkq/j/zD5h+P4r//99LfBKcDR9utK62NLxEIIhnmGGlpek3Lz/"
+    "jj5cv/ul7f+EvimH///0l6CENpfrHt/y9l7kr/4RT/f7f+PwRTkG7/tpav26XtrxoVI5/vSx"
+    "xsP/7ful7fdd1tv/7FRoj//DLgQZgQCFhlYlfv1kx9//28mPx/7ruu3/t9K3pEh/IKzkF3DL"
+    "g2BENDtBr9Jh4S12H/+3+17GwwltpbZBx0u0unr0v9IMjhrBYYpO0KZmDikMJsYTCDCeE2Gh"
+    "p6DTdiEE2KCdo8GcNj3pJsJofjiIiIiIiIiI4iIiIiIhhCIiIiIiIr1SMwyQbOkEiGQCvd4i"
+    "I//////////////////////////////////////////////////////+QVo7IEDkGwchpOQV"
+    "nIa0ENKCGhyC7kHchocgZschnHIMPtKk7oIP7ulv6f9Yj5DIDaH/3gjjr///+rI4aiIEXngg"
+    "RZBfCBEWQXsofKggu5DD5Y+Qw5UHghiCoIEYQw5VkCMIO5TkF7shhzOQxZ4IJZxy3IO5nIJZ"
+    "4IP//1iiPOGd0R+iPQgR3TQIIXZ3/S7BBnezui87MOiPbKHRHqftNNXvTTUjy/9JkcFjTpOk"
+    "9NsKmFTu+Etppw06VtMjhhO0OLCd3S+rSdIUvyDD+Iha8fQ//+K//3/+D/vbQRT7d9LsjhgI"
+    "7nH8Ivf/lw0bS/4RT////7f//pfq+lhr6/v/Yf/t//3/+D/sO2NNhpfiP66Xat8L/2//3S0r"
+    "XIMD/rvUEd9Isf/4Mp5wCDgYBlOzgO0fB3aem2mmnYTtipwCAZQ6DnAXDgynapwk20h/+IiI"
+    "iIy9ERxEREREZHDLiIiIiIjjj6kNWdP//qP/pMjhq8bSXwojsGkEwmliIiP/////////////"
+    "/////////////////////////wAQAQ4AAAEDAAEAAACSAwAAAQEDAAEAAAA2AgAAAgEDAAEA"
+    "AAABAAAAAwEDAAEAAAAEAAAABgEDAAEAAAABAAAAEQEEAAEAAAAIAAAAEgEDAAEAAAABAAAA"
+    "FQEDAAEAAAABAAAAFgEDAAEAAAA2AgAAFwEEAAEAAAAeBQAAGgEFAAEAAADUBQAAGwEFAAEA"
+    "AADcBQAAHAEDAAEAAAABAAAAKAEDAAEAAAACAAAAAAAAAAAAwBIAAAQAAADAEgAABAA=";
+
+static const char  fontdata_6[] =
+    "SUkqAMoGAAAmoHVf///////////////////////////////IZAUfsgeBdyGdyDjkMgI+QPKC"
+    "GIO5AhzOgyGiCMcgYtUrIKHohowhschs4hnwgXcgRQhsgguQQXwhov6/QYQI7qgRUUk2QIfV"
+    "F5hQmmugqCMTCBHj/9F8j9JuknWm7rSbCBFPLtou2sjhlBSOKkE3Qf3+kv9fpcMQaXY9PTwR"
+    "T6WvpX/0v19aVbeQ0D6X7+v/X//QIQfj6xSS4QLS3xx69IVtL/EQy8CvbSqhq4I7//pJeVnT"
+    "Dr/+Niloufj9fpJLxalYrDtdr2DGk/etf6CDrkduzQkw21/w2prRfYZcNbj1+kQMQuL03hF5"
+    "sQRT+CEMMj7pAjuk/5DVDINfr+k9b06Stj+GXgW6pN9/kNsdL/XQg/+nSx/0v20vxSv0v/S3"
+    "/yDA/19sV/6WkQ0D5DY/6+lkDyf/SX9h65BRBDTdJ/StLILuk2lWkl399U2kw0Thpa0r7S0U"
+    "A7S20rSVtJL/iGrFMSPJv+qYoEaA+KBA4pikmKCWIiDVCINaQ0KiIiIiIoFhoRfSodbS1xbp"
+    "Id0hx8f///////////////////////////////////////////////////IHMFnMgTA0hyGQ"
+    "G45DLcg0jkQfyGQDNxBv5DLcg3QQ2EEHDIEaEHDIaDkMTJzIeZBJkEmTwh5kNmEPhB7ITCGi"
+    "ZDOghsmQ0IIbJhHUEMzPAh8jYOeIuRsEZFHCZEHBDhdoww1DLm0bOGXGwZccGXHCMDgwQMED"
+    "BAwQMEi4ZwQdAg2GEEbYYZc2EbYYZcwwjB5dmDgwQMIMJoNbQNqHuRxF6I7YQIN+6BBrDf+E"
+    "E//pf3oEG9tAg3vC9//126bQWlXh0gyODd+l7fXwv/0u1gio0m90m916x9uu60nXXyB4G7kN"
+    "tx6JwU9oEU/4944qP/pcEU8EU+37f7f4j/q6q2tpDXhYaShBBDer1XfJD5IdL/0vtf9L9L//"
+    "ergin9JukvIHk5BiAggw+kn1fSr///9L3r2/fS30of9r1exWqXp4QQYaWl9XH/a2vH+l9/t/"
+    "6X58mgN//r07dJe04QRDYGGGgvpVeXb/jj5gT8X7r7f+CX6CDD/bp6bXY/xEIIQw16Xq8N/y"
+    "5ZcvT/Lp/de3/j+2QMd/r/p0l6CDdf0h73//ZF7/w37r99/fuD/vVq9SP3S9hpd+lLj/6444"
+    "a/9v7r39L0tt/7Xq9b0vDDIbAwQQu2ElKHq/fr3f/2/dfb39/b/V6jjSb1Io/hhiEFbEECFK"
+    "r/euRR+//28ivxXt913XZBcf/jaevr8geTkCHDDCCIF3bEk9XpN6X7f/7f7+xtpbaW+l2l9K"
+    "3pfpqGGEErBhJfCTBk4wl+wf/7f9fsMJba7cMJbDSa9JvSX2sPCwxCQYQaFBikIQQwQMMYIG"
+    "CBggeCBsNCgg3CBhBuGKBA2KBA24hAgbFdOlYIGh+NCIiIiIiIiI4iIiIhxEGCERERERER9L"
+    "GHfVBF0Tgtg0dSBoDTYk+h40PiP/////////////////////////////////////////////"
+    "//////5A887IHkOQbLIE8EFaCGvBBmsgosgaDcg3HIbHwaIbIvVVIZTkGHVUtv9IOHRHBU+D"
+    "g5DJBx//QRTr69fr/+3X+I+v/pa//v/9N0Q2XnshsshsjIaMyGjMhlOQIHycZAhyDUOQy+IZ"
+    "xzWQUWUOQYc7kGMyGdyTkH41kH4scnZB4JwQxhrIYp/64hF56DCLzBF4aLzQNF8+DyuCguuF"
+    "Kw/ApXIvMFTCI7FhU0XmgYUL/ap0tow3/6TdN2XCTpB0rVJqJHmHD6BYbNhoDEjzSbDDLhJo"
+    "NnHSdQ4cMJoMJQ0DpBphVC//x9v/ScMEkwqf9Lpp6dJum18cQwX3V9XXWv/pN9OkKX/9f6X1"
+    "1/TpdX+6umrDdRSS2yBGFv4iQZu/9D//4r//f/58CP3XI/p7pL9F9peEYv/zAF8NL/hFP///"
+    "/t/utrrutN6SQYr0F//7Ff+3////g3/11dJ+l+I/+ld7ey4KP+3//fpX5DOOD/3sb8j+6X/9"
+    "en1+v/b//dLr//Vuo0rY0ib//aphKGYdtAinbLfROC//Yf/8NKGEmwvaUOwvtK3SX/7DPcUG"
+    "NjhsUEHhBwwg8JuEGEGEHDCDhhiopiCKcIOKeJHTd8JNuh/+IiIiIsubERxEREREZcNKIiIi"
+    "IiNDj+En/X/IbQdf/+Cj/9Npd6SXq3WLDSrwSEdigkEGCDrEREf/////////////////////"
+    "///////4AIAIAA4AAAEDAAEAAABBBAAAAQEDAAEAAAA6AgAAAgEDAAEAAAABAAAAAwEDAAEA"
+    "AAAEAAAABgEDAAEAAAABAAAAEQEEAAEAAAAIAAAAEgEDAAEAAAABAAAAFQEDAAEAAAABAAAA"
+    "FgEDAAEAAAA6AgAAFwEEAAEAAADBBgAAGgEFAAEAAAB4BwAAGwEFAAEAAACABwAAHAEDAAEA"
+    "AAABAAAAKAEDAAEAAAACAAAAAAAAAAAAwBIAAAQAAADAEgAABAA=";
+
+static const char  fontdata_8[] =
+    "SUkqALIIAAAmoHcGf/////////////////////////////////kMgMsfUgeDaOQLjkHHIZAN"
+    "T5A8K5AiDQQ0OW7kMqCEHIZthNJkcMwuGQG8g34gYcgo8go4hmwQIDIGIIL1EGOIKO1/wRmG"
+    "cvBqEX3S3dBGJhUwmlQSpGINF2/9cIxkfa9U+k2Q2OlpNgqaNzWwgWk2k33Veluk2q6STadJ"
+    "U2jHlzcJtZcGlS4RJOt9f9f9L62GMw+vC0np5HXS/0n/6Vf9dapwxpdj7rr6Wl/f//v9dJLa"
+    "kG76X/XXpf//v/j62kl4I2i4ZVd8caX8UrS/xEgvV7aVMUP19f615+S7/6BmGXBh70tK21ev"
+    "60lxefkmGla/8WxVZM9Y31/RDYOEl5uappMV/1sGKhNfYX/1EOuEHiR57DbXfUMOieIxwZgN"
+    "vjpfrI7a9XQdJF9sSOv+QL+qLzSt//9IW6x6tUg21+Q2qpHnS3Tf5BtTkNSi/06710rYpeDM"
+    "MuBi6pNq3+QZX6/S0J8DHdUn8f+v3S/Fb9L/63r8hnH9f26/rS0sgXj9fXpV+vuP9X9Igofy"
+    "DD1el6WQPCR/pL+w7XIZUEGx660nS3V0vSrv/qm0m2UBr61T7S0dAd13XSTdBL+r0l6YYX+t"
+    "JtK1hhK7CTDCSthJLpeIpIMUGJHaf9rYohsQsQiBhDEIMQtiECCxESCjKESKPdDQqIiIiIig"
+    "sGhF1Wh16pfbSSrFtKh3odkcHWI/////////////////////////////////////////////"
+    "////5A7AyfkDqG265DJBRxDKmQanIZWpDKDIOnIaBhB05BQGQwgkcgiCCIIIglxBEEG/kGPI"
+    "J5DzIN6EG+pDKoQ2akDFCGBBBDkdCCUI5kE8iuRfIPxCwCZBHIYGMFhMI2w8M42COFBnCDIN"
+    "7JWQz2SsEcKQzwDBENEENkENkQRDRANwQNgwQRthhnDYRthgzZhhGG5cjZQYIGXDOCBhNYYW"
+    "k2rMBNcu2ECBhptBtAgdoGHQPQdFwTv+l6T4QIGG0Gwi4UOg2gg0777dNXg2gg9Qq+m0g37p"
+    "eG/8Jf/pd96Cb7Sb9f//1pvbS0vV0rT9L3/0v/0vWCKjV91fdJ//dK/0n1Xx6eXX0vvHGv/0"
+    "uXTkde9Jv0m//6+/T20rSevIZCggrxpErPFpX+O36j/6C/X2//7/Ecf95dUnSdIUvCsNLCCC"
+    "I6vvpL+RR8ij//pe3++lfpev+2l1ffdJeQPCOQ0OEEw9Un6+q3/0v/S/S9v/S/q//tfYp1S9"
+    "NMIIMNKkq1uwS////0vb/b9+t9KZg0fdL3Wm0v/CCDBpdfvF/wwsMLx/pfpff+Evz+ygMr9+"
+    "ldPdJe00EEQbpww0tV0rmDf8cfNhfxD9/2/8/foEw//f/Y0vEQQQgw6+l3wb/mB5gfoP8wn9"
+    "pe/+P4bBv90vfvS9Ag2l10lff++//7fv+3/3+Qau/vtK0kXTaX6bq9ePe9L/shZ/+39pfff/"
+    "th/3S9/+vhhL/SkcJ//HHBr/2/f9v0vS23/vdL0m9LwwwgmRwb20R1SW/f/d//b+0vff2/b/"
+    "3r70m9LwwyDdOEENsHpHH3+9LIUfv/9vIUff9vuvryGcf9dY2KX1IUfwYMQgnFik0r1b0v2/"
+    "/2++K+9tLbXbuu+Oum9L8geEchogMMEEQzXbFBb9N6Wvf/7f7+xvX1t6+k0+k/X6ahhhAk2G"
+    "kt6TZDj4S/b//b0v92GEttLb0tgwvTS3pL/QbQWGDBL7CQYMFTCVhbDBrffbaYW2r3YYSthh"
+    "K7gwguKr0m9Jfaw8JoMQgQYIMIQgxCQhAhkHQGIRBhBI5BEZBhAYaGCB4IGQSmGIRBugMQiG"
+    "hDDiiCg4YT+EoZDOhD8aERERERERERxERERDiIMIRERERERH1xb+qQfpJBF2UAZhn9EDUFTK"
+    "B7xoQYSB7Qjj/////////////////////////////////////////////////kDxf7IHgQOQ"
+    "VbIH1kCSyCrZA8cEMyCBqHcgYcgYfIHh7IF4TChVCkM1yGhwoVe+loHBwi8gdNMOHS2/tL6H"
+    "/yGSCkP/6BFOvrtNeE//Sv9cR+v/p1////W6////p1zZkNnZAv2bCDcchsHyLGQ2DmwnZAuO"
+    "bCBfiBcc3EGochoHNBAjsg3HIQcguOSHLHLHIJMm5LiC7kMocmOWOWOQXciv/62JDZPQZBv5"
+    "DYhF5z4Zy8yr0yDGEGM1yDGJoMgxyYRiDIEYmQboIYxNF2HPg8lkaH6hMjhDjQ//p0Xb0XmE"
+    "YmEYcJNhNJj0Xn+gtUXqL3ReaQbVF5ou1qk4TVQwgYQYWDCDoIMIMKXH/9bSbig6CDoIOlyO"
+    "jAbFVthw+gsG4qwbbSsGKDYQQcMSPJRSBwd6dPbSfpL/6f6tdXqx1YVf6XTCevem168GYDR9"
+    "fSutLS/9WxeuqrV/9/wl/7pXXXQ/91p7pXjSW5DRhFH+sLuor///6C//33X4P91bl1pjdJKt"
+    "hovBr4iQPKn/x/X/F////7NAz/v0tavW9aYaXhG3/+YDM2l/zCf///+3+9e3TvSTeglDFegv"
+    "//bS/9v//+vw3/q3Wt6pf0PpfV3+xX/t//3635DNv9utb0R9t1X4/+vreyOGZ/2//+uvyGx3"
+    "/16elvVIjH//Xp3/X/2//3X3//WKjjSeNb/+10rtWyMfX/2//7q0rX6u1d2kraSr/3RdYaTD"
+    "LdsIv2GvJAZ/+w//2GErCCbCLr2EoNiR161b0l/9g0HI6FBimKg2KCB2CBwwQPBA2wQMEDBA"
+    "4MEDhhiFFBisETgwITTCg2vCTDaQ//ERERERZg2IjiIiIiIzAa8REREREccfwgg/9f6X+v+Q"
+    "ZK///0x/+m0sF0q9W0sW6XyGSGkOkI7YSr4rYhAkEGCDrFhCI4//////////////////////"
+    "///////////8AEAEDgAAAQMAAQAAAP8EAAABAQMAAQAAAFUCAAACAQMAAQAAAAEAAAADAQMA"
+    "AQAAAAQAAAAGAQMAAQAAAAEAAAARAQQAAQAAAAgAAAASAQMAAQAAAAEAAAAVAQMAAQAAAAEA"
+    "AAAWAQMAAQAAAFUCAAAXAQQAAQAAAKoIAAAaAQUAAQAAAGAJAAAbAQUAAQAAAGgJAAAcAQMA"
+    "AQAAAAEAAAAoAQMAAQAAAAIAAAAAAAAAAADAEgAABAAAAMASAAAEAA==";
+
+static const char  fontdata_10[] =
+    "SUkqAGwKAAAmoFQGz///////////////////////////5DIBocgZg0PkDwy3JvkFdyB4Qchl"
+    "DkGB7yB5OnZBQ5J8hmckQ0rBNUyDSOkQWnIZXkMqZBrghs0INDkM/kdkDfsLqqhGYKDEHp0k"
+    "G0HkFEwoQaaqCcWQzzCMMPXfwg0m0gi89KyCgekkYmCpppYQKgjc0m//0Yy8/16VtP0EGwqN"
+    "to22ugtBBtJv2vpLdJtJJ1SbTpJKwjnoOgg2swGmFLgiStb3+lXf/69v1bYLpuuR1pLVX//X"
+    "r/S60mwYorKXH/dfS69J/2vX/9UvYyGU699PXXpa/3//4+l1S2EcXqvXHX1qr/8RIMCP17SS"
+    "pwggnqvj1XpClpf1+3SWlS2l/v6S+btbr/IKbknv62KH2Fel/VJeEGlTDS/1W9tJKiGL8f/1"
+    "Sri83qxVr/sQ2K1JBpXel/RAuOFXm29On//YMUk/dhf+qEOuEHQtWG2v+w9GEwZuXj1/Uuw1"
+    "6bnzaSDtF1/wbSI+Sdx/X9IQ6WPCb0YbYr38MvvCMTVv8gqlyGsR/pX/ukkHaS8gqiMOkk2l"
+    "f/pfpOlvXSTYa/9/b2/yBO9f9cTQMzuu4/RBSgnHpJe2l+KX6Wv6ST1j//7f/2lpdf/pfkM8"
+    "el+xVr0/pEMofIZV16+v//9tda/pdZAh1vS+sge4/0kv3fyGbBBVeutK126dLtJLuq+ttJuH"
+    "+FTV/SOR19dJPSWqr6SX2gyx+ur7S0LbS20n/oJf8PS20mwjeNtf0noINYMJBBwwk2kk2kEF"
+    "texFJBiExCYXXTWwwkCBrEIEDimGEErDCQILERBgsQwgafFRSDEIRDCEMIMUIYhQWQyAaHER"
+    "bSrERER/0q90tfukqxbWh3odtLbSxH//////////////////////////////////////////"
+    "////yBTDMpkFsFhyB4YOQyAboILYFByB4hyB4vkMgCIK4iOQsFWQ07IZxyBEeQyQ1PINNLIZ"
+    "icEDIMeWcgoBkFy4IGQIIIoZByCDhkHIInkMEEDFCGyhBJkFzggyDcYCDINxgQMgwoIIGRDk"
+    "EIIp0O0MhjrIPyZDCj0GCD4aOEHEN3CPDDaDTQaapp6bwjxByc2EeIOTmGEcbw1TTT7ppJ1U"
+    "4B46aPGGmQabJeECIJZDPZEmDNhIM2JQIHBggwQMEDBAwSBAwQNo4DdkCHQIGyCiw2gQNkFF"
+    "htBB5cZwWGCIMOGCBhBglBggdBA6U2Ca5c2EbDvwbSayCZh8Ogg+/6C329JvbSb3SD777/q3"
+    "TdQq9INoIN/oL2/9J//S7W9IN9pBvv//tJ720m0tL/SbT3X2/9L/9L+XXSvdK90v//1p0nrS"
+    "+npuXX0vb66X/9Ll0176b/b///eu++1/yGQxyBwOOk63+++ONV/6X8uu3r+l/iOP2t6uk9Cl"
+    "4WHqR8e7r6SH/Uf/S+19v3/f/96dGF7q0kvCw0qCBAn6vpff//pe9e39/3pX/a9XTaTql5A9"
+    "wQ2QEmHWgmKer6X8iPkR1/9L7X30vSS///991bpL1TCCDBpKv76Vb/9f+l719+/W+lD/erXW"
+    "K0v7wggw0qS9K4YIL////QX3+3/pfpMoBq/a9XTTapfWCCIFy4MNL694g/44+P9fdL2/8Jfn"
+    "mzoGZ96dX+6S92ggsMNLS9bmyD///i/v9v/P/6BMP+/r22KS8RCBCGGl+teDf84POD82DH79"
+    "1//5HDL+Gw3+6/a/XhBBhpddK+/9PT//N7/r2/8b9yGpT/q1ek2l9BBuvS6vu9f+yDuRj/+3"
+    "9r7ff/2D/2r16MLpfT9+kh7/X/xf/t+9e39fW2/71q2qV6XsML+qV//jjkCM/9h/a+36+u2/"
+    "/9dU3peGDCCbdtalw/2/93/9v3r/f2/b/20r71frwwyGWXBBVbaL8JK/+l9//t/a+33X1//7"
+    "G+levhh4QIXYqKNFX7fWQR9v/9vIO+9e3uu2ltkND/rHUaTekQw/hhiEE2IpK+l6///7elx+"
+    "33X+313TXX6X5A9uQUQGGEEQa4tKr9vS/b//b/a9jbS20tvX16dJvS/TChgwgk2Gkr6TDILj"
+    "4S/Yf/7f/+2ltpfdbaX6Tfr90GwgtsJd4JNhcEtLb//b/r3YaWw0tu0uDBJp9fSX/B4WGeNB"
+    "NNCEGZkghCCGEGGZlCDCDCDwg2GhhN0GE3YYJBBsMEEEGw4YJBBsV00kw0Gh+1QeE0xCCDBB"
+    "hBMQkCChBsQggwQYQeEG2FBA8IGCBuGIQQYYoINuIQINr8JWCBr4qIiDCERBhCIgygDw1IiI"
+    "tCLhghBghEGEIMJrxER+hEaERDiIiPpaB/0g/SIGwCcdJFzOgGgr6jEGvGgamgH2EL4j////"
+    "//////////////////////////////////////////+QP6EDob+QPBoHIElkDw9kCyyBJBA8"
+    "F7INVkDYDEZDLjyGVCZBXmCqQZPIaUENEAoKlt5A8sTSfV00/S2/6BwdF3D+Dg//pr6Q/+QW"
+    "wbj//MKvrtNeC/9JN1/iP//+vr//+k3////9r///+k9ZeECzPy+IZY5BuP5AuOXhHhDKHL4g"
+    "tOXxBowscg3HLjIGByHHIG9CMci+Qzv/+3BEMyeEGQMUCGQLzyBimgwUgRmRewVNBgqDIZXg"
+    "qYQsFTIEUyGzAUgucuippgmRLIOcuhDFX/pYhPTChGHCNzROBBuKAXpgoLoLBU0wVMIwwwVN"
+    "Fzgqow2icEgoYIGCDBYMK0EGEDClxP/7YRtvl20YOgg6CDYVBNaMXfQXovNGK6MUIJt0XbCT"
+    "WqCDhX336B6apJL/0ug3bpB0nSsGbDZZsNghBsHB9BYNhiE2GIQbSbBsNoJwYkergzYN4P1p"
+    "9pXXX/q3vTaWrr6V1/pf9at02vTX/t7fTaT+l/9Y/rr0370/6XTT0/fr44/6WnuukKpdkFFk"
+    "K/pN+9DWv//6C//S/rq/7+XVJum9Kt0DXxEF9V///9f/991+ZgY+6Tf8VrQSww0YwaXkDwOE"
+    "f/H3X/H////sH/+k2k1dJN6SQYrwjj//Ng1dL/m0////9h/t1/tvpN6SQa9Av//ev/b////w"
+    "3/rpN6ekrelQ+v//sMJf+3///X4N/3t+lt6X4+l6V33hiF/7f/9+t+D/ulr6L70q////+XBp"
+    "/7f//XX5BQO/9/TdJNvpER//16d1fS/9v/919//1emONK71r//0rtb1/9h//3Wla/XrHWrxS"
+    "S//YRdbpsijtourZFfT/9v/9+0E2vrZ3hourW0k26X/7aWgwgmGFYaVsMJJzWBDtPTYaaYTt"
+    "O20oaTYRhUGnUUxV76V0kF/9ioOXQpigxUNiggbYQOGEDwg3CBggwg4MIHDYaCimIWEHDCCa"
+    "ah9OrDeP/2ENBoNMIQwhbERxkcMgYqbQTCxDEJpoX8RocfxEREUYE4jiOIiIj/2En/r/IG5d"
+    "J/1/////H69JtLIH9NJf3S6uq9ISh0CxdL8gt46iO2kl6FbYSCQIMIHWGISCTCbWIiI/////"
+    "/////////////////////////wAQAQ4AAAEDAAEAAACoBQAAAQEDAAEAAABCAgAAAgEDAAEA"
+    "AAABAAAAAwEDAAEAAAAEAAAABgEDAAEAAAABAAAAEQEEAAEAAAAIAAAAEgEDAAEAAAABAAAA"
+    "FQEDAAEAAAABAAAAFgEDAAEAAABCAgAAFwEEAAEAAABkCgAAGgEFAAEAAAAaCwAAGwEFAAEA"
+    "AAAiCwAAHAEDAAEAAAABAAAAKAEDAAEAAAACAAAAAAAAAAAAwBIAAAQAAADAEgAABAA=";
+
+static const char  fontdata_12[] =
+    "SUkqAFAMAAAmoFsNP/////////////////////////////////kMgNpyBoLGQPBocjfIEkED"
+    "wU3ILjrkDxwmnkGmKIa+ENfFshpj0Qy5kNIcg0UIHhxyCjCLhDSHIa9kG8yGZPCqpAvBK4YR"
+    "oCU0km4PTChBkMqgJxhMhnCBBhB6u/QIoBubbpPSb0gjbYKmEH4S0bNo43/rhBpNqjHpKyBh"
+    "/SDYVNNLCBUkG0EG//0Yi7fdJOqt3S02CzjaPNroLSdJv6qtLDS2qT1TaaVLo5UEDwQb5gGx"
+    "TAYXdf/ql9PS+t3rVwurp0XXS6SdW+v9f9fpJwxRcUrj7/9JUv/7v1X/Wkl2DGv9aTpel16X"
+    "v66/6/pbkMyK79/S+tf2///H6tJLbBHv6/4/66Vpf4iQYUfqulXhAioHSrx6S9If//9uq0kk"
+    "tL/f0v9K0v/v62KHbq9f60vNNdhpX+QJ4JXe6pV7X1+qSXhB0kw0tf6Ye2l0RNFxb1/oEF8W"
+    "pf0xC/14gwxCSTXv6/yBiiXON4Qattr/sGOmtcL/0oNeEDappMO1+thpIxyIRuOl+kjDdcJ4"
+    "lzemwwjC/4byL6TbNgp//6ENpY3CDpBG5sV/qQaCEgjc0rfyDKTIbWiX6T+9WqCDbVbkGRRL"
+    "t6Tav/1/pWl9PShsNL14dJK6b/1X9LXLHf1Scf//bVv8gtRVfpPEX71vXRAnslG6SX2l+K39"
+    "a/qlrjX/+3/1paX/pb1+Qbj+l+2la/+lkM26/9L1T/+26/Sf1IZg9f6X//0l+xT1/6VrkNDp"
+    "N0vSWQPOOvX+2/yGlBBkdetLr/WrVLTX+km0m2H+Cp1a6RB3b+0n1eku/9L+0DLHtLpNXrQu"
+    "0t6tKrUJfXD0knpgwQt/+rSTW0EnYSbpW0kF/weEtsJMTcF/Tqw0iBepYYSIZurDCTDCSsMJ"
+    "BLa1DEQkgxCYQa0taoMV8QriExVMQiCjsREGFiGEGm8aHaEQYQsIMIQwoWQyA2nER6pIRERH"
+    "3Vf26pf0kq9v1xbSSHdKFtpDt11WI///////////////////////////////////////////"
+    "/kC0GD5AzAxBA8DCCGQCoQQMw0yCB4EEEDwYoQyA1YNxDuQ8Hwg2YQ24vIZILHkNQ+QaS4IG"
+    "QzqyGWkILkwQMhs1ITUg+pB9SD6kJQhjUhmHIGDkMUIZyAgyBgGEGQMBAgZDPQhaEEqIQggm"
+    "hCoQ1QyBFqQX5MgwGQl1hBgg7hhHyBw/CPkD///vCPEHDCPEHDRxhx/r+CeE6i5wDwxTCPkG"
+    "pDSmT9GwSQ0TIzkMuZF8homR+EcB2Q2eQI8g38g38g3+cBQfDUaPgoZDZYQIGGQMTJTCBAwy"
+    "BiZKaBA+QI4hnsGfAgEDBWQe00CbWvRttGwR7CDYQQdhEE9hA0wgaQQdpppppBNPTtIINsIN"
+    "oINsINpPLhDgmmnaaVyGzkgepgCPwg2EEGHe2k+GHvuk//pdrek3uk3uk//6/t02lSX7aTa+"
+    "l4f/Sf/0v70m9tJvbX/967SbV60vS0nvdL2/9Kv/S9b0n9J//3+9td0m0tL90m5dfX2/9L/9"
+    "Ll0+XT9vfb3Sr/3S/ur9J8erX9L7xxX/9L+XXb1/X/f6/+6dJ0q/IZAdyBY+pCQ9X+O/0P/o"
+    "L7X36v6v8Rx+/RhVbW0hS8LD6BBny1fpL/X/0vevb1f1f/90r/un0vCw0lRyddXr9//+l9r9"
+    "/f96V/3ule6TaSXkDzggogJMHVIJjdX6/yFfIV//0vf9vS9JL//dL3Suuv00wggw1Vf7wku/"
+    "+l/6X2l7f//pQ//691bVL1sEEGGlpVpeEFX///6Xv+/vpb6TB/36t7FaSX+EEDDqkv3iv//h"
+    "hf0vtL2/9L8IKdQ0/uk39U3SXvhBEMomGGgv+rg/44+P9ff+/8JfnOynBp/f1q+qXtMIIFhh"
+    "paXq84Qf//8X9pe3/nP/BBv961b7Yr8RCCww0vSXvITv58efH5wNH79/2/9hfuG/9ev3S8II"
+    "QwaX9Je3/CDwg//zif2l7/4/tkNQP9vbXpPS8IINpdfvvf///7fv+339/kNqf+l7a20l8IN1"
+    "fpJX36/9kGCP/Df6Xt//7Yf+/r0Y//v+lx7/X/3/7f3/fpeltv+9at0lel8MEt/ST9/33chs"
+    "//2/evb39/b/9f1pvS8MMIJvbRHWpgMfv8cbD/+39r79/f7/t02l6vpeGGQaSYQT3YXX/9L/"
+    "/9v3r2/r62//X29K9Lww8IIXYrCR4Sv2/9v/9h5Bgftfb3XbXbINx/1/rpX8gw/hg8IKwwmI"
+    "S76V6WQXf//29divvuvrbuu9uo46vS/DDEIJsWkkr9vS12//2//29tLbrtV+o3dJvS/IHnBA"
+    "vYMMEEQ04bFLfpvS62//2/39jettLfrdWqpX0v0woYYQSbaS3pNkM4+l+3/+3/Xu2l2lt69p"
+    "fpXr+tBhhArbCVPhJhhcJft//t67+7DS20tu62GvT030v+G0FsMJLagkygWmRaYLsNdf21BV"
+    "q12GEsMMJd2EtgwSafX0gv9B4WGfMIEUAgNCgxSEIhlkyC+oZoOQY0IXQhjXIZ9GDQyGEOCI"
+    "YYKAIsGCRAvoydogX0YcGEiGXoxX0CTBkC+iH7Sh4TQYhJqgQYSBLhiCu/t1vTtwxCsMQrbY"
+    "hWwunSbv8aERDCERBghEQZIA8GWIiNCLhghBghEGCEGF+IiP0IjQiJA8C+CIiK64QP6pB+kk"
+    "gf+i4zUBoDN0iBKb0INfCigak4HhI0QMw1IvYQjj////////////////////////////////"
+    "////////////kD9BA6hrjkM2CGYP5DIDUggeBiyB9hBYsgeGVBDVggbQ2ZiVHkGiCB4rkDfy"
+    "B4bJqQN5kNdyCiCBEyDVNBbeQPHyqqqqaf/e6aRBYsgeBfEXcgUYnZDRZDUtLb/90hf//9NL"
+    "1/8gtgsP/8xtfS2mvBf/X/8R//6ptfX+v/Xr///+m1////V////9K0iGb/kMz8g0fkD4fyB4"
+    "ZxyG3MhmjkDwUp5DMHIYHIHgTj//uwQTycyDTMhl0wnhPLmQy4BcheyBeC5kfgpcwQYKXMg1"
+    "0M5DZBPAg8FBSBBBM5DCCK5EoQx5C4QcgmcguI/9KxT0wQYQ0bmiQGgwyGBFMhsmQInpZDPN"
+    "NBkNk00cYZAiaDCGQXmFRttEgHkWbuune7//7hGDeEGEbOEbOEEGwqQfT10C9NNU0EG1QYRs"
+    "uqQcL4YIGCBgkyFsG0CDBAwUwFX/pXQfRt0EGggg6V6TWjDZBRZDZmlkFFow2jDkFGIw2k5D"
+    "RiMG0EGiGy1p1Bwd6fp0n6S/+n24hBtXSDpNgzYF84CgQg3voLiEGIQbYhBtJtiEDaTxLuuQ"
+    "0W76991paX/rdPCdLp/0un/S6rp+6dLhP//WtNq36//TY+366X71/pdNPWr02vjtft72rpdV"
+    "SXZAxhBx/X66f9v/f8Jf+9X/1Y/62i602lqKXug0/pv9RS1///QX/6/pfD/br3WKbpJBbaDS"
+    "8RIHgYPv/DC//+v//7/ygDH/dbprVIJYbRuBhLwRmv/x9pf8X//v/7B/6V17vShh4QVBj8I8"
+    "f/4L6/5tP////Yf7fq2vfTeqQa9Av/5wNS2l/7f///+G/9J66vVK9KgYXpf/+w0v/b///r8G"
+    "/2+9+26Sf8fX6u/2K/9v/+/W/Iav/6WlaSL71S/H69f7wwv/b//66/D///pb0v//16vouGp/"
+    "2//3X/yGU7+rdOrGrd9EKP/+vttr6/+3//daTf/36xVJNukkv/66Xe3pf+3///Wv16sfpXGl"
+    "//aLraTbYRhYZCPp/+3/+2laTYX1u0XWmnV9L/+wl3CbIjsMJbDCXIwG//Yf/7aVoKGEbXus"
+    "zthLfqm2kl/9iFMwXBhJhhJiFMwzjIMEWQYRBkMEZBghhkEIIYIMRMwwDg2GlDCTELIMaQwS"
+    "ioqZgY7glB6H/7XL4pimlYVtp3fbV3dp2xCimF6EJ2uq92v/2hoMIMINCGEIbERxDBCIiIhh"
+    "TeEGsQwmgwhd6EccfsREREIwE4jiOIiIjX+Egf//1f9f8gVq6/6////S1H0vSb8gfo0v90vu"
+    "v0m4WLrXkFsGsdRHtJL7S2GCCr4rDFEDwUYQyQ0yCCqGlhgqXaxERH//////////////////"
+    "/////////////////////4AIAIAOAAABAwABAAAAYwYAAAEBAwABAAAAeAIAAAIBAwABAAAA"
+    "AQAAAAMBAwABAAAABAAAAAYBAwABAAAAAQAAABEBBAABAAAACAAAABIBAwABAAAAAQAAABUB"
+    "AwABAAAAAQAAABYBAwABAAAAeAIAABcBBAABAAAASAwAABoBBQABAAAA/gwAABsBBQABAAAA"
+    "Bg0AABwBAwABAAAAAQAAACgBAwABAAAAAgAAAAAAAAAAAMASAAAEAAAAwBIAAAQA";
+
+static const char  fontdata_14[] =
+    "SUkqAKINAAAmoCAz/////////////////////////yGQBw/kMgGYcgw5DJBpvIHg1wR3kCuC"
+    "B4NFhbrIHiwnZAxZFjIafUQ2+BJJshrRkGnyGtBBqmQ05kNqyBcQQ1YINyZBRMhpfhf1CMwz"
+    "S5hqg9W4aggwoIGCDCWC4QYIPXrwR1BQm6Wkm6pGzYKmn2EFQRsgwjhB/9UjeXg0m1RifVkM"
+    "t1VBNhUGE1pAtBBtBN//hBYdboJOkk2nVJNgj3R4s8b8JUk6TftfpYfdafV09VbQXCDcEHWX"
+    "BWCmAIraTf/9eldL0ld1VcLp6bRddKkqff91Vf9fXbDeqtwum0v9L11v/+v+uqSwxR+rx/3S"
+    "9LS+vfqtf9da7DHr+/pel/79f1/9dKr5Boha9Lr/9L1/a/8fXSqsI/ev/HS9Kkrrv/IZ0n9V"
+    "aSXYIEU467ePX6j2v+I/tqulSulfX+qX0ldf/e9U6Q9wr1X6pfJ+u2l/kFqyO/tJYr2vr/qv"
+    "BA9JhpX/XeG0qqtq9f1SS9NIl3DS1/pg8MQlyJWuP/9JfF4QaTFN//EMaVd36/SIZrhNLnCe"
+    "EGob1/2U4bUJ/cLX/iDXQQb06Ydr0uw6RvZCaePX6V106EwdK2GF38NqQnJOzgE/1/SkcbS2"
+    "nhBtQjc2JfX6kGrSgjDDW3/r+hDfi3CekEG2v62XmoQTdN/kDgCIKtS/pOl+2qQba/IHCTD0"
+    "rat//X6Ta/XSuGEl/htaur/0v9et91SbH/+l1evIH0a/pOhJAaf0t/ogtWRY3Wm9v/GutLX/"
+    "S0sdfpfbS/X9L/0t/r9L9v/pv63r19L8gXH//tL9ddKiDVn9fX19JfbFPXXWkQan+npekv//"
+    "99df0tLIbHW+vXIHjj11S6bf8hrWQJHp/Sb/rVfS01/rddu/BUH2lpaW2k9JNpJa63pJX3D6"
+    "6TX9IoZddrf+gvrvS3psIMk7/9N1odpbpOkraQS/70km0mGEcxWvWrpJqwwknDCCbSStJL+o"
+    "PCW2EmKDXWtUwwkQy06xCINQyKYaWGGEECC2vDEQkgxBMINN/TSsV9bCYhJMUCBYiJBppiGC"
+    "DC0hxoMIRBghYIMIQwULIZAHDiIvpKIiIj91X7qtfdUvuklXtrS4t0o+lC20h263SxH/////"
+    "////////////////////////////////////yBlyPyBmCy5A8NUMhkrQgaA6CB4NKCB4ZhyG"
+    "QBxZCDkHcg8EUcg3cgr35BbB5kGw6kNRQQ1QZAgwQaBogwBkGgGQ0VkPWQxWQxWQxWQShBes"
+    "g0oINBBDCCDcMhmJyGWrIaichmKwQMhoEyD1kEDIPUQQiPjIMTIaOIL0IKMIEDc8B4WCBggd"
+    "sMIMMgYZkOCDDQYQaDCDShoNwg7QQMMGEDYYQeGE0GEGg0mGk1uutMIPBnthGYRAzwIGQaMO"
+    "nIKMPWEZhiQL8DBEMrgYIhldOBlngbcEDZDKgIzEYM8EYRmIyGbhCURwJwZ4C5gFAIGEGCwY"
+    "QNoEHSr7CMxA03ISYQIgxjkGJ5BiMgvCBB6apqkqtK9AgYbg2gQMPBsIINTAU8FT70/T0G1m"
+    "A2L5gbRwF34dBB8N/4QT/+gv70E3toJveuv/XT20m6pfSDhBBhp7aT4b/pBV/6Xa3oIN7oIN"
+    "7aT/+3X7aTpaX02k/ul7f+k//pf+k/aT+v1/+qT1daX/TaML6Xt/6X/6XMJowswnre63vX/7"
+    "ave2rpaXi6Tffpff///hL/9vSb9Jv1//6/0m168hkA3H0np/r3xxS//S9tL2/f9/xHH/tGF2"
+    "6ehXwpA/foh7bW/Ue/Uf/S//b0r9K//20vtK0rSS8LDpIEzZ19Vv9f+l9pf+/7//+9e6vpeF"
+    "hrhHmR/at6r/r/6Xv+3r9L9X+2lq3t1aSXkDyggYgJMHSSCjf+vvIO+Qd//0v0vb6/q9f/79"
+    "LSbSr00wggw10mtJ9Kt/+v/QXt/t/ev6V//pPtpevqmEEGGlr/eEl//X/0v0vb1fpX6Yf7aT"
+    "98baSX3ggQYaSSXpPhAv///9L2/2/9L8JSQCr/+vadJL/CCDDS6r7j//+P9L9L//S/CTNYa/"
+    "3S1dJq+vpoIIg0AQYaWv1yXDZ+OP/0/b/b/wl+ZDIgNP999+6S+00EFhh116vOCB///xf6Xt"
+    "/5Z/4Jh//pe3el4iEFhhpaql3g3//OAX/ft/t/8L9wb/bSferYpLwghBg0F9aT7f84D5wH//"
+    "Ob/S9v/H9shr1f/1arpeEEGGvX97f1///t+3///7kFU/7pWr6MJtV4QINpeqST7////7f6Xt"
+    "9/f2Df9//7r8IPX1xfd6/9kNGn/t+3+39fW2//ulaSTel9+36Xu//7//t/17e/v7b/tpe+k3"
+    "pfDBf1pf+scchld/7ftr7fr2u7//1ev14MMIJvdUpgGH96/b/+3//919d/71a9U3peGGEE7d"
+    "yOqSX79e//7ftpe3v/7f/avuqV6+GDINYEEEO2EnCW39/9//t//t91t1t/09aV6vpeGHhArY"
+    "qKLtL6fSyGd9//28hoftL2/X12yDd69bX/Sb0iGx/DDwQTYaYSW3rel/f/7f7/t7dbdf/f8b"
+    "1V9fhhiEE2IpL9N6/t//hv+K9vbXtdv/V6qNX0vyB5QQy7DDCCINsWtPq3pft//sPXf/tLet"
+    "vS26jd0r1/TBIGGEEm2l3pN6X7f/7f9extpbaW3a9r1Svpfrhgwgk20l9JhkNj4S12H/+3+/"
+    "u2lsNL+uwk19N6S/dBhhBbDCVN4JMMJYIL9h//t6XXuw0ttLbhhLYYS/Svpf8PBYYMIJO0KY"
+    "MFQhIUmwYVNNPTbQ03TTdhhBJsMJJtwwkmxVNOraaH9JB4TTFEFAZDGqCDEIIIg0AZBisMUQ"
+    "z1kPWQxXkNlbBhSC+mQlRDGmGKIZVYZQwiGVWwcQiDTW0/QJQZDKrX2sPCaBgvRTg2BIhA0u"
+    "GS4KP+/te4YLDEL2Fhr+n/xoREGCERIKgYiJBVDERxERxEODBCDBCIMEIMF04iI+oiNCIkDw"
+    "1bEREfrCB/WEH60gf0qMMH6VIIGU4GoKfSIEsGKCDV9UQNA9IeNA1JAHnhD4j///////////"
+    "//////////////////////////////+QPkEDMFW+yGQBPBA8NSAmQZ4IHhqQQ2oIEoDFkGuC"
+    "GlHkDwN4ILMyB4NM1ILMyB4NMyGrNLYeQPF4g14kFC4UgqQQLwFCpbe9pEGbiB4NfIu5As5N"
+    "Mg34hr9X+qu6Qd1t3Xb+0vUf//9G1/S+vIGYZj//tr67TXhf/S6/xH1//bX///9L/X///bX/"
+    "//9Lr///9Jtf/////8l/kNTiHwg2f/+k3LhpGgZclMhqeQaJ5Bp/INU9BkGiCBeMgnZDLgIM"
+    "IMhmwgyDXMg1QSmQ1KE3IF4JYQUHyGbBBdyBGhJBDXchrcQfCC4ZGggwE//xCDwgwQMIYIPJ"
+    "OCD0wUF1yCj00wVMEDBUGEMFCgg8gY8h+8hjRSEQE1//9JsJ6YUKEcMMIYRsjqBFMhsOC6BY"
+    "KmmQ0HTRsgwUINSDB1RgcI6BiCgz4OCBnwSDBBtAgz4OCmARf/thGxvTCOFCODoINhJJrRg3"
+    "+gvRt0YN6MGwgg3phGxVqkGgvvvbh6dqkv/S6D6MDaCDoIHS9J9BByBjCDfNLIGJhtJyBfEE"
+    "HSbIKMRgVoIHIKMVJ1IaMIJnTrTaTpaX/7e8Qm0mknSbIN8VnAMCn/S6YpuKem4hB0uJdpcg"
+    "oz3+9tb//9Lq6DpaTr9XV/hBdV1avTaXQff+61S66pL/9t3r/6b1en/S6aenW/Xof/dW/bSd"
+    "dL8gpD+lj7aTrr//+l//T02vVj/1ownTaV0KSW2QzMv6b/xr///0F//39ff9r1r060luEDXx"
+    "ELuq///+l/+vv/B/vTa3TFeqWw0DS8hkBoI/+Gv1/xf/+/r7JAZn7+n2m6Sr0bMMJeQyAXmb"
+    "P/j7X/v////Z1Av90v19UmHhBJBj8I8P/8iAMXr/nE////9h/3tpN03dJN/QYXoL/+cBs2l/"
+    "7f///+G/3S/W3XfSSBr0vr/2GEv/b///r8H//W6+kr9ofS//9iF/7f///+Q16f39Poum3pfj"
+    "6X93+GC/9v/+61vwf90m10lb1S//9L+9mA1v+3///X7/39N6T3SX//07r6X/t//v+/kMt3/d"
+    "LX0rdVId//11u9vS/9v/+0tK//19jikm+q//16bbX1/9v/9/rX69YqnVtvS//tdL0XWyDj6/"
+    "+3//aVpNr39our/XFJf/6L+GgmGQo7aW2vf/t//t1DSsIwvpWW8NL6pJt0l/9sJcMJMMKwwl"
+    "sMLyXAv/2H/+2lDCCYaX2lFMVbTurdKl/7EKDiExTFScNAogRrDIMazQMHUGJAjVsg+pDGpt"
+    "JOCHUQ0DQGEopiFkCKoYSdqThlfBKD0P/60Y07WGFt/+wuv9iFCDXxCaa3pqnf/8MIWgYQME"
+    "DCEMEIcRHFghEREQwU5BBhYhhNBhDT4jQ4/iIiIhGw7xHEcRERH/0g/9f4Sf//yB+Bf+l/6X"
+    "/9f/+ra+PVfXWCf/q2uC6r9NoLpuq9RHHS/IGeOltpV9rtpJehWwwSIHg08EDCDrDEKECDIM"
+    "tVYYIfaxER/////////////////////////////+ACACAA4AAAEDAAEAAAATBwAAAQEDAAEA"
+    "AABKAgAAAgEDAAEAAAABAAAAAwEDAAEAAAAEAAAABgEDAAEAAAABAAAAEQEEAAEAAAAIAAAA"
+    "EgEDAAEAAAABAAAAFQEDAAEAAAABAAAAFgEDAAEAAABKAgAAFwEEAAEAAACZDQAAGgEFAAEA"
+    "AABQDgAAGwEFAAEAAABYDgAAHAEDAAEAAAABAAAAKAEDAAEAAAACAAAAAAAAAAAAwBIAAAQA"
+    "AADAEgAABAA=";
+
+static const char  fontdata_16[] =
+    "SUkqAHAPAAAmoCQP/////////////////////////////////IZJx0QyQzjkM45DJA3vIHhr"
+    "2RbyB9BA8Gy00/IHg8XZDMsiXkGzqIK/Akk2Q2nSINUyG25DVoQ1aEGSCGUoINjkFEyGPIZU"
+    "yGrPBVXqwQahNUm4PCBhQQYQMFwQcYIGED131IZoaNsOk6SbVII4bBQgwmlhAtHDDCOEH79Y"
+    "QNINqnrZBoHrQQbCpp+EFSCDYQQb/1wjkXbSekbfSbT9JsFTR82uEFpOk3/+gsOtqk6STadJ"
+    "LYR9Z4bhBv0FSTdX9fpYf6SeltP6cILhBtBOswCkpsNFdX666S+m1/p7pJbgtJ6bRddBVVNp"
+    "X++v69LpK2G164XT1/pa/v79a/69dWGKJ2krY+3ul6XS6V/69f9a0uGP/rX/Wkv//9f9fSps"
+    "Ol/vWl6Wv7/X//1pa6kGu9f/0vS69f+v8fW6S8Izf6/xr/1uu99yGga/qtaSbBH1HS28fS9I"
+    "atf8R/dVdJLwlf/6S+q9f/fdVpD9PpL9VXkvqmGl//uqxCW2r//18EDVbSv8gerIl3tpVW7C"
+    "vS/VKvQekw0tevb7SVrx//pBJcXRH9MNBf/yhQxCrIUZXf/0kvahA1Ypv/qIMMJQmv+l+pBp"
+    "cIOueG8J0w9f1ZLgyJNVuC/9JCDXhB9NWG2v1sNQjnIWvx0v6uug3EwTSu19cMNIh/SsGcF/"
+    "/6UuNpdaBB8I5hsMI2lv4N4QaTeP6X6iG1xbptJBBtiF/5DU1SCON07//9But61SDtfkFgal"
+    "29INrf5BZEyDInS/S1/bpINtJf4dJK1b/0v9JuvrVXBhf+303Tf//6Wu+9U2P/ukv3X6pdaT"
+    "oSGDZ9JXrogerIl79Orf5A8S6/0v/Wtev9Jb3S/FJ/S1/pXrH//2//v0t69fX/0v20v0tdKi"
+    "Gl36/X0Qyn/+20nr+tIhpj/v16XS/SX8f6X9L5BQ9dL0lr//7Vr7+k2l6V9euQPDx/pJdNv+"
+    "Q2o7rS62/VdUsJ//trbD/BSBPiWulf6T0k3SXfrpJdWw3rVPetIhiel3V/0gv+9LdWwgyKP/"
+    "qlfobaW2k6STapa9XpJXTDCH/XulrDSuwk3S6QS3pYelthJibabS10m0kGsMIJOwk2ltpBBd"
+    "LyjggkgxCaDX9PtpEMwGsUQ0xDEJsJJMNBBBbXgxFYYTCYT/tbFfC4TELDFEMueIiQa0JCGC"
+    "Bq6FIUgwhEGCEMIMIQwUFkMk3ERdaxEREf60vbVL/qkvbSX9+ku7SS8W0qHekttIdtLbS3ax"
+    "H//////////////////////////////////////8gMBZD1yBoDQ5A8GXQhkg31IGgFAZA8G0"
+    "MgeGsQQyQ2oIG45AkvyC2GvMgqoTIa6QhtBCGgbINQqQYFCDWoIbBBBBBDAghgQQwIIOgguI"
+    "INYZDTIIYIIGKgREA0EwDYRANBMBqgyGgoIYGEMVEHrIY0IYqyC+hAiZBvMhg5DL4gQLMzA8"
+    "PBAyGsn4MIHIqGZoED//9bwQcGCDgwgf/64J9pcLCYQOyG0kBGgeQboIQgg1AZBQYCMweQLz"
+    "IGJkMuZDLmQy5o+GWZgqOZgYZDNxHwoZBpORaI+FDINJyKdHhNENlCBjAZoBgEDNAzyGzNHA"
+    "zuv7CNBA1Z8I0CB2CIMHZ4GEzwLwgQO00001CadJtoIIGHBA2EEDDYIG0EDzYc+HtNNU1dEC"
+    "9EgdJmwUL5smEfBh24NhIO4N4fDoIP/6Xe+gg27aCDe2k01u+364eg3wkvQQbQQYfugnww9/"
+    "Sa/9L1vSb20m90n//p/tJ0v+nQTa7aTW3/pP/6Xfek3uk3tpfX7/dNq3Wl+2kG79L2/9L/9L"
+    "1vSb7Sb///tK1V6tJUvS0nRhd0vf/S//CXcwswnpPuk+6X///tpOlpfugm+/r2/9L/9LmFX3"
+    "6b+m/3/9unutJv68dbS/X28cV//S+69vW/W/X//XRhdv0tfIZAaQ5A8Ufp9/r/6//QXuv30/"
+    "q/4jj7/2raTdCl4WHpEH5tb6Ue/Uf/S+69vX+v/+6tf0nVLwsOlBM3dP9b/X/pe6+39/3//q"
+    "9PTdWkl4WDWkeb/vSX/X/0vuvb1fpX0r/br79XqvIHhYIZdhWHWEE6TaT//kF3yC7//pe6+/"
+    "XrX//rpatpWkvhNMIIMNUko/vS9v/r/0vuvv7670r/er3punVL7UEEGHXvpegq////S9/2//"
+    "/ph/3ut+k3SX9hAgw0tKvfCS//r/6X2l7er6SvpQ/9enVjtKvXCCDDSSS9bhggX///+l7/t/"
+    "6X4SZ1BW+3X/T6++EEQaBMMNL/p4h/668f6C+0vf/S/CTIgGz+ut01aSX00EFhg0tV+4P+OP"
+    "/0/f+/8JfmIYP96un23SS9poILDDS6rSeeCB///xf6Xt/5ZH8Ew/73XXvS8RCCwYaX6XeDf/"
+    "88GX+H7f7f+wX7hh/69XVsVXgghDDrX0vb/ngfPA//57f6+3/j+2Q2hH717+6+EEGGl0l77f"
+    "++//7ft17f/+2QV9f7W19PS8IEGHX6S3v9b7//t/r//9bkFNH709NqjabSXwg2v/T93///+3"
+    "7de33Xf2G/7/6S9L4Qer1SQvf1/7IN6v/b/X2//9sP+66V9N9fa79V+/X+9/+37de3v7+2//"
+    "Xvrevwwv6pX/+OOQzJ/+3+vt+l6W//e2ukk+l4YMIJ7fVGwz/vX7D/+37df9/f2/7pdXpN6X"
+    "hhhArfRdUqf36///b/X29//b/7/f768MMhqiYIJrbS0Et/f+//7ft17fpb1t/7paWqT6+GHh"
+    "BC22lpU/vpff/7f6+339r/6X33SV6RBRHhh4QVsUxCJ2t9XrkG77f/7eQUPt17e9b1tkC8V/"
+    "exv76VeDB4QThhMJa9W+v//9vX/77S7S2/73Sr0m9L8MMQgmxGlf70tdv/9v+K99v39vS3X9"
+    "ikr6/IHhYINEBhhBEFS7S70m9L9v/9v9/b3S20v/umKrV9fwmChhggSbaVP03hLrv/9v+vY7"
+    "S7S29L136b0v7UMMILYYSW9WGQLvpft//sPS3/bS20tu67S90r0l/oMMIJNtL8JMMJYS1ww/"
+    "/2//3YaW2lt2lthWqpX0v1w2gsMMElbwSYMElIOfW2Gt3fbarbXuGwgrYaCu7CVsGEv0r6C+"
+    "6QPC2DCSpoQgxoQkNWDCqq6txrppuwYSUMMElbgwknFe6tpof1h4TQYhEDGpBisIIMIIIg1C"
+    "hBgQGIRDQIIIIIYEZBuIDBhSC9TRDjCD1OxCIZohiEQzRDBxCINYwNNNUCTBkMsQvtUHhNBh"
+    "eiXBVClWGrwZCAX/7r/4YWGFuGFhhf1/44iIMEIiDOoZIaDUGQEQiIuIhwYISCmGIgwQhgvx"
+    "ER9IRHERIHgrwIiI11hGgGwCzroO+qCB+loP9JGCNQGwGXpECYGYPSCBkuBsBt9Q0qBr0ooS"
+    "GciHjQMJHQDx6IGobv8IRx///////////////////////////////////////yB49PIZIsED"
+    "wZIIHgxxA8rIHgqWQVrIEsM2yGnZDUvyGQoIM8yB4KnhSB/MgeDZMhtTCWw8geCTIamBIFIH"
+    "g2IUgzEEFeCGXAKC1t7rXrpp+v9WpA+4geCryMHIHvk0yBfiCp1b7ql6Q/+vf2vr///o4tel"
+    "015AzBmj/6tf9prwv/q/64j4X/0rS//r/vf9f//0rX///+m////9df///6b////1dL///+rg"
+    "iGpTIvkG2ZDS/IaX5DUpkpkNOCGXGQf8hmOR+QTyGnBKZDXoQ04I5kNqhJyGVBLiBc+QanIZ"
+    "4IZ4ISCOCOCDa5BUwgvxBeCJBFciuQz8Qxf/q4gg8EDBAwgeCB4IPCBgoLrkC/BBhBgoQMED"
+    "BQgYIGFBQoI1gokMzgWOMg9VkKGQwdY44//qwnphQhhHDDR1BQbJnnpkFCCGdGlkM6EGgyDc"
+    "hMI4QZBuhNDIEIVGx0ageQqAZoGAQMEoMJuCDBBhL/6unphHChGxwgg2FCCY9P9AvCp6aCDe"
+    "gwjg1qEg0F9pphbCB0mg1MBhf/Vo2K9GyYQQcIIHScKrWjZMgY8go/QWQUejhsI4bIGPRsmk"
+    "2QL+jZNAg5BR/ThSBHkMe9PbtpPX/+r0H0EG0g6TpXLx4MtPEJ3fS2IJiE7EJ0m3QINhIO6p"
+    "Pu/6039aX/pXvEJtLSDpNj8+GWn/S6aenVuKDpcS5pXIF+9tJu1dJ1pL/6em6etf9J6b/QXT"
+    "TdNpPTa9P//61aXWl/63/q6Wl/1/pdV19/XQ//dft039Vv9Nj03/7evv+l7vuk9Nr9j+6ujC"
+    "aTpaQqvZBp4gQ/q/6Qpa///hL///S6v/q/7SvSrcINP6t9////9Bf/97/3+2vTdN06SSWw0D"
+    "S8RIHgrU9f///0v/1//ZQDX/3XVj9IILDDQa+QyAatP15OJ+v+L//39fmoMz91dfTdbegpsg"
+    "0vIZAZlDd/8ff/3////sH+66tpPqkw8JJBivCPj//KgDF0v+eT////2/+nr3fSb0kga8IF//"
+    "PBt7S/9v//+vwb/bW1bq7SSfqg16X1/7df+3////hv/r9b9K/wwvS//9hhL/2////8g2Eft+"
+    "l0rdfq0P/93+GIX/t//39X5BUn/pN7ejG9Uvx9L0v/Bgv/b//61/D/39apNvSX//7v3y4bf/"
+    "b//f6/IZkP+6Wr0t2qX//1d74S/9v//X2//19+1Sf0iGH//XX1vS/9v/+60v//bWK6Stuv//"
+    "+m219f/b//f1tfrtetjpvVJf/sLpdq3r/7f/9pXTa/+sbWk2xSX/9owtoJttGFhkHfT/9v/9"
+    "urQTa9pWSHbRftbS+lX/thBcNJhkOOwwlsMJcqwyv+w//20rCUMI2v9pwwl9aTbS//xXDCCb"
+    "CsQrY1hra6sGtrrbaUNBMQtbSYpit/VvSBf/ak4ZzCFMbUkBsRDPU2QYrlAOawzyBFbkHrIP"
+    "WauUA5rCFAbGlEINZAhPDCCpqUBmp2gSg9D/9hdNNBrDC2//YXX+xCnkmF8U01vXTtf/hoaB"
+    "hAwQaEMEIOIjiyOGQCwCwwgYWIMEGgwh/EccfoREREI2CPEcRxEREa/wgg///hJ/6/0n/X/I"
+    "HiiX///pdfT+n/+tpePX9fhfX1bSyB49NKvptL7/1IHg1wEYA1CxdKvSEdtJLyBmDU/2l/YS"
+    "2wkl8eGGEEQPDXcJBBhBpYYhMQgQMgUVwsGaAeCsF7WIiI//////////////////////////"
+    "////////wAQAQA4AAAEDAAEAAADOBwAAAQEDAAEAAAB3AgAAAgEDAAEAAAABAAAAAwEDAAEA"
+    "AAAEAAAABgEDAAEAAAABAAAAEQEEAAEAAAAIAAAAEgEDAAEAAAABAAAAFQEDAAEAAAABAAAA"
+    "FgEDAAEAAAB3AgAAFwEEAAEAAABoDwAAGgEFAAEAAAAeEAAAGwEFAAEAAAAmEAAAHAEDAAEA"
+    "AAABAAAAKAEDAAEAAAACAAAAAAAAAAAAwBIAAAQAAADAEgAABAA=";
+
+static const char  fontdata_18[] =
+    "SUkqAEARAAAmoCq/////////////////////////////////+QyXe5DJDVchncgthMyB4NFk"
+    "TMgeJBA8FKE06yB9ad5DbxIgScCpNkFYdSGnQgrOQbKENqhA3ghmWQz2QVRyBxZDMoQbJ4XU"
+    "g0YQl4IHhBhUm4OggwoIGCBhYwQZBuJggYIHhf1CJwazjaSdJNpqEGFQaYWgSwmg9d6yGanQ"
+    "Qb10m+gjxMKEGEGlhAtHhhhHyf/4QaVpIw3rZBpelQQbCpp+EFSCDaCDe/XSOMwbSfSDpJN3"
+    "1TYKqMyraC0nQTfT/pYaW0gv06dKk4Iz8+K4Qb9BUk2k/+ugt9+npbTXVtBcINwnWYAnTNg3"
+    "77f1+v1aS+k3dVXC6em0YXSqkrSv99UvX/S8N6q3C6dJ/0tLff/r9/S6pJsN0RB6rH2/S9JL"
+    "XX/r0v//WwxRfqt6XvXpaX1fv9f+lqlThjrf+tfS//////6pbdf910vrS9X+tdf9LSWsKQ1L"
+    "pfr/9fuv/f/H+1rcIzH+v8aS9LS17/yGwU96S0klsEf2OvePpfj3X+I/2v0l4Svr/S/SStf3"
+    "/9JwkwqevXf9L+m6/rvdLihW6vpfpL8jmktpf5A8WyEu+6She16/rSXggekwwgr/XvbXr2E3"
+    "1/SSXgmpHPYaWv+3tpJNEGt/H1/0viHhBpMU3/SyGoYhaZCg/v/0gSS7oINWtf9ifDVCSC6T"
+    "/X+Qa9Pnx1Tph3/0yEAkpr3Ba/pQaXBBvTUMNtf9hpI4mD+PX9JpdBvRwnV2F/2HhBOQxhFj"
+    "9f1mBh/TxBB0gjiDYYRxL1wbSIP6Tdj/X9QgbSxdJtQgg2xX/kNVPhA6t/1/SF/unpINwvel"
+    "DMbSCOG1b/IM4vX6TaW9OqQOGvogzCmD6TaT/5BSEL+k6X7aSTbSX+G0km+/9f+r/r0nDBf+"
+    "/TpN/9V1paWRjv6VNj/+kt7deQPBe9f0nQj99XS8geWEJe/6t/61fpf+lv8Kv0qb7S/FX9LX"
+    "9a6x1/X2/+v0v/pXX/0v20v110t69fr6IZcf/vv9daVENXt+vX/9L7bS6/9SGo//S9Ja/1/s"
+    "Va6t+ldZAu6V6X1/+l9tf11069//pZA9RX6/T/5BWhddK63p0krSSwnr9JOtsP8hteQLMpv0"
+    "tLtL1fS7/177Yb1qmvWk3X7aXaSWv/SXTcHr0nTa6IGBDXbSvSeku+r0ttJhhFIBO/XXS1tL"
+    "tJ0u1CXroPSSdWwj3f/ptJNbQSbaTaSTaQQXXw8JbDCCiE1117DSIZsBBlusMJENSAg4YQTD"
+    "CSsMIIILetkNQgkmKDQYVr00rFRGrEKJrDOKYqmKCC2FqDEVgwmEGnodqmvhbCYShhAgsREh"
+    "phpCDBBr0hUMIRBhCGCDCEMKCyGScCItpdCIiI/6S+9VX2uvvSX9qlXvWuraSVYtpUO9Jdqw"
+    "ttIdtLbS2mFiP///////////////////////////////////+QEwate8gaApwQPArqIZINtZ"
+    "A1DU1IHgpaEDwZCCC3wQPA4jyC2DJMgpIyG0BkFdQQUCZDUKSBAuQ1CZAuDIYBkFwZDAMguD"
+    "IYDIMAyGpqQ19CGNCGYnINYMg1DRBUBkGsbBEYDchgQQwwQYLlOGCIBc1A5GAxIEVENnkMqZ"
+    "BihBp4hoK5OB4KJBbBU1IbYxODBEaDORcGpYIH//63hA4MIHBhBxX/+QXDUJrwsIMIPDYRoC"
+    "MMGHDhGgOGGCDBBggYQYLDBBuEHDCCMw4YYYRmHYYaPBA3DBBhMEGEwSYYV9112EGpBXoQiA"
+    "gQNEDFCD6EGs5B6EDByCUCBA5AxQhmUIZtCGbQhmUR8Gg0BSonDMZBrwIEDZBqOQiAgQMMg1"
+    "nIQgIINZBvQg0YDNAzQgYLIKMdHAb0p8C69MIoCB3QdBB6IaEMIhsthEM9oIGmmmmmqaurpB"
+    "NsIG0E2wgbSDzAOZg9qnp9yGUdIN1BV84NozBh7hsJB3BvfdBP/6W6tukGHhtIMPDaT/7v6a"
+    "Qbw2lST8INhAgbT3QT7f+En/9LvvSb2wk3vXX/dfuk/pekHSb+0vDf+k//pevpP9P6T9P/uv"
+    "aVpf/aCDae6Xt/6X/4QX96Te2k3t//7pd09OlpfTpN/r7f/X/6XazCek36Tfpf/3+rat1per"
+    "03ML9Vv/r/+lzCza7et7re//+62vaTrpeOk636X3/pf/pfaXt9P9P///dPe9XX/pXT+vt44/"
+    "/6Xv/et+t+uOP/zCpNpNpCl5DIBocgeDj9Ot/Q/6Q/+l917+/7/j+6Wt+rpJeFh6RDH3T9Lt"
+    "+v/pe6+3pfpf/9/vt1el4WDrCDNzrev/1/6X3Xt/f99f7q2l1pOlXhYapBH2//qv//9L3X2/"
+    "fpX1v+6+1bStJfCw60E6t0/r+QIfIEOv/oL7r719f6//6fb30vIM9kM2wQQYaSQSf1vS9v//"
+    "/S919vr+vW/3S1/SbSS9BoMIIMNLqK6fSr/+v/S+/3++u+r/vvum0ukvVMIEGGuvreEF////"
+    "pe6Xt++kr6TD/enp16bX+8IIMOtL6fBBL+uq/+l9/t6+v6UH/a6+x2kl/hBBg0kl9eIL////"
+    "S/S+/9L8JMpwZf/03tPSX1hBEGsXDDS6r7lQGX/XXj/S9v9v/S/BBSoDb+6WvVWqXu0EFgw0"
+    "Fr6Twf8cf/p/pe/+EvzaMH/e36tulX1ggsMNLr+58IH///F+3+3/k9P4IMP966b9ul9oMIIL"
+    "DDS+kqfIPT/+fBo/f6Xt/8L9oN/669NxpeIhBCGGlqut7f8+GM+GP/z6fv/f+wX7YN/39Wqb"
+    "SXhAgw6/6fb/w+H//b+69v/H9sgyDP3SbV/0vCCDBpdaS+39f//7fuvt//7kDjT+//Ta/CCD"
+    "aXpfe////+w/uvfuu67B/3rq6Rvel8IP/0k/d6773/4b919v//bDf+urql6Xwgem/WL3f/9y"
+    "BhP/7f3X3v7+2/7f1+3pfDC/qkv/X/3/7fuvt+v+7/9Nq3SX18ML71V/f445Bqp/7f3Xt/Xp"
+    "dv/a/6Tevhhggm71WbBv/1+w//t+6+/f37f+9daq3peGGEFvouqSX79e//7f3+3v7+2/+urf"
+    "XpeGGEE3bfpd/f///t/pff19bf+3TddJN6XgwZDXFwghd0nCST++l9//t+3+32va/+l+uq3/"
+    "hh4QVthKIRPO+r/3//byBiPS9vet62yGU9f2vt6T6RDKjww8IJtimkkn1b0sgXjv/9v9v9vt"
+    "Lutv+9666pvS/DDwQLDCYKv/0v2//2/4r32/ddv911Y2Nb0vwwxCCbEV76b0utv/9v9/vdLt"
+    "L7S7pivSfr8gz2Qa4DDCCIMsNpJPq3r///t6XXt91t1t/69aV6/pkMzwwYQSDYaXfTelrt//"
+    "t/v7G2ltpbeltpe1vpV9qDDCCVsJK+kwyGaPpft//t/17tpbaW312rVaTekvrQYYIJNhpVeE"
+    "mwuEF+w//2/3920ttL7S20t9K9L+8MNBbDCS+kwYSUJa7f/7D16/bS20tu0uDBfaV9Jf0g8F"
+    "sGEltQSYYLZB0KFTDDVNNPTbUFTdNN2GEk2GEk24YSTYpqtK01C/WHhYYhINNCEGKCEJDTDB"
+    "gqaaem2hp6abhhhBJsGEEmw0GEk2v1YacfvQeE0GEQzKyGcQEEGEECIahQQIBhiCINwZDAMg"
+    "uDyCgGwYUgwnaIOIIYTuxCINQMMUQagcOIRDUBhhbuCTBkMwGvsLDwg0GF8hAZQUgQNnDJMM"
+    "r9b1/uGFhgtwwthNVVf+KQiIMEIiDBCIgynDIBRERGhFwYISBPqIkNGogwX4iI/QiOIiQPBZ"
+    "cRER9cIzA2gb+qCB/WEH60g/rQNdJJGxlOMjgbQaOpAmg2D1CBj+oaQg1egoogahpaXjQMKa"
+    "gPBjRA1Dbv4Q1sIcf////////////////////////////////////IFmpA0AkvUhkhlQQPAr"
+    "gIMgeFsgeBxBAkggTA0rIa9kNe/IZAJBA8vIHgT+FIHjmQPBS8gyeEth5A9HIa2BIgfkEDwU"
+    "iFIHxBA8FUghtkJbeHtL/IElkMu/S291UgeL5A8Cf0YOQPHNNMhleQZP/+6d0g4dNN3rfpV9"
+    "If/Xv00vX/yBoGoP/84n+l7+v/q6/7VeC//V167CDXhf/V1/xH//6tf/3/9J69f//9tf///0"
+    "v////2////9LX////br///9LQIg2UyE8gqTIa08hqzyDZTIsyGu5BofyDU5F8hiZDVgizIbZ"
+    "yGs5EmQVqEVyGa5F4hlnyGlBDZBA8G1yDJhA8NQC/9W2CBB4IGCBhA8EDwQPCBgpDK7ILzwU"
+    "IGEGChAwQMFCBhA1BQoI1hlQUFIaE5F0IOnUgmpBc5BjyDFZE0//rEIPCYQYQwnNQGHpkMs5"
+    "BufXIFzhNMhlnTCDIGDhMIZDYdQuSsgwcg5/77///VtPQYUI2OEeGwoR4iIDRTChdAsKmmFT"
+    "CPjYVBhHBYVUcFhDBQUgXoQI4hsopBjg2jYFzQCDwNzYLr/6sI4L0wjwsIIHQQbBUEGsJ/oL"
+    "008JoIMPTQQa1QQcF9qmug6TtV/+k9BvRwdBBoJB0m9J9HBshl+QMfoLIZfo4VHCZDL9HBtB"
+    "NkC/o4NhBByBj1UOkQ2eQY+6bvbV/S//bp9Ag2gg6TpWQL8k1EJ3fS2IQYhOxCdJ3QIG0ndG"
+    "3rmI8DTd/Wm60qS/9Lp4p10nSfVngzQg/6XCYTwg6txTpcQnVx/6e90m66//b7ptL3W+rq/0"
+    "F003V03Ta9Nf+2utWlrpf+l709Ol/77/hL/3Xp66f/+r1bS61//bHq1/SfXr/S6p69utfHH9"
+    "906em8UktshpYQ2P6X7+v/+/6Xv7pe2vV/2lzH7S1S/CBw/2/0hr7//9Bf/7/X3/9+k2r1SW"
+    "2g0vS//1///CX//e/8H+2lpXvVqkltoNLxEgeBORvr/9f+v/6//shhp/991iulBAsGDRww18"
+    "hkArV+vx9//F//7+vynBo+3WldNN6QMPBAkgwYS8ETv/9el/3////sP/W999JJh6SQYrwjMX"
+    "/8pAy7f/zyf///+w//dLSt+m9Kg16Bf/z4K+0v/b////w3+3X3vapfpA16X1/7aX/t///1+D"
+    "f+tq9JvSvpYYXpf/+wwgv/b////wb/bp6tbvSv2h9L+7/Yr/2//7/vyCuR/r/oxvSS/H/1/8"
+    "ML/2//+tL8H/erSel36/9L6/vBgv/b//f/8P/a/apN2kl//+22r6MArf9v//+n8g1O//TpPS"
+    "Tb6//+l/4S/9v/+0tb//Vtb7VK70iC8f/r1drel/7f//9f/69R/vpJf//q2+3pf+3/+3Wtr9"
+    "er7T0k231//YXS7X1/9v//StJtf+1j40rikq//RhbQTDbRhWyBA+n/7f/7faCte0rtG1qnSb"
+    "df/20uGk3YS4YXv/2//20oaTYRtf7Juwwgt3pXpJf/sILgwgmGQsMMILYYXlIGZ/2H/+2lDB"
+    "BMMJfDSjiuvSt0l/9irMPFMUxVsUnDTtPTYaaYTtO2GEopiFoM0WEmqTenVukP/6jmEnakgC"
+    "6IaE7DIMDJIDBThokNCdyC6cgunLGSGCEYHJANxChMLIaBEQqakMGn0CTB6/+wtIMINBrYLf"
+    "/2F/+wp5INegmmFtNPW//4NDQMIMEDQgwhBsRHEMjhkhAsGEDCxBhBoGEP4jQ4/iIiIhHATi"
+    "OI4iIiP/hBA3/X+Eg///pf9f6T/r/ZA8OLf//+l16T1///a6/S+k9aj//a5Arq0q9JtL//wY"
+    "YQLdtKvSEcdV8gaIddtKvTS20kvj2GEkvrYYIIgeCsOEggyB6sIOtiFFEFsGRPE6AZgsLDCY"
+    "XsFkDYDScREcf////////////////////////////////////4AIAIAADgAAAQMAAQAAAIEI"
+    "AAABAQMAAQAAAIsCAAACAQMAAQAAAAEAAAADAQMAAQAAAAQAAAAGAQMAAQAAAAEAAAARAQQA"
+    "AQAAAAgAAAASAQMAAQAAAAEAAAAVAQMAAQAAAAEAAAAWAQMAAQAAAIsCAAAXAQQAAQAAADcR"
+    "AAAaAQUAAQAAAO4RAAAbAQUAAQAAAPYRAAAcAQMAAQAAAAEAAAAoAQMAAQAAAAIAAAAAAAAA"
+    "AADAEgAABAAAAMASAAAEAA==";
+
+static const char  fontdata_20[] =
+    "SUkqABATAAAmoDgf////////////////////////////+QyQy7IGwGXPIZILLkNA/kDwVrIW"
+    "3IHgvBA8FqE00sgeC9pp5BWhIFSvIHhpOQPDToQK3ILYb01TTINOELmCJwypBY8FVsgy2kQ1"
+    "6BSCocEDBSDQBEFfCBcWINJwQeF/qDCDSCD0m4eCBhSDZWEGFwTwQMIPC1VKQa6keMPTpJu8"
+    "IMKEGmuECwg0fIP3dcIGgg2kE9JukkeGwqDQaWECwj42EEG//wiRhpN6ON0lZDSetBBsFTXw"
+    "gqQQNoJv/9HnJetpIJ1201SSbCpo0JroLQTdP/+EFh6b1ekm060mwRp5mNwQb8JUrat//1uu"
+    "kk+laeklhBaBA6QdZsCsKcAwqdK/qukv3/pXuvbgum4TaMLpUq3T7u9KltVaS61bfpcLp6/p"
+    "Kqp1vr1/1/qlcNpJK2wvfdL0tf3//X/S+qsGMjvrHpuuvS6XS//6//SVWw0c6X/q6+lr/f//"
+    "/pfXhj1b/9L0uv3+mvX/9JJLyGtiX9PX+uvr+/VePpf7YR9f/XGkvqquv/1X+u0klwUi3pL/"
+    "/66Wvf+Qbi/uqWklVhGaY/Xj6XpD3X+I/37pVuCT/36SX6Vpf1/0lpQl6vS/qv0lbr/720u0"
+    "h7hX+/6XkWfVpfv+6pRVbXpL+kvggaqw0r/IHgmELd7aWwldq//SSrwg6qGEtfpW9hoJKu2v"
+    "S/0kvCakWisNL/Xg8MV5DNp43/9IL4h4QaTEJv/4wwSSkEUf6X6gklrhB0+v+yXBmprW//0Q"
+    "06l5mK0k1DDv/5JgUIJrvBf+lB1wgbwnTDbX/Yejyh1sdL/tLhPo8TW9fqgw0kmyC/Eu//0k"
+    "cGH9NxBA2kEGwwjaX6hvIYmleP6X6UEG0tp0n0cbYYS+lyGqESCDSd//+hbXF4TaQSBuK/8h"
+    "tJ8I8w0m/9L9J673VINsL3+YbSQQbSv8gflZA4Cf6TaW9dJBsNJeQPyjD6Te3//+k/+2lTtf"
+    "+G0ltW/+kv0rS+vScGC/9+nr/1+utcijv6STY1/6S3t1/SX6vEfuu6/7/q3+QPDZi7fpa/0r"
+    "/RA8PhC56VN7a/il+lr+tdY/+vt1//pf+krr/6X9/6WulvX/1//+2k9f1pUQ1/30vS6ohmv6"
+    "X22tr/6RBsH//9dV+v9uv0m/SC110vVf/pfsV/9aTrkDELel6X//9tfpfpXX06/pZA8Hj/SS"
+    "6d+sgy3uul+39JWklhB//utsN/BSB4b4lddNpeler6X1rpJX3DtcKn/pdbaTpVpJaa1f/TcP"
+    "+k0m0tItXaX16t0l+vpJOkw0GQg71r7+h2l2k2lVqEv+Hpba2EeRrn/S9patpJthJulbSQX/"
+    "D0km0mdWmKtfdJtJNYYSuGEmwkraQS/4eEttBMQg09de2kQaUiygwiGuTk5ptKmGEEEFtexE"
+    "JJimgwv+kmDBLWK2ITBgkrBgkCC2qwYWDBBhBp0hSDWGIXwuExCoMQgQLERIauiQhggwr8Ug"
+    "whEGCEMEGEIYUFkMkMyMgeC/EMu+qwZwMgMo4B4axwDg8B4axwG0LxEW1SxEREfetL9Uv26p"
+    "L9JfVvpL20kv+qSxbSUd1S26YW2kO2ltpb1tNYj/////////////////////////////////"
+    "5AWBqr/IGoNMEMgk5DJBaGEDYGKyB4FlZA8CjQgtgYghkJ/IGYMUIHCLIKgkCKsC5QCHQNcl"
+    "oaCWBqlIGYVAMFWGCoBcqwXKgCDoDBUBrmoFQ1Bg6g1EQGmVYaREwZCrDSIoCqDIGKEDGhDC"
+    "ghnGEMAyBCchgvZDRWQUYQzaENEyGlMhsBfBAyCuMWRYFYjYaBKcNPQIiYF//9reEHIuG0HB"
+    "hA4r//IMEZBcOuaAeGnCDBA+wg4Pwgf//94QcMIOGEH/+uE1tetMIOyDIKBFAPIKCwhpi5DK"
+    "FQigGEQzCCGaQQzCCGaQQzCEaBmkgFNokBlshpzCJwcMhpaEQgInBwyGloRA0fD8g3IINPkD"
+    "CCDTMgoRkDE7R8NDqvTCJAQNQzMEYQIhsoGZgQ2aBns0BiEaAXtNNNNIJp6baQIG2aAu0CBt"
+    "mgLsIIPtNO01YaIGEUQMISnwy9do0Ah3g6CD5BQG5BRbkG9oIO00000gmm0naCCDDcNhBBhu"
+    "G6DzYYNAxap91oNpN1BV84Kwggw120EHwb38JB//S/vSb20m90nrf+vVtJtKkvQQbQQbvcJN"
+    "Yb/0E//pdrekG9tIN7aT7/v970/pfToIN+2gvb/pL/9L+9Jv0m/S//tLWm1bS/90m19L2/9J"
+    "//S770n3Sb2+v/fb/SetL0m0E97r7f+l/+l6za9X3X6//3Xat02lpf6TaNr9e3/1/+lzac2u"
+    "3pN7pN71//rrTaT1pfT0336Xv/r/+l+v3q/q///71362vXjq6T+vt44pf/pe3Xt9X9X6v/9q"
+    "2u3Tpa/pX39ff//6C/X29X9X/Ecff5tV0m6FLyGQCm5A8ND9Pv0kO/pD/6XvXv9/3//1902l"
+    "apeFg9SGKE/tL////0vtfb0n9J//7XSfb3pLwsOqCe+3qvfr/6XvXt/fXfX+9P/pWlXhYapB"
+    "GZv0vqt/r/0vtfv//1v+1vbSbSdV8Fh1oJtb76X///S969vV9Vfr/f0v6bpLyB4eyDVYSDDS"
+    "0unSfS/yGeMhnhf/S+19+vqvW/+v9tdJL0GEwggw9JJ//S+///9L3r2/v++r/tdJtXSbWvWw"
+    "gQYaWsfTelW//X/pfa+3/pfpMP96b+rrpL7TCCDBpaXr4QS////oL+vvV/V9KH/f/sU2kv+E"
+    "EGGlpV7eCC//1/9L2/2/9L9JmoFn7paTf6pf4QQYaSX6XEwGn//4/0v0vf/S/CCkICn//0mm"
+    "6S/wQRDTKwYaWl/cgQZn8Lhf/X2/2/8JfkKdlICt+1dJvabSr6aCCww6+tJ4P+OP/0/0vb/y"
+    "xwQX5tWD/er/v196CCww0tf+Zh3///F+3/f+1/BMP+//bbSS9hBoILDDS6VJJvBh//zMGv9/"
+    "pe3/wX7Qb/dLSbS40vEQgWGDS//w3///37f7/8F+2Df/v/bVeEEIYaWte3hv6mYEZmBH/5nv"
+    "9fb/x/bIKYT9tbX09Lwggw0v0kvf/ff/9v3r2//9yCwn/66bSV18EEDDrpf+////9v7X77ru"
+    "tsgtB///zadJfCDaX9JN73r/3/7fvXt//9h/20tL0ndL4Qer0lj7fr/yGZZBI/9v7X3//22/"
+    "/fb1vr4Qff6T3//3i//b969vf39sP+2trpJN6XwwX/X/////2/tfb9L0t//rp+vX4YX3SSv7"
+    "6xxshpI/9h+9e339/b//96t6XhhhBPeqSNgY++v4f/2/v+//9v/bSdLpJvrwwYQVu3LrX/fX"
+    "u//t+6XvvW9bb//e2qXpeGGEE3elqrf+v3/+39/t9r37/7df+3peGGQ2ysIJp20sIKv2+v//"
+    "2/0vb+vS7/9dL0vXww8ECG2wk4SW+vX2//w37f7e37+3Xpe+2kk3peGHhBOGKiieU/t9ZDLj"
+    "//28hmR6X36XaW2Qy4+9tLS9W+iDRHhg8IKwwmEq3revW3/+3+3+3t+3W///G/Xpfgw8IJsW"
+    "Cqn6b0tdv/9vXivfdL/vrdW640m9fwwxCCbFL9X0v7//b639vuttLb17qOqW9L8geHshp2GG"
+    "CCIG92q31D0v2//2/69vbS20tvr13dJ9L9MFDDCCCbaVPq3pft//t/v8baXpbeu3tV031+mE"
+    "gwwgVtpLek3hL9v/9v/920tuvtLtL6W9JfvDBhBK2Et9JhkM2NLXb//b12ve0thpbd1tha3S"
+    "fX/wwwgrYYSSvCTDCWCX7D//b//dhpbYS27CXaTtaV6S/pA6Cwwwl+CQYMElIEB6Ww17/bVd"
+    "rtw2Ethpd2lsMJf7ekF/w8LYMIJO0ITIwXEJDTDBqmqemw409Ndgwgkwwwgk24MJJs1DTW0k"
+    "2mh/0HhUGQyQIGCDoMUEECkNCgM1iyGxQQYVkMKMgXUMMJAgbQIiAzg3ZqJEGpQwYJEGpQw5"
+    "0JENRWxXWCwyDWo/aw8JoMQgQMhsBggQYSBAuGJIAxrrYYUgQIwUhgQ4YhYYhbDQhbX4SYev"
+    "sJIPBNBgvkmBwCkaBU4ZAgzf+/v7hgsMLcGFhhU71/40IiDCERILIgREgsCBEcREaEQ4MEJA"
+    "sTiIMEIME9UIiP5BbBq8hkhnmQWy/EgeDIOQUuIZAuEDwZuIHgz0ER9IRHEWZgSgVf0ED9LQ"
+    "f1QQP0tB/pI5g/SpBEQuSe+iByA3HqEDH6UMKINfUUQNgJXfCoGFNYHhlxhAwvogbAzB/hCO"
+    "P/////////////////////////////////+QPFrIGoF8IHYG3PIZIbdkMg4CZA8CIIZAb2QJ"
+    "7IE0NbMg255DIAw5A8PMhkLwpA8H8geBZMgpzCCww/CkDy0IHgVhqQPFDIHgcaEFXRLbyB4L"
+    "0INvL/kFiyDRnpbe6aXrhNP17+0iB4PMhkL0bKQPB/tMhlTIKc//XfSD67vW/2l6Q/+vfqvr"
+    "///zyf6W7XkDUo/9LS/6/C//Ta+uGgwvBf+lev8R//+rX/+v/V/1///q1////V////9K0v//"
+    "/9v////S/////bX///9LnA2ycNKQkyDLMg2/kG2eQ26ZEoQ2oINT+Q0nIkyDEyDa5EoQVzkN"
+    "qCEmQZTkRyDTBF4hmoyGq5Aw5A8FNyBxf/03BAg8EDIbWoIHggeQ19cIGFBcgwfBQgYQMFCB"
+    "ggYKCBhA1ChMEU4ZkFBSGwQRKiC4yyD1EGEENHkFxhEqIaBv/1cQg8JhBhDCDwg9Mg1UIGKa"
+    "4KmmQaKJhAwVBhDIGKKE8g0UIEU9V7X//6sJ6DChQjw2ERAFzxEGGygyBjQho00CyCgMJpkD"
+    "AaDCPjZAvog1IaNFR4WiMB5BNCBhBDP5BQjIEUtHAUEgGAX/6ujYr0wjwsI8LCCDYSQQfX9B"
+    "emE9UEG9MI8L1QQcL7TTSYaIGDpMINTYEL/6sJA+jg2gg4QQOk2FSawjxP9BejxtHieEeJpB"
+    "h6ODaBA16QcF96fp96SS/9XpvhB0EHQQdJvSfQINkM2ZDKnoLIZvoEHQTZDLmgQbSchlzQIN"
+    "hIOQy5qr5DRMhnn/e2ldVX/1e+kG0nSdLIZXqzMGgU7vpcUxCdinSbdIOk7o2eshl+7uk602"
+    "k/pf+r08QnWldW9XhP+lwmnhOtxCbS4hPv/ff9aWv/pX9Wk6T19XTf6XTTdN03TpdOv/06aT"
+    "aT+l/+33ul1rf//oL/9fbX6/9tf20rS6/9LF61169Xr/S6rr2666HH/rTp0nxSS2yGpxAu/7"
+    "ft/6v/v+l7vul7a/f77c2q33SX4Qafpf9Cl///4QX/+//V/2vXulqqW6DX6b/X///9L///S+"
+    "H/1q2k2k9JJbaBpeIgu///X/pf/97/sH+2rdfFWtILDDQa+QyQ31/XX//9P/9f/5qDU/1rdN"
+    "PpJbaPEQzXkMgCsR6/H3/8f/+/r7IgGn7/Tq1dJBh4QVBivBFB///S/7////2H/aVr16qw8J"
+    "JBrwjQT/8gYZt6/59P////Yf7703tvST6SQNegX/8zBT2l/7f//9fhv+6/Sbtav6DXhBfX/t"
+    "pf+3////hv/XSvTekn6UGF6X//tpf+3////g3+9N7/6V6tD//d/sMJf+3///35Bk0/tddJNt"
+    "V/H0v//Yhf+3//daX5AkR+/03o3vpL//0v28ML/2////8H/tK10km7Wv/S/d/wzCBf+3/+/1"
+    "+/771elvSX//1d/pD/7f//WrfkGuP+0tX1b9IgRH//r63hL/2//7Xr/f1+/SpttJf/9em730"
+    "v/b//f1v/7V6er0r9L//XSttb1/9v//rptfr+1jY0ntUq/+197X1/9v/+0rS1/9XqqVtiqX/"
+    "9bQVtowrZDYPr/7D//b7SYa9pW2jCxu6V6//thG/aTdhLbC9/+3/+6VoK1/yKPYS3rSbaS//"
+    "hhLhhJhkMOwwlw15AgaP+3//aVpMMEc/aVhOGEuulfS//iFoMIJhhWKthhJYd2urBra922lB"
+    "ggmK1tJimK/eraSBf/asqIpgwVqGwYJBA2GCDhhA8IG2EDBAwQODBBw2GlFMLCKcDDCVVBu1"
+    "hJh6H/7Cjm0ExQanQMoUQ2F7IEF50DBLhokNghyGC5DBcEDnQHIgEOgFwYIKE1kNgOUGE0wo"
+    "OtoKw9f/a6DQaDC2Cw//sF/+xCn0gwvimg1vXW0//hhDQMIMEDQgwhDYiOLLhkhlBYMEDCxD"
+    "BBoMEO+I44/iIkCThILGBHgTiQyQaOxHIHh+EREa/xFBEM58fH/sIJ/6/wk///pP+l/kDwIK"
+    "////X/3r+uvStf///8ev0nrC+v9pZA8WvSr0g2l//7aXtpfqJTgi4GwGeP16QjtpJeQNAanX"
+    "tL+0tsJJehWwwgklX2GEgkmg6wxCBIgZiCCB+DrDChfCyBtDOdkcDMMcMLEREf//////////"
+    "////////////////////4AIAIAAOAAABAwABAAAATAkAAAEBAwABAAAAcwIAAAIBAwABAAAA"
+    "AQAAAAMBAwABAAAABAAAAAYBAwABAAAAAQAAABEBBAABAAAACAAAABIBAwABAAAAAQAAABUB"
+    "AwABAAAAAQAAABYBAwABAAAAcwIAABcBBAABAAAABxMAABoBBQABAAAAvhMAABsBBQABAAAA"
+    "xhMAABwBAwABAAAAAQAAACgBAwABAAAAAgAAAAAAAAAAAMASAAAEAAAAwBIAAAQA";
+
+#endif  /* LEPTONICA_BMFDATA_H */
+
+

src/windows/leptonica/include/leptonica/bmp.h

@@ -0,0 +1,124 @@
+/*====================================================================*
+ -  Copyright (C) 2001 Leptonica.  All rights reserved.
+ -
+ -  Redistribution and use in source and binary forms, with or without
+ -  modification, are permitted provided that the following conditions
+ -  are met:
+ -  1. Redistributions of source code must retain the above copyright
+ -     notice, this list of conditions and the following disclaimer.
+ -  2. Redistributions in binary form must reproduce the above
+ -     copyright notice, this list of conditions and the following
+ -     disclaimer in the documentation and/or other materials
+ -     provided with the distribution.
+ -
+ -  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ -  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ -  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ -  A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ANY
+ -  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ -  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ -  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ -  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ -  OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ -  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ -  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *====================================================================*/
+
+#ifndef  LEPTONICA_BMP_H
+#define  LEPTONICA_BMP_H
+
+/*!
+ * \file bmp.h
+ *
+ * <pre>
+ * This file is here to describe the fields in the header of
+ * the BMP file.  These fields are not used directly in Leptonica.
+ * The only thing we use are the sizes of these two headers.
+ * Furthermore, because of potential namespace conflicts with
+ * the typedefs and defined sizes, we have changed the names
+ * to protect anyone who may also need to use the original definitions.
+ * Thanks to J. D. Bryan for pointing out the potential problems when
+ * developing on Win32 compatible systems.
+ * </pre>
+ */
+
+/*-------------------------------------------------------------*
+ *                       BMP file header                       *
+ *-------------------------------------------------------------*/
+
+/*! BMP file header
+ *
+ * Notes:
+ *  (1) The bfSize field is stored as a 32 bit integer and includes
+ *      the size of the BMP_FileHeader, BMP_InfoHeader, the color
+ *      table (if any), and the size of the DIB bits.
+ *  (2) The bfOffBits field is also stored as a 32 bit integer and
+ *      contains the absolute offset in bytes of the image data
+ *      in this file. Some bmp files have additional data after the
+ *      BMP_InfoHeader and before the color table (if it exists).
+ *      However, enabling reading of these files makes the reader
+ *      vulnerable to various malware attacks.  Therefore we do not
+ *      read bmp files with extra data, and require that the size
+ *      of the color table in bytes is
+ *         offset - sizeof(BMP_FileHeader) - sizeof(BMP_InfoHeader)
+ *  (3) Use arrays of l_uint8[] to make an endianness agnostic
+ *      access to the BMP_FileHeader easier.
+ */
+struct BMP_FileHeader
+{
+    l_uint8        bfType[2];      /*!< file type; must be "BM"            */
+    l_uint8        bfSize[4];      /*!< length of the file;
+                                       sizeof(BMP_FileHeader) +
+                                       sizeof(BMP_InfoHeader) +
+                                       size of optional extra data +
+                                       size of color table +
+                                       size of DIB bits                    */
+    l_uint8        bfReserved1[2]; /*!< don't care (set to 0)              */
+    l_uint8        bfReserved2[2]; /*!< don't care (set to 0)              */
+    l_uint8        bfOffBits[4];   /*!< offset from beginning of file      */
+};
+typedef struct BMP_FileHeader  BMP_FH;
+
+/*! Number of bytes in a BMP file header */
+#define BMP_FHBYTES  sizeof(BMP_FH)
+
+
+/*-------------------------------------------------------------*
+ *                       BMP info header                       *
+ *-------------------------------------------------------------*/
+
+/*! BMP info header */
+struct BMP_InfoHeader
+{
+    l_int32        biSize;          /*!< size of the BMP_InfoHeader struct   */
+    l_int32        biWidth;         /*!< bitmap width in pixels              */
+    l_int32        biHeight;        /*!< bitmap height in pixels             */
+    l_int16        biPlanes;        /*!< number of bitmap planes             */
+    l_int16        biBitCount;      /*!< number of bits per pixel            */
+    l_int32        biCompression;   /*!< compress format (0 == uncompressed) */
+    l_int32        biSizeImage;     /*!< size of image in bytes              */
+    l_int32        biXPelsPerMeter; /*!< pixels per meter in x direction     */
+    l_int32        biYPelsPerMeter; /*!< pixels per meter in y direction     */
+    l_int32        biClrUsed;       /*!< number of colors used               */
+    l_int32        biClrImportant;  /*!< number of important colors used     */
+};
+typedef struct BMP_InfoHeader  BMP_IH;
+
+/*! Number of bytes in a BMP info header */
+#define BMP_IHBYTES  sizeof(BMP_IH)
+
+
+/*-------------------------------------------------------------*
+ *           Align BMP headers on 4 byte boundaries            *
+ *-------------------------------------------------------------*/
+
+/*! BMP_IH is misaligned, causing crashes on some big-endians.
+ *  A packed struct forces alignment. */
+#if defined(__GNUC__)
+typedef struct __attribute__((__packed__)) {
+  BMP_FH bmpfh;
+  BMP_IH bmpih;
+} BMP_HEADER;
+#endif
+
+#endif  /* LEPTONICA_BMP_H */

src/windows/leptonica/include/leptonica/ccbord.h

@@ -0,0 +1,62 @@
+/*====================================================================*
+ -  Copyright (C) 2001 Leptonica.  All rights reserved.
+ -
+ -  Redistribution and use in source and binary forms, with or without
+ -  modification, are permitted provided that the following conditions
+ -  are met:
+ -  1. Redistributions of source code must retain the above copyright
+ -     notice, this list of conditions and the following disclaimer.
+ -  2. Redistributions in binary form must reproduce the above
+ -     copyright notice, this list of conditions and the following
+ -     disclaimer in the documentation and/or other materials
+ -     provided with the distribution.
+ -
+ -  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ -  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ -  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ -  A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ANY
+ -  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ -  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ -  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ -  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ -  OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ -  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ -  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *====================================================================*/
+
+#ifndef  LEPTONICA_CCBORD_H
+#define  LEPTONICA_CCBORD_H
+
+/*!
+ * \file ccbord.h
+ *
+ * <pre>
+ *
+ *    This is the public interface for representing all foreground pixels
+ *    in an image by the border pixels of connected components.  It contains
+ *    typedefs for data structures and enums for function inputs.
+ * </pre>
+ */
+
+/*! A single CCBord for a connected component */
+typedef struct CCBord CCBORD;
+
+/*! Array of CCBord */
+typedef struct CCBorda CCBORDA;
+
+    /*! Use in ccbaStepChainsToPixCoords() */
+/*! CCB Coords */
+enum {
+      CCB_LOCAL_COORDS = 1,
+      CCB_GLOBAL_COORDS = 2
+};
+
+    /*! Use in ccbaGenerateSPGlobalLocs() */
+/*! CCB Points */
+enum {
+      CCB_SAVE_ALL_PTS = 1,
+      CCB_SAVE_TURNING_PTS = 2
+};
+
+#endif  /* LEPTONICA_CCBORD_H */
+

src/windows/leptonica/include/leptonica/ccbord_internal.h

@@ -0,0 +1,107 @@
+/*====================================================================*
+ -  Copyright (C) 2001 Leptonica.  All rights reserved.
+ -
+ -  Redistribution and use in source and binary forms, with or without
+ -  modification, are permitted provided that the following conditions
+ -  are met:
+ -  1. Redistributions of source code must retain the above copyright
+ -     notice, this list of conditions and the following disclaimer.
+ -  2. Redistributions in binary form must reproduce the above
+ -     copyright notice, this list of conditions and the following
+ -     disclaimer in the documentation and/or other materials
+ -     provided with the distribution.
+ -
+ -  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ -  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ -  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ -  A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ANY
+ -  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ -  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ -  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ -  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ -  OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ -  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ -  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *====================================================================*/
+
+#ifndef  LEPTONICA_CCBORD_INTERNAL_H
+#define  LEPTONICA_CCBORD_INTERNAL_H
+
+/*!
+ * \file ccbord_internal.h
+ *
+ * <pre>
+ *
+ *    This file is internal; it is not part of the public interface.
+ *    It contains definitions of data structures that use border pixels
+ *    of connected components to represent the foreground pixels
+ *    in an image by the border
+ *
+ *        CCBord:   represents a single connected component
+ *        CCBorda:  an array of CCBord
+ *
+ *    The CCBord contains:
+ *
+ *    (1) a minimally-clipped bitmap of the component (pix),
+ *    (2) a boxa consisting of:
+ *          for the primary component:
+ *                (xul, yul) pixel location in global coords
+ *                (w, h) of the bitmap
+ *          for the hole components:
+ *                (x, y) in relative coordinates in primary component
+ *                (w, h) of the hole border (which is 2 pixels
+ *                       larger in each direction than the hole itself)
+ *    (3) a pta ('start') of the initial border pixel location for each
+ *        closed curve, all in relative coordinates of the primary
+ *        component.  This is given for the primary component,
+ *        followed by the hole components, if any.
+ *    (4) a refcount of the ccbord; used internally when a ccbord
+ *        is accessed from a ccborda (array of ccbord)
+ *    (5) a ptaa for the chain code for the border in relative
+ *        coordinates, where the first pta is the exterior border
+ *        and all other pta are for interior borders (holes)
+ *    (6) a ptaa for the global pixel loc rendition of the border,
+ *        where the first pta is the exterior border and all other
+ *        pta are for interior borders (holes).
+ *        This is derived from the local or step chain code.
+ *    (7) a numaa for the chain code for the border as orientation
+ *        directions between successive border pixels, where
+ *        the first numa is the exterior border and all other
+ *        numa are for interior borders (holes).  This is derived
+ *        from the local chain code.  The 8 directions are 0 - 7.
+ *    (8) a pta for a single chain for each c.c., comprised of outer
+ *        and hole borders, plus cut paths between them, all in
+ *        local coords.
+ *    (9) a pta for a single chain for each c.c., comprised of outer
+ *        and hole borders, plus cut paths between them, all in
+ *        global coords.
+ * </pre>
+ */
+
+/*! A single CCBord for a connected component */
+struct CCBord
+{
+    struct Pix          *pix;          /*!< component bitmap (min size)      */
+    struct Boxa         *boxa;         /*!< regions of each closed curve     */
+    struct Pta          *start;        /*!< initial border pixel locations   */
+    l_atomic             refcount;     /*!< number of handles; start at 1    */
+    struct Ptaa         *local;        /*!< ptaa of chain pixels (local)     */
+    struct Ptaa         *global;       /*!< ptaa of chain pixels (global)    */
+    struct Numaa        *step;         /*!< numaa of chain code (step dir)   */
+    struct Pta          *splocal;      /*!< pta of single chain (local)      */
+    struct Pta          *spglobal;     /*!< pta of single chain (global)     */
+};
+
+/*! Array of CCBord */
+struct CCBorda
+{
+    struct Pix          *pix;          /*!< input pix (may be null)          */
+    l_int32              w;            /*!< width of pix                     */
+    l_int32              h;            /*!< height of pix                    */
+    l_int32              n;            /*!< number of ccbord in ptr array    */
+    l_int32              nalloc;       /*!< number of ccbord ptrs allocated  */
+    struct CCBord      **ccb;          /*!< ccb ptr array                    */
+};
+
+#endif  /* LEPTONICA_CCBORD_INTERNAL_H */
+

src/windows/leptonica/include/leptonica/colorfill.h

@@ -0,0 +1,67 @@
+/*====================================================================*
+ -  Copyright (C) 2001 Leptonica.  All rights reserved.
+ -
+ -  Redistribution and use in source and binary forms, with or without
+ -  modification, are permitted provided that the following conditions
+ -  are met:
+ -  1. Redistributions of source code must retain the above copyright
+ -     notice, this list of conditions and the following disclaimer.
+ -  2. Redistributions in binary form must reproduce the above
+ -     copyright notice, this list of conditions and the following
+ -     disclaimer in the documentation and/or other materials
+ -     provided with the distribution.
+ -
+ -  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ -  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ -  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ -  A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ANY
+ -  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ -  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ -  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ -  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ -  OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ -  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ -  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *====================================================================*/
+
+#ifndef  LEPTONICA_COLORFILL_H
+#define  LEPTONICA_COLORFILL_H
+
+/*!
+ * \file colorfill.h
+ *
+ * <pre>
+ *  Contains the following struct
+ *      struct L_Colorfill
+ *
+ *  This accumulates color information, linked to location, within a
+ *  set of tiles that (mostly) covers an input RGB image.
+ * </pre>
+ */
+
+
+/*------------------------------------------------------------------------*
+ *                            Colorfill data                              *
+ *------------------------------------------------------------------------*/
+/*! Colorfill data */
+struct L_Colorfill
+{
+    struct Pix     *pixs;        /*!< clone of source pix                    */
+    struct Pix     *pixst;       /*!< source pix, after optional transform   */
+    l_int32         nx;          /*!< number of tiles in each tile row       */
+    l_int32         ny;          /*!< number of tiles in each tile column    */
+    l_int32         tw;          /*!< width of each tile                     */
+    l_int32         th;          /*!< height of each tile                    */
+    l_int32         minarea;     /*!< min number of pixels in a color region */
+    struct Boxa    *boxas;       /*!< tile locations                         */
+    struct Pixa    *pixas;       /*!< tiles from source pix                  */
+    struct Pixa    *pixam;       /*!< mask tiles with components covering    */
+                                 /*!< regions with similar color             */
+    struct Numaa   *naa;         /*!< sizes of color regions (in pixels)     */
+    struct L_Dnaa  *dnaa;        /*!< average color in each region           */
+    struct Pixa    *pixadb;      /*!< debug reconstruction from segmentation */
+};
+typedef struct L_Colorfill  L_COLORFILL;
+
+
+#endif  /* LEPTONICA_COLORFILL_H */

src/windows/leptonica/include/leptonica/dewarp.h

@@ -0,0 +1,191 @@
+/*====================================================================*
+ -  Copyright (C) 2001 Leptonica.  All rights reserved.
+ -
+ -  Redistribution and use in source and binary forms, with or without
+ -  modification, are permitted provided that the following conditions
+ -  are met:
+ -  1. Redistributions of source code must retain the above copyright
+ -     notice, this list of conditions and the following disclaimer.
+ -  2. Redistributions in binary form must reproduce the above
+ -     copyright notice, this list of conditions and the following
+ -     disclaimer in the documentation and/or other materials
+ -     provided with the distribution.
+ -
+ -  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ -  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ -  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ -  A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ANY
+ -  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ -  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ -  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ -  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ -  OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ -  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ -  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *====================================================================*/
+
+#ifndef  LEPTONICA_DEWARP_H
+#define  LEPTONICA_DEWARP_H
+
+/*!
+ * \file dewarp.h
+ *
+ * <pre>
+ *     Data structure to hold arrays and results for generating
+ *     horizontal and vertical disparity arrays based on textlines.
+ *     Each disparity array is two-dimensional.  The vertical disparity
+ *     array gives a vertical displacement, relative to the lowest point
+ *     in the textlines.  The horizontal disparty array gives a horizontal
+ *     displacement, relative to the minimum values (for even pages)
+ *     or maximum values (for odd pages) of the left and right ends of
+ *     full textlines.  Horizontal alignment always involves translations
+ *     away from the book gutter.
+ *
+ *     We have intentionally separated the process of building models
+ *     from the rendering process that uses the models.  For any page,
+ *     the building operation either creates an actual model (that is,
+ *     a model with at least the vertical disparity being computed, and
+ *     for which the 'success' flag is set) or fails to create a model.
+ *     However, at rendering time, a page can have one of two different
+ *     types of models.
+ *     (1) A valid model is an actual model that meets the rendering
+ *         constraints, which are limits on model curvature parameters.
+ *         See dewarpaTestForValidModel() for details.
+ *         Valid models are identified by dewarpaInsertRefModels(),
+ *         which sets the 'vvalid' and 'hvalid' fields.  Only valid
+ *         models are used for rendering.
+ *     (2) A reference model is used by a page that doesn't have
+ *         a valid model, but has a nearby valid model of the same
+ *         parity (even/odd page) that it can use.  The range in pages
+ *         to search for a valid model is given by the 'maxdist' field.
+ *
+ *     At the rendering stage, vertical and horizontal disparities are
+ *     treated differently.  It is somewhat more robust to generate
+ *     vertical disparity models (VDM) than horizontal disparity
+ *     models (HDM). A valid VDM is required for any correction to
+ *     be made; if a valid VDM is not available, just use the input
+ *     image.  Otherwise, assuming it is available, the use of the
+ *     HDM is controlled by two fields: 'useboth' and 'check_columns'.
+ *       (a) With useboth == 0, we use only the VDM.
+ *       (b) With useboth == 1, we require using the VDM and, if a valid
+ *           horizontal disparity model (HDM) is available, we also use it.
+ *       (c) With check_columns == 1, check for multiple columns and if
+ *           true, only use the VDM, even if a valid HDM is available.
+ *           Note that 'check_columns' takes precedence over 'useboth'
+ *           when there is more than 1 column of text.  By default,
+ *           check_columns == 0.
+ *
+ *     The 'maxdist' parameter is input when the dewarpa is created.
+ *     The other rendering parameters have default values given in dewarp1.c.
+ *     All parameters used by rendering can be set (or reset) using accessors.
+ *
+ *     After dewarping, use of the VDM will cause all points on each
+ *     altered curve to have a y-value equal to the minimum.  Use of
+ *     the HDA will cause the left and right edges of the textlines
+ *     to be vertically aligned if they had been typeset flush-left
+ *     and flush-right, respectively.
+ *
+ *     The sampled disparity arrays are expanded to full resolution,
+ *     using linear interpolation, and this is further expanded
+ *     by slope continuation to the right and below if the image
+ *     is larger than the full resolution disparity arrays.  Then
+ *     the disparity correction can be applied to the input image.
+ *     If the input pix are 2x reduced, the expansion from sampled
+ *     to full res uses the product of (sampling) * (redfactor).
+ *
+ *     The most accurate results are produced at full resolution, and
+ *     this is generally recommended.
+ * </pre>
+ */
+
+    /*! Dewarp version for serialization
+     * <pre>
+     * Note on versioning of the serialization of this data structure:
+     * The dewarping utility and the stored data can be expected to change.
+     * In most situations, the serialized version is ephemeral -- it is
+     * not needed after being used.  No functions will be provided to
+     * convert between different versions.
+     * </pre>
+     */
+#define  DEWARP_VERSION_NUMBER      4
+
+/*! Data structure to hold a number of Dewarp */
+struct L_Dewarpa
+{
+    l_int32            nalloc;        /*!< size of dewarp ptr array          */
+    l_int32            maxpage;       /*!< maximum page number in array      */
+    struct L_Dewarp  **dewarp;        /*!< array of ptrs to page dewarp      */
+    struct L_Dewarp  **dewarpcache;   /*!< array of ptrs to cached dewarps   */
+    struct Numa       *namodels;      /*!< list of page numbers for pages    */
+                                      /*!< with page models                  */
+    struct Numa       *napages;       /*!< list of page numbers with either  */
+                                      /*!< page models or ref page models    */
+    l_int32            redfactor;     /*!< reduction factor of input: 1 or 2 */
+    l_int32            sampling;      /*!< disparity arrays sampling factor  */
+    l_int32            minlines;      /*!< min number of long lines required */
+    l_int32            maxdist;       /*!< max distance for getting ref page */
+    l_int32            max_linecurv;  /*!< maximum abs line curvature,       */
+                                      /*!< in micro-units                    */
+    l_int32            min_diff_linecurv; /*!< minimum abs diff line         */
+                                          /*!< curvature in micro-units      */
+    l_int32            max_diff_linecurv; /*!< maximum abs diff line         */
+                                          /*!< curvature in micro-units      */
+    l_int32            max_edgeslope; /*!< maximum abs left or right edge    */
+                                      /*!< slope, in milli-units             */
+    l_int32            max_edgecurv;  /*!< maximum abs left or right edge    */
+                                      /*!< curvature, in micro-units         */
+    l_int32            max_diff_edgecurv; /*!< maximum abs diff left-right   */
+                                      /*!< edge curvature, in micro-units    */
+    l_int32            useboth;       /*!< use both disparity arrays if      */
+                                      /*!< available; only vertical otherwise */
+    l_int32            check_columns; /*!< if there are multiple columns,    */
+                                      /*!< only use the vertical disparity   */
+                                      /*!< array                             */
+    l_int32            modelsready;   /*!< invalid models have been removed  */
+                                      /*!< and refs built against valid set  */
+};
+typedef struct L_Dewarpa L_DEWARPA;
+
+
+/*! Data structure for a single dewarp */
+struct L_Dewarp
+{
+    struct L_Dewarpa  *dewa;         /*!< ptr to parent (not owned)          */
+    struct Pix        *pixs;         /*!< source pix, 1 bpp                  */
+    struct FPix       *sampvdispar;  /*!< sampled vert disparity array       */
+    struct FPix       *samphdispar;  /*!< sampled horiz disparity array      */
+    struct FPix       *sampydispar;  /*!< sampled slope h-disparity array    */
+    struct FPix       *fullvdispar;  /*!< full vert disparity array          */
+    struct FPix       *fullhdispar;  /*!< full horiz disparity array         */
+    struct FPix       *fullydispar;  /*!< full slope h-disparity array       */
+    struct Numa       *namidys;      /*!< sorted y val of midpoint each line */
+    struct Numa       *nacurves;     /*!< sorted curvature of each line      */
+    l_int32            w;            /*!< width of source image              */
+    l_int32            h;            /*!< height of source image             */
+    l_int32            pageno;       /*!< page number; important for reuse   */
+    l_int32            sampling;     /*!< sampling factor of disparity arrays */
+    l_int32            redfactor;    /*!< reduction factor of pixs: 1 or 2   */
+    l_int32            minlines;     /*!< min number of long lines required  */
+    l_int32            nlines;       /*!< number of long lines found         */
+    l_int32            mincurv;      /*!< min line curvature in micro-units  */
+    l_int32            maxcurv;      /*!< max line curvature in micro-units  */
+    l_int32            leftslope;    /*!< left edge slope in milli-units     */
+    l_int32            rightslope;   /*!< right edge slope in milli-units    */
+    l_int32            leftcurv;     /*!< left edge curvature in micro-units */
+    l_int32            rightcurv;    /*!< right edge curvature in micro-units*/
+    l_int32            nx;           /*!< number of sampling pts in x-dir    */
+    l_int32            ny;           /*!< number of sampling pts in y-dir    */
+    l_int32            hasref;       /*!< 0 if normal; 1 if has a refpage    */
+    l_int32            refpage;      /*!< page with disparity model to use   */
+    l_int32            vsuccess;     /*!< sets to 1 if vert disparity builds */
+    l_int32            hsuccess;     /*!< sets to 1 if horiz disparity builds */
+    l_int32            ysuccess;     /*!< sets to 1 if slope disparity builds */
+    l_int32            vvalid;       /*!< sets to 1 if valid vert disparity  */
+    l_int32            hvalid;       /*!< sets to 1 if valid horiz disparity */
+    l_int32            skip_horiz;   /*!< if 1, skip horiz disparity         */
+                                     /*!< correction                         */
+    l_int32            debug;        /*!< set to 1 if debug output requested */
+};
+typedef struct L_Dewarp L_DEWARP;
+
+#endif  /* LEPTONICA_DEWARP_H */

src/windows/leptonica/include/leptonica/endianness.h

@@ -0,0 +1,11 @@
+#if !defined (L_BIG_ENDIAN) && !defined (L_LITTLE_ENDIAN)
+# if 0
+#  ifdef __BIG_ENDIAN__
+#   define L_BIG_ENDIAN
+#  else
+#   define L_LITTLE_ENDIAN
+#  endif
+# else
+#  define L_LITTLE_ENDIAN
+# endif
+#endif

src/windows/leptonica/include/leptonica/environ.h

@@ -0,0 +1,608 @@
+/*====================================================================*
+ -  Copyright (C) 2001 Leptonica.  All rights reserved.
+ -
+ -  Redistribution and use in source and binary forms, with or without
+ -  modification, are permitted provided that the following conditions
+ -  are met:
+ -  1. Redistributions of source code must retain the above copyright
+ -     notice, this list of conditions and the following disclaimer.
+ -  2. Redistributions in binary form must reproduce the above
+ -     copyright notice, this list of conditions and the following
+ -     disclaimer in the documentation and/or other materials
+ -     provided with the distribution.
+ -
+ -  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ -  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ -  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ -  A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ANY
+ -  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ -  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ -  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ -  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ -  OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ -  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ -  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *====================================================================*/
+
+#ifndef  LEPTONICA_ENVIRON_H
+#define  LEPTONICA_ENVIRON_H
+
+/*------------------------------------------------------------------------*
+ *  Defines and includes differ for Unix and Windows.  Also for Windows,  *
+ *  differentiate between conditionals based on platform and compiler.    *
+ *      For platforms:                                                    *
+ *          _WIN32       =>     Windows, 32- or 64-bit                    *
+ *          _WIN64       =>     Windows, 64-bit only                      *
+ *          __CYGWIN__   =>     Cygwin                                    *
+ *      For compilers:                                                    *
+ *          __GNUC__     =>     gcc                                       *
+ *          _MSC_VER     =>     msvc                                      *
+ *------------------------------------------------------------------------*/
+
+/* MS VC++ does not provide stdint.h, so define the missing types here */
+
+
+#ifndef _MSC_VER
+#include <stdint.h>
+
+#else
+/* Note that _WIN32 is defined for both 32 and 64 bit applications,
+   whereas _WIN64 is defined only for the latter */
+
+#ifdef _WIN64
+typedef __int64 intptr_t;
+typedef unsigned __int64 uintptr_t;
+#else
+typedef int intptr_t;
+typedef unsigned int uintptr_t;
+#endif
+
+/* VC++6 doesn't seem to have powf, expf. */
+#if (_MSC_VER < 1400)
+#define powf(x, y) (float)pow((double)(x), (double)(y))
+#define expf(x) (float)exp((double)(x))
+#endif
+
+#endif /* _MSC_VER */
+
+#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) && !defined(__STDC_NO_ATOMICS__)
+#include <stdatomic.h>
+typedef atomic_int l_atomic;
+#else
+typedef int l_atomic;
+#endif
+
+#ifndef LEPT_DLL
+  /* Windows specifics */
+  #ifdef _WIN32
+    /* DLL EXPORTS and IMPORTS */
+    #if defined(LIBLEPT_EXPORTS)
+      #define LEPT_DLL __declspec(dllexport)
+    #elif defined(LIBLEPT_IMPORTS)
+      #define LEPT_DLL __declspec(dllimport)
+    #else
+      #define LEPT_DLL
+    #endif
+  #else  /* non-Windows specifics */
+    #define LEPT_DLL
+  #endif  /* _WIN32 */
+#endif  /* LEPT_DLL */
+
+#ifndef _WIN32  /* non-Windows specifics */
+  #include <stdint.h>
+#endif  /* _WIN32 */
+
+#ifdef __APPLE__
+  #include <Availability.h>
+#endif /* __APPLE__ */
+
+typedef intptr_t l_intptr_t;
+typedef uintptr_t l_uintptr_t;
+
+
+/*--------------------------------------------------------------------*
+ * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*
+ *                          USER CONFIGURABLE                         *
+ * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*
+ *               Environment variables with I/O libraries             *
+ *               Manual Configuration Only: NOT AUTO_CONF             *
+ *--------------------------------------------------------------------*/
+/*
+ *  Leptonica provides interfaces to link to several external image
+ *  I/O libraries, plus zlib.  Setting any of these to 0 here causes
+ *  non-functioning stubs to be linked.
+ */
+#if !defined(HAVE_CONFIG_H) && !defined(ANDROID_BUILD) && !defined(OS_IOS)
+
+  #if !defined(HAVE_LIBJPEG)
+  #define  HAVE_LIBJPEG       1
+  #endif
+  #if !defined(HAVE_LIBTIFF)
+  #define  HAVE_LIBTIFF       1
+  #endif
+  #if !defined(HAVE_LIBPNG)
+  #define  HAVE_LIBPNG        1
+  #endif
+  #if !defined(HAVE_LIBZ)
+  #define  HAVE_LIBZ          1
+  #endif
+  #if !defined(HAVE_LIBGIF)
+  #define  HAVE_LIBGIF        0
+  #endif
+  #if !defined(HAVE_LIBUNGIF)
+  #define  HAVE_LIBUNGIF      0
+  #endif
+  #if !defined(HAVE_LIBWEBP)
+  #define  HAVE_LIBWEBP       0
+  #endif
+  #if !defined(HAVE_LIBWEBP_ANIM)
+  #define  HAVE_LIBWEBP_ANIM  0
+  #endif
+  #if !defined(HAVE_LIBJP2K)
+  #define  HAVE_LIBJP2K       0
+  #endif
+
+
+  /*-----------------------------------------------------------------------*
+   * Leptonica supports OpenJPEG 2.0+.  If you have a version of openjpeg  *
+   * (HAVE_LIBJP2K == 1) that is >= 2.0, set the path to the openjpeg.h    *
+   * header in angle brackets here.                                        *
+   *-----------------------------------------------------------------------*/
+  #define  LIBJP2K_HEADER   <openjpeg-2.3/openjpeg.h>
+
+#endif  /* ! HAVE_CONFIG_H etc. */
+
+/*--------------------------------------------------------------------*
+ * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*
+ *                          USER CONFIGURABLE                         *
+ * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*
+ *     Environ variables for image I/O without external libraries     *
+ *--------------------------------------------------------------------*/
+/*
+ *  Leptonica supplies I/O support without using external libraries for:
+ *     * image read/write for bmp, pnm
+ *     * header read for jp2k
+ *     * image wrapping write for pdf and ps.
+ *  Setting any of these to 0 causes non-functioning stubs to be linked.
+ */
+#define  USE_BMPIO        1
+#define  USE_PNMIO        1
+#define  USE_JP2KHEADER   1
+#define  USE_PDFIO        1
+#define  USE_PSIO         1
+
+
+/*-------------------------------------------------------------------------*
+ * On linux, BSD, macOS (> 10.12), android (sdk >= 23) and iOS(>= 11.0),
+ * you can redirect writing data from a filestream to memory using
+ * open_memstream() and redirect reading data from a filestream to
+ * reading from memory using fmemopen().
+ * Specifically, you can compress (write compressed data to memory
+ * from raster data in a Pix) and uncompress (read from compressed data
+ * in memory to raster data in a Pix).
+ * For png, tiff and webp, data is compressed and uncompressed directly
+ * to memory without the use of the POSIX.1 (2008) functions fmemopen()
+ * and open_memstream().
+ * For jpeg, jp2k, gif, pnm and bmp, these functions are used on systems
+ * that support them, and for those we define HAVE_FMEMOPEN to 1.
+ *-------------------------------------------------------------------------*/
+#if !defined(HAVE_CONFIG_H) && \
+    (!defined(ANDROID_BUILD) || __ANDROID_API__ >= 23) && \
+    (!defined(__IPHONE_OS_VERSION_MIN_REQUIRED) || \
+              __IPHONE_OS_VERSION_MIN_REQUIRED >= 110000) && \
+    (!defined(__MAC_OS_X_VERSION_MIN_REQUIRED) || \
+              __MAC_OS_X_VERSION_MIN_REQUIRED > 101200) && \
+    !defined(_WIN32)
+#define  HAVE_FMEMOPEN    1
+#endif  /* ! HAVE_CONFIG_H etc. */
+
+/*-------------------------------------------------------------------------*
+ * fstatat() is defined by POSIX, but some systems do not support it.      *
+ * One example is older macOS systems (pre-10.10).                         *
+ * Also, dirfd() is required by fstatat().                                 *
+ * Play it safe and set the default values to 0.                           *
+ *-------------------------------------------------------------------------*/
+#if !defined(HAVE_CONFIG_H)
+#define  HAVE_FSTATAT     0
+#define  HAVE_DIRFD       0
+#endif /* ! HAVE_CONFIG_H */
+
+/*--------------------------------------------------------------------*
+ * It is desirable on Windows to have all temp files written to the same
+ * subdirectory of the Windows <Temp> directory, because files under <Temp>
+ * persist after reboot, and the regression tests write a lot of files.
+ * We write all test files to /tmp/lept or subdirectories of /tmp/lept.
+ * Windows temp files are specified as in unix, but have the translation
+ *        /tmp/lept/xxx  -->   <Temp>/lept/xxx
+ *--------------------------------------------------------------------*/
+
+
+/*--------------------------------------------------------------------*
+ *                          Built-in types                            *
+ *--------------------------------------------------------------------*/
+typedef int                     l_ok;    /*!< return type 0 if OK, 1 on error */
+typedef signed char             l_int8;     /*!< signed 8-bit value */
+typedef unsigned char           l_uint8;    /*!< unsigned 8-bit value */
+typedef short                   l_int16;    /*!< signed 16-bit value */
+typedef unsigned short          l_uint16;   /*!< unsigned 16-bit value */
+typedef int                     l_int32;    /*!< signed 32-bit value */
+typedef unsigned int            l_uint32;   /*!< unsigned 32-bit value */
+typedef float                   l_float32;  /*!< 32-bit floating point value */
+typedef double                  l_float64;  /*!< 64-bit floating point value */
+#ifdef COMPILER_MSVC
+typedef __int64                 l_int64;    /*!< signed 64-bit value */
+typedef unsigned __int64        l_uint64;   /*!< unsigned 64-bit value */
+#else
+typedef long long               l_int64;    /*!< signed 64-bit value */
+typedef unsigned long long      l_uint64;   /*!< unsigned 64-bit value */
+#endif  /* COMPILER_MSVC */
+
+
+/*-------------------------------------------------------------------------*
+ * For security, the library is distributed in a configuration that does   *
+ * not permit (1) forking with 'system', which is used for displaying      *
+ * images and generating gnuplots, and (2) writing files with specified    *
+ * compiled-in file names.  All such writes are with functions such as     *
+ * pixWriteDebug() where the "Debug" is appended to the usual name.        *
+ * Whether the "Debug" version defaults to the standard version or is a    *
+ * no-op depends on the value of this global variable.  The default value  *
+ * of LeptDebugOK is 0, and it is set in writefile.c.  This value can be   *
+ * over-ridden, for development and debugging, by setLeptDebugOK().        *
+ *-------------------------------------------------------------------------*/
+LEPT_DLL extern l_int32  LeptDebugOK;  /* default is 0 */
+
+
+/*------------------------------------------------------------------------*
+ *                            Standard macros                             *
+ *------------------------------------------------------------------------*/
+#ifndef L_MIN
+/*! Minimum of %x and %y */
+#define L_MIN(x, y)   (((x) < (y)) ? (x) : (y))
+#endif
+
+#ifndef L_MAX
+/*! Maximum of %x and %y */
+#define L_MAX(x, y)   (((x) > (y)) ? (x) : (y))
+#endif
+
+#ifndef L_ABS
+/*! Absolute value of %x */
+#define L_ABS(x)     (((x) < 0) ? (-1 * (x)) : (x))
+#endif
+
+#ifndef L_SIGN
+/*! Sign of %x */
+#define L_SIGN(x)    (((x) < 0) ? -1 : 1)
+#endif
+
+#ifndef UNDEF
+/*! Undefined value */
+#define UNDEF        -1
+#endif
+
+#ifndef NULL
+/*! NULL value */
+#define NULL          0
+#endif
+
+#ifndef TRUE
+/*! True value */
+#define TRUE          1
+#endif
+
+#ifndef FALSE
+/*! False value */
+#define FALSE         0
+#endif
+
+
+/*--------------------------------------------------------------------*
+ *            Environment variables for endian dependence             *
+ *--------------------------------------------------------------------*/
+/*
+ *  To control conditional compilation, one of two variables
+ *
+ *       L_LITTLE_ENDIAN  (e.g., for Intel X86)
+ *       L_BIG_ENDIAN     (e.g., for Sun SPARC, Mac Power PC)
+ *
+ *  is defined when the GCC compiler is invoked.
+ *  All code should compile properly for both hardware architectures.
+ */
+
+
+/*------------------------------------------------------------------------*
+ *                    Simple search state variables                       *
+ *------------------------------------------------------------------------*/
+/*! Search State */
+enum {
+    L_NOT_FOUND = 0,
+    L_FOUND = 1
+};
+
+
+/*------------------------------------------------------------------------*
+ *                     Path separator conversion                          *
+ *------------------------------------------------------------------------*/
+/*! Path Separators */
+enum {
+    UNIX_PATH_SEPCHAR = 0,
+    WIN_PATH_SEPCHAR = 1
+};
+
+
+/*------------------------------------------------------------------------*
+ *                          Timing structs                                *
+ *------------------------------------------------------------------------*/
+typedef void *L_TIMER;
+
+/*! Timing struct */
+struct L_WallTimer {
+    l_int32  start_sec;
+    l_int32  start_usec;
+    l_int32  stop_sec;
+    l_int32  stop_usec;
+};
+typedef struct L_WallTimer  L_WALLTIMER;
+
+
+/*------------------------------------------------------------------------*
+ *                      Standard memory allocation                        *
+ *                                                                        *
+ *  All default heap allocation is through the system malloc and free.    *
+ *                                                                        *
+ *  Leptonica also provides non-default allocation in two situations:     *
+ *                                                                        *
+ *  (1) A special allocator/deallocator pair can be provided for the      *
+ *      pix image data array.  This might be useful to prevent memory     *
+ *      fragmentation when large images are repeatedly allocated and      *
+ *      freed.  See the PixMemoryManager in pix1.c for details,           *
+ *      where the default is defined.                                     *
+ *                                                                        *
+ *  (2) Special allocator/deallocators can be provided for ALL heap       *
+ *      allocation if required, for example, for embedded systems.        *
+ *      For such builds, define LEPTONICA_INTERCEPT_ALLOC, and provide    *
+ *      custom leptonica_{malloc, calloc, realloc, free} functions.       *
+ *------------------------------------------------------------------------*/
+#ifdef LEPTONICA_INTERCEPT_ALLOC
+  #define LEPT_MALLOC(blocksize)           leptonica_malloc(blocksize)
+  #define LEPT_CALLOC(numelem, elemsize)   leptonica_calloc(numelem, elemsize)
+  #define LEPT_REALLOC(ptr, blocksize)     leptonica_realloc(ptr, blocksize)
+  #define LEPT_FREE(ptr)                   leptonica_free(ptr)
+  void *leptonica_malloc(size_t blocksize);
+  void *leptonica_calloc(size_t numelem, size_t elemsize);
+  void *leptonica_realloc(void *ptr, size_t blocksize);
+  void leptonica_free(void *ptr);
+#else
+  #define LEPT_MALLOC(blocksize)           malloc(blocksize)
+  #define LEPT_CALLOC(numelem, elemsize)   calloc(numelem, elemsize)
+  #define LEPT_REALLOC(ptr, blocksize)     realloc(ptr, blocksize)
+  #define LEPT_FREE(ptr)                   free(ptr)
+#endif   /* LEPTONICA_INTERCEPT_ALLOC */
+
+/*------------------------------------------------------------------------*
+ *         Control printing of error, warning, and info messages          *
+ *                                                                        *
+ *  Leptonica never sends output to stdout.  By default, all messages     *
+ *  go to stderr.  However, we provide a mechanism for runtime            *
+ *  redirection of output, using a custom stderr handler defined          *
+ *  by the user.  See utils1.c for details and examples.                  *
+ *                                                                        *
+ *  To omit all messages to stderr, simply define NO_CONSOLE_IO on the    *
+ *  command line.  For finer grained control, we have a mechanism         *
+ *  based on the message severity level.  The following assumes that      *
+ *  NO_CONSOLE_IO is not defined.                                         *
+ *                                                                        *
+ *  Messages are printed if the message severity is greater than or equal *
+ *  to the current severity threshold.  The current severity threshold    *
+ *  is the greater of the compile-time severity, which is the minimum     *
+ *  severity that can be reported, and the run-time severity, which is    *
+ *  the severity threshold at the moment.                                 *
+ *                                                                        *
+ *  The compile-time threshold determines which messages are compiled     *
+ *  into the library for potential printing.  Messages below the          *
+ *  compile-time threshold are omitted and can never be printed.  The     *
+ *  default compile-time threshold is L_SEVERITY_INFO, but this may be    *
+ *  overridden by defining MINIMUM_SEVERITY to the desired enumeration    *
+ *  identifier on the compiler command line.  Defining NO_CONSOLE_IO on   *
+ *  the command line is the same as setting MINIMUM_SEVERITY to           *
+ *  L_SEVERITY_NONE.                                                      *
+ *                                                                        *
+ *  The run-time threshold determines which messages are printed during   *
+ *  library execution.  It defaults to the compile-time threshold but     *
+ *  may be changed either statically by defining DEFAULT_SEVERITY to      *
+ *  the desired enumeration identifier on the compiler command line, or   *
+ *  dynamically by calling setMsgSeverity() to specify a new threshold.   *
+ *  The run-time threshold may also be set from the value of the          *
+ *  environment variable LEPT_MSG_SEVERITY by calling setMsgSeverity()   *
+ *  and specifying L_SEVERITY_EXTERNAL.                                   *
+ *                                                                        *
+ *  In effect, the compile-time threshold setting says, "Generate code    *
+ *  to permit messages of equal or greater severity than this to be       *
+ *  printed, if desired," whereas the run-time threshold setting says,    *
+ *  "Print messages that have an equal or greater severity than this."    *
+ *------------------------------------------------------------------------*/
+
+    /*! Control printing of error, warning and info messages */
+/*! Message Control */
+enum {
+    L_SEVERITY_EXTERNAL = 0,   /* Get the severity from the environment   */
+    L_SEVERITY_ALL      = 1,   /* Lowest severity: print all messages     */
+    L_SEVERITY_DEBUG    = 2,   /* Print debugging and higher messages     */
+    L_SEVERITY_INFO     = 3,   /* Print informational and higher messages */
+    L_SEVERITY_WARNING  = 4,   /* Print warning and higher messages       */
+    L_SEVERITY_ERROR    = 5,   /* Print error and higher messages         */
+    L_SEVERITY_NONE     = 6    /* Highest severity: print no messages     */
+};
+
+/*  No message less than the compile-time threshold will ever be
+ *  reported, regardless of the current run-time threshold.  This allows
+ *  selection of the set of messages to include in the library.  For
+ *  example, setting the threshold to L_SEVERITY_WARNING eliminates all
+ *  informational messages from the library.  With that setting, both
+ *  warning and error messages would be printed unless setMsgSeverity()
+ *  was called, or DEFAULT_SEVERITY was redefined, to set the run-time
+ *  severity to L_SEVERITY_ERROR.  In that case, only error messages
+ *  would be printed.
+ *
+ *  This mechanism makes the library smaller and faster, by eliminating
+ *  undesired message reporting and the associated run-time overhead for
+ *  message threshold checking, because code for messages whose severity
+ *  is lower than MINIMUM_SEVERITY won't be generated.
+ *
+ *  A production library might typically permit ERROR messages to be
+ *  generated, and a development library might permit DEBUG and higher.
+ *  The actual messages printed (as opposed to generated) would depend
+ *  on the current run-time severity threshold.
+ *
+ *  This is a complex mechanism and a few examples may help.
+ *  (1) No output permitted under any circumstances.
+ *      Use:  -DNO_CONSOLE_IO  or  -DMINIMUM_SEVERITY=6
+ *  (2) Suppose you want to only allow error messages, and you don't
+ *      want to permit info or warning messages at runtime.
+ *      Use:  -DMINIMUM_SEVERITY=5
+ *  (3) Suppose you want to only allow error messages by default,
+ *      but you will permit this to be over-ridden at runtime.
+ *      Use:  -DDEFAULT_SEVERITY=5
+ *            and to allow info and warning override:
+ *                 setMsgSeverity(L_SEVERITY_INFO);
+ */
+
+#ifdef  NO_CONSOLE_IO
+  #undef MINIMUM_SEVERITY
+  #undef DEFAULT_SEVERITY
+
+  #define MINIMUM_SEVERITY      L_SEVERITY_NONE    /*!< Compile-time default */
+  #define DEFAULT_SEVERITY      L_SEVERITY_NONE    /*!< Run-time default */
+
+#else
+  #ifndef MINIMUM_SEVERITY
+    #define MINIMUM_SEVERITY    L_SEVERITY_INFO    /*!< Compile-time default */
+  #endif
+
+  #ifndef DEFAULT_SEVERITY
+    #define DEFAULT_SEVERITY    MINIMUM_SEVERITY   /*!< Run-time default */
+  #endif
+#endif
+
+
+/*!  The run-time message severity threshold is defined in utils1.c.  */
+LEPT_DLL extern l_int32  LeptMsgSeverity;
+
+/*
+ * <pre>
+ *  Usage
+ *  =====
+ *  Messages are of two types.
+ *
+ *  (1) The messages
+ *      ERROR_INT(a,b,c)       : returns l_int32
+ *      ERROR_FLOAT(a,b,c)     : returns l_float32
+ *      ERROR_PTR(a,b,c)       : returns void*
+ *  are used to return from functions and take a fixed set of parameters:
+ *      a : <message string>
+ *      b : procName
+ *      c : <return value from function>
+ *  where procName is the name of the local variable naming the function.
+ *
+ *  (2) The purely informational L_* messages
+ *      L_ERROR(a,...)
+ *      L_WARNING(a,...)
+ *      L_INFO(a,...)
+ *  do not take a return value, but they take at least two parameters:
+ *      a  :  <message string> with optional format conversions
+ *      v1 : procName    (this must be included as the first vararg)
+ *      v2, ... :  optional varargs to match format converters in the message
+ *
+ *  To return an error from a function that returns void, use:
+ *      L_ERROR(<message string>, procName, [...])
+ *      return;
+ *
+ *  Implementation details
+ *  ======================
+ *  Messages are defined with the IF_SEV macro.  The first parameter is
+ *  the message severity, the second is the function to call if the
+ *  message is to be printed, and the third is the return value if the
+ *  message is to be suppressed.  For example, we might have an
+ *  informational message defined as:
+ *
+ *    IF_SEV(L_SEVERITY_INFO, fprintf(.......), 0)
+ *
+ *  The macro expands into a conditional.  Because the first comparison
+ *  is between two constants, an optimizing compiler will remove either
+ *  the comparison (if it's true) or the entire macro expansion (if it
+ *  is false).  This means that there is no run-time overhead for
+ *  messages whose severity falls below the minimum specified at compile
+ *  time, and for others the overhead is one (not two) comparisons.
+ *
+ *  The L_nnn() macros below do not return a value, but because the
+ *  conditional operator requires one for the false condition, we
+ *  specify a void expression.
+ * </pre>
+ */
+
+#ifdef  NO_CONSOLE_IO
+
+  #define PROCNAME(name)
+  #define ERROR_INT(a, b, c)            ((l_int32)(c))
+  #define ERROR_FLOAT(a, b, c)          ((l_float32)(c))
+  #define ERROR_PTR(a, b, c)            ((void *)(c))
+  #define L_ERROR(a, ...)
+  #define L_WARNING(a, ...)
+  #define L_INFO(a, ...)
+
+#else
+
+  #define PROCNAME(name)              static const char procName[] = name
+  #define IF_SEV(l, t, f) \
+      ((l) >= MINIMUM_SEVERITY && (l) >= LeptMsgSeverity ? (t) : (f))
+
+  #define ERROR_INT(a, b, c) \
+      IF_SEV(L_SEVERITY_ERROR, returnErrorInt((a), (b), (c)), (l_int32)(c))
+  #define ERROR_FLOAT(a, b, c) \
+      IF_SEV(L_SEVERITY_ERROR, returnErrorFloat((a), (b), (c)), (l_float32)(c))
+  #define ERROR_PTR(a, b, c) \
+      IF_SEV(L_SEVERITY_ERROR, returnErrorPtr((a), (b), (c)), (void *)(c))
+
+  #define L_ERROR(a, ...) \
+      IF_SEV(L_SEVERITY_ERROR, \
+             (void)lept_stderr("Error in %s: " a, __VA_ARGS__), \
+             (void)0)
+  #define L_WARNING(a, ...) \
+      IF_SEV(L_SEVERITY_WARNING, \
+             (void)lept_stderr("Warning in %s: " a, __VA_ARGS__), \
+             (void)0)
+  #define L_INFO(a, ...) \
+      IF_SEV(L_SEVERITY_INFO, \
+             (void)lept_stderr("Info in %s: " a, __VA_ARGS__), \
+             (void)0)
+
+#if 0  /* Alternative method for controlling L_* message output */
+  #define L_ERROR(a, ...) \
+    { if (L_SEVERITY_ERROR >= MINIMUM_SEVERITY && \
+          L_SEVERITY_ERROR >= LeptMsgSeverity) \
+          lept_stderr("Error in %s: " a, __VA_ARGS__) \
+    }
+  #define L_WARNING(a, ...) \
+    { if (L_SEVERITY_WARNING >= MINIMUM_SEVERITY && \
+          L_SEVERITY_WARNING >= LeptMsgSeverity) \
+          lept_stderr("Warning in %s: " a, __VA_ARGS__) \
+    }
+  #define L_INFO(a, ...) \
+    { if (L_SEVERITY_INFO >= MINIMUM_SEVERITY && \
+          L_SEVERITY_INFO >= LeptMsgSeverity) \
+          lept_stderr("Info in %s: " a, __VA_ARGS__) \
+    }
+#endif
+
+#endif  /* NO_CONSOLE_IO */
+
+
+/*------------------------------------------------------------------------*
+ *              snprintf() renamed in MSVC (pre-VS2015)                   *
+ *------------------------------------------------------------------------*/
+#if defined _MSC_VER && _MSC_VER < 1900
+#define snprintf(buf, size, ...)  _snprintf_s(buf, size, _TRUNCATE, __VA_ARGS__)
+#endif
+
+
+#endif /* LEPTONICA_ENVIRON_H */

src/windows/leptonica/include/leptonica/gplot.h

@@ -0,0 +1,96 @@
+/*====================================================================*
+ -  Copyright (C) 2001 Leptonica.  All rights reserved.
+ -
+ -  Redistribution and use in source and binary forms, with or without
+ -  modification, are permitted provided that the following conditions
+ -  are met:
+ -  1. Redistributions of source code must retain the above copyright
+ -     notice, this list of conditions and the following disclaimer.
+ -  2. Redistributions in binary form must reproduce the above
+ -     copyright notice, this list of conditions and the following
+ -     disclaimer in the documentation and/or other materials
+ -     provided with the distribution.
+ -
+ -  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ -  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ -  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ -  A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ANY
+ -  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ -  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ -  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ -  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ -  OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ -  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ -  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *====================================================================*/
+
+#ifndef  LEPTONICA_GPLOT_H
+#define  LEPTONICA_GPLOT_H
+
+/*!
+ * \file gplot.h
+ *
+ * <pre>
+ *   Data structures and parameters for generating gnuplot files
+ *
+ *   We used to support X11 output, but recent versions of gnuplot do not
+ *   support the X11 terminal.  To get display to your screen, use
+ *   GPLOT_PNG output; e.g.,
+ *       gplotSimple1(na, GPLOT_PNG, "/tmp/someroot", ...);
+ *       l_fileDisplay("/tmp/someroot.png", ...);
+ * </pre>
+ */
+
+#define  GPLOT_VERSION_NUMBER    1
+
+#define  NUM_GPLOT_STYLES  5
+enum GPLOT_STYLE {
+    GPLOT_LINES       = 0,
+    GPLOT_POINTS      = 1,
+    GPLOT_IMPULSES    = 2,
+    GPLOT_LINESPOINTS = 3,
+    GPLOT_DOTS        = 4
+};
+
+#define  NUM_GPLOT_OUTPUTS  6
+enum GPLOT_OUTPUT {
+    GPLOT_NONE  = 0,
+    GPLOT_PNG   = 1,
+    GPLOT_PS    = 2,
+    GPLOT_EPS   = 3,
+    GPLOT_LATEX = 4,
+    GPLOT_PNM   = 5,
+};
+
+enum GPLOT_SCALING {
+    GPLOT_LINEAR_SCALE  = 0,   /*!< default */
+    GPLOT_LOG_SCALE_X   = 1,
+    GPLOT_LOG_SCALE_Y   = 2,
+    GPLOT_LOG_SCALE_X_Y = 3
+};
+
+extern const char  *gplotstylenames[];  /*!< used in gnuplot cmd file */
+extern const char  *gplotfileoutputs[]; /*!< used in simple file input */
+
+/*! Data structure for generating gnuplot files */
+struct GPlot
+{
+    char          *rootname;   /*!< for cmd, data, output            */
+    char          *cmdname;    /*!< command file name                */
+    struct Sarray *cmddata;    /*!< command file contents            */
+    struct Sarray *datanames;  /*!< data file names                  */
+    struct Sarray *plotdata;   /*!< plot data (1 string/file)        */
+    struct Sarray *plotlabels; /*!< label for each individual plot   */
+    struct Numa   *plotstyles; /*!< plot style for individual plots  */
+    l_int32        nplots;     /*!< current number of plots          */
+    char          *outname;    /*!< output file name                 */
+    l_int32        outformat;  /*!< GPLOT_OUTPUT values              */
+    l_int32        scaling;    /*!< GPLOT_SCALING values             */
+    char          *title;      /*!< optional                         */
+    char          *xlabel;     /*!< optional x axis label            */
+    char          *ylabel;     /*!< optional y axis label            */
+};
+typedef struct GPlot  GPLOT;
+
+
+#endif /* LEPTONICA_GPLOT_H */

src/windows/leptonica/include/leptonica/hashmap.h

@@ -0,0 +1,134 @@
+/*====================================================================*
+ -  Copyright (C) 2001 Leptonica.  All rights reserved.
+ -
+ -  Redistribution and use in source and binary forms, with or without
+ -  modification, are permitted provided that the following conditions
+ -  are met:
+ -  1. Redistributions of source code must retain the above copyright
+ -     notice, this list of conditions and the following disclaimer.
+ -  2. Redistributions in binary form must reproduce the above
+ -     copyright notice, this list of conditions and the following
+ -     disclaimer in the documentation and/or other materials
+ -     provided with the distribution.
+ -
+ -  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ -  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ -  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ -  A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ANY
+ -  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ -  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ -  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ -  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ -  OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ -  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ -  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *====================================================================*/
+
+#ifndef  LEPTONICA_HASHMAP_H
+#define  LEPTONICA_HASHMAP_H
+
+/*
+ * \file hashmap.h
+ *
+ * <pre>
+ *  Contains the following structs:
+ *      struct L_Hashmap
+ *      struct L_Hashitem
+ *
+ *  Goal:
+ *      You have a set of objects (integers, strings, pts, whatever),
+ *      and you want to store them in a data structure (L_Hashmap) that allows
+ *      O(1) to find, insert and count the occurrences of such an object.
+ *      The tool is a hash map.  This is not ordered, unlike the O(log n)
+ *      ordered map (L_Amap), which is implemented by an rbtree.
+ *
+ *  In slightly more detail:
+ *      Store the set of objects in an array, which in general can be
+ *      held in a pointer array (L_Ptra).  You need a hash function that
+ *      will generate a unique uint64 key from each object.  For our simple
+ *      built-in arrays, such as float, double and Pta (points), these hash
+ *      functions are in utils1.c.  Then for each object in the array,
+ *      you store the key and the index to the array of objects (the val)
+ *      in a list of hashitems in the hash table, where the specific
+ *      list is determined by the key (specifically, the mod of the key
+ *      with the size of the hashtable).
+ *
+ *  In yet more detail:
+ *  (1) The design loosely follows the design of a hashmap in "The Practice
+ *      of Programming by Brian Kernighan and Rob Pike, Addison Wesley, 1999.
+ *  (2) The L_Hashmap contains a hashtable with a prime number of pointers
+ *      to lists of hashitems.  The lookup function takes a key and a value,
+ *      which are both 64-bit unsigned integers.  The key has been generated
+ *      by hashing the input object in a way that avoids collisions between
+ *      different objects. The value is an integer that identifies the
+ *      object; typically it is the index into an array of objects.
+ *      The hashtable size is a prime number, and an index into the table
+ *      is made from the key by taking its mod with the hashtable size.
+ *      The index points to a list of hashitems, which have all been hashed
+ *      by the mod function into the same index in the table.
+ *      Because the key is expected to be randomly distributed in uint64,
+ *      the table indices should be uniformly distributed, resulting in
+ *      approximately the same number of items being placed in each of
+ *      these lists.  The list of hashitems is traversed, comparing the
+ *      input uint64 key in the lookup() function with the key stored in
+ *      each hashitem.  If a hashitem is found with a matching key,
+ *      return a pointer to that hashitem.  If not found and the op is
+ *      L_HASH_CREATE, make a new hash item, add it to the list, and
+ *      return a pointer to it.
+ *  (3) The count field in the hashitem gives the number of times the
+ *      key has been seen when storing key/value pairs.
+ *  (4) The val field is the index into an array of the objects.  When
+ *      the hashmap is initially made, it is the index of the first item
+ *      seen with its key.
+ *  (5) For the hashmap to work efficiently, the lists must not become too
+ *      long.  Because in general you do not know the number of objects
+ *      in advance, it is important to be able to dynamically resize
+ *      the hashtable as it grows.  The hashmap is initialized with
+ *      room for some number of hashitems and the maximum average list
+ *      size.  These two numbers determine the size of the hashtable,
+ *      which is constrained to be a prime number.  As the hashtable grows,
+ *      if the average occupancy exceeds the input %maxocc, the hashtable
+ *      size is approximately doubled and the existing items are re-hashed
+ *      into it, mod the new (prime number) table size.
+ * </pre>
+ */
+
+/*------------------------------------------------------------------------*
+ *                           Hash map structs                             *
+ *------------------------------------------------------------------------*/
+/*! General hash map */
+struct L_Hashmap
+{
+    l_int32              nitems;    /*!< number of stored items              */
+    l_int32              ntogo;     /*!< number of items to be stored        */
+                                    /*!< before resizing the hashmap         */
+    l_int32              maxocc;    /*!< max average occupancy allowed       */
+    struct L_Hashitem  **hashtab;   /*!< array of hash item ptrs             */
+    l_int32              tabsize;   /*!< size of array of hash item ptrs     */
+};
+typedef struct L_Hashmap  L_HASHMAP;
+
+/*! Hash item, containing storage for the key, value and count.  The key
+    is a l_uint64, which is hashed by the mod function to find the index
+    into the hashtab. */
+struct L_Hashitem
+{
+    l_uint64            key;    /*!< key is hashed into index into hashtab   */
+    l_uint64            val;    /*!< number stored associated with the key   */
+    l_int32             count;  /*!< number of elements seen with this key   */
+    struct L_Hashitem  *next;   /*!< ptr to the next in the list             */
+};
+typedef struct L_Hashitem  L_HASHITEM;
+
+
+/*------------------------------------------------------------------------*
+ *                            Hashmap flags                               *
+ *------------------------------------------------------------------------*/
+/*! Hashmap Lookup */
+enum {
+    L_UNDEFINED = 0,         /*!< invalid operation                         */
+    L_HMAP_CHECK = 1,        /*!< check if this key/val has been stored     */
+    L_HMAP_CREATE = 2        /*!< create and store a hashitem if not found  */
+};
+
+#endif  /* LEPTONICA_HASHMAP_H */

src/windows/leptonica/include/leptonica/heap.h

@@ -0,0 +1,87 @@
+/*====================================================================*
+ -  Copyright (C) 2001 Leptonica.  All rights reserved.
+ -
+ -  Redistribution and use in source and binary forms, with or without
+ -  modification, are permitted provided that the following conditions
+ -  are met:
+ -  1. Redistributions of source code must retain the above copyright
+ -     notice, this list of conditions and the following disclaimer.
+ -  2. Redistributions in binary form must reproduce the above
+ -     copyright notice, this list of conditions and the following
+ -     disclaimer in the documentation and/or other materials
+ -     provided with the distribution.
+ -
+ -  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ -  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ -  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ -  A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ANY
+ -  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ -  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ -  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ -  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ -  OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ -  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ -  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *====================================================================*/
+
+#ifndef  LEPTONICA_HEAP_H
+#define  LEPTONICA_HEAP_H
+
+/*!
+ * \file heap.h
+ *
+ * <pre>
+ *      Expandable priority queue configured as a heap for arbitrary void* data
+ *
+ *      The L_Heap is used to implement a priority queue.  The elements
+ *      in the heap are ordered in either increasing or decreasing key value.
+ *      The key is a float field 'keyval' that is required to be
+ *      contained in the elements of the queue.
+ *
+ *      The heap is a simple binary tree with the following constraints:
+ *         - the key of each node is >= the keys of the two children
+ *         - the tree is complete, meaning that each level (1, 2, 4, ...)
+ *           is filled and the last level is filled from left to right
+ *
+ *      The tree structure is implicit in the queue array, with the
+ *      array elements numbered as a breadth-first search of the tree
+ *      from left to right.  It is thus guaranteed that the largest
+ *      (or smallest) key belongs to the first element in the array.
+ *
+ *      Heap sort is used to sort the array.  Once an array has been
+ *      sorted as a heap, it is convenient to use it as a priority queue,
+ *      because the min (or max) elements are always at the root of
+ *      the tree (element 0), and once removed, the heap can be
+ *      resorted in not more than log[n] steps, where n is the number
+ *      of elements on the heap.  Likewise, if an arbitrary element is
+ *      added to the end of the array A, the sorted heap can be restored
+ *      in not more than log[n] steps.
+ *
+ *      A L_Heap differs from a L_Queue in that the elements in the former
+ *      are sorted by a key.  Internally, the array is maintained
+ *      as a queue, with a pointer to the end of the array.  The
+ *      head of the array always remains at array[0].  The array is
+ *      maintained (sorted) as a heap.  When an item is removed from
+ *      the head, the last item takes its place (thus reducing the
+ *      array length by 1), and this is followed by array element
+ *      swaps to restore the heap property.   When an item is added,
+ *      it goes at the end of the array, and is swapped up to restore
+ *      the heap.  If the ptr array is full, adding another item causes
+ *      the ptr array size to double.
+ *
+ *      For further implementation details, see heap.c.
+ * </pre>
+ */
+
+/*! Heap of arbitrary void* data */
+struct L_Heap
+{
+    l_int32      nalloc;      /*!< size of allocated ptr array               */
+    l_int32      n;           /*!< number of elements stored in the heap     */
+    void       **array;       /*!< ptr array                                 */
+    l_int32      direction;   /*!< L_SORT_INCREASING or L_SORT_DECREASING    */
+};
+typedef struct L_Heap  L_HEAP;
+
+
+#endif  /* LEPTONICA_HEAP_H */

src/windows/leptonica/include/leptonica/imageio.h

@@ -0,0 +1,250 @@
+/*====================================================================*
+ -  Copyright (C) 2001 Leptonica.  All rights reserved.
+ -
+ -  Redistribution and use in source and binary forms, with or without
+ -  modification, are permitted provided that the following conditions
+ -  are met:
+ -  1. Redistributions of source code must retain the above copyright
+ -     notice, this list of conditions and the following disclaimer.
+ -  2. Redistributions in binary form must reproduce the above
+ -     copyright notice, this list of conditions and the following
+ -     disclaimer in the documentation and/or other materials
+ -     provided with the distribution.
+ -
+ -  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ -  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ -  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ -  A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ANY
+ -  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ -  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ -  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ -  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ -  OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ -  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ -  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *====================================================================*/
+
+/*!
+ * \file imageio.h
+ *
+ * <pre>
+ *  General features of image I/O in leptonica
+ *
+ *  At present, there are 9 file formats for images that can be read
+ *  and written:
+ *      png (requires libpng, libz)
+ *      jpeg (requires libjpeg)
+ *      tiff (requires libtiff, libz)
+ *      gif (requires libgif)
+ *      webp (requires libwebp)
+ *      jp2 (requires libopenjp2)
+ *      bmp (no library required)
+ *      pnm (no library required)
+ *      spix (no library required)
+ *  Additionally, there are two file formats for writing (only) images:
+ *      PostScript (requires libpng, libz, libjpeg, libtiff)
+ *      pdf (requires libpng, libz, libjpeg, libtiff)
+ *
+ *  For all 9 read/write formats, leptonica provides interconversion
+ *  between pix (with raster data) and formatted image data:
+ *      Conversion from pix (typically compression):
+ *          pixWrite():        pix --> file
+ *          pixWriteStream():  pix --> filestream (aka FILE*)
+ *          pixWriteMem():     pix --> memory buffer
+ *      Conversion to pix (typically decompression):
+ *          pixRead():         file --> pix
+ *          pixReadStream():   filestream --> pix
+ *          pixReadMem():      memory buffer --> pix
+ *
+ *  Conversions for which the image data is not compressed are:
+ *     * uncompressed tiff   (IFF_TIFF)
+ *     * bmp
+ *     * pnm
+ *     * spix (fast serialization that copies the pix raster data)
+ *
+ *  The image header (metadata) information can be read from either
+ *  the compressed file or a memory buffer, for all 9 formats.
+ * </pre>
+ */
+
+#ifndef  LEPTONICA_IMAGEIO_H
+#define  LEPTONICA_IMAGEIO_H
+
+/* --------------------------------------------------------------- *
+ *                    Image file format types                      *
+ * --------------------------------------------------------------- */
+/*
+ *  The IFF_DEFAULT flag is used to write the file out in the
+ *  same (input) file format that the pix was read from.  If the pix
+ *  was not read from file, the input format field will be
+ *  IFF_UNKNOWN and the output file format will be chosen to
+ *  be compressed and lossless; namely, IFF_TIFF_G4 for d = 1
+ *  and IFF_PNG for everything else.
+ *
+ *  In the future, new format types that have defined extensions
+ *  will be added before IFF_DEFAULT, and will be kept in sync with
+ *  the file format extensions in writefile.c.  The positions of
+ *  file formats before IFF_DEFAULT will remain invariant.
+ */
+
+/*! Image Formats */
+enum {
+    IFF_UNKNOWN        = 0,
+    IFF_BMP            = 1,
+    IFF_JFIF_JPEG      = 2,
+    IFF_PNG            = 3,
+    IFF_TIFF           = 4,
+    IFF_TIFF_PACKBITS  = 5,
+    IFF_TIFF_RLE       = 6,
+    IFF_TIFF_G3        = 7,
+    IFF_TIFF_G4        = 8,
+    IFF_TIFF_LZW       = 9,
+    IFF_TIFF_ZIP       = 10,
+    IFF_PNM            = 11,
+    IFF_PS             = 12,
+    IFF_GIF            = 13,
+    IFF_JP2            = 14,
+    IFF_WEBP           = 15,
+    IFF_LPDF           = 16,
+    IFF_TIFF_JPEG      = 17,
+    IFF_DEFAULT        = 18,
+    IFF_SPIX           = 19
+};
+
+/* Convenient macro for checking requested tiff output */
+#define  L_FORMAT_IS_TIFF(f)  ((f) == IFF_TIFF || (f) == IFF_TIFF_PACKBITS || \
+                               (f) == IFF_TIFF_RLE || (f) == IFF_TIFF_G3 || \
+                               (f) == IFF_TIFF_G4 || (f) == IFF_TIFF_LZW || \
+                               (f) == IFF_TIFF_ZIP || (f) == IFF_TIFF_JPEG)
+
+
+/* --------------------------------------------------------------- *
+ *                         Format header ids                       *
+ * --------------------------------------------------------------- */
+/*! Header Ids */
+enum {
+    BMP_ID             = 0x4d42,     /*!< BM - for bitmaps    */
+    TIFF_BIGEND_ID     = 0x4d4d,     /*!< MM - for 'motorola' */
+    TIFF_LITTLEEND_ID  = 0x4949      /*!< II - for 'intel'    */
+};
+
+
+/* --------------------------------------------------------------- *
+ *                Hinting bit flags in jpeg reader                 *
+ * --------------------------------------------------------------- */
+/*! Jpeg Hints */
+/* The default behavior is now to fail on data corruption. */
+enum {
+    L_JPEG_READ_LUMINANCE = 1,    /*!< only want luminance data; no chroma */
+    L_JPEG_CONTINUE_WITH_BAD_DATA = 2  /*!< return possibly damaged pix */
+};
+
+
+/* --------------------------------------------------------------- *
+ *                            Jp2k codecs                          *
+ * --------------------------------------------------------------- */
+/*! Jp2k Codecs */
+enum {
+    L_J2K_CODEC = 1,    /*!< codestream                 */
+    L_JP2_CODEC = 2     /*!< file format with 'ihdr'    */
+};
+
+
+/* --------------------------------------------------------------- *
+ *                    Pdf formatted encoding types                 *
+ * --------------------------------------------------------------- */
+/*! Pdf Encoding */
+enum {
+    L_DEFAULT_ENCODE  = 0,  /*!< use default encoding based on image        */
+    L_JPEG_ENCODE     = 1,  /*!< use dct encoding: 8 and 32 bpp, no cmap    */
+    L_G4_ENCODE       = 2,  /*!< use ccitt g4 fax encoding: 1 bpp           */
+    L_FLATE_ENCODE    = 3,  /*!< use flate encoding: any depth, cmap ok     */
+    L_JP2K_ENCODE     = 4   /*!< use jp2k encoding: 8 and 32 bpp, no cmap   */
+};
+
+
+/* --------------------------------------------------------------- *
+ *                    Compressed image data                        *
+ * --------------------------------------------------------------- */
+/*
+ *  In use, either datacomp or data85 will be produced, depending
+ *  on whether the data needs to be ascii85 encoded.  PostScript
+ *  requires ascii85 encoding; pdf does not.
+ *
+ *  For the colormap (flate compression only), PostScript uses ascii85
+ *  encoding and pdf uses a bracketed array of space-separated
+ *  hex-encoded rgb triples.  Only tiff g4 (type == L_G4_ENCODE) uses
+ *  the minisblack field.
+ */
+
+/*! Compressed image data */
+struct L_Compressed_Data
+{
+    l_int32            type;         /*!< encoding type: L_JPEG_ENCODE, etc   */
+    l_uint8           *datacomp;     /*!< gzipped raster data                 */
+    size_t             nbytescomp;   /*!< number of compressed bytes          */
+    char              *data85;       /*!< ascii85-encoded gzipped raster data */
+    size_t             nbytes85;     /*!< number of ascii85 encoded bytes     */
+    char              *cmapdata85;   /*!< ascii85-encoded uncompressed cmap   */
+    char              *cmapdatahex;  /*!< hex pdf array for the cmap          */
+    l_int32            ncolors;      /*!< number of colors in cmap            */
+    l_int32            w;            /*!< image width                         */
+    l_int32            h;            /*!< image height                        */
+    l_int32            bps;          /*!< bits/sample; typ. 1, 2, 4 or 8      */
+    l_int32            spp;          /*!< samples/pixel; typ. 1 or 3          */
+    l_int32            minisblack;   /*!< tiff g4 photometry                  */
+    l_int32            predictor;    /*!< flate data has PNG predictors       */
+    size_t             nbytes;       /*!< number of uncompressed raster bytes */
+    l_int32            res;          /*!< resolution (ppi)                    */
+};
+typedef struct L_Compressed_Data  L_COMP_DATA;
+
+
+/* ------------------------------------------------------------------------- *
+ *                           Pdf multi image flags                           *
+ * ------------------------------------------------------------------------- */
+/*! Pdf MultiImage */
+enum {
+    L_FIRST_IMAGE   = 1,    /*!< first image to be used                      */
+    L_NEXT_IMAGE    = 2,    /*!< intermediate image; not first or last       */
+    L_LAST_IMAGE    = 3     /*!< last image to be used                       */
+};
+
+
+/* ------------------------------------------------------------------------- *
+ *                     Intermediate pdf generation data                      *
+ * ------------------------------------------------------------------------- */
+/*
+ *  This accumulates data for generating a pdf of a single page consisting
+ *  of an arbitrary number of images.
+ *
+ *  None of the strings have a trailing newline.
+ */
+
+/*! Intermediate pdf generation data */
+struct L_Pdf_Data
+{
+    char              *title;        /*!< optional title for pdf              */
+    l_int32            n;            /*!< number of images                    */
+    l_int32            ncmap;        /*!< number of colormaps                 */
+    struct L_Ptra     *cida;         /*!< array of compressed image data      */
+    char              *id;           /*!< %PDF-1.2 id string                  */
+    char              *obj1;         /*!< catalog string                      */
+    char              *obj2;         /*!< metadata string                     */
+    char              *obj3;         /*!< pages string                        */
+    char              *obj4;         /*!< page string (variable data)         */
+    char              *obj5;         /*!< content string (variable data)      */
+    char              *poststream;   /*!< post-binary-stream string           */
+    char              *trailer;      /*!< trailer string (variable data)      */
+    struct Pta        *xy;           /*!< store (xpt, ypt) array              */
+    struct Pta        *wh;           /*!< store (wpt, hpt) array              */
+    struct Box        *mediabox;     /*!< bounding region for all images      */
+    struct Sarray     *saprex;       /*!< pre-binary-stream xobject strings   */
+    struct Sarray     *sacmap;       /*!< colormap pdf object strings         */
+    struct L_Dna      *objsize;      /*!< sizes of each pdf string object     */
+    struct L_Dna      *objloc;       /*!< location of each pdf string object  */
+    l_int32            xrefloc;      /*!< location of xref                    */
+};
+typedef struct L_Pdf_Data  L_PDF_DATA;
+
+#endif  /* LEPTONICA_IMAGEIO_H */

src/windows/leptonica/include/leptonica/jbclass.h

@@ -0,0 +1,142 @@
+/*====================================================================*
+ -  Copyright (C) 2001 Leptonica.  All rights reserved.
+ -
+ -  Redistribution and use in source and binary forms, with or without
+ -  modification, are permitted provided that the following conditions
+ -  are met:
+ -  1. Redistributions of source code must retain the above copyright
+ -     notice, this list of conditions and the following disclaimer.
+ -  2. Redistributions in binary form must reproduce the above
+ -     copyright notice, this list of conditions and the following
+ -     disclaimer in the documentation and/or other materials
+ -     provided with the distribution.
+ -
+ -  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ -  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ -  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ -  A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ANY
+ -  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ -  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ -  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ -  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ -  OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ -  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ -  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *====================================================================*/
+
+#ifndef  LEPTONICA_JBCLASS_H
+#define  LEPTONICA_JBCLASS_H
+
+/*!
+ * \file jbclass.h
+ *
+ *       JbClasser
+ *       JbData
+ */
+
+
+    /*!
+     * <pre>
+     * The JbClasser struct holds all the data accumulated during the
+     * classification process that can be used for a compressed
+     * jbig2-type representation of a set of images.  This is created
+     * in an initialization process and added to as the selected components
+     * on each successive page are analyzed.
+     * </pre>
+     */
+struct JbClasser
+{
+    struct Sarray   *safiles;      /*!< input page image file names          */
+    l_int32          method;       /*!< JB_RANKHAUS, JB_CORRELATION          */
+    l_int32          components;   /*!< JB_CONN_COMPS, JB_CHARACTERS or      */
+                                   /*!< JB_WORDS                             */
+    l_int32          maxwidth;     /*!< max component width allowed          */
+    l_int32          maxheight;    /*!< max component height allowed         */
+    l_int32          npages;       /*!< number of pages already processed    */
+    l_int32          baseindex;    /*!< number components already processed  */
+                                   /*!< on fully processed pages             */
+    struct Numa     *nacomps;      /*!< number of components on each page    */
+    l_int32          sizehaus;     /*!< size of square struct elem for haus  */
+    l_float32        rankhaus;     /*!< rank val of haus match, each way     */
+    l_float32        thresh;       /*!< thresh value for correlation score   */
+    l_float32        weightfactor; /*!< corrects thresh value for heaver     */
+                                   /*!< components; use 0 for no correction  */
+    struct Numa     *naarea;       /*!< w * h of each template, without      */
+                                   /*!< extra border pixels                  */
+    l_int32          w;            /*!< max width of original src images     */
+    l_int32          h;            /*!< max height of original src images    */
+    l_int32          nclass;       /*!< current number of classes            */
+    l_int32          keep_pixaa;   /*!< If zero, pixaa isn't filled          */
+    struct Pixaa    *pixaa;        /*!< instances for each class; unbordered */
+    struct Pixa     *pixat;        /*!< templates for each class; bordered   */
+                                   /*!< and not dilated                      */
+    struct Pixa     *pixatd;       /*!< templates for each class; bordered   */
+                                   /*!< and dilated                          */
+    struct L_DnaHash *dahash;      /*!< Hash table to find templates by size */
+    struct Numa     *nafgt;        /*!< fg areas of undilated templates;     */
+                                   /*!< only used for rank < 1.0             */
+    struct Pta      *ptac;         /*!< centroids of all bordered cc         */
+    struct Pta      *ptact;        /*!< centroids of all bordered template cc */
+    struct Numa     *naclass;      /*!< array of class ids for each component */
+    struct Numa     *napage;       /*!< array of page nums for each component */
+    struct Pta      *ptaul;        /*!< array of UL corners at which the     */
+                                   /*!< template is to be placed for each    */
+                                   /*!< component                            */
+    struct Pta      *ptall;        /*!< similar to ptaul, but for LL corners */
+};
+typedef struct JbClasser  JBCLASSER;
+
+
+    /*!
+     * <pre>
+     * The JbData struct holds all the data required for
+     * the compressed jbig-type representation of a set of images.
+     * The data can be written to file, read back, and used
+     * to regenerate an approximate version of the original,
+     * which differs in two ways from the original:
+     *   (1) It uses a template image for each c.c. instead of the
+     *       original instance, for each occurrence on each page.
+     *   (2) It discards components with either a height or width larger
+     *       than the maximuma, given here by the lattice dimensions
+     *       used for storing the templates.
+     * </pre>
+     */
+struct JbData
+{
+    struct Pix      *pix;        /*!< template composite for all classes    */
+    l_int32          npages;     /*!< number of pages                       */
+    l_int32          w;          /*!< max width of original page images     */
+    l_int32          h;          /*!< max height of original page images    */
+    l_int32          nclass;     /*!< number of classes                     */
+    l_int32          latticew;   /*!< lattice width for template composite  */
+    l_int32          latticeh;   /*!< lattice height for template composite */
+    struct Numa     *naclass;    /*!< array of class ids for each component */
+    struct Numa     *napage;     /*!< array of page nums for each component */
+    struct Pta      *ptaul;      /*!< array of UL corners at which the      */
+                                 /*!< template is to be placed for each     */
+                                 /*!< component                             */
+};
+typedef struct JbData  JBDATA;
+
+
+/*! JB Classifier */
+enum {
+    JB_RANKHAUS = 0,
+    JB_CORRELATION = 1
+};
+
+    /*! For jbGetComponents(): type of component to extract from images */
+/*! JB Component */
+enum {
+    JB_CONN_COMPS = 0,
+    JB_CHARACTERS = 1,
+    JB_WORDS = 2
+};
+
+    /*! These parameters are used for naming the two files
+     * in which the jbig2-like compressed data is stored.  */
+#define   JB_TEMPLATE_EXT      ".templates.png"
+#define   JB_DATA_EXT          ".data"
+
+
+#endif  /* LEPTONICA_JBCLASS_H */

src/windows/leptonica/include/leptonica/leptwin.h

@@ -0,0 +1,45 @@
+/*====================================================================*
+ -  Copyright (C) 2001 Leptonica.  All rights reserved.
+ -
+ -  Redistribution and use in source and binary forms, with or without
+ -  modification, are permitted provided that the following conditions
+ -  are met:
+ -  1. Redistributions of source code must retain the above copyright
+ -     notice, this list of conditions and the following disclaimer.
+ -  2. Redistributions in binary form must reproduce the above
+ -     copyright notice, this list of conditions and the following
+ -     disclaimer in the documentation and/or other materials
+ -     provided with the distribution.
+ -
+ -  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ -  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ -  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ -  A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ANY
+ -  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ -  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ -  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ -  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ -  OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ -  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ -  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *====================================================================*/
+
+#ifdef _WIN32
+#ifndef  LEPTONICA_LEPTWIN_H
+#define  LEPTONICA_LEPTWIN_H
+
+#include "allheaders.h"
+#include <windows.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif  /* __cplusplus */
+
+LEPT_DLL extern HBITMAP pixGetWindowsHBITMAP( PIX *pixs );
+
+#ifdef __cplusplus
+}
+#endif  /* __cplusplus */
+
+#endif /* LEPTONICA_LEPTWIN_H */
+#endif /* _WIN32 */

src/windows/leptonica/include/leptonica/list.h

@@ -0,0 +1,90 @@
+/*====================================================================*
+ -  Copyright (C) 2001 Leptonica.  All rights reserved.
+ -
+ -  Redistribution and use in source and binary forms, with or without
+ -  modification, are permitted provided that the following conditions
+ -  are met:
+ -  1. Redistributions of source code must retain the above copyright
+ -     notice, this list of conditions and the following disclaimer.
+ -  2. Redistributions in binary form must reproduce the above
+ -     copyright notice, this list of conditions and the following
+ -     disclaimer in the documentation and/or other materials
+ -     provided with the distribution.
+ -
+ -  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ -  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ -  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ -  A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ANY
+ -  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ -  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ -  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ -  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ -  OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ -  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ -  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *====================================================================*/
+
+
+#ifndef  LEPTONICA_LIST_H
+#define  LEPTONICA_LIST_H
+
+/*!
+ * \file list.h
+ *
+ * <pre>
+ *       Cell for double-linked lists
+ *
+ *       This allows composition of a list of cells with
+ *           prev, next and data pointers.  Generic data
+ *           structures hang on the list cell data pointers.
+ *
+ *       The list is not circular because that would add much
+ *           complexity in traversing the list under general
+ *           conditions where list cells can be added and removed.
+ *           The only disadvantage of not having the head point to
+ *           the last cell is that the list must be traversed to
+ *           find its tail.  However, this traversal is fast, and
+ *           the listRemoveFromTail() function updates the tail
+ *           so there is no searching overhead with repeated use.
+ *
+ *       The list macros are used to run through a list, and their
+ *       use is encouraged.  They are invoked, e.g., as
+ *
+ *             DLLIST  *head, *elem;
+ *             ...
+ *             L_BEGIN_LIST_FORWARD(head, elem)
+ *                 <do something with elem and/or elem->data >
+ *             L_END_LIST
+ * </pre>
+ */
+
+struct DoubleLinkedList
+{
+    struct DoubleLinkedList    *prev;
+    struct DoubleLinkedList    *next;
+    void                       *data;
+};
+typedef struct DoubleLinkedList    DLLIST;
+
+
+    /*!  Simple list traverse macro - forward */
+#define L_BEGIN_LIST_FORWARD(head, element) \
+        { \
+        DLLIST   *_leptvar_nextelem_; \
+        for ((element) = (head); (element); (element) = _leptvar_nextelem_) { \
+            _leptvar_nextelem_ = (element)->next;
+
+
+    /*!  Simple list traverse macro - reverse */
+#define L_BEGIN_LIST_REVERSE(tail, element) \
+        { \
+        DLLIST   *_leptvar_prevelem_; \
+        for ((element) = (tail); (element); (element) = _leptvar_prevelem_) { \
+            _leptvar_prevelem_ = (element)->prev;
+
+
+    /*!  Simple list traverse macro - end of a list traverse */
+#define L_END_LIST    }}
+
+
+#endif  /* LEPTONICA_LIST_H */

src/windows/leptonica/include/leptonica/morph.h

@@ -0,0 +1,225 @@
+/*====================================================================*
+ -  Copyright (C) 2001 Leptonica.  All rights reserved.
+ -
+ -  Redistribution and use in source and binary forms, with or without
+ -  modification, are permitted provided that the following conditions
+ -  are met:
+ -  1. Redistributions of source code must retain the above copyright
+ -     notice, this list of conditions and the following disclaimer.
+ -  2. Redistributions in binary form must reproduce the above
+ -     copyright notice, this list of conditions and the following
+ -     disclaimer in the documentation and/or other materials
+ -     provided with the distribution.
+ -
+ -  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ -  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ -  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ -  A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ANY
+ -  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ -  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ -  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ -  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ -  OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ -  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ -  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *====================================================================*/
+
+#ifndef  LEPTONICA_MORPH_H
+#define  LEPTONICA_MORPH_H
+
+/*!
+ * \file morph.h
+ *
+ * <pre>
+ *  Contains the following structs:
+ *      struct Sel
+ *      struct Sela
+ *      struct Kernel
+ *
+ *  Contains definitions for:
+ *      morphological b.c. flags
+ *      structuring element types
+ *      runlength flags for granulometry
+ *      direction flags for grayscale morphology
+ *      morphological operation flags
+ *      standard border size
+ *      grayscale intensity scaling flags
+ *      morphological tophat flags
+ *      arithmetic and logical operator flags
+ *      grayscale morphology selection flags
+ *      distance function b.c. flags
+ *      image comparison flags
+ * </pre>
+ */
+
+/*-------------------------------------------------------------------------*
+ *                             Sel and Sel array                           *
+ *-------------------------------------------------------------------------*/
+#define  SEL_VERSION_NUMBER    1
+
+/*! Selection */
+struct Sel
+{
+    l_int32       sy;        /*!< sel height                               */
+    l_int32       sx;        /*!< sel width                                */
+    l_int32       cy;        /*!< y location of sel origin                 */
+    l_int32       cx;        /*!< x location of sel origin                 */
+    l_int32     **data;      /*!< {0,1,2}; data[i][j] in [row][col] order  */
+    char         *name;      /*!< used to find sel by name                 */
+};
+typedef struct Sel SEL;
+
+/*! Array of Sel */
+struct Sela
+{
+    l_int32          n;       /*!< number of sel actually stored           */
+    l_int32          nalloc;  /*!< size of allocated ptr array             */
+    struct Sel     **sel;     /*!< sel ptr array                           */
+};
+typedef struct Sela SELA;
+
+
+/*-------------------------------------------------------------------------*
+ *                                 Kernel                                  *
+ *-------------------------------------------------------------------------*/
+#define  KERNEL_VERSION_NUMBER    2
+
+/*! Kernel */
+struct L_Kernel
+{
+    l_int32       sy;        /*!< kernel height                            */
+    l_int32       sx;        /*!< kernel width                             */
+    l_int32       cy;        /*!< y location of kernel origin              */
+    l_int32       cx;        /*!< x location of kernel origin              */
+    l_float32   **data;      /*!< data[i][j] in [row][col] order           */
+};
+typedef struct L_Kernel  L_KERNEL;
+
+
+/*-------------------------------------------------------------------------*
+ *                 Morphological boundary condition flags                  *
+ *                                                                         *
+ *  Two types of boundary condition for erosion.                           *
+ *  The global variable MORPH_BC takes on one of these two values.         *
+ *  See notes in morph.c for usage.                                        *
+ *-------------------------------------------------------------------------*/
+/*! Morph Boundary */
+enum {
+    SYMMETRIC_MORPH_BC = 0,
+    ASYMMETRIC_MORPH_BC = 1
+};
+
+/*-------------------------------------------------------------------------*
+ *                        Structuring element vals                         *
+ *-------------------------------------------------------------------------*/
+/*! SEL Vals */
+enum {
+    SEL_DONT_CARE  = 0,
+    SEL_HIT        = 1,
+    SEL_MISS       = 2
+};
+
+/*-------------------------------------------------------------------------*
+ *                  Runlength flags for granulometry                       *
+ *-------------------------------------------------------------------------*/
+/*! Runlength Polarity */
+enum {
+    L_RUN_OFF = 0,
+    L_RUN_ON  = 1
+};
+
+/*-------------------------------------------------------------------------*
+ *         Direction flags for grayscale morphology, granulometry,         *
+ *                 composable Sels, convolution, etc.                      *
+ *-------------------------------------------------------------------------*/
+/*! Direction Flags */
+enum {
+    L_HORIZ            = 1,
+    L_VERT             = 2,
+    L_BOTH_DIRECTIONS  = 3
+};
+
+/*-------------------------------------------------------------------------*
+ *                   Morphological operation flags                         *
+ *-------------------------------------------------------------------------*/
+/*! Morph Operator */
+enum {
+    L_MORPH_DILATE    = 1,
+    L_MORPH_ERODE     = 2,
+    L_MORPH_OPEN      = 3,
+    L_MORPH_CLOSE     = 4,
+    L_MORPH_HMT       = 5
+};
+
+/*-------------------------------------------------------------------------*
+ *                    Grayscale intensity scaling flags                    *
+ *-------------------------------------------------------------------------*/
+/*! Pixel Value Scaling */
+enum {
+    L_LINEAR_SCALE  = 1,
+    L_LOG_SCALE     = 2
+};
+
+/*-------------------------------------------------------------------------*
+ *                      Morphological tophat flags                         *
+ *-------------------------------------------------------------------------*/
+/*! Morph Tophat */
+enum {
+    L_TOPHAT_WHITE = 0,
+    L_TOPHAT_BLACK = 1
+};
+
+/*-------------------------------------------------------------------------*
+ *                Arithmetic and logical operator flags                    *
+ *                 (use on grayscale images and Numas)                     *
+ *-------------------------------------------------------------------------*/
+/*! ArithLogical Ops */
+enum {
+    L_ARITH_ADD       = 1,
+    L_ARITH_SUBTRACT  = 2,
+    L_ARITH_MULTIPLY  = 3,   /* on numas only */
+    L_ARITH_DIVIDE    = 4,   /* on numas only */
+    L_UNION           = 5,   /* on numas only */
+    L_INTERSECTION    = 6,   /* on numas only */
+    L_SUBTRACTION     = 7,   /* on numas only */
+    L_EXCLUSIVE_OR    = 8    /* on numas only */
+};
+
+/*-------------------------------------------------------------------------*
+ *                        Min/max selection flags                          *
+ *-------------------------------------------------------------------------*/
+/*! MinMax Selection */
+enum {
+    L_CHOOSE_MIN = 1,         /* useful in a downscaling "erosion"       */
+    L_CHOOSE_MAX = 2,         /* useful in a downscaling "dilation"      */
+    L_CHOOSE_MAXDIFF = 3,     /* useful in a downscaling contrast        */
+    L_CHOOSE_MIN_BOOST = 4,   /* use a modification of the min value     */
+    L_CHOOSE_MAX_BOOST = 5    /* use a modification of the max value     */
+};
+
+/*-------------------------------------------------------------------------*
+ *            Exterior value b.c. for distance function flags              *
+ *-------------------------------------------------------------------------*/
+/*! Exterior Value */
+enum {
+    L_BOUNDARY_BG = 1,  /* assume bg outside image */
+    L_BOUNDARY_FG = 2   /* assume fg outside image */
+};
+
+/*-------------------------------------------------------------------------*
+ *                         Image comparison flags                          *
+ *-------------------------------------------------------------------------*/
+/*! Image Comparison */
+enum {
+    L_COMPARE_XOR = 1,
+    L_COMPARE_SUBTRACT = 2,
+    L_COMPARE_ABS_DIFF = 3
+};
+
+/*-------------------------------------------------------------------------*
+ *    Standard size of border added around images for special processing   *
+ *-------------------------------------------------------------------------*/
+static const l_int32  ADDED_BORDER = 32;   /*!< pixels, not bits */
+
+
+#endif  /* LEPTONICA_MORPH_H */

src/windows/leptonica/include/leptonica/pix_internal.h

@@ -0,0 +1,426 @@
+/*====================================================================*
+ -  Copyright (C) 2001 Leptonica.  All rights reserved.
+ -
+ -  Redistribution and use in source and binary forms, with or without
+ -  modification, are permitted provided that the following conditions
+ -  are met:
+ -  1. Redistributions of source code must retain the above copyright
+ -     notice, this list of conditions and the following disclaimer.
+ -  2. Redistributions in binary form must reproduce the above
+ -     copyright notice, this list of conditions and the following
+ -     disclaimer in the documentation and/or other materials
+ -     provided with the distribution.
+ -
+ -  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ -  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ -  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ -  A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ANY
+ -  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ -  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ -  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ -  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ -  OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ -  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ -  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *====================================================================*/
+
+#ifndef  LEPTONICA_PIX_INTERNAL_H
+#define  LEPTONICA_PIX_INTERNAL_H
+
+/*!
+ * \file pix_internal.h
+ *
+ * <pre>
+ *  Valid image types in leptonica:
+ *       Pix: 1 bpp, with and without colormap
+ *       Pix: 2 bpp, with and without colormap
+ *       Pix: 4 bpp, with and without colormap
+ *       Pix: 8 bpp, with and without colormap
+ *       Pix: 16 bpp (1 spp)
+ *       Pix: 32 bpp (rgb, 3 spp)
+ *       Pix: 32 bpp (rgba, 4 spp)
+ *       FPix: 32 bpp float
+ *       DPix: 64 bpp double
+ *       Notes:
+ *          (1) The only valid Pix image type with alpha is rgba.
+ *              In particular, the alpha component is not used in
+ *              cmapped images.
+ *          (2) PixComp can hold any Pix with IFF_PNG encoding.
+ *
+ *  This file is internal: it is not part of the public interface.
+ *  It contains the definitions of most of the image-related structs
+ *  used in leptonica:
+ *       struct Pix
+ *       struct PixColormap
+ *       struct RGBA_Quad
+ *       struct Pixa
+ *       struct Pixaa
+ *       struct Box
+ *       struct Boxa
+ *       struct Boxaa
+ *       struct Pta
+ *       struct Ptaa
+ *       struct Pixacc
+ *       struct PixTiling
+ *       struct FPix
+ *       struct FPixa
+ *       struct DPix
+ *       struct PixComp
+ *       struct PixaComp
+ *
+ *  This file can be #included after allheaders.h in source files that
+ *  require direct access to the internal data fields in these structs.
+ *
+ *  Notes on the pixels in the raster image.  Most of this information
+ *  can also be found in pix.h.
+ *
+ *       (1) The image data is stored in a single contiguous
+ *           array of l_uint32, into which the pixels are packed.
+ *           By "packed" we mean that there are no unused bits
+ *           between pixels, except for end-of-line padding to
+ *           satisfy item (2) below.
+ *
+ *       (2) Every image raster line begins on a 32-bit word
+ *           boundary within this array.
+ *
+ *       (3) Pix image data is stored in 32-bit units, with the
+ *           pixels ordered from left to right in the image being
+ *           stored in order from the MSB to LSB within the word,
+ *           for both big-endian and little-endian machines.
+ *           This is the natural ordering for big-endian machines,
+ *           as successive bytes are stored and fetched progressively
+ *           to the right.  However, for little-endians, when storing
+ *           we re-order the bytes from this byte stream order, and
+ *           reshuffle again for byte access on 32-bit entities.
+ *           So if the bytes come in sequence from left to right, we
+ *           store them on little-endians in byte order:
+ *                3 2 1 0 7 6 5 4 ...
+ *           This MSB to LSB ordering allows left and right shift
+ *           operations on 32 bit words to move the pixels properly.
+ *
+ *       (4) We use 32 bit pixels for both RGB and RGBA color images.
+ *           The A (alpha) byte is ignored in most leptonica functions
+ *           operating on color images.  Within each 4 byte pixel, the
+ *           color samples are ordered from MSB to LSB, as follows:
+ *
+ *                |  MSB  |  2nd MSB  |  3rd MSB  |  LSB  |
+ *                   red      green       blue      alpha
+ *                    0         1           2         3   (big-endian)
+ *                    3         2           1         0   (little-endian)
+ *
+ *           Because we use MSB to LSB ordering within the 32-bit word,
+ *           the individual 8-bit samples can be accessed with
+ *           GET_DATA_BYTE and SET_DATA_BYTE macros, using the
+ *           (implicitly big-ending) ordering
+ *                 red:    byte 0  (MSB)
+ *                 green:  byte 1  (2nd MSB)
+ *                 blue:   byte 2  (3rd MSB)
+ *                 alpha:  byte 3  (LSB)
+ *
+ *           The specific color assignment is made in this file,
+ *           through the definitions of COLOR_RED, etc.  Then the R, G
+ *           B and A sample values can be retrieved using
+ *                 redval = GET_DATA_BYTE(&pixel, COLOR_RED);
+ *                 greenval = GET_DATA_BYTE(&pixel, COLOR_GREEN);
+ *                 blueval = GET_DATA_BYTE(&pixel, COLOR_BLUE);
+ *                 alphaval = GET_DATA_BYTE(&pixel, L_ALPHA_CHANNEL);
+ *           and they can be set with
+ *                 SET_DATA_BYTE(&pixel, COLOR_RED, redval);
+ *                 SET_DATA_BYTE(&pixel, COLOR_GREEN, greenval);
+ *                 SET_DATA_BYTE(&pixel, COLOR_BLUE, blueval);
+ *                 SET_DATA_BYTE(&pixel, L_ALPHA_CHANNEL, alphaval);
+ *
+ *           More efficiently, these components can be extracted directly
+ *           by shifting and masking, explicitly using the values in
+ *           L_RED_SHIFT, etc.:
+ *                 (pixel32 >> L_RED_SHIFT) & 0xff;         (red)
+ *                 (pixel32 >> L_GREEN_SHIFT) & 0xff;       (green)
+ *                 (pixel32 >> L_BLUE_SHIFT) & 0xff;        (blue)
+ *                 (pixel32 >> L_ALPHA_SHIFT) & 0xff;       (alpha)
+ *           The functions extractRGBValues() and extractRGBAValues() are
+ *           provided to do this.  Likewise, the pixels can be set
+ *           directly by shifting, using composeRGBPixel() and
+ *           composeRGBAPixel().
+ *
+ *           All these operations work properly on both big- and little-endians.
+ *
+ *       (5) A reference count is held within each pix, giving the
+ *           number of ptrs to the pix.  When a pixClone() call
+ *           is made, the ref count is increased by 1, and
+ *           when a pixDestroy() call is made, the reference count
+ *           of the pix is decremented.  The pix is only destroyed
+ *           when the reference count goes to zero.
+ *
+ *       (6) The version numbers (below) are used in the serialization
+ *           of these data structures.  They are placed in the files,
+ *           and rarely (if ever) change.
+ *
+ *       (7) The serialization dependencies are as follows:
+ *               pixaa  :  pixa  :  boxa
+ *               boxaa  :  boxa
+ *           So, for example, pixaa and boxaa can be changed without
+ *           forcing a change in pixa or boxa.  However, if pixa is
+ *           changed, it forces a change in pixaa, and if boxa is
+ *           changed, if forces a change in the other three.
+ *           We define four version numbers:
+ *               PIXAA_VERSION_NUMBER
+ *               PIXA_VERSION_NUMBER
+ *               BOXAA_VERSION_NUMBER
+ *               BOXA_VERSION_NUMBER
+ * </pre>
+ *-------------------------------------------------------------------------*/
+
+/*-------------------------------------------------------------------------*
+ *                              Basic Pix                                  *
+ *-------------------------------------------------------------------------*/
+    /* The 'special' field is by default 0, but it can hold integers
+     * that direct non-default actions, e.g., in png and jpeg I/O. */
+
+/*! Basic Pix */
+struct Pix
+{
+    l_uint32             w;         /*!< width in pixels                   */
+    l_uint32             h;         /*!< height in pixels                  */
+    l_uint32             d;         /*!< depth in bits (bpp)               */
+    l_uint32             spp;       /*!< number of samples per pixel       */
+    l_uint32             wpl;       /*!< 32-bit words/line                 */
+    l_atomic             refcount;  /*!< reference count (1 if no clones)  */
+    l_int32              xres;      /*!< image res (ppi) in x direction    */
+                                    /*!< (use 0 if unknown)                */
+    l_int32              yres;      /*!< image res (ppi) in y direction    */
+                                    /*!< (use 0 if unknown)                */
+    l_int32              informat;  /*!< input file format, IFF_*          */
+    l_int32              special;   /*!< special instructions for I/O, etc */
+    char                *text;      /*!< text string associated with pix   */
+    struct PixColormap  *colormap;  /*!< colormap (may be null)            */
+    l_uint32            *data;      /*!< the image data                    */
+};
+
+/*! Colormap of a Pix */
+struct PixColormap
+{
+    void            *array;   /*!< colormap table (array of RGBA_QUAD)     */
+    l_int32          depth;   /*!< of pix (1, 2, 4 or 8 bpp)               */
+    l_int32          nalloc;  /*!< number of color entries allocated       */
+    l_int32          n;       /*!< number of color entries used            */
+};
+
+
+    /*! Colormap table entry (after the BMP version).
+     * Note that the BMP format stores the colormap table exactly
+     * as it appears here, with color samples being stored sequentially,
+     * in the order (b,g,r,a). */
+struct RGBA_Quad
+{
+    l_uint8     blue;         /*!< blue value */
+    l_uint8     green;        /*!< green value */
+    l_uint8     red;          /*!< red value */
+    l_uint8     alpha;        /*!< alpha value */
+};
+
+
+/*-------------------------------------------------------------------------*
+ *                              Array of pix                               *
+ *-------------------------------------------------------------------------*/
+    /*  Serialization for primary data structures */
+#define  PIXAA_VERSION_NUMBER      2  /*!< Version for Pixaa serialization */
+#define  PIXA_VERSION_NUMBER       2  /*!< Version for Pixa serialization  */
+#define  BOXA_VERSION_NUMBER       2  /*!< Version for Boxa serialization  */
+#define  BOXAA_VERSION_NUMBER      3  /*!< Version for Boxaa serialization */
+
+/*! Array of pix */
+struct Pixa
+{
+    l_int32             n;          /*!< number of Pix in ptr array        */
+    l_int32             nalloc;     /*!< number of Pix ptrs allocated      */
+    l_atomic            refcount;   /*!< reference count (1 if no clones)  */
+    struct Pix        **pix;        /*!< the array of ptrs to pix          */
+    struct Boxa        *boxa;       /*!< array of boxes                    */
+};
+
+/*! Array of arrays of pix */
+struct Pixaa
+{
+    l_int32             n;          /*!< number of Pixa in ptr array       */
+    l_int32             nalloc;     /*!< number of Pixa ptrs allocated     */
+    struct Pixa       **pixa;       /*!< array of ptrs to pixa             */
+    struct Boxa        *boxa;       /*!< array of boxes                    */
+};
+
+
+/*-------------------------------------------------------------------------*
+ *                    Basic rectangle and rectangle arrays                 *
+ *-------------------------------------------------------------------------*/
+/*! Basic rectangle */
+struct Box
+{
+    l_int32            x;           /*!< left coordinate                   */
+    l_int32            y;           /*!< top coordinate                    */
+    l_int32            w;           /*!< box width                         */
+    l_int32            h;           /*!< box height                        */
+    l_atomic           refcount;    /*!< reference count (1 if no clones)  */
+};
+
+/*! Array of Box */
+struct Boxa
+{
+    l_int32            n;           /*!< number of box in ptr array        */
+    l_int32            nalloc;      /*!< number of box ptrs allocated      */
+    l_atomic           refcount;    /*!< reference count (1 if no clones)  */
+    struct Box       **box;         /*!< box ptr array                     */
+};
+
+/*! Array of Boxa */
+struct Boxaa
+{
+    l_int32            n;           /*!< number of boxa in ptr array       */
+    l_int32            nalloc;      /*!< number of boxa ptrs allocated     */
+    struct Boxa      **boxa;        /*!< boxa ptr array                    */
+};
+
+
+/*-------------------------------------------------------------------------*
+ *                               Array of points                           *
+ *-------------------------------------------------------------------------*/
+#define  PTA_VERSION_NUMBER      1  /*!< Version for Pta serialization     */
+
+/*! Array of points */
+struct Pta
+{
+    l_int32            n;           /*!< actual number of pts              */
+    l_int32            nalloc;      /*!< size of allocated arrays          */
+    l_atomic           refcount;    /*!< reference count (1 if no clones)  */
+    l_float32         *x, *y;       /*!< arrays of floats                  */
+};
+
+
+/*-------------------------------------------------------------------------*
+ *                              Array of Pta                               *
+ *-------------------------------------------------------------------------*/
+/*! Array of Pta */
+struct Ptaa
+{
+    l_int32              n;         /*!< number of pta in ptr array        */
+    l_int32              nalloc;    /*!< number of pta ptrs allocated      */
+    struct Pta         **pta;       /*!< pta ptr array                     */
+};
+
+
+/*-------------------------------------------------------------------------*
+ *                       Pix accumulator container                         *
+ *-------------------------------------------------------------------------*/
+/*! Pix accumulator container */
+struct Pixacc
+{
+    l_int32             w;          /*!< array width                       */
+    l_int32             h;          /*!< array height                      */
+    l_int32             offset;     /*!< used to allow negative            */
+                                    /*!< intermediate results              */
+    struct Pix         *pix;        /*!< the 32 bit accumulator pix        */
+};
+
+
+/*-------------------------------------------------------------------------*
+ *                              Pix tiling                                 *
+ *-------------------------------------------------------------------------*/
+/*! Pix tiling */
+struct PixTiling
+{
+    struct Pix          *pix;       /*!< input pix (a clone)               */
+    l_int32              nx;        /*!< number of tiles horizontally      */
+    l_int32              ny;        /*!< number of tiles vertically        */
+    l_int32              w;         /*!< tile width                        */
+    l_int32              h;         /*!< tile height                       */
+    l_int32              xoverlap;  /*!< overlap on left and right         */
+    l_int32              yoverlap;  /*!< overlap on top and bottom         */
+    l_int32              strip;     /*!< strip for paint; default is TRUE  */
+};
+
+
+/*-------------------------------------------------------------------------*
+ *                       FPix: pix with float array                        *
+ *-------------------------------------------------------------------------*/
+#define  FPIX_VERSION_NUMBER      2 /*!< Version for FPix serialization    */
+
+/*! Pix with float array */
+struct FPix
+{
+    l_int32              w;         /*!< width in pixels                   */
+    l_int32              h;         /*!< height in pixels                  */
+    l_int32              wpl;       /*!< 32-bit words/line                 */
+    l_atomic             refcount;  /*!< reference count (1 if no clones)  */
+    l_int32              xres;      /*!< image res (ppi) in x direction    */
+                                    /*!< (use 0 if unknown)                */
+    l_int32              yres;      /*!< image res (ppi) in y direction    */
+                                    /*!< (use 0 if unknown)                */
+    l_float32           *data;      /*!< the float image data              */
+};
+
+/*! Array of FPix */
+struct FPixa
+{
+    l_int32             n;          /*!< number of fpix in ptr array       */
+    l_int32             nalloc;     /*!< number of fpix ptrs allocated     */
+    l_atomic            refcount;   /*!< reference count (1 if no clones)  */
+    struct FPix       **fpix;       /*!< the array of ptrs to fpix         */
+};
+
+
+/*-------------------------------------------------------------------------*
+ *                       DPix: pix with double array                       *
+ *-------------------------------------------------------------------------*/
+#define  DPIX_VERSION_NUMBER      2 /*!< Version for DPix serialization    */
+
+/*! Pix with double array */
+struct DPix
+{
+    l_int32              w;         /*!< width in pixels                   */
+    l_int32              h;         /*!< height in pixels                  */
+    l_int32              wpl;       /*!< 32-bit words/line                 */
+    l_atomic             refcount;  /*!< reference count (1 if no clones)  */
+    l_int32              xres;      /*!< image res (ppi) in x direction    */
+                                    /*!< (use 0 if unknown)                */
+    l_int32              yres;      /*!< image res (ppi) in y direction    */
+                                    /*!< (use 0 if unknown)                */
+    l_float64           *data;      /*!< the double image data             */
+};
+
+
+/*-------------------------------------------------------------------------*
+ *                        PixComp: compressed pix                          *
+ *-------------------------------------------------------------------------*/
+/*! Compressed Pix */
+struct PixComp
+{
+    l_int32              w;         /*!< width in pixels                   */
+    l_int32              h;         /*!< height in pixels                  */
+    l_int32              d;         /*!< depth in bits                     */
+    l_int32              xres;      /*!< image res (ppi) in x direction    */
+                                    /*!<   (use 0 if unknown)              */
+    l_int32              yres;      /*!< image res (ppi) in y direction    */
+                                    /*!<   (use 0 if unknown)              */
+    l_int32              comptype;  /*!< compressed format (IFF_TIFF_G4,   */
+                                    /*!<   IFF_PNG, IFF_JFIF_JPEG)         */
+    char                *text;      /*!< text string associated with pix   */
+    l_int32              cmapflag;  /*!< flag (1 for cmap, 0 otherwise)    */
+    l_uint8             *data;      /*!< the compressed image data         */
+    size_t               size;      /*!< size of the data array            */
+};
+
+
+/*-------------------------------------------------------------------------*
+ *                     PixaComp: array of compressed pix                   *
+ *-------------------------------------------------------------------------*/
+#define  PIXACOMP_VERSION_NUMBER 2  /*!< Version for PixaComp serialization */
+
+/*! Array of compressed pix */
+struct PixaComp
+{
+    l_int32              n;         /*!< number of PixComp in ptr array    */
+    l_int32              nalloc;    /*!< number of PixComp ptrs allocated  */
+    l_int32              offset;    /*!< indexing offset into ptr array    */
+    struct PixComp     **pixc;      /*!< the array of ptrs to PixComp      */
+    struct Boxa         *boxa;      /*!< array of boxes                    */
+};
+
+#endif  /* LEPTONICA_PIX_INTERNAL_H */

src/windows/leptonica/include/leptonica/ptra.h

@@ -0,0 +1,97 @@
+/*====================================================================*
+ -  Copyright (C) 2001 Leptonica.  All rights reserved.
+ -
+ -  Redistribution and use in source and binary forms, with or without
+ -  modification, are permitted provided that the following conditions
+ -  are met:
+ -  1. Redistributions of source code must retain the above copyright
+ -     notice, this list of conditions and the following disclaimer.
+ -  2. Redistributions in binary form must reproduce the above
+ -     copyright notice, this list of conditions and the following
+ -     disclaimer in the documentation and/or other materials
+ -     provided with the distribution.
+ -
+ -  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ -  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ -  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ -  A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ANY
+ -  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ -  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ -  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ -  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ -  OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ -  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ -  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *====================================================================*/
+
+#ifndef  LEPTONICA_PTRA_H
+#define  LEPTONICA_PTRA_H
+
+/*!
+ * \file ptra.h
+ *
+ * <pre>
+ *  Contains the following structs:
+ *      struct L_Ptra
+ *      struct L_Ptraa
+ *
+ *  Contains definitions for:
+ *      L_Ptra compaction flags for removal
+ *      L_Ptra shifting flags for insert
+ *      L_Ptraa accessor flags
+ * </pre>
+ */
+
+    /* Bound on max initial ptra size */
+LEPT_DLL extern const l_uint32  MaxInitPtraSize;
+
+/*------------------------------------------------------------------------*
+ *                     Generic Ptr Array Structs                          *
+ *------------------------------------------------------------------------*/
+
+    /*! Generic pointer array */
+struct L_Ptra
+{
+    l_int32          nalloc;    /*!< size of allocated ptr array         */
+    l_int32          imax;      /*!< greatest valid index                */
+    l_int32          nactual;   /*!< actual number of stored elements    */
+    void           **array;     /*!< ptr array                           */
+};
+typedef struct L_Ptra  L_PTRA;
+
+
+    /*! Array of generic pointer arrays */
+struct L_Ptraa
+{
+    l_int32          nalloc;    /*!< size of allocated ptr array         */
+    struct L_Ptra  **ptra;      /*!< array of ptra                       */
+};
+typedef struct L_Ptraa  L_PTRAA;
+
+
+
+/*------------------------------------------------------------------------*
+ *          Accessor and modifier flags for L_Ptra and L_Ptraa            *
+ *------------------------------------------------------------------------*/
+
+/*! Ptra Removal */
+enum {
+    L_NO_COMPACTION = 1,        /*!< null the pointer only                */
+    L_COMPACTION = 2            /*!< compact the array                    */
+};
+
+/*! Ptra Insertion */
+enum {
+    L_AUTO_DOWNSHIFT = 0,     /*!< choose based on number of holes        */
+    L_MIN_DOWNSHIFT = 1,      /*!< downshifts min # of ptrs below insert  */
+    L_FULL_DOWNSHIFT = 2      /*!< downshifts all ptrs below insert       */
+};
+
+/*! Ptraa Accessor */
+enum {
+    L_HANDLE_ONLY = 0,     /*!< ptr to L_Ptra; caller can inspect only    */
+    L_REMOVE = 1           /*!< caller owns; destroy or save in L_Ptraa   */
+};
+
+
+#endif  /* LEPTONICA_PTRA_H */

src/windows/leptonica/include/leptonica/queue.h

@@ -0,0 +1,77 @@
+/*====================================================================*
+ -  Copyright (C) 2001 Leptonica.  All rights reserved.
+ -
+ -  Redistribution and use in source and binary forms, with or without
+ -  modification, are permitted provided that the following conditions
+ -  are met:
+ -  1. Redistributions of source code must retain the above copyright
+ -     notice, this list of conditions and the following disclaimer.
+ -  2. Redistributions in binary form must reproduce the above
+ -     copyright notice, this list of conditions and the following
+ -     disclaimer in the documentation and/or other materials
+ -     provided with the distribution.
+ -
+ -  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ -  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ -  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ -  A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ANY
+ -  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ -  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ -  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ -  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ -  OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ -  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ -  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *====================================================================*/
+
+#ifndef  LEPTONICA_QUEUE_H
+#define  LEPTONICA_QUEUE_H
+
+/*!
+ * \file queue.h
+ *
+ * <pre>
+ *      Expandable pointer queue for arbitrary void* data.
+ *
+ *      The L_Queue is a fifo that implements a queue of void* pointers.
+ *      It can be used to hold a queue of any type of struct.
+ *
+ *      Internally, it maintains two counters:
+ *          nhead:  location of head (in ptrs) from the beginning
+ *                  of the array.
+ *          nelem:  number of ptr elements stored in the queue.
+ *
+ *      The element at the head of the queue, which is the next to
+ *      be removed, is array[nhead].  The location at the tail of the
+ *      queue to which the next element will be added is
+ *      array[nhead + nelem].
+ *
+ *      As items are added to the queue, nelem increases.
+ *      As items are removed, nhead increases and nelem decreases.
+ *      Any time the tail reaches the end of the allocated array,
+ *      all the pointers are shifted to the left, so that the head
+ *      is at the beginning of the array.
+ *      If the array becomes more than 3/4 full, it doubles in size.
+ *
+ *      The auxiliary stack can be used in a wrapper for re-using
+ *      items popped from the queue.  It is not made by default.
+ *
+ *      For further implementation details, see queue.c.
+ * </pre>
+ */
+
+/*! Expandable pointer queue for arbitrary void* data */
+struct L_Queue
+{
+    l_int32          nalloc;   /*!< size of allocated ptr array            */
+    l_int32          nhead;    /*!< location of head (in ptrs) from the    */
+                               /*!< beginning of the array                 */
+    l_int32          nelem;    /*!< number of elements stored in the queue */
+    void           **array;    /*!< ptr array                              */
+    struct L_Stack  *stack;    /*!< auxiliary stack                        */
+
+};
+typedef struct L_Queue L_QUEUE;
+
+
+#endif  /* LEPTONICA_QUEUE_H */

src/windows/leptonica/include/leptonica/rbtree.h

@@ -0,0 +1,91 @@
+/*====================================================================*
+ -  Copyright (C) 2001 Leptonica.  All rights reserved.
+ -
+ -  Redistribution and use in source and binary forms, with or without
+ -  modification, are permitted provided that the following conditions
+ -  are met:
+ -  1. Redistributions of source code must retain the above copyright
+ -     notice, this list of conditions and the following disclaimer.
+ -  2. Redistributions in binary form must reproduce the above
+ -     copyright notice, this list of conditions and the following
+ -     disclaimer in the documentation and/or other materials
+ -     provided with the distribution.
+ -
+ -  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ -  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ -  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ -  A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ANY
+ -  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ -  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ -  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ -  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ -  OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ -  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ -  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *====================================================================*/
+
+/*
+ * Modified from the excellent code here:
+ *     http://en.literateprograms.org/Red-black_tree_(C)?oldid=19567
+ * which has been placed in the public domain under the Creative Commons
+ * CC0 1.0 waiver (http://creativecommons.org/publicdomain/zero/1.0/).
+ *
+ * When the key is generated from a hash (e.g., string --> uint64),
+ * there is always the possibility of having collisions, but to make
+ * the collision probability very low requires using a large hash.
+ * For that reason, the key types are 64 bit quantities, which will result
+ * in a negligible probabililty of collisions for millions of hashed values.
+ * Using 8 byte keys instead of 4 byte keys requires a little more
+ * storage, but the simplification in being able to ignore collisions
+ * with the red-black trees for most applications is worth it.
+ */
+
+#ifndef  LEPTONICA_RBTREE_H
+#define  LEPTONICA_RBTREE_H
+
+    /*! The three valid key types for red-black trees, maps and sets. */
+/*! RBTree Key Type */
+enum {
+    L_INT_TYPE = 1,
+    L_UINT_TYPE = 2,
+    L_FLOAT_TYPE = 3
+};
+
+    /*!
+     * Storage for keys and values for red-black trees, maps and sets.
+     * <pre>
+     * Note:
+     *   (1) Keys and values of the valid key types are all 64-bit
+     *   (2) (void *) can be used for values but not for keys.
+     * </pre>
+     */
+union Rb_Type {
+    l_int64    itype;
+    l_uint64   utype;
+    l_float64  ftype;
+    void      *ptype;
+};
+typedef union Rb_Type RB_TYPE;
+
+struct L_Rbtree {
+    struct L_Rbtree_Node  *root;
+    l_int32                keytype;
+};
+typedef struct L_Rbtree L_RBTREE;
+typedef struct L_Rbtree L_AMAP;  /* hide underlying implementation for map */
+typedef struct L_Rbtree L_ASET;  /* hide underlying implementation for set */
+
+struct L_Rbtree_Node {
+    union Rb_Type          key;
+    union Rb_Type          value;
+    struct L_Rbtree_Node  *left;
+    struct L_Rbtree_Node  *right;
+    struct L_Rbtree_Node  *parent;
+    l_int32                color;
+};
+typedef struct L_Rbtree_Node L_RBTREE_NODE;
+typedef struct L_Rbtree_Node L_AMAP_NODE;  /* hide tree implementation */
+typedef struct L_Rbtree_Node L_ASET_NODE;  /* hide tree implementation */
+
+
+#endif  /* LEPTONICA_RBTREE_H */

src/windows/leptonica/include/leptonica/readbarcode.h

@@ -0,0 +1,239 @@
+/*====================================================================*
+ -  Copyright (C) 2001 Leptonica.  All rights reserved.
+ -
+ -  Redistribution and use in source and binary forms, with or without
+ -  modification, are permitted provided that the following conditions
+ -  are met:
+ -  1. Redistributions of source code must retain the above copyright
+ -     notice, this list of conditions and the following disclaimer.
+ -  2. Redistributions in binary form must reproduce the above
+ -     copyright notice, this list of conditions and the following
+ -     disclaimer in the documentation and/or other materials
+ -     provided with the distribution.
+ -
+ -  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ -  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ -  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ -  A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ANY
+ -  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ -  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ -  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ -  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ -  OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ -  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ -  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *====================================================================*/
+
+#ifndef  LEPTONICA_READBARCODE_H
+#define  LEPTONICA_READBARCODE_H
+
+    /* ----------------------------------------------------------------- *
+     *            Flags for method of extracting barcode widths          *
+     * ----------------------------------------------------------------- */
+
+/*! Barcode Method */
+enum {
+    L_USE_WIDTHS = 1,     /*!< use histogram of barcode widths           */
+    L_USE_WINDOWS = 2     /*!< find best window for decoding transitions */
+};
+
+    /* ----------------------------------------------------------------- *
+     *                     Flags for barcode formats                     *
+     * These are used both to identify a barcode format and to identify  *
+     * the decoding method to use on a barcode.                          *
+     * ----------------------------------------------------------------- */
+
+/*! Barcode Format */
+enum {
+    L_BF_UNKNOWN = 0,     /*!< unknown format                            */
+    L_BF_ANY = 1,         /*!< try decoding with all known formats       */
+    L_BF_CODE128 = 2,     /*!< decode with Code128 format                */
+    L_BF_EAN8 = 3,        /*!< decode with EAN8 format                   */
+    L_BF_EAN13 = 4,       /*!< decode with EAN13 format                  */
+    L_BF_CODE2OF5 = 5,    /*!< decode with Code 2 of 5 format            */
+    L_BF_CODEI2OF5 = 6,   /*!< decode with Interleaved 2 of 5 format     */
+    L_BF_CODE39 = 7,      /*!< decode with Code39 format                 */
+    L_BF_CODE93 = 8,      /*!< decode with Code93 format                 */
+    L_BF_CODABAR = 9,     /*!< decode with Code93 format                 */
+    L_BF_UPCA = 10        /*!< decode with UPC A format                  */
+};
+
+    /* ----------------------------------------------------------------- *
+     *                  Currently supported formats                      *
+     *            Update these arrays as new formats are added.          *
+     * ----------------------------------------------------------------- */
+
+/*! Currently supported formats */
+static const l_int32  SupportedBarcodeFormat[] = {
+    L_BF_CODE2OF5,
+    L_BF_CODEI2OF5,
+    L_BF_CODE93,
+    L_BF_CODE39,
+    L_BF_CODABAR,
+    L_BF_UPCA,
+    L_BF_EAN13
+};
+
+/*! Currently supported format names */
+static const char  *SupportedBarcodeFormatName[] = {
+    "Code2of5",
+    "CodeI2of5",
+    "Code93",
+    "Code39",
+    "Codabar",
+    "Upca",
+    "Ean13"
+};
+static const l_int32  NumSupportedBarcodeFormats = 7; /*!< Number of formats */
+
+
+    /* ----------------------------------------------------------------- *
+     *                       Code 2 of 5 symbology                       *
+     * ----------------------------------------------------------------- */
+static const char *Code2of5[] = {
+    "111121211", "211111112", "112111112", "212111111",   /* 0 - 3 */
+    "111121112", "211121111", "112121111", "111111212",   /* 4 - 7 */
+    "211111211", "112111211",                             /* 8 - 9 */
+    "21211", "21112"                                      /* Start, Stop */
+};
+
+static const l_int32  C25_START = 10;
+static const l_int32  C25_STOP =  11;
+
+
+    /* ----------------------------------------------------------------- *
+     *                Code Interleaved 2 of 5 symbology                  *
+     * ----------------------------------------------------------------- */
+static const char *CodeI2of5[] = {
+    "11221", "21112", "12112", "22111", "11212",    /*  0 - 4 */
+    "21211", "12211", "11122", "21121", "12121",    /*  5 - 9 */
+    "1111", "211"                                   /*  start, stop */
+};
+
+static const l_int32  CI25_START = 10;
+static const l_int32  CI25_STOP =  11;
+
+
+    /* ----------------------------------------------------------------- *
+     *                         Code 93 symbology                         *
+     * ----------------------------------------------------------------- */
+static const char *Code93[] = {
+    "131112", "111213", "111312", "111411", "121113", /* 0: 0 - 4 */
+    "121212", "121311", "111114", "131211", "141111", /* 5: 5 - 9 */
+    "211113", "211212", "211311", "221112", "221211", /* 10: A - E */
+    "231111", "112113", "112212", "112311", "122112", /* 15: F - J */
+    "132111", "111123", "111222", "111321", "121122", /* 20: K - O */
+    "131121", "212112", "212211", "211122", "211221", /* 25: P - T */
+    "221121", "222111", "112122", "112221", "122121", /* 30: U - Y */
+    "123111", "121131", "311112", "311211", "321111", /* 35: Z,-,.,SP,$ */
+    "112131", "113121", "211131", "131221", "312111", /* 40: /,+,%,($),(%) */
+    "311121", "122211", "111141"                      /* 45: (/),(+), Start */
+};
+
+    /* Use "[]{}#" to represent special codes 43-47 */
+static const char Code93Val[] =
+    "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. $/+%[]{}#";
+
+static const l_int32  C93_START = 47;
+static const l_int32  C93_STOP =  47;
+
+
+    /* ----------------------------------------------------------------- *
+     *                         Code 39 symbology                         *
+     * ----------------------------------------------------------------- */
+static const char *Code39[] = {
+    "111221211", "211211112", "112211112", "212211111",  /* 0: 0 - 3      */
+    "111221112", "211221111", "112221111", "111211212",  /* 4: 4 - 7      */
+    "211211211", "112211211", "211112112", "112112112",  /* 8: 8 - B      */
+    "212112111", "111122112", "211122111", "112122111",  /* 12: C - F     */
+    "111112212", "211112211", "112112211", "111122211",  /* 16: G - J     */
+    "211111122", "112111122", "212111121", "111121122",  /* 20: K - N     */
+    "211121121", "112121121", "111111222", "211111221",  /* 24: O - R     */
+    "112111221", "111121221", "221111112", "122111112",  /* 28: S - V     */
+    "222111111", "121121112", "221121111", "122121111",  /* 32: W - Z     */
+    "121111212", "221111211", "122111211", "121212111",  /* 36: -,.,SP,$  */
+    "121211121", "121112121", "111212121", "121121211"   /* 40: /,+,%,*   */
+};
+
+    /* Use "*" to represent the Start and Stop codes (43) */
+static const char Code39Val[] =
+    "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. $/+%*";
+
+static const l_int32  C39_START = 43;
+static const l_int32  C39_STOP =  43;
+
+
+    /* ----------------------------------------------------------------- *
+     *                         Codabar symbology                         *
+     * ----------------------------------------------------------------- */
+static const char *Codabar[] = {
+    "1111122", "1111221", "1112112", "2211111", "1121121", /* 0: 0 - 4      */
+    "2111121", "1211112", "1211211", "1221111", "2112111", /* 5: 5 - 9      */
+    "1112211", "1122111", "2111212", "2121112", "2121211", /* 10: -,$,:,/,. */
+    "1121212", "1122121", "1212112", "1112122", "1112221"  /* 15: +,A,B,C,D */
+};
+
+    /* Ascii representations for codes 16-19: (A or T), (B or N), (C or *),
+     * (D or E).  These are used in pairs for the Start and Stop codes. */
+static const char CodabarVal[] = "0123456789-$:/.+ABCD";
+
+
+    /* ----------------------------------------------------------------- *
+     *                          UPC-A symbology                          *
+     * ----------------------------------------------------------------- */
+static const char *Upca[] = {
+    "3211", "2221", "2122", "1411", "1132",  /* 0: 0 - 4              */
+    "1231", "1114", "1312", "1213", "3112",  /* 5: 5 - 9              */
+    "111", "111", "11111"                    /* 10: Start, Stop, Mid  */
+};
+
+static const l_int32  UPCA_START = 10;
+static const l_int32  UPCA_STOP =  11;
+static const l_int32  UPCA_MID =   12;
+
+
+    /* ----------------------------------------------------------------- *
+     *                         Code128 symbology                         *
+     * ----------------------------------------------------------------- */
+static const char *Code128[] = {
+    "212222", "222122", "222221", "121223", "121322",    /*  0 - 4 */
+    "131222", "122213", "122312", "132212", "221213",    /*  5 - 9 */
+    "221312", "231212", "112232", "122132", "122231",    /* 10 - 14 */
+    "113222", "123122", "123221", "223211", "221132",    /* 15 - 19 */
+    "221231", "213212", "223112", "312131", "311222",    /* 20 - 24 */
+    "321122", "321221", "312212", "322112", "322211",    /* 25 - 29 */
+    "212123", "212321", "232121", "111323", "131123",    /* 30 - 34 */
+    "131321", "112313", "132113", "132311", "211313",    /* 35 - 39 */
+    "231113", "231311", "112133", "112331", "132131",    /* 40 - 44 */
+    "113123", "113321", "133121", "313121", "211331",    /* 45 - 49 */
+    "231131", "213113", "213311", "213131", "311123",    /* 50 - 54 */
+    "311321", "331121", "312113", "312311", "332111",    /* 55 - 59 */
+    "314111", "221411", "431111", "111224", "111422",    /* 60 - 64 */
+    "121124", "121421", "141122", "141221", "112214",    /* 65 - 69 */
+    "112412", "122114", "122411", "142112", "142211",    /* 70 - 74 */
+    "241211", "221114", "413111", "241112", "134111",    /* 75 - 79 */
+    "111242", "121142", "121241", "114212", "124112",    /* 80 - 84 */
+    "124211", "411212", "421112", "421211", "212141",    /* 85 - 89 */
+    "214121", "412121", "111143", "111341", "131141",    /* 90 - 94 */
+    "114113", "114311", "411113", "411311", "113141",    /* 95 - 99 */
+    "114131", "311141", "411131", "211412", "211214",    /* 100 - 104 */
+    "211232", "2331112"                                  /* 105 - 106 */
+};
+
+static const l_int32  C128_FUN_3 =    96;   /* in A or B only; in C it is 96 */
+static const l_int32  C128_FUNC_2 =   97;   /* in A or B only; in C it is 97 */
+static const l_int32  C128_SHIFT =    98;   /* in A or B only; in C it is 98 */
+static const l_int32  C128_GOTO_C =   99;   /* in A or B only; in C it is 99 */
+static const l_int32  C128_GOTO_B =  100;
+static const l_int32  C128_GOTO_A =  101;
+static const l_int32  C128_FUNC_1 =  102;
+static const l_int32  C128_START_A = 103;
+static const l_int32  C128_START_B = 104;
+static const l_int32  C128_START_C = 105;
+static const l_int32  C128_STOP =    106;
+    /* code 128 symbols are 11 units */
+static const l_int32  C128_SYMBOL_WIDTH = 11;
+
+
+
+#endif  /* LEPTONICA_READBARCODE_H */

src/windows/leptonica/include/leptonica/recog.h

@@ -0,0 +1,264 @@
+/*====================================================================*
+ -  Copyright (C) 2001 Leptonica.  All rights reserved.
+ -
+ -  Redistribution and use in source and binary forms, with or without
+ -  modification, are permitted provided that the following conditions
+ -  are met:
+ -  1. Redistributions of source code must retain the above copyright
+ -     notice, this list of conditions and the following disclaimer.
+ -  2. Redistributions in binary form must reproduce the above
+ -     copyright notice, this list of conditions and the following
+ -     disclaimer in the documentation and/or other materials
+ -     provided with the distribution.
+ -
+ -  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ -  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ -  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ -  A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ANY
+ -  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ -  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ -  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ -  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ -  OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ -  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ -  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *====================================================================*/
+
+#ifndef  LEPTONICA_RECOG_H
+#define  LEPTONICA_RECOG_H
+
+/*!
+ * \file recog.h
+ *
+ * <pre>
+ *     This is a simple utility for training and recognizing individual
+ *     machine-printed text characters.  It is designed to be adapted
+ *     to a particular set of character images; e.g., from a book.
+ *
+ *     There are two methods of training the recognizer.  In the most
+ *     simple, a set of bitmaps has been labeled by some means, such
+ *     a generic OCR program.  This is input either one template at a time
+ *     or as a pixa of templates, to a function that creates a recog.
+ *     If in a pixa, the text string label must be embedded in the
+ *     text field of each pix.
+ *
+ *     If labeled data is not available, we start with a bootstrap
+ *     recognizer (BSR) that has labeled data from a variety of sources.
+ *     These images are scaled, typically to a fixed height, and then
+ *     fed similarly scaled unlabeled images from the source (e.g., book),
+ *     and the BSR attempts to identify them.  All images that have
+ *     a high enough correlation score with one of the templates in the
+ *     BSR are emitted in a pixa, which now holds unscaled and labeled
+ *     templates from the source.  This is the generator for a book adapted
+ *     recognizer (BAR).
+ *
+ *     The pixa should always be thought of as the primary structure.
+ *     It is the generator for the recog, because a recog is built
+ *     from a pixa of unscaled images.
+ *
+ *     New image templates can be added to a recog as long as it is
+ *     in training mode.  Once training is finished, to add templates
+ *     it is necessary to extract the generating pixa, add templates
+ *     to that pixa, and make a new recog.  Similarly, we do not
+ *     join two recog; instead, we simply join their generating pixa,
+ *     and make a recog from that.
+ *
+ *     To remove outliers from a pixa of labeled pix, make a recog,
+ *     determine the outliers, and generate a new pixa with the
+ *     outliers removed.  The outliers are determined by building
+ *     special templates for each character set that are scaled averages
+ *     of the individual templates.  Then a correlation score is found
+ *     between each template and the averaged templates.  There are
+ *     two implementations; outliers are determined as either:
+ *      (1) a template having a correlation score with its class average
+ *          that is below a threshold, or
+ *      (2) a template having a correlation score with its class average
+ *          that is smaller than the correlation score with the average
+ *          of another class.
+ *     Outliers are removed from the generating pixa.  Scaled averaging
+ *     is only performed for determining outliers and for splitting
+ *     characters; it is never used in a trained recognizer for identifying
+ *     unlabeled samples.
+ *
+ *     Two methods using averaged templates are provided for splitting
+ *     touching characters:
+ *      (1) greedy matching
+ *      (2) document image decoding (DID)
+ *     The DID method is the default.  It is about 5x faster and
+ *     possibly more accurate.
+ *
+ *     Once a BAR has been made, unlabeled sample images are identified
+ *     by finding the individual template in the BAR with highest
+ *     correlation.  The input images and images in the BAR can be
+ *     represented in two ways:
+ *      (1) as scanned, binarized to 1 bpp
+ *      (2) as a width-normalized outline formed by thinning to a
+ *          skeleton and then dilating by a fixed amount.
+ *
+ *     The recog can be serialized to file and read back.  The serialized
+ *     version holds the templates used for correlation (which may have
+ *     been modified by scaling and turning into lines from the unscaled
+ *     templates), plus, for arbitrary character sets, the UTF8
+ *     representation and the lookup table mapping from the character
+ *     representation to index.
+ *
+ *     Why do we not use averaged templates for recognition?
+ *     Letterforms can take on significantly different shapes (eg.,
+ *     the letters 'a' and 'g'), and it makes no sense to average these.
+ *     The previous version of this utility allowed multiple recognizers
+ *     to exist, but this is an unnecessary complication if recognition
+ *     is done on all samples instead of on averages.
+ * </pre>
+ */
+
+#define  RECOG_VERSION_NUMBER      2
+
+struct L_Recog {
+    l_int32        scalew;       /*!< scale all examples to this width;      */
+                                 /*!< use 0 prevent horizontal scaling       */
+    l_int32        scaleh;       /*!< scale all examples to this height;     */
+                                 /*!< use 0 prevent vertical scaling         */
+    l_int32        linew;        /*!< use a value > 0 to convert the bitmap  */
+                                 /*!< to lines of fixed width; 0 to skip     */
+    l_int32        templ_use;    /*!< template use: use either the average   */
+                                 /*!< or all temmplates (L_USE_AVERAGE or    */
+                                 /*!< L_USE_ALL)                             */
+    l_int32        maxarraysize; /*!< initialize container arrays to this    */
+    l_int32        setsize;      /*!< size of character set                  */
+    l_int32        threshold;    /*!< for binarizing if depth > 1            */
+    l_int32        maxyshift;    /*!< vertical jiggle on nominal centroid    */
+                                 /*!< alignment; typically 0 or 1            */
+    l_int32        charset_type; /*!< one of L_ARABIC_NUMERALS, etc.         */
+    l_int32        charset_size; /*!< expected number of classes in charset  */
+    l_int32        min_nopad;    /*!< min number of samples without padding  */
+    l_int32        num_samples;  /*!< number of training samples             */
+    l_int32        minwidth_u;   /*!< min width averaged unscaled templates  */
+    l_int32        maxwidth_u;   /*!< max width averaged unscaled templates  */
+    l_int32        minheight_u;  /*!< min height averaged unscaled templates */
+    l_int32        maxheight_u;  /*!< max height averaged unscaled templates */
+    l_int32        minwidth;     /*!< min width averaged scaled templates    */
+    l_int32        maxwidth;     /*!< max width averaged scaled templates    */
+    l_int32        ave_done;     /*!< set to 1 when averaged bitmaps are made */
+    l_int32        train_done;   /*!< set to 1 when training is complete or  */
+                                 /*!< identification has started             */
+    l_float32      max_wh_ratio; /*!< max width/height ratio to split        */
+    l_float32      max_ht_ratio; /*!< max of max/min template height ratio   */
+    l_int32        min_splitw;   /*!< min component width kept in splitting  */
+    l_int32        max_splith;   /*!< max component height kept in splitting */
+    struct Sarray *sa_text;      /*!< text array for arbitrary char set      */
+    struct L_Dna  *dna_tochar;   /*!< index-to-char lut for arbitrary charset */
+    l_int32       *centtab;      /*!< table for finding centroids            */
+    l_int32       *sumtab;       /*!< table for finding pixel sums           */
+    struct Pixaa  *pixaa_u;      /*!< all unscaled templates for each class  */
+    struct Ptaa   *ptaa_u;       /*!< centroids of all unscaled templates    */
+    struct Numaa  *naasum_u;     /*!< area of all unscaled templates         */
+    struct Pixaa  *pixaa;        /*!< all (scaled) templates for each class  */
+    struct Ptaa   *ptaa;         /*!< centroids of all (scaledl) templates   */
+    struct Numaa  *naasum;       /*!< area of all (scaled) templates         */
+    struct Pixa   *pixa_u;       /*!< averaged unscaled templates per class  */
+    struct Pta    *pta_u;        /*!< centroids of unscaled ave. templates   */
+    struct Numa   *nasum_u;      /*!< area of unscaled averaged templates    */
+    struct Pixa   *pixa;         /*!< averaged (scaled) templates per class  */
+    struct Pta    *pta;          /*!< centroids of (scaled) ave. templates   */
+    struct Numa   *nasum;        /*!< area of (scaled) averaged templates    */
+    struct Pixa   *pixa_tr;      /*!< all input training images              */
+    struct Pixa   *pixadb_ave;   /*!< unscaled and scaled averaged bitmaps   */
+    struct Pixa   *pixa_id;      /*!< input images for identifying           */
+    struct Pix    *pixdb_ave;    /*!< debug: best match of input against ave. */
+    struct Pix    *pixdb_range;  /*!< debug: best matches within range       */
+    struct Pixa   *pixadb_boot;  /*!< debug: bootstrap training results      */
+    struct Pixa   *pixadb_split; /*!< debug: splitting results               */
+    struct L_Bmf  *bmf;          /*!< bmf fonts                              */
+    l_int32        bmf_size;     /*!< font size of bmf; default is 6 pt      */
+    struct L_Rdid *did;          /*!< temp data used for image decoding      */
+    struct L_Rch  *rch;          /*!< temp data used for holding best char   */
+    struct L_Rcha *rcha;         /*!< temp data used for array of best chars */
+};
+typedef struct L_Recog L_RECOG;
+
+/*!
+ *  Data returned from correlation matching on a single character
+ */
+struct L_Rch {
+    l_int32        index;      /*!< index of best template                   */
+    l_float32      score;      /*!< correlation score of best template       */
+    char          *text;       /*!< character string of best template        */
+    l_int32        sample;     /*!< index of best sample (within the best    */
+                               /*!< template class, if all samples are used) */
+    l_int32        xloc;       /*!< x-location of template (delx + shiftx)   */
+    l_int32        yloc;       /*!< y-location of template (dely + shifty)   */
+    l_int32        width;      /*!< width of best template                   */
+};
+typedef struct L_Rch L_RCH;
+
+/*!
+ *  Data returned from correlation matching on an array of characters
+ */
+struct L_Rcha {
+    struct Numa   *naindex;    /*!< indices of best templates                */
+    struct Numa   *nascore;    /*!< correlation scores of best templates     */
+    struct Sarray *satext;     /*!< character strings of best templates      */
+    struct Numa   *nasample;   /*!< indices of best samples                  */
+    struct Numa   *naxloc;     /*!< x-locations of templates (delx + shiftx) */
+    struct Numa   *nayloc;     /*!< y-locations of templates (dely + shifty) */
+    struct Numa   *nawidth;    /*!< widths of best templates                 */
+};
+typedef struct L_Rcha L_RCHA;
+
+/*!
+ *  Data used for decoding a line of characters.
+ */
+struct L_Rdid {
+    struct Pix    *pixs;         /*!< clone of pix to be decoded             */
+    l_int32      **counta;       /*!< count array for each averaged template */
+    l_int32      **delya;        /*!< best y-shift array per average template */
+    l_int32        narray;       /*!< number of averaged templates           */
+    l_int32        size;         /*!< size of count array (width of pixs)    */
+    l_int32       *setwidth;     /*!< setwidths for each template            */
+    struct Numa   *nasum;        /*!< pixel count in pixs by column          */
+    struct Numa   *namoment;     /*!< first moment of pixels in pixs by cols */
+    l_int32        fullarrays;   /*!< 1 if full arrays are made; 0 otherwise */
+    l_float32     *beta;         /*!< channel coeffs for template fg term    */
+    l_float32     *gamma;        /*!< channel coeffs for bit-and term        */
+    l_float32     *trellisscore; /*!< score on trellis                       */
+    l_int32       *trellistempl; /*!< template on trellis (for backtrack)    */
+    struct Numa   *natempl;      /*!< indices of best path templates         */
+    struct Numa   *naxloc;       /*!< x locations of best path templates     */
+    struct Numa   *nadely;       /*!< y locations of best path templates     */
+    struct Numa   *nawidth;      /*!< widths of best path templates          */
+    struct Boxa   *boxa;         /*!< Viterbi result for splitting input pixs */
+    struct Numa   *nascore;      /*!< correlation scores: best path templates */
+    struct Numa   *natempl_r;    /*!< indices of best rescored templates     */
+    struct Numa   *nasample_r;   /*!< samples of best scored templates       */
+    struct Numa   *naxloc_r;     /*!< x locations of best rescoredtemplates  */
+    struct Numa   *nadely_r;     /*!< y locations of best rescoredtemplates  */
+    struct Numa   *nawidth_r;    /*!< widths of best rescoredtemplates       */
+    struct Numa   *nascore_r;    /*!< correlation scores: rescored templates */
+};
+typedef struct L_Rdid L_RDID;
+
+
+/*-------------------------------------------------------------------------*
+ *             Flags for describing limited character sets                 *
+ *-------------------------------------------------------------------------*/
+/*! Character Set */
+enum {
+    L_UNKNOWN = 0,           /*!< character set type is not specified      */
+    L_ARABIC_NUMERALS = 1,   /*!< 10 digits                                */
+    L_LC_ROMAN_NUMERALS = 2, /*!< 7 lower-case letters (i,v,x,l,c,d,m)     */
+    L_UC_ROMAN_NUMERALS = 3, /*!< 7 upper-case letters (I,V,X,L,C,D,M)     */
+    L_LC_ALPHA = 4,          /*!< 26 lower-case letters                    */
+    L_UC_ALPHA = 5           /*!< 26 upper-case letters                    */
+};
+
+/*-------------------------------------------------------------------------*
+ *      Flags for selecting between using average and all templates:       *
+ *                           recog->templ_use                              *
+ *-------------------------------------------------------------------------*/
+/*! Template Select */
+enum {
+    L_USE_ALL_TEMPLATES = 0,     /*!< use all templates; default            */
+    L_USE_AVERAGE_TEMPLATES = 1  /*!< use average templates; special cases  */
+};
+
+#endif  /* LEPTONICA_RECOG_H */

src/windows/leptonica/include/leptonica/regutils.h

@@ -0,0 +1,141 @@
+/*====================================================================*
+ -  Copyright (C) 2001 Leptonica.  All rights reserved.
+ -
+ -  Redistribution and use in source and binary forms, with or without
+ -  modification, are permitted provided that the following conditions
+ -  are met:
+ -  1. Redistributions of source code must retain the above copyright
+ -     notice, this list of conditions and the following disclaimer.
+ -  2. Redistributions in binary form must reproduce the above
+ -     copyright notice, this list of conditions and the following
+ -     disclaimer in the documentation and/or other materials
+ -     provided with the distribution.
+ -
+ -  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ -  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ -  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ -  A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ANY
+ -  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ -  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ -  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ -  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ -  OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ -  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ -  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *====================================================================*/
+
+#ifndef  LEPTONICA_REGUTILS_H
+#define  LEPTONICA_REGUTILS_H
+
+/*!
+ * \file regutils.h
+ *
+ * <pre>
+ *   Contains this regression test parameter packaging struct
+ *       struct L_RegParams
+ *
+ *   The regression test utility allows you to write regression tests
+ *   that compare results with existing "golden files" and with
+ *   compiled in data.
+ *
+ *   Regression tests can be called in three ways.
+ *   For example, for distance_reg:
+ *
+ *       Case 1: distance_reg [compare]
+ *           This runs the test against the set of golden files.  It
+ *           appends to 'outfile.txt' either "SUCCESS" or "FAILURE",
+ *           as well as the details of any parts of the test that failed.
+ *           It writes to a temporary file stream (fp).
+ *           Using 'compare' on the command line is optional.
+ *
+ *       Case 2: distance_reg generate
+ *           This generates golden files in /tmp for the reg test.
+ *
+ *       Case 3: distance_reg display
+ *           This runs the test but makes no comparison of the output
+ *           against the set of golden files.  In addition, this displays
+ *           images and plots that are specified in the test under
+ *           control of the display variable.  Display is enabled only
+ *           for this case.
+ *
+ *   Regression tests follow the pattern given below.  Tests are
+ *   automatically numbered sequentially, and it is convenient to
+ *   comment each with a number to keep track (for comparison tests
+ *   and for debugging).  In an actual case, comparisons of pix and
+ *   of files can occur in any order.  We give a specific order here
+ *   for clarity.
+ *
+ *       L_REGPARAMS  *rp;  // holds data required by the test functions
+ *
+ *       // Setup variables; optionally open stream
+ *       if (regTestSetup(argc, argv, &rp))
+ *           return 1;
+ *
+ *       // Test pairs of generated pix for identity.  This compares
+ *       // two pix; no golden file is generated.
+ *       regTestComparePix(rp, pix1, pix2);  // 0
+ *
+ *       // Test pairs of generated pix for similarity.  This compares
+ *       // two pix; no golden file is generated.  The last arg determines
+ *       // if stats are to be written to stderr.
+ *       regTestCompareSimilarPix(rp, pix1, pix2, 15, 0.001, 0);  // 1
+ *
+ *       // Generation of <newfile*> outputs and testing for identity
+ *       // These files can be anything, of course.
+ *       regTestCheckFile(rp, <newfile0>);  // 2
+ *       regTestCheckFile(rp, <newfile1>);  // 3
+ *
+ *       // Test pairs of output golden files for identity.  Here we
+ *       // are comparing golden files 2 and 3.
+ *       regTestCompareFiles(rp, 2, 3);  // 4
+ *
+ *       // "Write and check".  This writes a pix using a canonical
+ *       // formulation for the local filename and either:
+ *       //     case 1: generates a golden file
+ *       //     case 2: compares the local file with a golden file
+ *       //     case 3: generates local files and displays
+ *       // Here we write the pix compressed with png and jpeg, respectively;
+ *       // Then check against the golden file.  The internal %index
+ *       // is incremented; it is embedded in the local filename and,
+ *       // if generating, in the golden file as well.
+ *       regTestWritePixAndCheck(rp, pix1, IFF_PNG);  // 5
+ *       regTestWritePixAndCheck(rp, pix2, IFF_JFIF_JPEG);  // 6
+ *
+ *       // Display if reg test was called in 'display' mode
+ *       pixDisplayWithTitle(pix1, 100, 100, NULL, rp->display);
+ *
+ *       // Clean up and output result
+ *       regTestCleanup(rp);
+ * </pre>
+ */
+
+/*----------------------------------------------------------------------------*
+ *                      Regression test parameter packer                      *
+ *----------------------------------------------------------------------------*/
+
+/*! Regression test parameter packer */
+struct L_RegParams
+{
+    FILE    *fp;        /*!< stream to temporary output file for compare mode */
+    char    *testname;  /*!< name of test, without '_reg'                     */
+    char    *tempfile;  /*!< name of temp file for compare mode output        */
+    l_int32  mode;      /*!< generate, compare or display                     */
+    l_int32  index;     /*!< index into saved files for this test; 0-based    */
+    l_int32  success;   /*!< overall result of the test                       */
+    l_int32  display;   /*!< 1 if in display mode; 0 otherwise                */
+    L_TIMER  tstart;    /*!< marks beginning of the reg test                  */
+};
+typedef struct L_RegParams  L_REGPARAMS;
+
+
+    /*! Running modes for the test */
+/*! Regtest Mode */
+enum {
+    L_REG_GENERATE = 0,
+    L_REG_COMPARE = 1,
+    L_REG_DISPLAY = 2
+};
+
+
+#endif  /* LEPTONICA_REGUTILS_H */
+

src/windows/leptonica/include/leptonica/stack.h

@@ -0,0 +1,70 @@
+/*====================================================================*
+ -  Copyright (C) 2001 Leptonica.  All rights reserved.
+ -
+ -  Redistribution and use in source and binary forms, with or without
+ -  modification, are permitted provided that the following conditions
+ -  are met:
+ -  1. Redistributions of source code must retain the above copyright
+ -     notice, this list of conditions and the following disclaimer.
+ -  2. Redistributions in binary form must reproduce the above
+ -     copyright notice, this list of conditions and the following
+ -     disclaimer in the documentation and/or other materials
+ -     provided with the distribution.
+ -
+ -  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ -  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ -  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ -  A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ANY
+ -  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ -  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ -  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ -  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ -  OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ -  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ -  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *====================================================================*/
+
+#ifndef  LEPTONICA_STACK_H
+#define  LEPTONICA_STACK_H
+
+/*!
+ * \file stack.h
+ *
+ * <pre>
+ *       Expandable pointer stack for arbitrary void* data.
+ *
+ *       The L_Stack is an array of void * ptrs, onto which arbitrary
+ *       objects can be stored.  At any time, the number of
+ *       stored objects is stack->n.  The object at the bottom
+ *       of the stack is at array[0]; the object at the top of
+ *       the stack is at array[n-1].  New objects are added
+ *       to the top of the stack, at the first available location,
+ *       which is array[n].  Objects are removed from the top of the
+ *       stack.  When an attempt is made to remove an object from an
+ *       empty stack, the result is null.   When the stack becomes
+ *       filled, so that n = nalloc, the size is doubled.
+ *
+ *       The auxiliary stack can be used to store and remove
+ *       objects for re-use.  It must be created by a separate
+ *       call to pstackCreate().  [Just imagine the chaos if
+ *       pstackCreate() created the auxiliary stack!]
+ *       pstackDestroy() checks for the auxiliary stack and removes it.
+ * </pre>
+ */
+
+
+    /*! Expandable pointer stack for arbitrary void* data.
+     * Note that array[n] is the first null ptr in the array
+     */
+struct L_Stack
+{
+    l_int32          nalloc;     /*!< size of ptr array              */
+    l_int32          n;          /*!< number of stored elements      */
+    void           **array;      /*!< ptr array                      */
+    struct L_Stack  *auxstack;   /*!< auxiliary stack                */
+};
+typedef struct L_Stack  L_STACK;
+
+
+#endif /*  LEPTONICA_STACK_H */
+

src/windows/leptonica/include/leptonica/stringcode.h

@@ -0,0 +1,61 @@
+/*====================================================================*
+ -  Copyright (C) 2001 Leptonica.  All rights reserved.
+ -
+ -  Redistribution and use in source and binary forms, with or without
+ -  modification, are permitted provided that the following conditions
+ -  are met:
+ -  1. Redistributions of source code must retain the above copyright
+ -     notice, this list of conditions and the following disclaimer.
+ -  2. Redistributions in binary form must reproduce the above
+ -     copyright notice, this list of conditions and the following
+ -     disclaimer in the documentation and/or other materials
+ -     provided with the distribution.
+ -
+ -  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ -  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ -  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ -  A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ANY
+ -  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ -  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ -  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ -  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ -  OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ -  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ -  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *====================================================================*/
+
+#ifndef  LEPTONICA_STRINGCODE_H
+#define  LEPTONICA_STRINGCODE_H
+
+/*!
+ * \file stringcode.h
+ *
+ *     Data structure to hold accumulating generated code for storing
+ *     and extracting serializable leptonica objects (e.g., pixa, recog).
+ *
+ *     Also a flag for selecting a string from the L_GenAssoc struct
+ *     in stringcode.
+ */
+
+struct L_StrCode
+{
+    l_int32       fileno;    /*!< index for function and output file names   */
+    l_int32       ifunc;     /*!< index into struct currently being stored   */
+    SARRAY       *function;  /*!< store case code for extraction             */
+    SARRAY       *data;      /*!< store base64 encoded data as strings       */
+    SARRAY       *descr;     /*!< store line in description table            */
+    l_int32       n;         /*!< number of data strings                     */
+};
+typedef struct L_StrCode  L_STRCODE;
+
+
+    /*! Select string in stringcode for a specific serializable data type */
+/*! Stringcode Select */
+enum {
+    L_STR_TYPE = 0,      /*!< typedef for the data type                      */
+    L_STR_NAME = 1,      /*!< name of the data type                          */
+    L_STR_READER = 2,    /*!< reader to get the data type from file          */
+    L_STR_MEMREADER = 3  /*!< reader to get the compressed string in memory  */
+};
+
+#endif  /* LEPTONICA_STRINGCODE_H */

src/windows/leptonica/include/leptonica/sudoku.h

@@ -0,0 +1,77 @@
+/*====================================================================*
+ -  Copyright (C) 2001 Leptonica.  All rights reserved.
+ -
+ -  Redistribution and use in source and binary forms, with or without
+ -  modification, are permitted provided that the following conditions
+ -  are met:
+ -  1. Redistributions of source code must retain the above copyright
+ -     notice, this list of conditions and the following disclaimer.
+ -  2. Redistributions in binary form must reproduce the above
+ -     copyright notice, this list of conditions and the following
+ -     disclaimer in the documentation and/or other materials
+ -     provided with the distribution.
+ -
+ -  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ -  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ -  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ -  A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ANY
+ -  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ -  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ -  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ -  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ -  OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ -  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ -  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *====================================================================*/
+
+#ifndef SUDOKU_H_INCLUDED
+#define SUDOKU_H_INCLUDED
+
+/*!
+ * \file sudoku.h
+ *
+ * <pre>
+ *    The L_Sudoku holds all the information of the current state.
+ *
+ *    The input to sudokuCreate() is a file with any number of lines
+ *    starting with '#', followed by 9 lines consisting of 9 numbers
+ *    in each line.  These have the known values and use 0 for the unknowns.
+ *    Blank lines are ignored.
+ *
+ *    The %locs array holds the indices of the unknowns, numbered
+ *    left-to-right and top-to-bottom from 0 to 80.  The array size
+ *    is initialized to %num.  %current is the index into the %locs
+ *    array of the current guess: locs[current].
+ *
+ *    The %state array is used to determine the validity of each guess.
+ *    It is of size 81, and is initialized by setting the unknowns to 0
+ *    and the knowns to their input values.
+ * </pre>
+ */
+
+struct L_Sudoku
+{
+    l_int32        num;       /*!< number of unknowns                     */
+    l_int32       *locs;      /*!< location of unknowns                   */
+    l_int32        current;   /*!< index into %locs of current location   */
+    l_int32       *init;      /*!< initial state, with 0 representing     */
+                              /*!< the unknowns                           */
+    l_int32       *state;     /*!< present state, including inits and     */
+                              /*!< guesses of unknowns up to %current     */
+    l_int32        nguess;    /*!< shows current number of guesses        */
+    l_int32        finished;  /*!< set to 1 when solved                   */
+    l_int32        failure;   /*!< set to 1 if no solution is possible    */
+};
+typedef struct L_Sudoku  L_SUDOKU;
+
+
+    /*! For printing out array data */
+/*! Sudoku Output */
+enum {
+    L_SUDOKU_INIT = 0,
+    L_SUDOKU_STATE = 1
+};
+
+#endif /* SUDOKU_H_INCLUDED */
+
+

src/windows/leptonica/include/leptonica/watershed.h

@@ -0,0 +1,64 @@
+/*====================================================================*
+ -  Copyright (C) 2001 Leptonica.  All rights reserved.
+ -
+ -  Redistribution and use in source and binary forms, with or without
+ -  modification, are permitted provided that the following conditions
+ -  are met:
+ -  1. Redistributions of source code must retain the above copyright
+ -     notice, this list of conditions and the following disclaimer.
+ -  2. Redistributions in binary form must reproduce the above
+ -     copyright notice, this list of conditions and the following
+ -     disclaimer in the documentation and/or other materials
+ -     provided with the distribution.
+ -
+ -  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ -  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ -  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ -  A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ANY
+ -  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ -  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ -  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ -  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ -  OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ -  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ -  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *====================================================================*/
+
+#ifndef  LEPTONICA_WATERSHED_H
+#define  LEPTONICA_WATERSHED_H
+
+/*!
+ * \file watershed.h
+ *
+ *     Simple data structure to hold watershed data.
+ *     All data here is owned by the L_WShed and must be freed.
+ */
+
+/*! Simple data structure to hold watershed data. */
+struct L_WShed
+{
+    struct Pix    *pixs;      /*!< clone of input 8 bpp pixs                */
+    struct Pix    *pixm;      /*!< clone of input 1 bpp seed (marker) pixm  */
+    l_int32        mindepth;  /*!< minimum depth allowed for a watershed    */
+    struct Pix    *pixlab;    /*!< 16 bpp label pix                         */
+    struct Pix    *pixt;      /*!< scratch pix for computing wshed regions  */
+    void         **lines8;    /*!< line ptrs for pixs                       */
+    void         **linem1;    /*!< line ptrs for pixm                       */
+    void         **linelab32; /*!< line ptrs for pixlab                     */
+    void         **linet1;    /*!< line ptrs for pixt                       */
+    struct Pixa   *pixad;     /*!< result: 1 bpp pixa of watersheds         */
+    struct Pta    *ptas;      /*!< pta of initial seed pixels               */
+    struct Numa   *nasi;      /*!< numa of seed indicators; 0 if completed  */
+    struct Numa   *nash;      /*!< numa of initial seed heights             */
+    struct Numa   *namh;      /*!< numa of initial minima heights           */
+    struct Numa   *nalevels;  /*!< result: numa of watershed levels         */
+    l_int32        nseeds;    /*!< number of seeds (markers)                */
+    l_int32        nother;    /*!< number of minima different from seeds    */
+    l_int32       *lut;       /*!< lut for pixel indices                    */
+    struct Numa  **links;     /*!< back-links into lut, for updates         */
+    l_int32        arraysize; /*!< size of links array                      */
+    l_int32        debug;     /*!< set to 1 for debug output                */
+};
+typedef struct L_WShed L_WSHED;
+
+#endif  /* LEPTONICA_WATERSHED_H */

src/windows/leptonica/lib/cmake/LeptonicaConfig-version.cmake

@@ -0,0 +1,14 @@
+set(Leptonica_VERSION 1.83.1)
+set(PACKAGE_VERSION ${Leptonica_VERSION})
+
+set(PACKAGE_VERSION_EXACT False)
+set(PACKAGE_VERSION_COMPATIBLE False)
+
+if(PACKAGE_FIND_VERSION VERSION_EQUAL PACKAGE_VERSION)
+  set(PACKAGE_VERSION_EXACT True)
+  set(PACKAGE_VERSION_COMPATIBLE True)
+endif()
+
+if(PACKAGE_FIND_VERSION VERSION_LESS PACKAGE_VERSION)
+  set(PACKAGE_VERSION_COMPATIBLE True)
+endif()

src/windows/leptonica/lib/cmake/LeptonicaConfig.cmake

@@ -0,0 +1,45 @@
+# ===================================================================================
+#  The Leptonica CMake configuration file
+#
+#             ** File generated automatically, do not modify **
+#
+#  Usage from an external project:
+#    In your CMakeLists.txt, add these lines:
+#
+#    find_package(Leptonica REQUIRED)
+#    include_directories(${Leptonica_INCLUDE_DIRS})
+#    target_link_libraries(MY_TARGET_NAME ${Leptonica_LIBRARIES})
+#
+#    This file will define the following variables:
+#      - Leptonica_LIBRARIES             : The list of all imported targets for OpenCV modules.
+#      - Leptonica_INCLUDE_DIRS          : The Leptonica include directories.
+#      - Leptonica_VERSION               : The version of this Leptonica build: "1.83.1"
+#      - Leptonica_VERSION_MAJOR         : Major version part of Leptonica_VERSION: "1"
+#      - Leptonica_VERSION_MINOR         : Minor version part of Leptonica_VERSION: "83"
+#      - Leptonica_VERSION_PATCH         : Patch version part of Leptonica_VERSION: "1"
+#
+# ===================================================================================
+
+include(${CMAKE_CURRENT_LIST_DIR}/LeptonicaTargets.cmake)
+
+# ======================================================
+#  Version variables:
+# ======================================================
+
+SET(Leptonica_VERSION           1.83.1)
+SET(Leptonica_VERSION_MAJOR     1)
+SET(Leptonica_VERSION_MINOR     83)
+SET(Leptonica_VERSION_PATCH     1)
+
+# ======================================================
+# Include directories to add to the user project:
+# ======================================================
+
+# Provide the include directories to the caller
+set(Leptonica_INCLUDE_DIRS      "/mingw64/include/leptonica")
+
+# ====================================================================
+# Link libraries:
+# ====================================================================
+
+set(Leptonica_LIBRARIES         lept)

src/windows/leptonica/lib/pkgconfig/lept.pc

@@ -0,0 +1,12 @@
+prefix=/mingw64
+exec_prefix=${prefix}
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include/leptonica
+
+Name: leptonica
+Description: An open source C library for efficient image processing and image analysis operations
+Version: 1.83.1
+Libs: -L${libdir} -lleptonica
+Libs.private: -lz -lpng16 -ljpeg -lopenjp2 -lgif -ltiff -lwebp -lwebpmux -lwebp
+Cflags: -I${includedir}
+

src/windows/tesseract/include/tesseract/baseapi.h

@@ -0,0 +1,812 @@
+// SPDX-License-Identifier: Apache-2.0
+// File:        baseapi.h
+// Description: Simple API for calling tesseract.
+// Author:      Ray Smith
+//
+// (C) Copyright 2006, Google Inc.
+// Licensed 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.
+
+#ifndef TESSERACT_API_BASEAPI_H_
+#define TESSERACT_API_BASEAPI_H_
+
+#ifdef HAVE_CONFIG_H
+#  include "config_auto.h" // DISABLED_LEGACY_ENGINE
+#endif
+
+#include "export.h"
+#include "pageiterator.h"
+#include "publictypes.h"
+#include "resultiterator.h"
+#include "unichar.h"
+
+#include <tesseract/version.h>
+
+#include <cstdio>
+#include <vector> // for std::vector
+
+struct Pix;
+struct Pixa;
+struct Boxa;
+
+namespace tesseract {
+
+class PAGE_RES;
+class ParagraphModel;
+class BLOCK_LIST;
+class ETEXT_DESC;
+struct OSResults;
+class UNICHARSET;
+
+class Dawg;
+class Dict;
+class EquationDetect;
+class PageIterator;
+class ImageThresholder;
+class LTRResultIterator;
+class ResultIterator;
+class MutableIterator;
+class TessResultRenderer;
+class Tesseract;
+
+// Function to read a std::vector<char> from a whole file.
+// Returns false on failure.
+using FileReader = bool (*)(const char *filename, std::vector<char> *data);
+
+using DictFunc = int (Dict::*)(void *, const UNICHARSET &, UNICHAR_ID,
+                               bool) const;
+using ProbabilityInContextFunc = double (Dict::*)(const char *, const char *,
+                                                  int, const char *, int);
+
+/**
+ * Base class for all tesseract APIs.
+ * Specific classes can add ability to work on different inputs or produce
+ * different outputs.
+ * This class is mostly an interface layer on top of the Tesseract instance
+ * class to hide the data types so that users of this class don't have to
+ * include any other Tesseract headers.
+ */
+class TESS_API TessBaseAPI {
+public:
+  TessBaseAPI();
+  virtual ~TessBaseAPI();
+  // Copy constructor and assignment operator are currently unsupported.
+  TessBaseAPI(TessBaseAPI const &) = delete;
+  TessBaseAPI &operator=(TessBaseAPI const &) = delete;
+
+  /**
+   * Returns the version identifier as a static string. Do not delete.
+   */
+  static const char *Version();
+
+  /**
+   * If compiled with OpenCL AND an available OpenCL
+   * device is deemed faster than serial code, then
+   * "device" is populated with the cl_device_id
+   * and returns sizeof(cl_device_id)
+   * otherwise *device=nullptr and returns 0.
+   */
+  static size_t getOpenCLDevice(void **device);
+
+  /**
+   * Set the name of the input file. Needed for training and
+   * reading a UNLV zone file, and for searchable PDF output.
+   */
+  void SetInputName(const char *name);
+  /**
+   * These functions are required for searchable PDF output.
+   * We need our hands on the input file so that we can include
+   * it in the PDF without transcoding. If that is not possible,
+   * we need the original image. Finally, resolution metadata
+   * is stored in the PDF so we need that as well.
+   */
+  const char *GetInputName();
+  // Takes ownership of the input pix.
+  void SetInputImage(Pix *pix);
+  Pix *GetInputImage();
+  int GetSourceYResolution();
+  const char *GetDatapath();
+
+  /** Set the name of the bonus output files. Needed only for debugging. */
+  void SetOutputName(const char *name);
+
+  /**
+   * Set the value of an internal "parameter."
+   * Supply the name of the parameter and the value as a string, just as
+   * you would in a config file.
+   * Returns false if the name lookup failed.
+   * Eg SetVariable("tessedit_char_blacklist", "xyz"); to ignore x, y and z.
+   * Or SetVariable("classify_bln_numeric_mode", "1"); to set numeric-only mode.
+   * SetVariable may be used before Init, but settings will revert to
+   * defaults on End().
+   *
+   * Note: Must be called after Init(). Only works for non-init variables
+   * (init variables should be passed to Init()).
+   */
+  bool SetVariable(const char *name, const char *value);
+  bool SetDebugVariable(const char *name, const char *value);
+
+  /**
+   * Returns true if the parameter was found among Tesseract parameters.
+   * Fills in value with the value of the parameter.
+   */
+  bool GetIntVariable(const char *name, int *value) const;
+  bool GetBoolVariable(const char *name, bool *value) const;
+  bool GetDoubleVariable(const char *name, double *value) const;
+
+  /**
+   * Returns the pointer to the string that represents the value of the
+   * parameter if it was found among Tesseract parameters.
+   */
+  const char *GetStringVariable(const char *name) const;
+
+#ifndef DISABLED_LEGACY_ENGINE
+
+  /**
+   * Print Tesseract fonts table to the given file.
+   */
+  void PrintFontsTable(FILE *fp) const;
+
+#endif
+
+  /**
+   * Print Tesseract parameters to the given file.
+   */
+  void PrintVariables(FILE *fp) const;
+
+  /**
+   * Get value of named variable as a string, if it exists.
+   */
+  bool GetVariableAsString(const char *name, std::string *val) const;
+
+  /**
+   * Instances are now mostly thread-safe and totally independent,
+   * but some global parameters remain. Basically it is safe to use multiple
+   * TessBaseAPIs in different threads in parallel, UNLESS:
+   * you use SetVariable on some of the Params in classify and textord.
+   * If you do, then the effect will be to change it for all your instances.
+   *
+   * Start tesseract. Returns zero on success and -1 on failure.
+   * NOTE that the only members that may be called before Init are those
+   * listed above here in the class definition.
+   *
+   * The datapath must be the name of the tessdata directory.
+   * The language is (usually) an ISO 639-3 string or nullptr will default to
+   * eng. It is entirely safe (and eventually will be efficient too) to call
+   * Init multiple times on the same instance to change language, or just
+   * to reset the classifier.
+   * The language may be a string of the form [~]<lang>[+[~]<lang>]* indicating
+   * that multiple languages are to be loaded. Eg hin+eng will load Hindi and
+   * English. Languages may specify internally that they want to be loaded
+   * with one or more other languages, so the ~ sign is available to override
+   * that. Eg if hin were set to load eng by default, then hin+~eng would force
+   * loading only hin. The number of loaded languages is limited only by
+   * memory, with the caveat that loading additional languages will impact
+   * both speed and accuracy, as there is more work to do to decide on the
+   * applicable language, and there is more chance of hallucinating incorrect
+   * words.
+   * WARNING: On changing languages, all Tesseract parameters are reset
+   * back to their default values. (Which may vary between languages.)
+   * If you have a rare need to set a Variable that controls
+   * initialization for a second call to Init you should explicitly
+   * call End() and then use SetVariable before Init. This is only a very
+   * rare use case, since there are very few uses that require any parameters
+   * to be set before Init.
+   *
+   * If set_only_non_debug_params is true, only params that do not contain
+   * "debug" in the name will be set.
+   */
+  int Init(const char *datapath, const char *language, OcrEngineMode mode,
+           char **configs, int configs_size,
+           const std::vector<std::string> *vars_vec,
+           const std::vector<std::string> *vars_values,
+           bool set_only_non_debug_params);
+  int Init(const char *datapath, const char *language, OcrEngineMode oem) {
+    return Init(datapath, language, oem, nullptr, 0, nullptr, nullptr, false);
+  }
+  int Init(const char *datapath, const char *language) {
+    return Init(datapath, language, OEM_DEFAULT, nullptr, 0, nullptr, nullptr,
+                false);
+  }
+  // In-memory version reads the traineddata file directly from the given
+  // data[data_size] array, and/or reads data via a FileReader.
+  int Init(const char *data, int data_size, const char *language,
+           OcrEngineMode mode, char **configs, int configs_size,
+           const std::vector<std::string> *vars_vec,
+           const std::vector<std::string> *vars_values,
+           bool set_only_non_debug_params, FileReader reader);
+
+  /**
+   * Returns the languages string used in the last valid initialization.
+   * If the last initialization specified "deu+hin" then that will be
+   * returned. If hin loaded eng automatically as well, then that will
+   * not be included in this list. To find the languages actually
+   * loaded use GetLoadedLanguagesAsVector.
+   * The returned string should NOT be deleted.
+   */
+  const char *GetInitLanguagesAsString() const;
+
+  /**
+   * Returns the loaded languages in the vector of std::string.
+   * Includes all languages loaded by the last Init, including those loaded
+   * as dependencies of other loaded languages.
+   */
+  void GetLoadedLanguagesAsVector(std::vector<std::string> *langs) const;
+
+  /**
+   * Returns the available languages in the sorted vector of std::string.
+   */
+  void GetAvailableLanguagesAsVector(std::vector<std::string> *langs) const;
+
+  /**
+   * Init only for page layout analysis. Use only for calls to SetImage and
+   * AnalysePage. Calls that attempt recognition will generate an error.
+   */
+  void InitForAnalysePage();
+
+  /**
+   * Read a "config" file containing a set of param, value pairs.
+   * Searches the standard places: tessdata/configs, tessdata/tessconfigs
+   * and also accepts a relative or absolute path name.
+   * Note: only non-init params will be set (init params are set by Init()).
+   */
+  void ReadConfigFile(const char *filename);
+  /** Same as above, but only set debug params from the given config file. */
+  void ReadDebugConfigFile(const char *filename);
+
+  /**
+   * Set the current page segmentation mode. Defaults to PSM_SINGLE_BLOCK.
+   * The mode is stored as an IntParam so it can also be modified by
+   * ReadConfigFile or SetVariable("tessedit_pageseg_mode", mode as string).
+   */
+  void SetPageSegMode(PageSegMode mode);
+
+  /** Return the current page segmentation mode. */
+  PageSegMode GetPageSegMode() const;
+
+  /**
+   * Recognize a rectangle from an image and return the result as a string.
+   * May be called many times for a single Init.
+   * Currently has no error checking.
+   * Greyscale of 8 and color of 24 or 32 bits per pixel may be given.
+   * Palette color images will not work properly and must be converted to
+   * 24 bit.
+   * Binary images of 1 bit per pixel may also be given but they must be
+   * byte packed with the MSB of the first byte being the first pixel, and a
+   * 1 represents WHITE. For binary images set bytes_per_pixel=0.
+   * The recognized text is returned as a char* which is coded
+   * as UTF8 and must be freed with the delete [] operator.
+   *
+   * Note that TesseractRect is the simplified convenience interface.
+   * For advanced uses, use SetImage, (optionally) SetRectangle, Recognize,
+   * and one or more of the Get*Text functions below.
+   */
+  char *TesseractRect(const unsigned char *imagedata, int bytes_per_pixel,
+                      int bytes_per_line, int left, int top, int width,
+                      int height);
+
+  /**
+   * Call between pages or documents etc to free up memory and forget
+   * adaptive data.
+   */
+  void ClearAdaptiveClassifier();
+
+  /**
+   * @defgroup AdvancedAPI Advanced API
+   * The following methods break TesseractRect into pieces, so you can
+   * get hold of the thresholded image, get the text in different formats,
+   * get bounding boxes, confidences etc.
+   */
+  /* @{ */
+
+  /**
+   * Provide an image for Tesseract to recognize. Format is as
+   * TesseractRect above. Copies the image buffer and converts to Pix.
+   * SetImage clears all recognition results, and sets the rectangle to the
+   * full image, so it may be followed immediately by a GetUTF8Text, and it
+   * will automatically perform recognition.
+   */
+  void SetImage(const unsigned char *imagedata, int width, int height,
+                int bytes_per_pixel, int bytes_per_line);
+
+  /**
+   * Provide an image for Tesseract to recognize. As with SetImage above,
+   * Tesseract takes its own copy of the image, so it need not persist until
+   * after Recognize.
+   * Pix vs raw, which to use?
+   * Use Pix where possible. Tesseract uses Pix as its internal representation
+   * and it is therefore more efficient to provide a Pix directly.
+   */
+  void SetImage(Pix *pix);
+
+  /**
+   * Set the resolution of the source image in pixels per inch so font size
+   * information can be calculated in results.  Call this after SetImage().
+   */
+  void SetSourceResolution(int ppi);
+
+  /**
+   * Restrict recognition to a sub-rectangle of the image. Call after SetImage.
+   * Each SetRectangle clears the recogntion results so multiple rectangles
+   * can be recognized with the same image.
+   */
+  void SetRectangle(int left, int top, int width, int height);
+
+  /**
+   * Get a copy of the internal thresholded image from Tesseract.
+   * Caller takes ownership of the Pix and must pixDestroy it.
+   * May be called any time after SetImage, or after TesseractRect.
+   */
+  Pix *GetThresholdedImage();
+
+  /**
+   * Get the result of page layout analysis as a leptonica-style
+   * Boxa, Pixa pair, in reading order.
+   * Can be called before or after Recognize.
+   */
+  Boxa *GetRegions(Pixa **pixa);
+
+  /**
+   * Get the textlines as a leptonica-style
+   * Boxa, Pixa pair, in reading order.
+   * Can be called before or after Recognize.
+   * If raw_image is true, then extract from the original image instead of the
+   * thresholded image and pad by raw_padding pixels.
+   * If blockids is not nullptr, the block-id of each line is also returned as
+   * an array of one element per line. delete [] after use. If paraids is not
+   * nullptr, the paragraph-id of each line within its block is also returned as
+   * an array of one element per line. delete [] after use.
+   */
+  Boxa *GetTextlines(bool raw_image, int raw_padding, Pixa **pixa,
+                     int **blockids, int **paraids);
+  /*
+   Helper method to extract from the thresholded image. (most common usage)
+*/
+  Boxa *GetTextlines(Pixa **pixa, int **blockids) {
+    return GetTextlines(false, 0, pixa, blockids, nullptr);
+  }
+
+  /**
+   * Get textlines and strips of image regions as a leptonica-style Boxa, Pixa
+   * pair, in reading order. Enables downstream handling of non-rectangular
+   * regions.
+   * Can be called before or after Recognize.
+   * If blockids is not nullptr, the block-id of each line is also returned as
+   * an array of one element per line. delete [] after use.
+   */
+  Boxa *GetStrips(Pixa **pixa, int **blockids);
+
+  /**
+   * Get the words as a leptonica-style
+   * Boxa, Pixa pair, in reading order.
+   * Can be called before or after Recognize.
+   */
+  Boxa *GetWords(Pixa **pixa);
+
+  /**
+   * Gets the individual connected (text) components (created
+   * after pages segmentation step, but before recognition)
+   * as a leptonica-style Boxa, Pixa pair, in reading order.
+   * Can be called before or after Recognize.
+   * Note: the caller is responsible for calling boxaDestroy()
+   * on the returned Boxa array and pixaDestroy() on cc array.
+   */
+  Boxa *GetConnectedComponents(Pixa **cc);
+
+  /**
+   * Get the given level kind of components (block, textline, word etc.) as a
+   * leptonica-style Boxa, Pixa pair, in reading order.
+   * Can be called before or after Recognize.
+   * If blockids is not nullptr, the block-id of each component is also returned
+   * as an array of one element per component. delete [] after use.
+   * If blockids is not nullptr, the paragraph-id of each component with its
+   * block is also returned as an array of one element per component. delete []
+   * after use. If raw_image is true, then portions of the original image are
+   * extracted instead of the thresholded image and padded with raw_padding. If
+   * text_only is true, then only text components are returned.
+   */
+  Boxa *GetComponentImages(PageIteratorLevel level, bool text_only,
+                           bool raw_image, int raw_padding, Pixa **pixa,
+                           int **blockids, int **paraids);
+  // Helper function to get binary images with no padding (most common usage).
+  Boxa *GetComponentImages(const PageIteratorLevel level, const bool text_only,
+                           Pixa **pixa, int **blockids) {
+    return GetComponentImages(level, text_only, false, 0, pixa, blockids,
+                              nullptr);
+  }
+
+  /**
+   * Returns the scale factor of the thresholded image that would be returned by
+   * GetThresholdedImage() and the various GetX() methods that call
+   * GetComponentImages().
+   * Returns 0 if no thresholder has been set.
+   */
+  int GetThresholdedImageScaleFactor() const;
+
+  /**
+   * Runs page layout analysis in the mode set by SetPageSegMode.
+   * May optionally be called prior to Recognize to get access to just
+   * the page layout results. Returns an iterator to the results.
+   * If merge_similar_words is true, words are combined where suitable for use
+   * with a line recognizer. Use if you want to use AnalyseLayout to find the
+   * textlines, and then want to process textline fragments with an external
+   * line recognizer.
+   * Returns nullptr on error or an empty page.
+   * The returned iterator must be deleted after use.
+   * WARNING! This class points to data held within the TessBaseAPI class, and
+   * therefore can only be used while the TessBaseAPI class still exists and
+   * has not been subjected to a call of Init, SetImage, Recognize, Clear, End
+   * DetectOS, or anything else that changes the internal PAGE_RES.
+   */
+  PageIterator *AnalyseLayout();
+  PageIterator *AnalyseLayout(bool merge_similar_words);
+
+  /**
+   * Recognize the image from SetAndThresholdImage, generating Tesseract
+   * internal structures. Returns 0 on success.
+   * Optional. The Get*Text functions below will call Recognize if needed.
+   * After Recognize, the output is kept internally until the next SetImage.
+   */
+  int Recognize(ETEXT_DESC *monitor);
+
+  /**
+   * Methods to retrieve information after SetAndThresholdImage(),
+   * Recognize() or TesseractRect(). (Recognize is called implicitly if needed.)
+   */
+
+  /**
+   * Turns images into symbolic text.
+   *
+   * filename can point to a single image, a multi-page TIFF,
+   * or a plain text list of image filenames.
+   *
+   * retry_config is useful for debugging. If not nullptr, you can fall
+   * back to an alternate configuration if a page fails for some
+   * reason.
+   *
+   * timeout_millisec terminates processing if any single page
+   * takes too long. Set to 0 for unlimited time.
+   *
+   * renderer is responible for creating the output. For example,
+   * use the TessTextRenderer if you want plaintext output, or
+   * the TessPDFRender to produce searchable PDF.
+   *
+   * If tessedit_page_number is non-negative, will only process that
+   * single page. Works for multi-page tiff file, or filelist.
+   *
+   * Returns true if successful, false on error.
+   */
+  bool ProcessPages(const char *filename, const char *retry_config,
+                    int timeout_millisec, TessResultRenderer *renderer);
+  // Does the real work of ProcessPages.
+  bool ProcessPagesInternal(const char *filename, const char *retry_config,
+                            int timeout_millisec, TessResultRenderer *renderer);
+
+  /**
+   * Turn a single image into symbolic text.
+   *
+   * The pix is the image processed. filename and page_index are
+   * metadata used by side-effect processes, such as reading a box
+   * file or formatting as hOCR.
+   *
+   * See ProcessPages for descriptions of other parameters.
+   */
+  bool ProcessPage(Pix *pix, int page_index, const char *filename,
+                   const char *retry_config, int timeout_millisec,
+                   TessResultRenderer *renderer);
+
+  /**
+   * Get a reading-order iterator to the results of LayoutAnalysis and/or
+   * Recognize. The returned iterator must be deleted after use.
+   * WARNING! This class points to data held within the TessBaseAPI class, and
+   * therefore can only be used while the TessBaseAPI class still exists and
+   * has not been subjected to a call of Init, SetImage, Recognize, Clear, End
+   * DetectOS, or anything else that changes the internal PAGE_RES.
+   */
+  ResultIterator *GetIterator();
+
+  /**
+   * Get a mutable iterator to the results of LayoutAnalysis and/or Recognize.
+   * The returned iterator must be deleted after use.
+   * WARNING! This class points to data held within the TessBaseAPI class, and
+   * therefore can only be used while the TessBaseAPI class still exists and
+   * has not been subjected to a call of Init, SetImage, Recognize, Clear, End
+   * DetectOS, or anything else that changes the internal PAGE_RES.
+   */
+  MutableIterator *GetMutableIterator();
+
+  /**
+   * The recognized text is returned as a char* which is coded
+   * as UTF8 and must be freed with the delete [] operator.
+   */
+  char *GetUTF8Text();
+
+  /**
+   * Make a HTML-formatted string with hOCR markup from the internal
+   * data structures.
+   * page_number is 0-based but will appear in the output as 1-based.
+   * monitor can be used to
+   *  cancel the recognition
+   *  receive progress callbacks
+   * Returned string must be freed with the delete [] operator.
+   */
+  char *GetHOCRText(ETEXT_DESC *monitor, int page_number);
+
+  /**
+   * Make a HTML-formatted string with hOCR markup from the internal
+   * data structures.
+   * page_number is 0-based but will appear in the output as 1-based.
+   * Returned string must be freed with the delete [] operator.
+   */
+  char *GetHOCRText(int page_number);
+
+  /**
+   * Make an XML-formatted string with Alto markup from the internal
+   * data structures.
+   */
+  char *GetAltoText(ETEXT_DESC *monitor, int page_number);
+
+  /**
+   * Make an XML-formatted string with Alto markup from the internal
+   * data structures.
+   */
+  char *GetAltoText(int page_number);
+
+  /**
+   * Make a TSV-formatted string from the internal data structures.
+   * page_number is 0-based but will appear in the output as 1-based.
+   * Returned string must be freed with the delete [] operator.
+   */
+  char *GetTSVText(int page_number);
+
+  /**
+   * Make a box file for LSTM training from the internal data structures.
+   * Constructs coordinates in the original image - not just the rectangle.
+   * page_number is a 0-based page index that will appear in the box file.
+   * Returned string must be freed with the delete [] operator.
+   */
+  char *GetLSTMBoxText(int page_number);
+
+  /**
+   * The recognized text is returned as a char* which is coded in the same
+   * format as a box file used in training.
+   * Constructs coordinates in the original image - not just the rectangle.
+   * page_number is a 0-based page index that will appear in the box file.
+   * Returned string must be freed with the delete [] operator.
+   */
+  char *GetBoxText(int page_number);
+
+  /**
+   * The recognized text is returned as a char* which is coded in the same
+   * format as a WordStr box file used in training.
+   * page_number is a 0-based page index that will appear in the box file.
+   * Returned string must be freed with the delete [] operator.
+   */
+  char *GetWordStrBoxText(int page_number);
+
+  /**
+   * The recognized text is returned as a char* which is coded
+   * as UNLV format Latin-1 with specific reject and suspect codes.
+   * Returned string must be freed with the delete [] operator.
+   */
+  char *GetUNLVText();
+
+  /**
+   * Detect the orientation of the input image and apparent script (alphabet).
+   * orient_deg is the detected clockwise rotation of the input image in degrees
+   * (0, 90, 180, 270)
+   * orient_conf is the confidence (15.0 is reasonably confident)
+   * script_name is an ASCII string, the name of the script, e.g. "Latin"
+   * script_conf is confidence level in the script
+   * Returns true on success and writes values to each parameter as an output
+   */
+  bool DetectOrientationScript(int *orient_deg, float *orient_conf,
+                               const char **script_name, float *script_conf);
+
+  /**
+   * The recognized text is returned as a char* which is coded
+   * as UTF8 and must be freed with the delete [] operator.
+   * page_number is a 0-based page index that will appear in the osd file.
+   */
+  char *GetOsdText(int page_number);
+
+  /** Returns the (average) confidence value between 0 and 100. */
+  int MeanTextConf();
+  /**
+   * Returns all word confidences (between 0 and 100) in an array, terminated
+   * by -1.  The calling function must delete [] after use.
+   * The number of confidences should correspond to the number of space-
+   * delimited words in GetUTF8Text.
+   */
+  int *AllWordConfidences();
+
+#ifndef DISABLED_LEGACY_ENGINE
+  /**
+   * Applies the given word to the adaptive classifier if possible.
+   * The word must be SPACE-DELIMITED UTF-8 - l i k e t h i s , so it can
+   * tell the boundaries of the graphemes.
+   * Assumes that SetImage/SetRectangle have been used to set the image
+   * to the given word. The mode arg should be PSM_SINGLE_WORD or
+   * PSM_CIRCLE_WORD, as that will be used to control layout analysis.
+   * The currently set PageSegMode is preserved.
+   * Returns false if adaption was not possible for some reason.
+   */
+  bool AdaptToWordStr(PageSegMode mode, const char *wordstr);
+#endif //  ndef DISABLED_LEGACY_ENGINE
+
+  /**
+   * Free up recognition results and any stored image data, without actually
+   * freeing any recognition data that would be time-consuming to reload.
+   * Afterwards, you must call SetImage or TesseractRect before doing
+   * any Recognize or Get* operation.
+   */
+  void Clear();
+
+  /**
+   * Close down tesseract and free up all memory. End() is equivalent to
+   * destructing and reconstructing your TessBaseAPI.
+   * Once End() has been used, none of the other API functions may be used
+   * other than Init and anything declared above it in the class definition.
+   */
+  void End();
+
+  /**
+   * Clear any library-level memory caches.
+   * There are a variety of expensive-to-load constant data structures (mostly
+   * language dictionaries) that are cached globally -- surviving the Init()
+   * and End() of individual TessBaseAPI's.  This function allows the clearing
+   * of these caches.
+   **/
+  static void ClearPersistentCache();
+
+  /**
+   * Check whether a word is valid according to Tesseract's language model
+   * @return 0 if the word is invalid, non-zero if valid.
+   * @warning temporary! This function will be removed from here and placed
+   * in a separate API at some future time.
+   */
+  int IsValidWord(const char *word) const;
+  // Returns true if utf8_character is defined in the UniCharset.
+  bool IsValidCharacter(const char *utf8_character) const;
+
+  bool GetTextDirection(int *out_offset, float *out_slope);
+
+  /** Sets Dict::letter_is_okay_ function to point to the given function. */
+  void SetDictFunc(DictFunc f);
+
+  /** Sets Dict::probability_in_context_ function to point to the given
+   * function.
+   */
+  void SetProbabilityInContextFunc(ProbabilityInContextFunc f);
+
+  /**
+   * Estimates the Orientation And Script of the image.
+   * @return true if the image was processed successfully.
+   */
+  bool DetectOS(OSResults *);
+
+  /**
+   * Return text orientation of each block as determined by an earlier run
+   * of layout analysis.
+   */
+  void GetBlockTextOrientations(int **block_orientation,
+                                bool **vertical_writing);
+
+  /** This method returns the string form of the specified unichar. */
+  const char *GetUnichar(int unichar_id) const;
+
+  /** Return the pointer to the i-th dawg loaded into tesseract_ object. */
+  const Dawg *GetDawg(int i) const;
+
+  /** Return the number of dawgs loaded into tesseract_ object. */
+  int NumDawgs() const;
+
+  Tesseract *tesseract() const {
+    return tesseract_;
+  }
+
+  OcrEngineMode oem() const {
+    return last_oem_requested_;
+  }
+
+  void set_min_orientation_margin(double margin);
+  /* @} */
+
+protected:
+  /** Common code for setting the image. Returns true if Init has been called.
+   */
+  bool InternalSetImage();
+
+  /**
+   * Run the thresholder to make the thresholded image. If pix is not nullptr,
+   * the source is thresholded to pix instead of the internal IMAGE.
+   */
+  virtual bool Threshold(Pix **pix);
+
+  /**
+   * Find lines from the image making the BLOCK_LIST.
+   * @return 0 on success.
+   */
+  int FindLines();
+
+  /** Delete the pageres and block list ready for a new page. */
+  void ClearResults();
+
+  /**
+   * Return an LTR Result Iterator -- used only for training, as we really want
+   * to ignore all BiDi smarts at that point.
+   * delete once you're done with it.
+   */
+  LTRResultIterator *GetLTRIterator();
+
+  /**
+   * Return the length of the output text string, as UTF8, assuming
+   * one newline per line and one per block, with a terminator,
+   * and assuming a single character reject marker for each rejected character.
+   * Also return the number of recognized blobs in blob_count.
+   */
+  int TextLength(int *blob_count) const;
+
+  //// paragraphs.cpp ////////////////////////////////////////////////////
+  void DetectParagraphs(bool after_text_recognition);
+
+  const PAGE_RES *GetPageRes() const {
+    return page_res_;
+  }
+
+protected:
+  Tesseract *tesseract_;          ///< The underlying data object.
+  Tesseract *osd_tesseract_;      ///< For orientation & script detection.
+  EquationDetect *equ_detect_;    ///< The equation detector.
+  FileReader reader_;             ///< Reads files from any filesystem.
+  ImageThresholder *thresholder_; ///< Image thresholding module.
+  std::vector<ParagraphModel *> *paragraph_models_;
+  BLOCK_LIST *block_list_;           ///< The page layout.
+  PAGE_RES *page_res_;               ///< The page-level data.
+  std::string input_file_;           ///< Name used by training code.
+  std::string output_file_;          ///< Name used by debug code.
+  std::string datapath_;             ///< Current location of tessdata.
+  std::string language_;             ///< Last initialized language.
+  OcrEngineMode last_oem_requested_; ///< Last ocr language mode requested.
+  bool recognition_done_;            ///< page_res_ contains recognition data.
+
+  /**
+   * @defgroup ThresholderParams Thresholder Parameters
+   * Parameters saved from the Thresholder. Needed to rebuild coordinates.
+   */
+  /* @{ */
+  int rect_left_;
+  int rect_top_;
+  int rect_width_;
+  int rect_height_;
+  int image_width_;
+  int image_height_;
+  /* @} */
+
+private:
+  // A list of image filenames gets special consideration
+  bool ProcessPagesFileList(FILE *fp, std::string *buf,
+                            const char *retry_config, int timeout_millisec,
+                            TessResultRenderer *renderer,
+                            int tessedit_page_number);
+  // TIFF supports multipage so gets special consideration.
+  bool ProcessPagesMultipageTiff(const unsigned char *data, size_t size,
+                                 const char *filename, const char *retry_config,
+                                 int timeout_millisec,
+                                 TessResultRenderer *renderer,
+                                 int tessedit_page_number);
+}; // class TessBaseAPI.
+
+/** Escape a char string - remove &<>"' with HTML codes. */
+std::string HOcrEscape(const char *text);
+
+} // namespace tesseract
+
+#endif // TESSERACT_API_BASEAPI_H_

src/windows/tesseract/include/tesseract/capi.h

@@ -0,0 +1,484 @@
+// SPDX-License-Identifier: Apache-2.0
+// File:        capi.h
+// Description: C-API TessBaseAPI
+//
+// (C) Copyright 2012, Google Inc.
+// Licensed 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.
+
+#ifndef API_CAPI_H_
+#define API_CAPI_H_
+
+#include "export.h"
+
+#ifdef __cplusplus
+#  include <tesseract/baseapi.h>
+#  include <tesseract/ocrclass.h>
+#  include <tesseract/pageiterator.h>
+#  include <tesseract/renderer.h>
+#  include <tesseract/resultiterator.h>
+#endif
+
+#include <stdbool.h>
+#include <stdio.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef BOOL
+#  define BOOL int
+#  define TRUE 1
+#  define FALSE 0
+#endif
+
+#ifdef __cplusplus
+typedef tesseract::TessResultRenderer TessResultRenderer;
+typedef tesseract::TessBaseAPI TessBaseAPI;
+typedef tesseract::PageIterator TessPageIterator;
+typedef tesseract::ResultIterator TessResultIterator;
+typedef tesseract::MutableIterator TessMutableIterator;
+typedef tesseract::ChoiceIterator TessChoiceIterator;
+typedef tesseract::OcrEngineMode TessOcrEngineMode;
+typedef tesseract::PageSegMode TessPageSegMode;
+typedef tesseract::PageIteratorLevel TessPageIteratorLevel;
+typedef tesseract::Orientation TessOrientation;
+typedef tesseract::ParagraphJustification TessParagraphJustification;
+typedef tesseract::WritingDirection TessWritingDirection;
+typedef tesseract::TextlineOrder TessTextlineOrder;
+typedef tesseract::PolyBlockType TessPolyBlockType;
+typedef tesseract::ETEXT_DESC ETEXT_DESC;
+#else
+typedef struct TessResultRenderer TessResultRenderer;
+typedef struct TessBaseAPI TessBaseAPI;
+typedef struct TessPageIterator TessPageIterator;
+typedef struct TessResultIterator TessResultIterator;
+typedef struct TessMutableIterator TessMutableIterator;
+typedef struct TessChoiceIterator TessChoiceIterator;
+typedef enum TessOcrEngineMode {
+  OEM_TESSERACT_ONLY,
+  OEM_LSTM_ONLY,
+  OEM_TESSERACT_LSTM_COMBINED,
+  OEM_DEFAULT
+} TessOcrEngineMode;
+typedef enum TessPageSegMode {
+  PSM_OSD_ONLY,
+  PSM_AUTO_OSD,
+  PSM_AUTO_ONLY,
+  PSM_AUTO,
+  PSM_SINGLE_COLUMN,
+  PSM_SINGLE_BLOCK_VERT_TEXT,
+  PSM_SINGLE_BLOCK,
+  PSM_SINGLE_LINE,
+  PSM_SINGLE_WORD,
+  PSM_CIRCLE_WORD,
+  PSM_SINGLE_CHAR,
+  PSM_SPARSE_TEXT,
+  PSM_SPARSE_TEXT_OSD,
+  PSM_RAW_LINE,
+  PSM_COUNT
+} TessPageSegMode;
+typedef enum TessPageIteratorLevel {
+  RIL_BLOCK,
+  RIL_PARA,
+  RIL_TEXTLINE,
+  RIL_WORD,
+  RIL_SYMBOL
+} TessPageIteratorLevel;
+typedef enum TessPolyBlockType {
+  PT_UNKNOWN,
+  PT_FLOWING_TEXT,
+  PT_HEADING_TEXT,
+  PT_PULLOUT_TEXT,
+  PT_EQUATION,
+  PT_INLINE_EQUATION,
+  PT_TABLE,
+  PT_VERTICAL_TEXT,
+  PT_CAPTION_TEXT,
+  PT_FLOWING_IMAGE,
+  PT_HEADING_IMAGE,
+  PT_PULLOUT_IMAGE,
+  PT_HORZ_LINE,
+  PT_VERT_LINE,
+  PT_NOISE,
+  PT_COUNT
+} TessPolyBlockType;
+typedef enum TessOrientation {
+  ORIENTATION_PAGE_UP,
+  ORIENTATION_PAGE_RIGHT,
+  ORIENTATION_PAGE_DOWN,
+  ORIENTATION_PAGE_LEFT
+} TessOrientation;
+typedef enum TessParagraphJustification {
+  JUSTIFICATION_UNKNOWN,
+  JUSTIFICATION_LEFT,
+  JUSTIFICATION_CENTER,
+  JUSTIFICATION_RIGHT
+} TessParagraphJustification;
+typedef enum TessWritingDirection {
+  WRITING_DIRECTION_LEFT_TO_RIGHT,
+  WRITING_DIRECTION_RIGHT_TO_LEFT,
+  WRITING_DIRECTION_TOP_TO_BOTTOM
+} TessWritingDirection;
+typedef enum TessTextlineOrder {
+  TEXTLINE_ORDER_LEFT_TO_RIGHT,
+  TEXTLINE_ORDER_RIGHT_TO_LEFT,
+  TEXTLINE_ORDER_TOP_TO_BOTTOM
+} TessTextlineOrder;
+typedef struct ETEXT_DESC ETEXT_DESC;
+#endif
+
+typedef bool (*TessCancelFunc)(void *cancel_this, int words);
+typedef bool (*TessProgressFunc)(ETEXT_DESC *ths, int left, int right, int top,
+                                 int bottom);
+
+struct Pix;
+struct Boxa;
+struct Pixa;
+
+/* General free functions */
+
+TESS_API const char *TessVersion();
+TESS_API void TessDeleteText(const char *text);
+TESS_API void TessDeleteTextArray(char **arr);
+TESS_API void TessDeleteIntArray(const int *arr);
+
+/* Renderer API */
+TESS_API TessResultRenderer *TessTextRendererCreate(const char *outputbase);
+TESS_API TessResultRenderer *TessHOcrRendererCreate(const char *outputbase);
+TESS_API TessResultRenderer *TessHOcrRendererCreate2(const char *outputbase,
+                                                     BOOL font_info);
+TESS_API TessResultRenderer *TessAltoRendererCreate(const char *outputbase);
+TESS_API TessResultRenderer *TessTsvRendererCreate(const char *outputbase);
+TESS_API TessResultRenderer *TessPDFRendererCreate(const char *outputbase,
+                                                   const char *datadir,
+                                                   BOOL textonly);
+TESS_API TessResultRenderer *TessUnlvRendererCreate(const char *outputbase);
+TESS_API TessResultRenderer *TessBoxTextRendererCreate(const char *outputbase);
+TESS_API TessResultRenderer *TessLSTMBoxRendererCreate(const char *outputbase);
+TESS_API TessResultRenderer *TessWordStrBoxRendererCreate(
+    const char *outputbase);
+
+TESS_API void TessDeleteResultRenderer(TessResultRenderer *renderer);
+TESS_API void TessResultRendererInsert(TessResultRenderer *renderer,
+                                       TessResultRenderer *next);
+TESS_API TessResultRenderer *TessResultRendererNext(
+    TessResultRenderer *renderer);
+TESS_API BOOL TessResultRendererBeginDocument(TessResultRenderer *renderer,
+                                              const char *title);
+TESS_API BOOL TessResultRendererAddImage(TessResultRenderer *renderer,
+                                         TessBaseAPI *api);
+TESS_API BOOL TessResultRendererEndDocument(TessResultRenderer *renderer);
+
+TESS_API const char *TessResultRendererExtention(TessResultRenderer *renderer);
+TESS_API const char *TessResultRendererTitle(TessResultRenderer *renderer);
+TESS_API int TessResultRendererImageNum(TessResultRenderer *renderer);
+
+/* Base API */
+
+TESS_API TessBaseAPI *TessBaseAPICreate();
+TESS_API void TessBaseAPIDelete(TessBaseAPI *handle);
+
+TESS_API size_t TessBaseAPIGetOpenCLDevice(TessBaseAPI *handle, void **device);
+
+TESS_API void TessBaseAPISetInputName(TessBaseAPI *handle, const char *name);
+TESS_API const char *TessBaseAPIGetInputName(TessBaseAPI *handle);
+
+TESS_API void TessBaseAPISetInputImage(TessBaseAPI *handle, struct Pix *pix);
+TESS_API struct Pix *TessBaseAPIGetInputImage(TessBaseAPI *handle);
+
+TESS_API int TessBaseAPIGetSourceYResolution(TessBaseAPI *handle);
+TESS_API const char *TessBaseAPIGetDatapath(TessBaseAPI *handle);
+
+TESS_API void TessBaseAPISetOutputName(TessBaseAPI *handle, const char *name);
+
+TESS_API BOOL TessBaseAPISetVariable(TessBaseAPI *handle, const char *name,
+                                     const char *value);
+TESS_API BOOL TessBaseAPISetDebugVariable(TessBaseAPI *handle, const char *name,
+                                          const char *value);
+
+TESS_API BOOL TessBaseAPIGetIntVariable(const TessBaseAPI *handle,
+                                        const char *name, int *value);
+TESS_API BOOL TessBaseAPIGetBoolVariable(const TessBaseAPI *handle,
+                                         const char *name, BOOL *value);
+TESS_API BOOL TessBaseAPIGetDoubleVariable(const TessBaseAPI *handle,
+                                           const char *name, double *value);
+TESS_API const char *TessBaseAPIGetStringVariable(const TessBaseAPI *handle,
+                                                  const char *name);
+
+TESS_API void TessBaseAPIPrintVariables(const TessBaseAPI *handle, FILE *fp);
+TESS_API BOOL TessBaseAPIPrintVariablesToFile(const TessBaseAPI *handle,
+                                              const char *filename);
+
+TESS_API int TessBaseAPIInit1(TessBaseAPI *handle, const char *datapath,
+                              const char *language, TessOcrEngineMode oem,
+                              char **configs, int configs_size);
+TESS_API int TessBaseAPIInit2(TessBaseAPI *handle, const char *datapath,
+                              const char *language, TessOcrEngineMode oem);
+TESS_API int TessBaseAPIInit3(TessBaseAPI *handle, const char *datapath,
+                              const char *language);
+
+TESS_API int TessBaseAPIInit4(TessBaseAPI *handle, const char *datapath,
+                              const char *language, TessOcrEngineMode mode,
+                              char **configs, int configs_size, char **vars_vec,
+                              char **vars_values, size_t vars_vec_size,
+                              BOOL set_only_non_debug_params);
+
+TESS_API int TessBaseAPIInit5(TessBaseAPI *handle, const char *data, int data_size,
+                              const char *language, TessOcrEngineMode mode,
+                              char **configs, int configs_size, char **vars_vec,
+                              char **vars_values, size_t vars_vec_size,
+                              BOOL set_only_non_debug_params);
+
+TESS_API const char *TessBaseAPIGetInitLanguagesAsString(
+    const TessBaseAPI *handle);
+TESS_API char **TessBaseAPIGetLoadedLanguagesAsVector(
+    const TessBaseAPI *handle);
+TESS_API char **TessBaseAPIGetAvailableLanguagesAsVector(
+    const TessBaseAPI *handle);
+
+TESS_API void TessBaseAPIInitForAnalysePage(TessBaseAPI *handle);
+
+TESS_API void TessBaseAPIReadConfigFile(TessBaseAPI *handle,
+                                        const char *filename);
+TESS_API void TessBaseAPIReadDebugConfigFile(TessBaseAPI *handle,
+                                             const char *filename);
+
+TESS_API void TessBaseAPISetPageSegMode(TessBaseAPI *handle,
+                                        TessPageSegMode mode);
+TESS_API TessPageSegMode TessBaseAPIGetPageSegMode(const TessBaseAPI *handle);
+
+TESS_API char *TessBaseAPIRect(TessBaseAPI *handle,
+                               const unsigned char *imagedata,
+                               int bytes_per_pixel, int bytes_per_line,
+                               int left, int top, int width, int height);
+
+TESS_API void TessBaseAPIClearAdaptiveClassifier(TessBaseAPI *handle);
+
+TESS_API void TessBaseAPISetImage(TessBaseAPI *handle,
+                                  const unsigned char *imagedata, int width,
+                                  int height, int bytes_per_pixel,
+                                  int bytes_per_line);
+TESS_API void TessBaseAPISetImage2(TessBaseAPI *handle, struct Pix *pix);
+
+TESS_API void TessBaseAPISetSourceResolution(TessBaseAPI *handle, int ppi);
+
+TESS_API void TessBaseAPISetRectangle(TessBaseAPI *handle, int left, int top,
+                                      int width, int height);
+
+TESS_API struct Pix *TessBaseAPIGetThresholdedImage(TessBaseAPI *handle);
+TESS_API struct Boxa *TessBaseAPIGetRegions(TessBaseAPI *handle,
+                                            struct Pixa **pixa);
+TESS_API struct Boxa *TessBaseAPIGetTextlines(TessBaseAPI *handle,
+                                              struct Pixa **pixa,
+                                              int **blockids);
+TESS_API struct Boxa *TessBaseAPIGetTextlines1(TessBaseAPI *handle,
+                                               BOOL raw_image, int raw_padding,
+                                               struct Pixa **pixa,
+                                               int **blockids, int **paraids);
+TESS_API struct Boxa *TessBaseAPIGetStrips(TessBaseAPI *handle,
+                                           struct Pixa **pixa, int **blockids);
+TESS_API struct Boxa *TessBaseAPIGetWords(TessBaseAPI *handle,
+                                          struct Pixa **pixa);
+TESS_API struct Boxa *TessBaseAPIGetConnectedComponents(TessBaseAPI *handle,
+                                                        struct Pixa **cc);
+TESS_API struct Boxa *TessBaseAPIGetComponentImages(TessBaseAPI *handle,
+                                                    TessPageIteratorLevel level,
+                                                    BOOL text_only,
+                                                    struct Pixa **pixa,
+                                                    int **blockids);
+TESS_API struct Boxa *TessBaseAPIGetComponentImages1(
+    TessBaseAPI *handle, TessPageIteratorLevel level, BOOL text_only,
+    BOOL raw_image, int raw_padding, struct Pixa **pixa, int **blockids,
+    int **paraids);
+
+TESS_API int TessBaseAPIGetThresholdedImageScaleFactor(
+    const TessBaseAPI *handle);
+
+TESS_API TessPageIterator *TessBaseAPIAnalyseLayout(TessBaseAPI *handle);
+
+TESS_API int TessBaseAPIRecognize(TessBaseAPI *handle, ETEXT_DESC *monitor);
+
+TESS_API BOOL TessBaseAPIProcessPages(TessBaseAPI *handle, const char *filename,
+                                      const char *retry_config,
+                                      int timeout_millisec,
+                                      TessResultRenderer *renderer);
+TESS_API BOOL TessBaseAPIProcessPage(TessBaseAPI *handle, struct Pix *pix,
+                                     int page_index, const char *filename,
+                                     const char *retry_config,
+                                     int timeout_millisec,
+                                     TessResultRenderer *renderer);
+
+TESS_API TessResultIterator *TessBaseAPIGetIterator(TessBaseAPI *handle);
+TESS_API TessMutableIterator *TessBaseAPIGetMutableIterator(
+    TessBaseAPI *handle);
+
+TESS_API char *TessBaseAPIGetUTF8Text(TessBaseAPI *handle);
+TESS_API char *TessBaseAPIGetHOCRText(TessBaseAPI *handle, int page_number);
+
+TESS_API char *TessBaseAPIGetAltoText(TessBaseAPI *handle, int page_number);
+TESS_API char *TessBaseAPIGetTsvText(TessBaseAPI *handle, int page_number);
+
+TESS_API char *TessBaseAPIGetBoxText(TessBaseAPI *handle, int page_number);
+TESS_API char *TessBaseAPIGetLSTMBoxText(TessBaseAPI *handle, int page_number);
+TESS_API char *TessBaseAPIGetWordStrBoxText(TessBaseAPI *handle,
+                                            int page_number);
+
+TESS_API char *TessBaseAPIGetUNLVText(TessBaseAPI *handle);
+TESS_API int TessBaseAPIMeanTextConf(TessBaseAPI *handle);
+
+TESS_API int *TessBaseAPIAllWordConfidences(TessBaseAPI *handle);
+
+#ifndef DISABLED_LEGACY_ENGINE
+TESS_API BOOL TessBaseAPIAdaptToWordStr(TessBaseAPI *handle,
+                                        TessPageSegMode mode,
+                                        const char *wordstr);
+#endif // #ifndef DISABLED_LEGACY_ENGINE
+
+TESS_API void TessBaseAPIClear(TessBaseAPI *handle);
+TESS_API void TessBaseAPIEnd(TessBaseAPI *handle);
+
+TESS_API int TessBaseAPIIsValidWord(TessBaseAPI *handle, const char *word);
+TESS_API BOOL TessBaseAPIGetTextDirection(TessBaseAPI *handle, int *out_offset,
+                                          float *out_slope);
+
+TESS_API const char *TessBaseAPIGetUnichar(TessBaseAPI *handle, int unichar_id);
+
+TESS_API void TessBaseAPIClearPersistentCache(TessBaseAPI *handle);
+
+#ifndef DISABLED_LEGACY_ENGINE
+
+// Call TessDeleteText(*best_script_name) to free memory allocated by this
+// function
+TESS_API BOOL TessBaseAPIDetectOrientationScript(TessBaseAPI *handle,
+                                                 int *orient_deg,
+                                                 float *orient_conf,
+                                                 const char **script_name,
+                                                 float *script_conf);
+#endif // #ifndef DISABLED_LEGACY_ENGINE
+
+TESS_API void TessBaseAPISetMinOrientationMargin(TessBaseAPI *handle,
+                                                 double margin);
+
+TESS_API int TessBaseAPINumDawgs(const TessBaseAPI *handle);
+
+TESS_API TessOcrEngineMode TessBaseAPIOem(const TessBaseAPI *handle);
+
+TESS_API void TessBaseGetBlockTextOrientations(TessBaseAPI *handle,
+                                               int **block_orientation,
+                                               bool **vertical_writing);
+
+/* Page iterator */
+
+TESS_API void TessPageIteratorDelete(TessPageIterator *handle);
+
+TESS_API TessPageIterator *TessPageIteratorCopy(const TessPageIterator *handle);
+
+TESS_API void TessPageIteratorBegin(TessPageIterator *handle);
+
+TESS_API BOOL TessPageIteratorNext(TessPageIterator *handle,
+                                   TessPageIteratorLevel level);
+
+TESS_API BOOL TessPageIteratorIsAtBeginningOf(const TessPageIterator *handle,
+                                              TessPageIteratorLevel level);
+
+TESS_API BOOL TessPageIteratorIsAtFinalElement(const TessPageIterator *handle,
+                                               TessPageIteratorLevel level,
+                                               TessPageIteratorLevel element);
+
+TESS_API BOOL TessPageIteratorBoundingBox(const TessPageIterator *handle,
+                                          TessPageIteratorLevel level,
+                                          int *left, int *top, int *right,
+                                          int *bottom);
+
+TESS_API TessPolyBlockType
+TessPageIteratorBlockType(const TessPageIterator *handle);
+
+TESS_API struct Pix *TessPageIteratorGetBinaryImage(
+    const TessPageIterator *handle, TessPageIteratorLevel level);
+
+TESS_API struct Pix *TessPageIteratorGetImage(const TessPageIterator *handle,
+                                              TessPageIteratorLevel level,
+                                              int padding,
+                                              struct Pix *original_image,
+                                              int *left, int *top);
+
+TESS_API BOOL TessPageIteratorBaseline(const TessPageIterator *handle,
+                                       TessPageIteratorLevel level, int *x1,
+                                       int *y1, int *x2, int *y2);
+
+TESS_API void TessPageIteratorOrientation(
+    TessPageIterator *handle, TessOrientation *orientation,
+    TessWritingDirection *writing_direction, TessTextlineOrder *textline_order,
+    float *deskew_angle);
+
+TESS_API void TessPageIteratorParagraphInfo(
+    TessPageIterator *handle, TessParagraphJustification *justification,
+    BOOL *is_list_item, BOOL *is_crown, int *first_line_indent);
+
+/* Result iterator */
+
+TESS_API void TessResultIteratorDelete(TessResultIterator *handle);
+TESS_API TessResultIterator *TessResultIteratorCopy(
+    const TessResultIterator *handle);
+TESS_API TessPageIterator *TessResultIteratorGetPageIterator(
+    TessResultIterator *handle);
+TESS_API const TessPageIterator *TessResultIteratorGetPageIteratorConst(
+    const TessResultIterator *handle);
+TESS_API TessChoiceIterator *TessResultIteratorGetChoiceIterator(
+    const TessResultIterator *handle);
+
+TESS_API BOOL TessResultIteratorNext(TessResultIterator *handle,
+                                     TessPageIteratorLevel level);
+TESS_API char *TessResultIteratorGetUTF8Text(const TessResultIterator *handle,
+                                             TessPageIteratorLevel level);
+TESS_API float TessResultIteratorConfidence(const TessResultIterator *handle,
+                                            TessPageIteratorLevel level);
+TESS_API const char *TessResultIteratorWordRecognitionLanguage(
+    const TessResultIterator *handle);
+TESS_API const char *TessResultIteratorWordFontAttributes(
+    const TessResultIterator *handle, BOOL *is_bold, BOOL *is_italic,
+    BOOL *is_underlined, BOOL *is_monospace, BOOL *is_serif, BOOL *is_smallcaps,
+    int *pointsize, int *font_id);
+
+TESS_API BOOL
+TessResultIteratorWordIsFromDictionary(const TessResultIterator *handle);
+TESS_API BOOL TessResultIteratorWordIsNumeric(const TessResultIterator *handle);
+TESS_API BOOL
+TessResultIteratorSymbolIsSuperscript(const TessResultIterator *handle);
+TESS_API BOOL
+TessResultIteratorSymbolIsSubscript(const TessResultIterator *handle);
+TESS_API BOOL
+TessResultIteratorSymbolIsDropcap(const TessResultIterator *handle);
+
+TESS_API void TessChoiceIteratorDelete(TessChoiceIterator *handle);
+TESS_API BOOL TessChoiceIteratorNext(TessChoiceIterator *handle);
+TESS_API const char *TessChoiceIteratorGetUTF8Text(
+    const TessChoiceIterator *handle);
+TESS_API float TessChoiceIteratorConfidence(const TessChoiceIterator *handle);
+
+/* Progress monitor */
+
+TESS_API ETEXT_DESC *TessMonitorCreate();
+TESS_API void TessMonitorDelete(ETEXT_DESC *monitor);
+TESS_API void TessMonitorSetCancelFunc(ETEXT_DESC *monitor,
+                                       TessCancelFunc cancelFunc);
+TESS_API void TessMonitorSetCancelThis(ETEXT_DESC *monitor, void *cancelThis);
+TESS_API void *TessMonitorGetCancelThis(ETEXT_DESC *monitor);
+TESS_API void TessMonitorSetProgressFunc(ETEXT_DESC *monitor,
+                                         TessProgressFunc progressFunc);
+TESS_API int TessMonitorGetProgress(ETEXT_DESC *monitor);
+TESS_API void TessMonitorSetDeadlineMSecs(ETEXT_DESC *monitor, int deadline);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // API_CAPI_H_

src/windows/tesseract/include/tesseract/export.h

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: Apache-2.0
+// File:        export.h
+// Description: Place holder
+//
+// (C) Copyright 2006, Google Inc.
+// Licensed 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.
+
+#ifndef TESSERACT_PLATFORM_H_
+#define TESSERACT_PLATFORM_H_
+
+#ifndef TESS_API
+#  if defined(_WIN32) || defined(__CYGWIN__)
+#    if defined(TESS_EXPORTS)
+#      define TESS_API __declspec(dllexport)
+#    elif defined(TESS_IMPORTS)
+#      define TESS_API __declspec(dllimport)
+#    else
+#      define TESS_API
+#    endif
+#  else
+#    if defined(TESS_EXPORTS) || defined(TESS_IMPORTS)
+#      define TESS_API __attribute__((visibility("default")))
+#    else
+#      define TESS_API
+#    endif
+#  endif
+#endif
+
+#endif // TESSERACT_PLATFORM_H_

src/windows/tesseract/include/tesseract/ltrresultiterator.h

@@ -0,0 +1,235 @@
+// SPDX-License-Identifier: Apache-2.0
+// File:        ltrresultiterator.h
+// Description: Iterator for tesseract results in strict left-to-right
+//              order that avoids using tesseract internal data structures.
+// Author:      Ray Smith
+//
+// (C) Copyright 2010, Google Inc.
+// Licensed 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.
+
+#ifndef TESSERACT_CCMAIN_LTR_RESULT_ITERATOR_H_
+#define TESSERACT_CCMAIN_LTR_RESULT_ITERATOR_H_
+
+#include "export.h"       // for TESS_API
+#include "pageiterator.h" // for PageIterator
+#include "publictypes.h"  // for PageIteratorLevel
+#include "unichar.h"      // for StrongScriptDirection
+
+namespace tesseract {
+
+class BLOB_CHOICE_IT;
+class PAGE_RES;
+class WERD_RES;
+
+class Tesseract;
+
+// Class to iterate over tesseract results, providing access to all levels
+// of the page hierarchy, without including any tesseract headers or having
+// to handle any tesseract structures.
+// WARNING! This class points to data held within the TessBaseAPI class, and
+// therefore can only be used while the TessBaseAPI class still exists and
+// has not been subjected to a call of Init, SetImage, Recognize, Clear, End
+// DetectOS, or anything else that changes the internal PAGE_RES.
+// See tesseract/publictypes.h for the definition of PageIteratorLevel.
+// See also base class PageIterator, which contains the bulk of the interface.
+// LTRResultIterator adds text-specific methods for access to OCR output.
+
+class TESS_API LTRResultIterator : public PageIterator {
+  friend class ChoiceIterator;
+
+public:
+  // page_res and tesseract come directly from the BaseAPI.
+  // The rectangle parameters are copied indirectly from the Thresholder,
+  // via the BaseAPI. They represent the coordinates of some rectangle in an
+  // original image (in top-left-origin coordinates) and therefore the top-left
+  // needs to be added to any output boxes in order to specify coordinates
+  // in the original image. See TessBaseAPI::SetRectangle.
+  // The scale and scaled_yres are in case the Thresholder scaled the image
+  // rectangle prior to thresholding. Any coordinates in tesseract's image
+  // must be divided by scale before adding (rect_left, rect_top).
+  // The scaled_yres indicates the effective resolution of the binary image
+  // that tesseract has been given by the Thresholder.
+  // After the constructor, Begin has already been called.
+  LTRResultIterator(PAGE_RES *page_res, Tesseract *tesseract, int scale,
+                    int scaled_yres, int rect_left, int rect_top,
+                    int rect_width, int rect_height);
+
+  ~LTRResultIterator() override;
+
+  // LTRResultIterators may be copied! This makes it possible to iterate over
+  // all the objects at a lower level, while maintaining an iterator to
+  // objects at a higher level. These constructors DO NOT CALL Begin, so
+  // iterations will continue from the location of src.
+  // TODO: For now the copy constructor and operator= only need the base class
+  // versions, but if new data members are added, don't forget to add them!
+
+  // ============= Moving around within the page ============.
+
+  // See PageIterator.
+
+  // ============= Accessing data ==============.
+
+  // Returns the null terminated UTF-8 encoded text string for the current
+  // object at the given level. Use delete [] to free after use.
+  char *GetUTF8Text(PageIteratorLevel level) const;
+
+  // Set the string inserted at the end of each text line. "\n" by default.
+  void SetLineSeparator(const char *new_line);
+
+  // Set the string inserted at the end of each paragraph. "\n" by default.
+  void SetParagraphSeparator(const char *new_para);
+
+  // Returns the mean confidence of the current object at the given level.
+  // The number should be interpreted as a percent probability. (0.0f-100.0f)
+  float Confidence(PageIteratorLevel level) const;
+
+  // ============= Functions that refer to words only ============.
+
+  // Returns the font attributes of the current word. If iterating at a higher
+  // level object than words, eg textlines, then this will return the
+  // attributes of the first word in that textline.
+  // The actual return value is a string representing a font name. It points
+  // to an internal table and SHOULD NOT BE DELETED. Lifespan is the same as
+  // the iterator itself, ie rendered invalid by various members of
+  // TessBaseAPI, including Init, SetImage, End or deleting the TessBaseAPI.
+  // Pointsize is returned in printers points (1/72 inch.)
+  const char *WordFontAttributes(bool *is_bold, bool *is_italic,
+                                 bool *is_underlined, bool *is_monospace,
+                                 bool *is_serif, bool *is_smallcaps,
+                                 int *pointsize, int *font_id) const;
+
+  // Return the name of the language used to recognize this word.
+  // On error, nullptr.  Do not delete this pointer.
+  const char *WordRecognitionLanguage() const;
+
+  // Return the overall directionality of this word.
+  StrongScriptDirection WordDirection() const;
+
+  // Returns true if the current word was found in a dictionary.
+  bool WordIsFromDictionary() const;
+
+  // Returns the number of blanks before the current word.
+  int BlanksBeforeWord() const;
+
+  // Returns true if the current word is numeric.
+  bool WordIsNumeric() const;
+
+  // Returns true if the word contains blamer information.
+  bool HasBlamerInfo() const;
+
+  // Returns the pointer to ParamsTrainingBundle stored in the BlamerBundle
+  // of the current word.
+  const void *GetParamsTrainingBundle() const;
+
+  // Returns a pointer to the string with blamer information for this word.
+  // Assumes that the word's blamer_bundle is not nullptr.
+  const char *GetBlamerDebug() const;
+
+  // Returns a pointer to the string with misadaption information for this word.
+  // Assumes that the word's blamer_bundle is not nullptr.
+  const char *GetBlamerMisadaptionDebug() const;
+
+  // Returns true if a truth string was recorded for the current word.
+  bool HasTruthString() const;
+
+  // Returns true if the given string is equivalent to the truth string for
+  // the current word.
+  bool EquivalentToTruth(const char *str) const;
+
+  // Returns a null terminated UTF-8 encoded truth string for the current word.
+  // Use delete [] to free after use.
+  char *WordTruthUTF8Text() const;
+
+  // Returns a null terminated UTF-8 encoded normalized OCR string for the
+  // current word. Use delete [] to free after use.
+  char *WordNormedUTF8Text() const;
+
+  // Returns a pointer to serialized choice lattice.
+  // Fills lattice_size with the number of bytes in lattice data.
+  const char *WordLattice(int *lattice_size) const;
+
+  // ============= Functions that refer to symbols only ============.
+
+  // Returns true if the current symbol is a superscript.
+  // If iterating at a higher level object than symbols, eg words, then
+  // this will return the attributes of the first symbol in that word.
+  bool SymbolIsSuperscript() const;
+  // Returns true if the current symbol is a subscript.
+  // If iterating at a higher level object than symbols, eg words, then
+  // this will return the attributes of the first symbol in that word.
+  bool SymbolIsSubscript() const;
+  // Returns true if the current symbol is a dropcap.
+  // If iterating at a higher level object than symbols, eg words, then
+  // this will return the attributes of the first symbol in that word.
+  bool SymbolIsDropcap() const;
+
+protected:
+  const char *line_separator_;
+  const char *paragraph_separator_;
+};
+
+// Class to iterate over the classifier choices for a single RIL_SYMBOL.
+class TESS_API ChoiceIterator {
+public:
+  // Construction is from a LTRResultIterator that points to the symbol of
+  // interest. The ChoiceIterator allows a one-shot iteration over the
+  // choices for this symbol and after that it is useless.
+  explicit ChoiceIterator(const LTRResultIterator &result_it);
+  ~ChoiceIterator();
+
+  // Moves to the next choice for the symbol and returns false if there
+  // are none left.
+  bool Next();
+
+  // ============= Accessing data ==============.
+
+  // Returns the null terminated UTF-8 encoded text string for the current
+  // choice.
+  // NOTE: Unlike LTRResultIterator::GetUTF8Text, the return points to an
+  // internal structure and should NOT be delete[]ed to free after use.
+  const char *GetUTF8Text() const;
+
+  // Returns the confidence of the current choice depending on the used language
+  // data. If only LSTM traineddata is used the value range is 0.0f - 1.0f. All
+  // choices for one symbol should roughly add up to 1.0f.
+  // If only traineddata of the legacy engine is used, the number should be
+  // interpreted as a percent probability. (0.0f-100.0f) In this case
+  // probabilities won't add up to 100. Each one stands on its own.
+  float Confidence() const;
+
+  // Returns a vector containing all timesteps, which belong to the currently
+  // selected symbol. A timestep is a vector containing pairs of symbols and
+  // floating point numbers. The number states the probability for the
+  // corresponding symbol.
+  std::vector<std::vector<std::pair<const char *, float>>> *Timesteps() const;
+
+private:
+  // clears the remaining spaces out of the results and adapt the probabilities
+  void filterSpaces();
+  // Pointer to the WERD_RES object owned by the API.
+  WERD_RES *word_res_;
+  // Iterator over the blob choices.
+  BLOB_CHOICE_IT *choice_it_;
+  std::vector<std::pair<const char *, float>> *LSTM_choices_ = nullptr;
+  std::vector<std::pair<const char *, float>>::iterator LSTM_choice_it_;
+
+  const int *tstep_index_;
+  // regulates the rating granularity
+  double rating_coefficient_;
+  // leading blanks
+  int blanks_before_word_;
+  // true when there is lstm engine related trained data
+  bool oemLSTM_;
+};
+
+} // namespace tesseract.
+
+#endif // TESSERACT_CCMAIN_LTR_RESULT_ITERATOR_H_

src/windows/tesseract/include/tesseract/ocrclass.h

@@ -0,0 +1,158 @@
+// SPDX-License-Identifier: Apache-2.0
+/**********************************************************************
+ * File:        ocrclass.h
+ * Description: Class definitions and constants for the OCR API.
+ * Author:      Hewlett-Packard Co
+ *
+ * (C) Copyright 1996, Hewlett-Packard Co.
+ ** Licensed 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.
+ *
+ **********************************************************************/
+
+/**********************************************************************
+ * This file contains typedefs for all the structures used by
+ * the HP OCR interface.
+ * The structures are designed to allow them to be used with any
+ * structure alignment up to 8.
+ **********************************************************************/
+
+#ifndef CCUTIL_OCRCLASS_H_
+#define CCUTIL_OCRCLASS_H_
+
+#include <chrono>
+#include <ctime>
+
+namespace tesseract {
+
+/**********************************************************************
+ * EANYCODE_CHAR
+ * Description of a single character. The character code is defined by
+ * the character set of the current font.
+ * Output text is sent as an array of these structures.
+ * Spaces and line endings in the output are represented in the
+ * structures of the surrounding characters. They are not directly
+ * represented as characters.
+ * The first character in a word has a positive value of blanks.
+ * Missing information should be set to the defaults in the comments.
+ * If word bounds are known, but not character bounds, then the top and
+ * bottom of each character should be those of the word. The left of the
+ * first and right of the last char in each word should be set. All other
+ * lefts and rights should be set to -1.
+ * If set, the values of right and bottom are left+width and top+height.
+ * Most of the members come directly from the parameters to ocr_append_char.
+ * The formatting member uses the enhancement parameter and combines the
+ * line direction stuff into the top 3 bits.
+ * The coding is 0=RL char, 1=LR char, 2=DR NL, 3=UL NL, 4=DR Para,
+ * 5=UL Para, 6=TB char, 7=BT char. API users do not need to know what
+ * the coding is, only that it is backwards compatible with the previous
+ * version.
+ **********************************************************************/
+
+struct EANYCODE_CHAR { /*single character */
+  // It should be noted that the format for char_code for version 2.0 and beyond
+  // is UTF8 which means that ASCII characters will come out as one structure
+  // but other characters will be returned in two or more instances of this
+  // structure with a single byte of the  UTF8 code in each, but each will have
+  // the same bounding box. Programs which want to handle languagues with
+  // different characters sets will need to handle extended characters
+  // appropriately, but *all* code needs to be prepared to receive UTF8 coded
+  // characters for characters such as bullet and fancy quotes.
+  uint16_t char_code; /*character itself */
+  int16_t left;       /*of char (-1) */
+  int16_t right;      /*of char (-1) */
+  int16_t top;        /*of char (-1) */
+  int16_t bottom;     /*of char (-1) */
+  int16_t font_index; /*what font (0) */
+  uint8_t confidence; /*0=perfect, 100=reject (0/100) */
+  uint8_t point_size; /*of char, 72=i inch, (10) */
+  int8_t blanks;      /*no of spaces before this char (1) */
+  uint8_t formatting; /*char formatting (0) */
+};
+
+/**********************************************************************
+ * ETEXT_DESC
+ * Description of the output of the OCR engine.
+ * This structure is used as both a progress monitor and the final
+ * output header, since it needs to be a valid progress monitor while
+ * the OCR engine is storing its output to shared memory.
+ * During progress, all the buffer info is -1.
+ * Progress starts at 0 and increases to 100 during OCR. No other constraint.
+ * Additionally the progress callback contains the bounding box of the word that
+ * is currently being processed.
+ * Every progress callback, the OCR engine must set ocr_alive to 1.
+ * The HP side will set ocr_alive to 0. Repeated failure to reset
+ * to 1 indicates that the OCR engine is dead.
+ * If the cancel function is not null then it is called with the number of
+ * user words found. If it returns true then operation is cancelled.
+ **********************************************************************/
+class ETEXT_DESC;
+
+using CANCEL_FUNC = bool (*)(void *, int);
+using PROGRESS_FUNC = bool (*)(int, int, int, int, int);
+using PROGRESS_FUNC2 = bool (*)(ETEXT_DESC *, int, int, int, int);
+
+class ETEXT_DESC { // output header
+public:
+  int16_t count{0};    /// chars in this buffer(0)
+  int16_t progress{0}; /// percent complete increasing (0-100)
+  /** Progress monitor covers word recognition and it does not cover layout
+   * analysis.
+   * See Ray comment in https://github.com/tesseract-ocr/tesseract/pull/27 */
+  int8_t more_to_come{0};       /// true if not last
+  volatile int8_t ocr_alive{0}; /// ocr sets to 1, HP 0
+  int8_t err_code{0};           /// for errcode use
+  CANCEL_FUNC cancel{nullptr};  /// returns true to cancel
+  PROGRESS_FUNC progress_callback{
+      nullptr};                      /// called whenever progress increases
+  PROGRESS_FUNC2 progress_callback2; /// monitor-aware progress callback
+  void *cancel_this{nullptr};        /// this or other data for cancel
+  std::chrono::steady_clock::time_point end_time;
+  /// Time to stop. Expected to be set only
+  /// by call to set_deadline_msecs().
+  EANYCODE_CHAR text[1]{}; /// character data
+
+  ETEXT_DESC() : progress_callback2(&default_progress_func) {
+    end_time = std::chrono::time_point<std::chrono::steady_clock,
+                                       std::chrono::milliseconds>();
+  }
+
+  // Sets the end time to be deadline_msecs milliseconds from now.
+  void set_deadline_msecs(int32_t deadline_msecs) {
+    if (deadline_msecs > 0) {
+      end_time = std::chrono::steady_clock::now() +
+                 std::chrono::milliseconds(deadline_msecs);
+    }
+  }
+
+  // Returns false if we've not passed the end_time, or have not set a deadline.
+  bool deadline_exceeded() const {
+    if (end_time.time_since_epoch() ==
+        std::chrono::steady_clock::duration::zero()) {
+      return false;
+    }
+    auto now = std::chrono::steady_clock::now();
+    return (now > end_time);
+  }
+
+private:
+  static bool default_progress_func(ETEXT_DESC *ths, int left, int right,
+                                    int top, int bottom) {
+    if (ths->progress_callback != nullptr) {
+      return (*(ths->progress_callback))(ths->progress, left, right, top,
+                                         bottom);
+    }
+    return true;
+  }
+};
+
+} // namespace tesseract
+
+#endif // CCUTIL_OCRCLASS_H_

src/windows/tesseract/include/tesseract/osdetect.h

@@ -0,0 +1,139 @@
+// SPDX-License-Identifier: Apache-2.0
+// File:        osdetect.h
+// Description: Orientation and script detection.
+// Author:      Samuel Charron
+//              Ranjith Unnikrishnan
+//
+// (C) Copyright 2008, Google Inc.
+// Licensed 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.
+
+#ifndef TESSERACT_CCMAIN_OSDETECT_H_
+#define TESSERACT_CCMAIN_OSDETECT_H_
+
+#include "export.h" // for TESS_API
+
+#include <vector> // for std::vector
+
+namespace tesseract {
+
+class BLOBNBOX;
+class BLOBNBOX_CLIST;
+class BLOB_CHOICE_LIST;
+class TO_BLOCK_LIST;
+class UNICHARSET;
+
+class Tesseract;
+
+// Max number of scripts in ICU + "NULL" + Japanese and Korean + Fraktur
+const int kMaxNumberOfScripts = 116 + 1 + 2 + 1;
+
+struct OSBestResult {
+  OSBestResult()
+      : orientation_id(0), script_id(0), sconfidence(0.0), oconfidence(0.0) {}
+  int orientation_id;
+  int script_id;
+  float sconfidence;
+  float oconfidence;
+};
+
+struct OSResults {
+  OSResults() : unicharset(nullptr) {
+    for (int i = 0; i < 4; ++i) {
+      for (int j = 0; j < kMaxNumberOfScripts; ++j) {
+        scripts_na[i][j] = 0;
+      }
+      orientations[i] = 0;
+    }
+  }
+  void update_best_orientation();
+  // Set the estimate of the orientation to the given id.
+  void set_best_orientation(int orientation_id);
+  // Update/Compute the best estimate of the script assuming the given
+  // orientation id.
+  void update_best_script(int orientation_id);
+  // Return the index of the script with the highest score for this orientation.
+  TESS_API int get_best_script(int orientation_id) const;
+  // Accumulate scores with given OSResults instance and update the best script.
+  void accumulate(const OSResults &osr);
+
+  // Print statistics.
+  void print_scores(void) const;
+  void print_scores(int orientation_id) const;
+
+  // Array holding scores for each orientation id [0,3].
+  // Orientation ids [0..3] map to [0, 270, 180, 90] degree orientations of the
+  // page respectively, where the values refer to the amount of clockwise
+  // rotation to be applied to the page for the text to be upright and readable.
+  float orientations[4];
+  // Script confidence scores for each of 4 possible orientations.
+  float scripts_na[4][kMaxNumberOfScripts];
+
+  UNICHARSET *unicharset;
+  OSBestResult best_result;
+};
+
+class OrientationDetector {
+public:
+  OrientationDetector(const std::vector<int> *allowed_scripts,
+                      OSResults *results);
+  bool detect_blob(BLOB_CHOICE_LIST *scores);
+  int get_orientation();
+
+private:
+  OSResults *osr_;
+  const std::vector<int> *allowed_scripts_;
+};
+
+class ScriptDetector {
+public:
+  ScriptDetector(const std::vector<int> *allowed_scripts, OSResults *osr,
+                 tesseract::Tesseract *tess);
+  void detect_blob(BLOB_CHOICE_LIST *scores);
+  bool must_stop(int orientation) const;
+
+private:
+  OSResults *osr_;
+  static const char *korean_script_;
+  static const char *japanese_script_;
+  static const char *fraktur_script_;
+  int korean_id_;
+  int japanese_id_;
+  int katakana_id_;
+  int hiragana_id_;
+  int han_id_;
+  int hangul_id_;
+  int latin_id_;
+  int fraktur_id_;
+  tesseract::Tesseract *tess_;
+  const std::vector<int> *allowed_scripts_;
+};
+
+int orientation_and_script_detection(const char *filename, OSResults *,
+                                     tesseract::Tesseract *);
+
+int os_detect(TO_BLOCK_LIST *port_blocks, OSResults *osr,
+              tesseract::Tesseract *tess);
+
+int os_detect_blobs(const std::vector<int> *allowed_scripts,
+                    BLOBNBOX_CLIST *blob_list, OSResults *osr,
+                    tesseract::Tesseract *tess);
+
+bool os_detect_blob(BLOBNBOX *bbox, OrientationDetector *o, ScriptDetector *s,
+                    OSResults *, tesseract::Tesseract *tess);
+
+// Helper method to convert an orientation index to its value in degrees.
+// The value represents the amount of clockwise rotation in degrees that must be
+// applied for the text to be upright (readable).
+TESS_API int OrientationIdToValue(const int &id);
+
+} // namespace tesseract
+
+#endif // TESSERACT_CCMAIN_OSDETECT_H_

src/windows/tesseract/include/tesseract/pageiterator.h

@@ -0,0 +1,364 @@
+// SPDX-License-Identifier: Apache-2.0
+// File:        pageiterator.h
+// Description: Iterator for tesseract page structure that avoids using
+//              tesseract internal data structures.
+// Author:      Ray Smith
+//
+// (C) Copyright 2010, Google Inc.
+// Licensed 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.
+
+#ifndef TESSERACT_CCMAIN_PAGEITERATOR_H_
+#define TESSERACT_CCMAIN_PAGEITERATOR_H_
+
+#include "export.h"
+#include "publictypes.h"
+
+struct Pix;
+struct Pta;
+
+namespace tesseract {
+
+struct BlamerBundle;
+class C_BLOB_IT;
+class PAGE_RES;
+class PAGE_RES_IT;
+class WERD;
+
+class Tesseract;
+
+/**
+ * Class to iterate over tesseract page structure, providing access to all
+ * levels of the page hierarchy, without including any tesseract headers or
+ * having to handle any tesseract structures.
+ * WARNING! This class points to data held within the TessBaseAPI class, and
+ * therefore can only be used while the TessBaseAPI class still exists and
+ * has not been subjected to a call of Init, SetImage, Recognize, Clear, End
+ * DetectOS, or anything else that changes the internal PAGE_RES.
+ * See tesseract/publictypes.h for the definition of PageIteratorLevel.
+ * See also ResultIterator, derived from PageIterator, which adds in the
+ * ability to access OCR output with text-specific methods.
+ */
+
+class TESS_API PageIterator {
+public:
+  /**
+   * page_res and tesseract come directly from the BaseAPI.
+   * The rectangle parameters are copied indirectly from the Thresholder,
+   * via the BaseAPI. They represent the coordinates of some rectangle in an
+   * original image (in top-left-origin coordinates) and therefore the top-left
+   * needs to be added to any output boxes in order to specify coordinates
+   * in the original image. See TessBaseAPI::SetRectangle.
+   * The scale and scaled_yres are in case the Thresholder scaled the image
+   * rectangle prior to thresholding. Any coordinates in tesseract's image
+   * must be divided by scale before adding (rect_left, rect_top).
+   * The scaled_yres indicates the effective resolution of the binary image
+   * that tesseract has been given by the Thresholder.
+   * After the constructor, Begin has already been called.
+   */
+  PageIterator(PAGE_RES *page_res, Tesseract *tesseract, int scale,
+               int scaled_yres, int rect_left, int rect_top, int rect_width,
+               int rect_height);
+  virtual ~PageIterator();
+
+  /**
+   * Page/ResultIterators may be copied! This makes it possible to iterate over
+   * all the objects at a lower level, while maintaining an iterator to
+   * objects at a higher level. These constructors DO NOT CALL Begin, so
+   * iterations will continue from the location of src.
+   */
+  PageIterator(const PageIterator &src);
+  const PageIterator &operator=(const PageIterator &src);
+
+  /** Are we positioned at the same location as other? */
+  bool PositionedAtSameWord(const PAGE_RES_IT *other) const;
+
+  // ============= Moving around within the page ============.
+
+  /**
+   * Moves the iterator to point to the start of the page to begin an
+   * iteration.
+   */
+  virtual void Begin();
+
+  /**
+   * Moves the iterator to the beginning of the paragraph.
+   * This class implements this functionality by moving it to the zero indexed
+   * blob of the first (leftmost) word on the first row of the paragraph.
+   */
+  virtual void RestartParagraph();
+
+  /**
+   * Return whether this iterator points anywhere in the first textline of a
+   * paragraph.
+   */
+  bool IsWithinFirstTextlineOfParagraph() const;
+
+  /**
+   * Moves the iterator to the beginning of the text line.
+   * This class implements this functionality by moving it to the zero indexed
+   * blob of the first (leftmost) word of the row.
+   */
+  virtual void RestartRow();
+
+  /**
+   * Moves to the start of the next object at the given level in the
+   * page hierarchy, and returns false if the end of the page was reached.
+   * NOTE that RIL_SYMBOL will skip non-text blocks, but all other
+   * PageIteratorLevel level values will visit each non-text block once.
+   * Think of non text blocks as containing a single para, with a single line,
+   * with a single imaginary word.
+   * Calls to Next with different levels may be freely intermixed.
+   * This function iterates words in right-to-left scripts correctly, if
+   * the appropriate language has been loaded into Tesseract.
+   */
+  virtual bool Next(PageIteratorLevel level);
+
+  /**
+   * Returns true if the iterator is at the start of an object at the given
+   * level.
+   *
+   * For instance, suppose an iterator it is pointed to the first symbol of the
+   * first word of the third line of the second paragraph of the first block in
+   * a page, then:
+   *   it.IsAtBeginningOf(RIL_BLOCK) = false
+   *   it.IsAtBeginningOf(RIL_PARA) = false
+   *   it.IsAtBeginningOf(RIL_TEXTLINE) = true
+   *   it.IsAtBeginningOf(RIL_WORD) = true
+   *   it.IsAtBeginningOf(RIL_SYMBOL) = true
+   */
+  virtual bool IsAtBeginningOf(PageIteratorLevel level) const;
+
+  /**
+   * Returns whether the iterator is positioned at the last element in a
+   * given level. (e.g. the last word in a line, the last line in a block)
+   *
+   *     Here's some two-paragraph example
+   *   text.  It starts off innocuously
+   *   enough but quickly turns bizarre.
+   *     The author inserts a cornucopia
+   *   of words to guard against confused
+   *   references.
+   *
+   * Now take an iterator it pointed to the start of "bizarre."
+   *  it.IsAtFinalElement(RIL_PARA, RIL_SYMBOL) = false
+   *  it.IsAtFinalElement(RIL_PARA, RIL_WORD) = true
+   *  it.IsAtFinalElement(RIL_BLOCK, RIL_WORD) = false
+   */
+  virtual bool IsAtFinalElement(PageIteratorLevel level,
+                                PageIteratorLevel element) const;
+
+  /**
+   * Returns whether this iterator is positioned
+   *   before other:   -1
+   *   equal to other:  0
+   *   after other:     1
+   */
+  int Cmp(const PageIterator &other) const;
+
+  // ============= Accessing data ==============.
+  // Coordinate system:
+  // Integer coordinates are at the cracks between the pixels.
+  // The top-left corner of the top-left pixel in the image is at (0,0).
+  // The bottom-right corner of the bottom-right pixel in the image is at
+  // (width, height).
+  // Every bounding box goes from the top-left of the top-left contained
+  // pixel to the bottom-right of the bottom-right contained pixel, so
+  // the bounding box of the single top-left pixel in the image is:
+  // (0,0)->(1,1).
+  // If an image rectangle has been set in the API, then returned coordinates
+  // relate to the original (full) image, rather than the rectangle.
+
+  /**
+   * Controls what to include in a bounding box. Bounding boxes of all levels
+   * between RIL_WORD and RIL_BLOCK can include or exclude potential diacritics.
+   * Between layout analysis and recognition, it isn't known where all
+   * diacritics belong, so this control is used to include or exclude some
+   * diacritics that are above or below the main body of the word. In most cases
+   * where the placement is obvious, and after recognition, it doesn't make as
+   * much difference, as the diacritics will already be included in the word.
+   */
+  void SetBoundingBoxComponents(bool include_upper_dots,
+                                bool include_lower_dots) {
+    include_upper_dots_ = include_upper_dots;
+    include_lower_dots_ = include_lower_dots;
+  }
+
+  /**
+   * Returns the bounding rectangle of the current object at the given level.
+   * See comment on coordinate system above.
+   * Returns false if there is no such object at the current position.
+   * The returned bounding box is guaranteed to match the size and position
+   * of the image returned by GetBinaryImage, but may clip foreground pixels
+   * from a grey image. The padding argument to GetImage can be used to expand
+   * the image to include more foreground pixels. See GetImage below.
+   */
+  bool BoundingBox(PageIteratorLevel level, int *left, int *top, int *right,
+                   int *bottom) const;
+  bool BoundingBox(PageIteratorLevel level, int padding, int *left, int *top,
+                   int *right, int *bottom) const;
+  /**
+   * Returns the bounding rectangle of the object in a coordinate system of the
+   * working image rectangle having its origin at (rect_left_, rect_top_) with
+   * respect to the original image and is scaled by a factor scale_.
+   */
+  bool BoundingBoxInternal(PageIteratorLevel level, int *left, int *top,
+                           int *right, int *bottom) const;
+
+  /** Returns whether there is no object of a given level. */
+  bool Empty(PageIteratorLevel level) const;
+
+  /**
+   * Returns the type of the current block.
+   * See tesseract/publictypes.h for PolyBlockType.
+   */
+  PolyBlockType BlockType() const;
+
+  /**
+   * Returns the polygon outline of the current block. The returned Pta must
+   * be ptaDestroy-ed after use. Note that the returned Pta lists the vertices
+   * of the polygon, and the last edge is the line segment between the last
+   * point and the first point. nullptr will be returned if the iterator is
+   * at the end of the document or layout analysis was not used.
+   */
+  Pta *BlockPolygon() const;
+
+  /**
+   * Returns a binary image of the current object at the given level.
+   * The position and size match the return from BoundingBoxInternal, and so
+   * this could be upscaled with respect to the original input image.
+   * Use pixDestroy to delete the image after use.
+   */
+  Pix *GetBinaryImage(PageIteratorLevel level) const;
+
+  /**
+   * Returns an image of the current object at the given level in greyscale
+   * if available in the input. To guarantee a binary image use BinaryImage.
+   * NOTE that in order to give the best possible image, the bounds are
+   * expanded slightly over the binary connected component, by the supplied
+   * padding, so the top-left position of the returned image is returned
+   * in (left,top). These will most likely not match the coordinates
+   * returned by BoundingBox.
+   * If you do not supply an original image, you will get a binary one.
+   * Use pixDestroy to delete the image after use.
+   */
+  Pix *GetImage(PageIteratorLevel level, int padding, Pix *original_img,
+                int *left, int *top) const;
+
+  /**
+   * Returns the baseline of the current object at the given level.
+   * The baseline is the line that passes through (x1, y1) and (x2, y2).
+   * WARNING: with vertical text, baselines may be vertical!
+   * Returns false if there is no baseline at the current position.
+   */
+  bool Baseline(PageIteratorLevel level, int *x1, int *y1, int *x2,
+                int *y2) const;
+
+  // Returns the attributes of the current row.
+  void RowAttributes(float *row_height, float *descenders,
+                     float *ascenders) const;
+
+  /**
+   * Returns orientation for the block the iterator points to.
+   *   orientation, writing_direction, textline_order: see publictypes.h
+   *   deskew_angle: after rotating the block so the text orientation is
+   *                 upright, how many radians does one have to rotate the
+   *                 block anti-clockwise for it to be level?
+   *                   -Pi/4 <= deskew_angle <= Pi/4
+   */
+  void Orientation(tesseract::Orientation *orientation,
+                   tesseract::WritingDirection *writing_direction,
+                   tesseract::TextlineOrder *textline_order,
+                   float *deskew_angle) const;
+
+  /**
+   * Returns information about the current paragraph, if available.
+   *
+   *   justification -
+   *     LEFT if ragged right, or fully justified and script is left-to-right.
+   *     RIGHT if ragged left, or fully justified and script is right-to-left.
+   *     unknown if it looks like source code or we have very few lines.
+   *   is_list_item -
+   *     true if we believe this is a member of an ordered or unordered list.
+   *   is_crown -
+   *     true if the first line of the paragraph is aligned with the other
+   *     lines of the paragraph even though subsequent paragraphs have first
+   *     line indents.  This typically indicates that this is the continuation
+   *     of a previous paragraph or that it is the very first paragraph in
+   *     the chapter.
+   *   first_line_indent -
+   *     For LEFT aligned paragraphs, the first text line of paragraphs of
+   *     this kind are indented this many pixels from the left edge of the
+   *     rest of the paragraph.
+   *     for RIGHT aligned paragraphs, the first text line of paragraphs of
+   *     this kind are indented this many pixels from the right edge of the
+   *     rest of the paragraph.
+   *     NOTE 1: This value may be negative.
+   *     NOTE 2: if *is_crown == true, the first line of this paragraph is
+   *             actually flush, and first_line_indent is set to the "common"
+   *             first_line_indent for subsequent paragraphs in this block
+   *             of text.
+   */
+  void ParagraphInfo(tesseract::ParagraphJustification *justification,
+                     bool *is_list_item, bool *is_crown,
+                     int *first_line_indent) const;
+
+  // If the current WERD_RES (it_->word()) is not nullptr, sets the BlamerBundle
+  // of the current word to the given pointer (takes ownership of the pointer)
+  // and returns true.
+  // Can only be used when iterating on the word level.
+  bool SetWordBlamerBundle(BlamerBundle *blamer_bundle);
+
+protected:
+  /**
+   * Sets up the internal data for iterating the blobs of a new word, then
+   * moves the iterator to the given offset.
+   */
+  void BeginWord(int offset);
+
+  /** Pointer to the page_res owned by the API. */
+  PAGE_RES *page_res_;
+  /** Pointer to the Tesseract object owned by the API. */
+  Tesseract *tesseract_;
+  /**
+   * The iterator to the page_res_. Owned by this ResultIterator.
+   * A pointer just to avoid dragging in Tesseract includes.
+   */
+  PAGE_RES_IT *it_;
+  /**
+   * The current input WERD being iterated. If there is an output from OCR,
+   * then word_ is nullptr. Owned by the API
+   */
+  WERD *word_;
+  /** The length of the current word_. */
+  int word_length_;
+  /** The current blob index within the word. */
+  int blob_index_;
+  /**
+   * Iterator to the blobs within the word. If nullptr, then we are iterating
+   * OCR results in the box_word.
+   * Owned by this ResultIterator.
+   */
+  C_BLOB_IT *cblob_it_;
+  /** Control over what to include in bounding boxes. */
+  bool include_upper_dots_;
+  bool include_lower_dots_;
+  /** Parameters saved from the Thresholder. Needed to rebuild coordinates.*/
+  int scale_;
+  int scaled_yres_;
+  int rect_left_;
+  int rect_top_;
+  int rect_width_;
+  int rect_height_;
+};
+
+} // namespace tesseract.
+
+#endif // TESSERACT_CCMAIN_PAGEITERATOR_H_

src/windows/tesseract/include/tesseract/publictypes.h

@@ -0,0 +1,281 @@
+// SPDX-License-Identifier: Apache-2.0
+// File:        publictypes.h
+// Description: Types used in both the API and internally
+// Author:      Ray Smith
+//
+// (C) Copyright 2010, Google Inc.
+// Licensed 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.
+
+#ifndef TESSERACT_CCSTRUCT_PUBLICTYPES_H_
+#define TESSERACT_CCSTRUCT_PUBLICTYPES_H_
+
+namespace tesseract {
+
+// This file contains types that are used both by the API and internally
+// to Tesseract. In order to decouple the API from Tesseract and prevent cyclic
+// dependencies, THIS FILE SHOULD NOT DEPEND ON ANY OTHER PART OF TESSERACT.
+// Restated: It is OK for low-level Tesseract files to include publictypes.h,
+// but not for the low-level tesseract code to include top-level API code.
+// This file should not use other Tesseract types, as that would drag
+// their includes into the API-level.
+
+/** Number of printers' points in an inch. The unit of the pointsize return. */
+constexpr int kPointsPerInch = 72;
+/**
+ * Minimum believable resolution. Used as a default if there is no other
+ * information, as it is safer to under-estimate than over-estimate.
+ */
+constexpr int kMinCredibleResolution = 70;
+/** Maximum believable resolution.  */
+constexpr int kMaxCredibleResolution = 2400;
+/**
+ * Ratio between median blob size and likely resolution. Used to estimate
+ * resolution when none is provided. This is basically 1/usual text size in
+ * inches.  */
+constexpr int kResolutionEstimationFactor = 10;
+
+/**
+ * Possible types for a POLY_BLOCK or ColPartition.
+ * Must be kept in sync with kPBColors in polyblk.cpp and PTIs*Type functions
+ * below, as well as kPolyBlockNames in layout_test.cc.
+ * Used extensively by ColPartition, and POLY_BLOCK.
+ */
+enum PolyBlockType {
+  PT_UNKNOWN,         // Type is not yet known. Keep as the first element.
+  PT_FLOWING_TEXT,    // Text that lives inside a column.
+  PT_HEADING_TEXT,    // Text that spans more than one column.
+  PT_PULLOUT_TEXT,    // Text that is in a cross-column pull-out region.
+  PT_EQUATION,        // Partition belonging to an equation region.
+  PT_INLINE_EQUATION, // Partition has inline equation.
+  PT_TABLE,           // Partition belonging to a table region.
+  PT_VERTICAL_TEXT,   // Text-line runs vertically.
+  PT_CAPTION_TEXT,    // Text that belongs to an image.
+  PT_FLOWING_IMAGE,   // Image that lives inside a column.
+  PT_HEADING_IMAGE,   // Image that spans more than one column.
+  PT_PULLOUT_IMAGE,   // Image that is in a cross-column pull-out region.
+  PT_HORZ_LINE,       // Horizontal Line.
+  PT_VERT_LINE,       // Vertical Line.
+  PT_NOISE,           // Lies outside of any column.
+  PT_COUNT
+};
+
+/** Returns true if PolyBlockType is of horizontal line type */
+inline bool PTIsLineType(PolyBlockType type) {
+  return type == PT_HORZ_LINE || type == PT_VERT_LINE;
+}
+/** Returns true if PolyBlockType is of image type */
+inline bool PTIsImageType(PolyBlockType type) {
+  return type == PT_FLOWING_IMAGE || type == PT_HEADING_IMAGE ||
+         type == PT_PULLOUT_IMAGE;
+}
+/** Returns true if PolyBlockType is of text type */
+inline bool PTIsTextType(PolyBlockType type) {
+  return type == PT_FLOWING_TEXT || type == PT_HEADING_TEXT ||
+         type == PT_PULLOUT_TEXT || type == PT_TABLE ||
+         type == PT_VERTICAL_TEXT || type == PT_CAPTION_TEXT ||
+         type == PT_INLINE_EQUATION;
+}
+// Returns true if PolyBlockType is of pullout(inter-column) type
+inline bool PTIsPulloutType(PolyBlockType type) {
+  return type == PT_PULLOUT_IMAGE || type == PT_PULLOUT_TEXT;
+}
+
+/**
+ *  +------------------+  Orientation Example:
+ *  | 1 Aaaa Aaaa Aaaa |  ====================
+ *  | Aaa aa aaa aa    |  To left is a diagram of some (1) English and
+ *  | aaaaaa A aa aaa. |  (2) Chinese text and a (3) photo credit.
+ *  |                2 |
+ *  |   #######  c c C |  Upright Latin characters are represented as A and a.
+ *  |   #######  c c c |  '<' represents a latin character rotated
+ *  | < #######  c c c |      anti-clockwise 90 degrees.
+ *  | < #######  c   c |
+ *  | < #######  .   c |  Upright Chinese characters are represented C and c.
+ *  | 3 #######      c |
+ *  +------------------+  NOTA BENE: enum values here should match goodoc.proto
+
+ * If you orient your head so that "up" aligns with Orientation,
+ * then the characters will appear "right side up" and readable.
+ *
+ * In the example above, both the English and Chinese paragraphs are oriented
+ * so their "up" is the top of the page (page up).  The photo credit is read
+ * with one's head turned leftward ("up" is to page left).
+ *
+ * The values of this enum match the convention of Tesseract's osdetect.h
+*/
+enum Orientation {
+  ORIENTATION_PAGE_UP = 0,
+  ORIENTATION_PAGE_RIGHT = 1,
+  ORIENTATION_PAGE_DOWN = 2,
+  ORIENTATION_PAGE_LEFT = 3,
+};
+
+/**
+ * The grapheme clusters within a line of text are laid out logically
+ * in this direction, judged when looking at the text line rotated so that
+ * its Orientation is "page up".
+ *
+ * For English text, the writing direction is left-to-right.  For the
+ * Chinese text in the above example, the writing direction is top-to-bottom.
+ */
+enum WritingDirection {
+  WRITING_DIRECTION_LEFT_TO_RIGHT = 0,
+  WRITING_DIRECTION_RIGHT_TO_LEFT = 1,
+  WRITING_DIRECTION_TOP_TO_BOTTOM = 2,
+};
+
+/**
+ * The text lines are read in the given sequence.
+ *
+ * In English, the order is top-to-bottom.
+ * In Chinese, vertical text lines are read right-to-left.  Mongolian is
+ * written in vertical columns top to bottom like Chinese, but the lines
+ * order left-to right.
+ *
+ * Note that only some combinations make sense.  For example,
+ * WRITING_DIRECTION_LEFT_TO_RIGHT implies TEXTLINE_ORDER_TOP_TO_BOTTOM
+ */
+enum TextlineOrder {
+  TEXTLINE_ORDER_LEFT_TO_RIGHT = 0,
+  TEXTLINE_ORDER_RIGHT_TO_LEFT = 1,
+  TEXTLINE_ORDER_TOP_TO_BOTTOM = 2,
+};
+
+/**
+ * Possible modes for page layout analysis. These *must* be kept in order
+ * of decreasing amount of layout analysis to be done, except for OSD_ONLY,
+ * so that the inequality test macros below work.
+ */
+enum PageSegMode {
+  PSM_OSD_ONLY = 0,      ///< Orientation and script detection only.
+  PSM_AUTO_OSD = 1,      ///< Automatic page segmentation with orientation and
+                         ///< script detection. (OSD)
+  PSM_AUTO_ONLY = 2,     ///< Automatic page segmentation, but no OSD, or OCR.
+  PSM_AUTO = 3,          ///< Fully automatic page segmentation, but no OSD.
+  PSM_SINGLE_COLUMN = 4, ///< Assume a single column of text of variable sizes.
+  PSM_SINGLE_BLOCK_VERT_TEXT = 5, ///< Assume a single uniform block of
+                                  ///< vertically aligned text.
+  PSM_SINGLE_BLOCK = 6, ///< Assume a single uniform block of text. (Default.)
+  PSM_SINGLE_LINE = 7,  ///< Treat the image as a single text line.
+  PSM_SINGLE_WORD = 8,  ///< Treat the image as a single word.
+  PSM_CIRCLE_WORD = 9,  ///< Treat the image as a single word in a circle.
+  PSM_SINGLE_CHAR = 10, ///< Treat the image as a single character.
+  PSM_SPARSE_TEXT =
+      11, ///< Find as much text as possible in no particular order.
+  PSM_SPARSE_TEXT_OSD = 12, ///< Sparse text with orientation and script det.
+  PSM_RAW_LINE = 13, ///< Treat the image as a single text line, bypassing
+                     ///< hacks that are Tesseract-specific.
+
+  PSM_COUNT ///< Number of enum entries.
+};
+
+/**
+ * Inline functions that act on a PageSegMode to determine whether components of
+ * layout analysis are enabled.
+ * *Depend critically on the order of elements of PageSegMode.*
+ * NOTE that arg is an int for compatibility with INT_PARAM.
+ */
+inline bool PSM_OSD_ENABLED(int pageseg_mode) {
+  return pageseg_mode <= PSM_AUTO_OSD || pageseg_mode == PSM_SPARSE_TEXT_OSD;
+}
+inline bool PSM_ORIENTATION_ENABLED(int pageseg_mode) {
+  return pageseg_mode <= PSM_AUTO || pageseg_mode == PSM_SPARSE_TEXT_OSD;
+}
+inline bool PSM_COL_FIND_ENABLED(int pageseg_mode) {
+  return pageseg_mode >= PSM_AUTO_OSD && pageseg_mode <= PSM_AUTO;
+}
+inline bool PSM_SPARSE(int pageseg_mode) {
+  return pageseg_mode == PSM_SPARSE_TEXT || pageseg_mode == PSM_SPARSE_TEXT_OSD;
+}
+inline bool PSM_BLOCK_FIND_ENABLED(int pageseg_mode) {
+  return pageseg_mode >= PSM_AUTO_OSD && pageseg_mode <= PSM_SINGLE_COLUMN;
+}
+inline bool PSM_LINE_FIND_ENABLED(int pageseg_mode) {
+  return pageseg_mode >= PSM_AUTO_OSD && pageseg_mode <= PSM_SINGLE_BLOCK;
+}
+inline bool PSM_WORD_FIND_ENABLED(int pageseg_mode) {
+  return (pageseg_mode >= PSM_AUTO_OSD && pageseg_mode <= PSM_SINGLE_LINE) ||
+         pageseg_mode == PSM_SPARSE_TEXT || pageseg_mode == PSM_SPARSE_TEXT_OSD;
+}
+
+/**
+ * enum of the elements of the page hierarchy, used in ResultIterator
+ * to provide functions that operate on each level without having to
+ * have 5x as many functions.
+ */
+enum PageIteratorLevel {
+  RIL_BLOCK,    // Block of text/image/separator line.
+  RIL_PARA,     // Paragraph within a block.
+  RIL_TEXTLINE, // Line within a paragraph.
+  RIL_WORD,     // Word within a textline.
+  RIL_SYMBOL    // Symbol/character within a word.
+};
+
+/**
+ * JUSTIFICATION_UNKNOWN
+ *   The alignment is not clearly one of the other options.  This could happen
+ *   for example if there are only one or two lines of text or the text looks
+ *   like source code or poetry.
+ *
+ * NOTA BENE: Fully justified paragraphs (text aligned to both left and right
+ *    margins) are marked by Tesseract with JUSTIFICATION_LEFT if their text
+ *    is written with a left-to-right script and with JUSTIFICATION_RIGHT if
+ *    their text is written in a right-to-left script.
+ *
+ * Interpretation for text read in vertical lines:
+ *   "Left" is wherever the starting reading position is.
+ *
+ * JUSTIFICATION_LEFT
+ *   Each line, except possibly the first, is flush to the same left tab stop.
+ *
+ * JUSTIFICATION_CENTER
+ *   The text lines of the paragraph are centered about a line going
+ *   down through their middle of the text lines.
+ *
+ * JUSTIFICATION_RIGHT
+ *   Each line, except possibly the first, is flush to the same right tab stop.
+ */
+enum ParagraphJustification {
+  JUSTIFICATION_UNKNOWN,
+  JUSTIFICATION_LEFT,
+  JUSTIFICATION_CENTER,
+  JUSTIFICATION_RIGHT,
+};
+
+/**
+ * When Tesseract/Cube is initialized we can choose to instantiate/load/run
+ * only the Tesseract part, only the Cube part or both along with the combiner.
+ * The preference of which engine to use is stored in tessedit_ocr_engine_mode.
+ *
+ * ATTENTION: When modifying this enum, please make sure to make the
+ * appropriate changes to all the enums mirroring it (e.g. OCREngine in
+ * cityblock/workflow/detection/detection_storage.proto). Such enums will
+ * mention the connection to OcrEngineMode in the comments.
+ */
+enum OcrEngineMode {
+  OEM_TESSERACT_ONLY,          // Run Tesseract only - fastest; deprecated
+  OEM_LSTM_ONLY,               // Run just the LSTM line recognizer.
+  OEM_TESSERACT_LSTM_COMBINED, // Run the LSTM recognizer, but allow fallback
+                               // to Tesseract when things get difficult.
+                               // deprecated
+  OEM_DEFAULT,                 // Specify this mode when calling init_*(),
+                               // to indicate that any of the above modes
+                               // should be automatically inferred from the
+                               // variables in the language-specific config,
+                               // command-line configs, or if not specified
+                               // in any of the above should be set to the
+                               // default OEM_TESSERACT_ONLY.
+  OEM_COUNT                    // Number of OEMs
+};
+
+} // namespace tesseract.
+
+#endif // TESSERACT_CCSTRUCT_PUBLICTYPES_H_

src/windows/tesseract/include/tesseract/renderer.h

@@ -0,0 +1,311 @@
+// SPDX-License-Identifier: Apache-2.0
+// File:        renderer.h
+// Description: Rendering interface to inject into TessBaseAPI
+//
+// (C) Copyright 2011, Google Inc.
+// Licensed 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.
+
+#ifndef TESSERACT_API_RENDERER_H_
+#define TESSERACT_API_RENDERER_H_
+
+#include "export.h"
+
+// To avoid collision with other typenames include the ABSOLUTE MINIMUM
+// complexity of includes here. Use forward declarations wherever possible
+// and hide includes of complex types in baseapi.cpp.
+#include <cstdint>
+#include <string> // for std::string
+#include <vector> // for std::vector
+
+struct Pix;
+
+namespace tesseract {
+
+class TessBaseAPI;
+
+/**
+ * Interface for rendering tesseract results into a document, such as text,
+ * HOCR or pdf. This class is abstract. Specific classes handle individual
+ * formats. This interface is then used to inject the renderer class into
+ * tesseract when processing images.
+ *
+ * For simplicity implementing this with tesseract version 3.01,
+ * the renderer contains document state that is cleared from document
+ * to document just as the TessBaseAPI is. This way the base API can just
+ * delegate its rendering functionality to injected renderers, and the
+ * renderers can manage the associated state needed for the specific formats
+ * in addition to the heuristics for producing it.
+ */
+class TESS_API TessResultRenderer {
+public:
+  virtual ~TessResultRenderer();
+
+  // Takes ownership of pointer so must be new'd instance.
+  // Renderers aren't ordered, but appends the sequences of next parameter
+  // and existing next(). The renderers should be unique across both lists.
+  void insert(TessResultRenderer *next);
+
+  // Returns the next renderer or nullptr.
+  TessResultRenderer *next() {
+    return next_;
+  }
+
+  /**
+   * Starts a new document with the given title.
+   * This clears the contents of the output data.
+   * Title should use UTF-8 encoding.
+   */
+  bool BeginDocument(const char *title);
+
+  /**
+   * Adds the recognized text from the source image to the current document.
+   * Invalid if BeginDocument not yet called.
+   *
+   * Note that this API is a bit weird but is designed to fit into the
+   * current TessBaseAPI implementation where the api has lots of state
+   * information that we might want to add in.
+   */
+  bool AddImage(TessBaseAPI *api);
+
+  /**
+   * Finishes the document and finalizes the output data
+   * Invalid if BeginDocument not yet called.
+   */
+  bool EndDocument();
+
+  const char *file_extension() const {
+    return file_extension_;
+  }
+  const char *title() const {
+    return title_.c_str();
+  }
+
+  // Is everything fine? Otherwise something went wrong.
+  bool happy() const {
+    return happy_;
+  }
+
+  /**
+   * Returns the index of the last image given to AddImage
+   * (i.e. images are incremented whether the image succeeded or not)
+   *
+   * This is always defined. It means either the number of the
+   * current image, the last image ended, or in the completed document
+   * depending on when in the document lifecycle you are looking at it.
+   * Will return -1 if a document was never started.
+   */
+  int imagenum() const {
+    return imagenum_;
+  }
+
+protected:
+  /**
+   * Called by concrete classes.
+   *
+   * outputbase is the name of the output file excluding
+   * extension. For example, "/path/to/chocolate-chip-cookie-recipe"
+   *
+   * extension indicates the file extension to be used for output
+   * files. For example "pdf" will produce a .pdf file, and "hocr"
+   * will produce .hocr files.
+   */
+  TessResultRenderer(const char *outputbase, const char *extension);
+
+  // Hook for specialized handling in BeginDocument()
+  virtual bool BeginDocumentHandler();
+
+  // This must be overridden to render the OCR'd results
+  virtual bool AddImageHandler(TessBaseAPI *api) = 0;
+
+  // Hook for specialized handling in EndDocument()
+  virtual bool EndDocumentHandler();
+
+  // Renderers can call this to append '\0' terminated strings into
+  // the output string returned by GetOutput.
+  // This method will grow the output buffer if needed.
+  void AppendString(const char *s);
+
+  // Renderers can call this to append binary byte sequences into
+  // the output string returned by GetOutput. Note that s is not necessarily
+  // '\0' terminated (and can contain '\0' within it).
+  // This method will grow the output buffer if needed.
+  void AppendData(const char *s, int len);
+
+private:
+  TessResultRenderer *next_;   // Can link multiple renderers together
+  FILE *fout_;                 // output file pointer
+  const char *file_extension_; // standard extension for generated output
+  std::string title_;          // title of document being rendered
+  int imagenum_;               // index of last image added
+  bool happy_;                 // I get grumpy when the disk fills up, etc.
+};
+
+/**
+ * Renders tesseract output into a plain UTF-8 text string
+ */
+class TESS_API TessTextRenderer : public TessResultRenderer {
+public:
+  explicit TessTextRenderer(const char *outputbase);
+
+protected:
+  bool AddImageHandler(TessBaseAPI *api) override;
+};
+
+/**
+ * Renders tesseract output into an hocr text string
+ */
+class TESS_API TessHOcrRenderer : public TessResultRenderer {
+public:
+  explicit TessHOcrRenderer(const char *outputbase, bool font_info);
+  explicit TessHOcrRenderer(const char *outputbase);
+
+protected:
+  bool BeginDocumentHandler() override;
+  bool AddImageHandler(TessBaseAPI *api) override;
+  bool EndDocumentHandler() override;
+
+private:
+  bool font_info_; // whether to print font information
+};
+
+/**
+ * Renders tesseract output into an alto text string
+ */
+class TESS_API TessAltoRenderer : public TessResultRenderer {
+public:
+  explicit TessAltoRenderer(const char *outputbase);
+
+protected:
+  bool BeginDocumentHandler() override;
+  bool AddImageHandler(TessBaseAPI *api) override;
+  bool EndDocumentHandler() override;
+
+private:
+  bool begin_document;
+};
+
+/**
+ * Renders Tesseract output into a TSV string
+ */
+class TESS_API TessTsvRenderer : public TessResultRenderer {
+public:
+  explicit TessTsvRenderer(const char *outputbase, bool font_info);
+  explicit TessTsvRenderer(const char *outputbase);
+
+protected:
+  bool BeginDocumentHandler() override;
+  bool AddImageHandler(TessBaseAPI *api) override;
+  bool EndDocumentHandler() override;
+
+private:
+  bool font_info_; // whether to print font information
+};
+
+/**
+ * Renders tesseract output into searchable PDF
+ */
+class TESS_API TessPDFRenderer : public TessResultRenderer {
+public:
+  // datadir is the location of the TESSDATA. We need it because
+  // we load a custom PDF font from this location.
+  TessPDFRenderer(const char *outputbase, const char *datadir,
+                  bool textonly = false);
+
+protected:
+  bool BeginDocumentHandler() override;
+  bool AddImageHandler(TessBaseAPI *api) override;
+  bool EndDocumentHandler() override;
+
+private:
+  // We don't want to have every image in memory at once,
+  // so we store some metadata as we go along producing
+  // PDFs one page at a time. At the end, that metadata is
+  // used to make everything that isn't easily handled in a
+  // streaming fashion.
+  long int obj_;                  // counter for PDF objects
+  std::vector<uint64_t> offsets_; // offset of every PDF object in bytes
+  std::vector<long int> pages_;   // object number for every /Page object
+  std::string datadir_;           // where to find the custom font
+  bool textonly_;                 // skip images if set
+  // Bookkeeping only. DIY = Do It Yourself.
+  void AppendPDFObjectDIY(size_t objectsize);
+  // Bookkeeping + emit data.
+  void AppendPDFObject(const char *data);
+  // Create the /Contents object for an entire page.
+  char *GetPDFTextObjects(TessBaseAPI *api, double width, double height);
+  // Turn an image into a PDF object. Only transcode if we have to.
+  static bool imageToPDFObj(Pix *pix, const char *filename, long int objnum,
+                            char **pdf_object, long int *pdf_object_size,
+                            int jpg_quality);
+};
+
+/**
+ * Renders tesseract output into a plain UTF-8 text string
+ */
+class TESS_API TessUnlvRenderer : public TessResultRenderer {
+public:
+  explicit TessUnlvRenderer(const char *outputbase);
+
+protected:
+  bool AddImageHandler(TessBaseAPI *api) override;
+};
+
+/**
+ * Renders tesseract output into a plain UTF-8 text string for LSTMBox
+ */
+class TESS_API TessLSTMBoxRenderer : public TessResultRenderer {
+public:
+  explicit TessLSTMBoxRenderer(const char *outputbase);
+
+protected:
+  bool AddImageHandler(TessBaseAPI *api) override;
+};
+
+/**
+ * Renders tesseract output into a plain UTF-8 text string
+ */
+class TESS_API TessBoxTextRenderer : public TessResultRenderer {
+public:
+  explicit TessBoxTextRenderer(const char *outputbase);
+
+protected:
+  bool AddImageHandler(TessBaseAPI *api) override;
+};
+
+/**
+ * Renders tesseract output into a plain UTF-8 text string in WordStr format
+ */
+class TESS_API TessWordStrBoxRenderer : public TessResultRenderer {
+public:
+  explicit TessWordStrBoxRenderer(const char *outputbase);
+
+protected:
+  bool AddImageHandler(TessBaseAPI *api) override;
+};
+
+#ifndef DISABLED_LEGACY_ENGINE
+
+/**
+ * Renders tesseract output into an osd text string
+ */
+class TESS_API TessOsdRenderer : public TessResultRenderer {
+public:
+  explicit TessOsdRenderer(const char *outputbase);
+
+protected:
+  bool AddImageHandler(TessBaseAPI *api) override;
+};
+
+#endif // ndef DISABLED_LEGACY_ENGINE
+
+} // namespace tesseract.
+
+#endif // TESSERACT_API_RENDERER_H_

src/windows/tesseract/include/tesseract/resultiterator.h

@@ -0,0 +1,250 @@
+// SPDX-License-Identifier: Apache-2.0
+// File:        resultiterator.h
+// Description: Iterator for tesseract results that is capable of
+//              iterating in proper reading order over Bi Directional
+//              (e.g. mixed Hebrew and English) text.
+// Author:      David Eger
+//
+// (C) Copyright 2011, Google Inc.
+// Licensed 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.
+
+#ifndef TESSERACT_CCMAIN_RESULT_ITERATOR_H_
+#define TESSERACT_CCMAIN_RESULT_ITERATOR_H_
+
+#include "export.h"            // for TESS_API, TESS_LOCAL
+#include "ltrresultiterator.h" // for LTRResultIterator
+#include "publictypes.h"       // for PageIteratorLevel
+#include "unichar.h"           // for StrongScriptDirection
+
+#include <set>    // for std::pair
+#include <vector> // for std::vector
+
+namespace tesseract {
+
+class TESS_API ResultIterator : public LTRResultIterator {
+public:
+  static ResultIterator *StartOfParagraph(const LTRResultIterator &resit);
+
+  /**
+   * ResultIterator is copy constructible!
+   * The default copy constructor works just fine for us.
+   */
+  ~ResultIterator() override = default;
+
+  // ============= Moving around within the page ============.
+  /**
+   * Moves the iterator to point to the start of the page to begin
+   * an iteration.
+   */
+  void Begin() override;
+
+  /**
+   * Moves to the start of the next object at the given level in the
+   * page hierarchy in the appropriate reading order and returns false if
+   * the end of the page was reached.
+   * NOTE that RIL_SYMBOL will skip non-text blocks, but all other
+   * PageIteratorLevel level values will visit each non-text block once.
+   * Think of non text blocks as containing a single para, with a single line,
+   * with a single imaginary word.
+   * Calls to Next with different levels may be freely intermixed.
+   * This function iterates words in right-to-left scripts correctly, if
+   * the appropriate language has been loaded into Tesseract.
+   */
+  bool Next(PageIteratorLevel level) override;
+
+  /**
+   * IsAtBeginningOf() returns whether we're at the logical beginning of the
+   * given level.  (as opposed to ResultIterator's left-to-right top-to-bottom
+   * order).  Otherwise, this acts the same as PageIterator::IsAtBeginningOf().
+   * For a full description, see pageiterator.h
+   */
+  bool IsAtBeginningOf(PageIteratorLevel level) const override;
+
+  /**
+   * Implement PageIterator's IsAtFinalElement correctly in a BiDi context.
+   * For instance, IsAtFinalElement(RIL_PARA, RIL_WORD) returns whether we
+   * point at the last word in a paragraph.  See PageIterator for full comment.
+   */
+  bool IsAtFinalElement(PageIteratorLevel level,
+                        PageIteratorLevel element) const override;
+
+  // ============= Functions that refer to words only ============.
+  // Returns the number of blanks before the current word.
+  int BlanksBeforeWord() const;
+
+  // ============= Accessing data ==============.
+
+  /**
+   * Returns the null terminated UTF-8 encoded text string for the current
+   * object at the given level. Use delete [] to free after use.
+   */
+  virtual char *GetUTF8Text(PageIteratorLevel level) const;
+
+  /**
+   * Returns the LSTM choices for every LSTM timestep for the current word.
+   */
+  virtual std::vector<std::vector<std::vector<std::pair<const char *, float>>>>
+      *GetRawLSTMTimesteps() const;
+  virtual std::vector<std::vector<std::pair<const char *, float>>>
+      *GetBestLSTMSymbolChoices() const;
+
+  /**
+   * Return whether the current paragraph's dominant reading direction
+   * is left-to-right (as opposed to right-to-left).
+   */
+  bool ParagraphIsLtr() const;
+
+  // ============= Exposed only for testing =============.
+
+  /**
+   * Yields the reading order as a sequence of indices and (optional)
+   * meta-marks for a set of words (given left-to-right).
+   * The meta marks are passed as negative values:
+   *   kMinorRunStart  Start of minor direction text.
+   *   kMinorRunEnd    End of minor direction text.
+   *   kComplexWord    The next indexed word contains both left-to-right and
+   *                    right-to-left characters and was treated as neutral.
+   *
+   * For example, suppose we have five words in a text line,
+   * indexed [0,1,2,3,4] from the leftmost side of the text line.
+   * The following are all believable reading_orders:
+   *
+   * Left-to-Right (in ltr paragraph):
+   *     { 0, 1, 2, 3, 4 }
+   * Left-to-Right (in rtl paragraph):
+   *     { kMinorRunStart, 0, 1, 2, 3, 4, kMinorRunEnd }
+   * Right-to-Left (in rtl paragraph):
+   *     { 4, 3, 2, 1, 0 }
+   * Left-to-Right except for an RTL phrase in words 2, 3 in an ltr paragraph:
+   *     { 0, 1, kMinorRunStart, 3, 2, kMinorRunEnd, 4 }
+   */
+  static void CalculateTextlineOrder(
+      bool paragraph_is_ltr,
+      const std::vector<StrongScriptDirection> &word_dirs,
+      std::vector<int> *reading_order);
+
+  static const int kMinorRunStart;
+  static const int kMinorRunEnd;
+  static const int kComplexWord;
+
+protected:
+  /**
+   * We presume the data associated with the given iterator will outlive us.
+   * NB: This is private because it does something that is non-obvious:
+   *   it resets to the beginning of the paragraph instead of staying wherever
+   *   resit might have pointed.
+   */
+  explicit ResultIterator(const LTRResultIterator &resit);
+
+private:
+  /**
+   * Calculates the current paragraph's dominant writing direction.
+   * Typically, members should use current_paragraph_ltr_ instead.
+   */
+  bool CurrentParagraphIsLtr() const;
+
+  /**
+   * Returns word indices as measured from resit->RestartRow() = index 0
+   * for the reading order of words within a textline given an iterator
+   * into the middle of the text line.
+   * In addition to non-negative word indices, the following negative values
+   * may be inserted:
+   *   kMinorRunStart  Start of minor direction text.
+   *   kMinorRunEnd    End of minor direction text.
+   *   kComplexWord    The previous word contains both left-to-right and
+   *                   right-to-left characters and was treated as neutral.
+   */
+  void CalculateTextlineOrder(bool paragraph_is_ltr,
+                              const LTRResultIterator &resit,
+                              std::vector<int> *indices) const;
+  /** Same as above, but the caller's ssd gets filled in if ssd != nullptr. */
+  void CalculateTextlineOrder(bool paragraph_is_ltr,
+                              const LTRResultIterator &resit,
+                              std::vector<StrongScriptDirection> *ssd,
+                              std::vector<int> *indices) const;
+
+  /**
+   * What is the index of the current word in a strict left-to-right reading
+   * of the row?
+   */
+  int LTRWordIndex() const;
+
+  /**
+   * Given an iterator pointing at a word, returns the logical reading order
+   * of blob indices for the word.
+   */
+  void CalculateBlobOrder(std::vector<int> *blob_indices) const;
+
+  /** Precondition: current_paragraph_is_ltr_ is set. */
+  void MoveToLogicalStartOfTextline();
+
+  /**
+   * Precondition: current_paragraph_is_ltr_ and in_minor_direction_
+   * are set.
+   */
+  void MoveToLogicalStartOfWord();
+
+  /** Are we pointing at the final (reading order) symbol of the word? */
+  bool IsAtFinalSymbolOfWord() const;
+
+  /** Are we pointing at the first (reading order) symbol of the word? */
+  bool IsAtFirstSymbolOfWord() const;
+
+  /**
+   * Append any extra marks that should be appended to this word when printed.
+   * Mostly, these are Unicode BiDi control characters.
+   */
+  void AppendSuffixMarks(std::string *text) const;
+
+  /** Appends the current word in reading order to the given buffer.*/
+  void AppendUTF8WordText(std::string *text) const;
+
+  /**
+   * Appends the text of the current text line, *assuming this iterator is
+   * positioned at the beginning of the text line*  This function
+   * updates the iterator to point to the first position past the text line.
+   * Each textline is terminated in a single newline character.
+   * If the textline ends a paragraph, it gets a second terminal newline.
+   */
+  void IterateAndAppendUTF8TextlineText(std::string *text);
+
+  /**
+   * Appends the text of the current paragraph in reading order
+   * to the given buffer.
+   * Each textline is terminated in a single newline character, and the
+   * paragraph gets an extra newline at the end.
+   */
+  void AppendUTF8ParagraphText(std::string *text) const;
+
+  /** Returns whether the bidi_debug flag is set to at least min_level. */
+  bool BidiDebug(int min_level) const;
+
+  bool current_paragraph_is_ltr_;
+
+  /**
+   * Is the currently pointed-at character at the beginning of
+   * a minor-direction run?
+   */
+  bool at_beginning_of_minor_run_;
+
+  /** Is the currently pointed-at character in a minor-direction sequence? */
+  bool in_minor_direction_;
+
+  /**
+   * Should detected inter-word spaces be preserved, or "compressed" to a single
+   * space character (default behavior).
+   */
+  bool preserve_interword_spaces_;
+};
+
+} // namespace tesseract.
+
+#endif // TESSERACT_CCMAIN_RESULT_ITERATOR_H_

src/windows/tesseract/include/tesseract/unichar.h

@@ -0,0 +1,174 @@
+// SPDX-License-Identifier: Apache-2.0
+// File:        unichar.h
+// Description: Unicode character/ligature class.
+// Author:      Ray Smith
+//
+// (C) Copyright 2006, Google Inc.
+// Licensed 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.
+
+#ifndef TESSERACT_CCUTIL_UNICHAR_H_
+#define TESSERACT_CCUTIL_UNICHAR_H_
+
+#include "export.h"
+
+#include <memory.h>
+#include <cstring>
+#include <string>
+#include <vector>
+
+namespace tesseract {
+
+// Maximum number of characters that can be stored in a UNICHAR. Must be
+// at least 4. Must not exceed 31 without changing the coding of length.
+#define UNICHAR_LEN 30
+
+// A UNICHAR_ID is the unique id of a unichar.
+using UNICHAR_ID = int;
+
+// A variable to indicate an invalid or uninitialized unichar id.
+static const int INVALID_UNICHAR_ID = -1;
+// A special unichar that corresponds to INVALID_UNICHAR_ID.
+static const char INVALID_UNICHAR[] = "__INVALID_UNICHAR__";
+
+enum StrongScriptDirection {
+  DIR_NEUTRAL = 0,       // Text contains only neutral characters.
+  DIR_LEFT_TO_RIGHT = 1, // Text contains no Right-to-Left characters.
+  DIR_RIGHT_TO_LEFT = 2, // Text contains no Left-to-Right characters.
+  DIR_MIX = 3,           // Text contains a mixture of left-to-right
+                         // and right-to-left characters.
+};
+
+using char32 = signed int;
+
+// The UNICHAR class holds a single classification result. This may be
+// a single Unicode character (stored as between 1 and 4 utf8 bytes) or
+// multiple Unicode characters representing the NFKC expansion of a ligature
+// such as fi, ffl etc. These are also stored as utf8.
+class TESS_API UNICHAR {
+public:
+  UNICHAR() {
+    memset(chars, 0, UNICHAR_LEN);
+  }
+
+  // Construct from a utf8 string. If len<0 then the string is null terminated.
+  // If the string is too long to fit in the UNICHAR then it takes only what
+  // will fit.
+  UNICHAR(const char *utf8_str, int len);
+
+  // Construct from a single UCS4 character.
+  explicit UNICHAR(int unicode);
+
+  // Default copy constructor and operator= are OK.
+
+  // Get the first character as UCS-4.
+  int first_uni() const;
+
+  // Get the length of the UTF8 string.
+  int utf8_len() const {
+    int len = chars[UNICHAR_LEN - 1];
+    return len >= 0 && len < UNICHAR_LEN ? len : UNICHAR_LEN;
+  }
+
+  // Get a UTF8 string, but NOT nullptr terminated.
+  const char *utf8() const {
+    return chars;
+  }
+
+  // Get a terminated UTF8 string: Must delete[] it after use.
+  char *utf8_str() const;
+
+  // Get the number of bytes in the first character of the given utf8 string.
+  static int utf8_step(const char *utf8_str);
+
+  // A class to simplify iterating over and accessing elements of a UTF8
+  // string. Note that unlike the UNICHAR class, const_iterator does NOT COPY or
+  // take ownership of the underlying byte array. It also does not permit
+  // modification of the array (as the name suggests).
+  //
+  // Example:
+  //   for (UNICHAR::const_iterator it = UNICHAR::begin(str, str_len);
+  //        it != UNICHAR::end(str, len);
+  //        ++it) {
+  //     printf("UCS-4 symbol code = %d\n", *it);
+  //     char buf[5];
+  //     int char_len = it.get_utf8(buf); buf[char_len] = '\0';
+  //     printf("Char = %s\n", buf);
+  //   }
+  class TESS_API const_iterator {
+    using CI = const_iterator;
+
+  public:
+    // Step to the next UTF8 character.
+    // If the current position is at an illegal UTF8 character, then print an
+    // error message and step by one byte. If the current position is at a
+    // nullptr value, don't step past it.
+    const_iterator &operator++();
+
+    // Return the UCS-4 value at the current position.
+    // If the current position is at an illegal UTF8 value, return a single
+    // space character.
+    int operator*() const;
+
+    // Store the UTF-8 encoding of the current codepoint into buf, which must be
+    // at least 4 bytes long. Return the number of bytes written.
+    // If the current position is at an illegal UTF8 value, writes a single
+    // space character and returns 1.
+    // Note that this method does not null-terminate the buffer.
+    int get_utf8(char *buf) const;
+    // Returns the number of bytes of the current codepoint. Returns 1 if the
+    // current position is at an illegal UTF8 value.
+    int utf8_len() const;
+    // Returns true if the UTF-8 encoding at the current position is legal.
+    bool is_legal() const;
+
+    // Return the pointer into the string at the current position.
+    const char *utf8_data() const {
+      return it_;
+    }
+
+    // Iterator equality operators.
+    friend bool operator==(const CI &lhs, const CI &rhs) {
+      return lhs.it_ == rhs.it_;
+    }
+    friend bool operator!=(const CI &lhs, const CI &rhs) {
+      return !(lhs == rhs);
+    }
+
+  private:
+    friend class UNICHAR;
+    explicit const_iterator(const char *it) : it_(it) {}
+
+    const char *it_; // Pointer into the string.
+  };
+
+  // Create a start/end iterator pointing to a string. Note that these methods
+  // are static and do NOT create a copy or take ownership of the underlying
+  // array.
+  static const_iterator begin(const char *utf8_str, int byte_length);
+  static const_iterator end(const char *utf8_str, int byte_length);
+
+  // Converts a utf-8 string to a vector of unicodes.
+  // Returns an empty vector if the input contains invalid UTF-8.
+  static std::vector<char32> UTF8ToUTF32(const char *utf8_str);
+  // Converts a vector of unicodes to a utf8 string.
+  // Returns an empty string if the input contains an invalid unicode.
+  static std::string UTF32ToUTF8(const std::vector<char32> &str32);
+
+private:
+  // A UTF-8 representation of 1 or more Unicode characters.
+  // The last element (chars[UNICHAR_LEN - 1]) is a length if
+  // its value < UNICHAR_LEN, otherwise it is a genuine character.
+  char chars[UNICHAR_LEN]{};
+};
+
+} // namespace tesseract
+
+#endif // TESSERACT_CCUTIL_UNICHAR_H_

src/windows/tesseract/include/tesseract/version.h

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: Apache-2.0
+// File:        version.h
+// Description: Version information
+//
+// (C) Copyright 2018, Google Inc.
+// Licensed 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.
+
+#ifndef TESSERACT_API_VERSION_H_
+#define TESSERACT_API_VERSION_H_
+
+// clang-format off
+
+#define TESSERACT_MAJOR_VERSION 5
+#define TESSERACT_MINOR_VERSION 3
+#define TESSERACT_MICRO_VERSION 0
+
+#define TESSERACT_VERSION          \
+  (TESSERACT_MAJOR_VERSION << 16 | \
+   TESSERACT_MINOR_VERSION <<  8 | \
+   TESSERACT_MICRO_VERSION)
+
+#define TESSERACT_VERSION_STR "5.3.0"
+
+// clang-format on
+
+#endif // TESSERACT_API_VERSION_H_

src/windows/tesseract/lib/pkgconfig/tesseract.pc

@@ -0,0 +1,16 @@
+prefix=/mingw64
+exec_prefix=${prefix}
+bindir=${exec_prefix}/bin
+datarootdir = ${prefix}/share
+datadir=${datarootdir}
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include
+
+Name: tesseract
+Description: An OCR Engine that was developed at HP Labs between 1985 and 1995... and now at Google.
+URL: https://github.com/tesseract-ocr/tesseract
+Version: 5.3.0
+Requires.private: lept
+Libs: -L${libdir} -ltesseract -larchive -lcurl 
+Libs.private: -lpthread 
+Cflags: -I${includedir}

tst/Devices/Schwinn170Bike/schwinn170biketestdata.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "Devices/bluetoothdevicetestdata.h"
+#include "schwinn170bike.h"
+
+class Schwinn170BikeTestData : public BluetoothDeviceTestData {
+
+public:
+    Schwinn170BikeTestData() : BluetoothDeviceTestData("Schwinn 170 Bike") {
+
+        this->addDeviceName("SCHWINN 170/270", comparison::StartsWithIgnoreCase);
+    }
+
+
+    deviceType get_expectedDeviceType() const override { return deviceType::Schwinn170Bike; }
+
+    bool get_isExpectedDevice(bluetoothdevice * detectedDevice) const override {
+        return dynamic_cast<schwinn170bike*>(detectedDevice)!=nullptr;
+    }
+};
+

tst/Devices/bluetoothdevicetestdata.h

@@ -62,6 +62,7 @@ enum deviceType {
     EchelonRower,
     EchelonConnectSport,
     SchwinnIC4Bike,
+    Schwinn170Bike,
     SportsTechBike,
     SportsPlusBike,
     YesoulBike,

tst/Devices/devices.h

@@ -64,6 +64,7 @@
 #include "RenphoBike/renphobiketestdata.h"
 #include "Rower/rowertestdata.h"
 #include "SchwinnIC4Bike/schwinnic4biketestdata.h"
+#include "Schwinn170Bike/schwinn170biketestdata.h"
 #include "Shuaa5Treadmill/shuaa5treadmilltestdata.h"
 #include "SkandikaWiryBike/skandikawirybiketestdata.h"
 #include "SmartRowRower/smartrowrowertestdata.h"
@@ -155,6 +156,7 @@ ProFormWiFiTreadmillTestData,
 RenphoBike1TestData,
 RenphoBike2TestData,
 RowerTestData,
+Schwinn170BikeTestData,
 SchwinnIC4BikeTestData,
 Shuaa5TreadmillTestData,
 SkandikaWiryBikeTestData,

tst/qdomyos-zwift-tests.pro

@@ -98,6 +98,7 @@ HEADERS += \
     Devices/ProFormWiFiTreadmill/proformwifitreadmilltestdata.h \
     Devices/RenphoBike/renphobiketestdata.h \
     Devices/Rower/rowertestdata.h \
+    Devices/Schwinn170Bike/schwinn170biketestdata.h \
     Devices/SchwinnIC4Bike/schwinnic4biketestdata.h \
     Devices/Shuaa5Treadmill/shuaa5treadmilltestdata.h \
     Devices/SkandikaWiryBike/skandikawirybiketestdata.h \