Dev

.gitignore

@@ -1,8 +1,8 @@
 *.tif
 *.tif.aux.xml
 /CMakeLists.txt.user
-/3rdparty/*
 build/
 .vscode
-unittest_tiles
+/unittests/output
 .vs
+/extern/*

CMakeLists.txt

@@ -3,6 +3,10 @@ cmake_minimum_required(VERSION 3.21)
 project(alpine-terrain-builder)
 option(ALP_UNITTESTS "include unit test targets in the buildsystem" ON)
 
+include(cmake/AddRepo.cmake)
+include(cmake/SetupCMakeProject.cmake)
+
+
 add_subdirectory(src)
 if (ALP_UNITTESTS)
     add_subdirectory(unittests)

README.md

@@ -83,4 +83,5 @@ In order to build, you need to install:
 - FreeImage
 - tbb (intel threading building blocks)
 
-sudo apt-get install libfmt-dev libglm-dev libgdal-dev catch2 libfreeimage-dev libtbb-dev
+sudo apt-get install libcgal-dev libopencv-dev libfmt-dev libglm-dev libgdal-dev catch2 libfreeimage-dev libtbb-dev libcurl4-openssl-dev 
+(libgmp-dev libmpfr-dev libeigen3-dev)

cmake/AddRepo.cmake

@@ -0,0 +1,242 @@
+#############################################################################
+# AlpineMaps.org
+# Copyright (C) 2023 Adam Celarek <family name at cg tuwien ac at>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#############################################################################
+
+find_package(Git 2.22 REQUIRED)
+
+# CMake's FetchContent caches information about the downloads / clones in the build dir.
+# Therefore it walks over the clones every time we switch the build type (release, debug, webassembly, android etc),
+# which takes forever. Moreover, it messes up changes to subprojects. This function, on the other hand, checks whether
+# we are on a branch and in that case only issues a warning. Use origin/main or similar, if you want to stay up-to-date
+# with upstream.
+
+if(NOT DEFINED _alp_add_repo_check_flag)
+    set_property(GLOBAL PROPERTY _alp_add_repo_check_flag FALSE)
+endif()
+
+function(_alp_git_checkout repo repo_dir commitish)
+    message(STATUS "[alp/git] ${repo}: Checking out ${commitish}.")
+    execute_process(
+        COMMAND ${GIT_EXECUTABLE} checkout --quiet ${commitish}
+        WORKING_DIRECTORY ${repo_dir}
+        RESULT_VARIABLE GIT_CHECKOUT_RESULT
+        ERROR_VARIABLE checkout_output
+        OUTPUT_VARIABLE checkout_output
+    )
+    if (NOT GIT_CHECKOUT_RESULT)
+        # message(STATUS "[alp/git] In ${repo}, checking out ${commitish} succeeded.")
+    else()
+        message(WARNING "[alp/git] ${repo}: Checking out ${commitish} was NOT successful: ${checkout_output}")
+    endif()
+
+    if (EXISTS "${repo_dir}/.gitmodules")
+        # init/update submodules; for shallow clones this will still be shallow because the super‑project is.
+        execute_process(
+            COMMAND ${GIT_EXECUTABLE} submodule update --init --recursive ${_ALP_SUBMODULE_UPDATE_ARGS}
+            WORKING_DIRECTORY ${repo_dir}
+            RESULT_VARIABLE GIT_SUBMODULE_RESULT
+            ERROR_VARIABLE checkout_output
+            OUTPUT_VARIABLE checkout_output
+        )
+        if(GIT_SUBMODULE_RESULT EQUAL 0)
+            # message(STATUS "[alp/git] ${repo}: Submodules updated to match ${commitish}.")
+        else()
+            message(WARNING "[alp/git] ${repo}: Submodule update failed after checking out ${commitish}: ${checkout_output}")
+        endif()
+    endif()
+endfunction()
+
+function(alp_add_git_repository name)
+    set(options DO_NOT_ADD_SUBPROJECT NOT_SYSTEM DEEP_CLONE PRIVATE_DO_NOT_CHECK_FOR_SCRIPT_UPDATES)
+    set(oneValueArgs URL COMMITISH DESTINATION_PATH)
+    set(multiValueArgs )
+    cmake_parse_arguments(PARSE_ARGV 1 PARAM "${options}" "${oneValueArgs}" "${multiValueArgs}")
+
+    # Determine whether we should do a shallow or deep clone/fetch.
+    if(PARAM_DEEP_CLONE)
+        # message(STATUS "[alp/git] Cloning ${PARAM_URL} DEEPLY to ${repo_dir}.")
+        set(_ALP_GIT_CLONE_ARGS)
+        set(_ALP_SUBMODULE_UPDATE_ARGS)
+    else()
+        # message(STATUS "[alp/git] Cloning ${PARAM_URL} SHALLOWY to ${repo_dir}.")
+        set(_ALP_GIT_CLONE_ARGS --no-checkout --depth 1 --shallow-submodules)
+        set(_ALP_SUBMODULE_UPDATE_ARGS --depth 1 --recommend-shallow)
+    endif()
+
+    get_property(_check_ran GLOBAL PROPERTY _alp_add_repo_check_flag)
+    if(NOT PARAM_PRIVATE_DO_NOT_CHECK_FOR_SCRIPT_UPDATES AND NOT _check_ran)
+        if(NOT COMMAND alp_check_for_script_updates)
+            include(${CMAKE_CURRENT_FUNCTION_LIST_DIR}/CheckForScriptUpdates.cmake)
+        endif()
+        alp_check_for_script_updates(${CMAKE_CURRENT_FUNCTION_LIST_FILE})
+        set_property(GLOBAL PROPERTY _alp_add_repo_check_flag TRUE)
+    endif()
+
+    if (NOT DEFINED ALP_EXTERN_DIR OR ALP_EXTERN_DIR STREQUAL "")
+        set(ALP_EXTERN_DIR extern)
+    endif()
+
+    set(repo_dir ${CMAKE_SOURCE_DIR}/${ALP_EXTERN_DIR}/${name})
+    set(short_repo_dir ${ALP_EXTERN_DIR}/${name})
+    if (DEFINED PARAM_DESTINATION_PATH AND NOT PARAM_DESTINATION_PATH STREQUAL "")
+        set(repo_dir ${CMAKE_SOURCE_DIR}/${PARAM_DESTINATION_PATH})
+        set(short_repo_dir ${PARAM_DESTINATION_PATH})
+    endif()
+    file(MAKE_DIRECTORY ${repo_dir})
+
+    set(${name}_SOURCE_DIR "${repo_dir}" PARENT_SCOPE)
+
+    # Detect if the requested ref looks like a remote branch (e.g. origin/main)
+    string(REGEX MATCH "^[^/]+/.+" force_fetch "${PARAM_COMMITISH}")
+
+    set(force_checkout FALSE)
+    if(NOT EXISTS "${repo_dir}/.git")
+        # Do a fresh clone
+        message(STATUS "[alp/git] ${short_repo_dir}: Cloning ${PARAM_URL} to ${repo_dir}.")
+        execute_process(
+            COMMAND ${GIT_EXECUTABLE} clone ${_ALP_GIT_CLONE_ARGS} --recurse-submodules ${PARAM_URL} ${repo_dir}
+            RESULT_VARIABLE GIT_CLONE_RESULT
+            ERROR_VARIABLE clone_output
+            OUTPUT_VARIABLE clone_output
+        )
+        if (NOT GIT_CLONE_RESULT EQUAL 0)
+            message(SEND_ERROR "[alp/git] ${short_repo_dir}: Cloning was NOT successful: ${clone_output}")
+        endif()
+        if (NOT PARAM_DEEP_CLONE)
+            # shallow clone, fetch ref and checkout
+            set(force_fetch TRUE)
+        endif()
+        set(force_checkout TRUE)
+    endif()
+
+    # Check out the correct branch:
+    # First, see if PARAM_COMMITISH is a valid local ref:
+    execute_process(
+        COMMAND ${GIT_EXECUTABLE} rev-parse --verify ${PARAM_COMMITISH}
+        WORKING_DIRECTORY ${repo_dir}
+        OUTPUT_VARIABLE GIT_COMMIT_OUTPUT
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+        RESULT_VARIABLE commit_present_result
+        ERROR_QUIET
+    )
+    if (commit_present_result EQUAL 0 AND NOT force_fetch)
+        # PARAM_COMMITISH is recognized by Git => no need to fetch
+        # (could be a tag (lightweight or annotated) or a direct commit SHA).
+        # if it's an *annotated* tag, rev-parse gives us the tag object's hash, not the commit hash.
+        # => Force resolve the actual commit object with ^{commit}:
+        execute_process(
+            COMMAND ${GIT_EXECUTABLE} rev-parse --verify ${PARAM_COMMITISH}^{commit}
+            WORKING_DIRECTORY ${repo_dir}
+            OUTPUT_VARIABLE GIT_COMMIT_OBJECT
+            OUTPUT_STRIP_TRAILING_WHITESPACE
+            RESULT_VARIABLE commit_object_result
+        )
+
+        if (commit_object_result EQUAL 0)
+            # Successfully resolved a commit object
+            set(commitish_hash "${GIT_COMMIT_OBJECT}")
+        else()
+            # Fallback if that fails (should rarely happen if it's a proper commit/tag)
+            set(commitish_hash "${GIT_COMMIT_OUTPUT}")
+        endif()
+
+        # Grab HEAD commit
+        execute_process(
+            COMMAND ${GIT_EXECUTABLE} rev-parse --verify HEAD
+            WORKING_DIRECTORY ${repo_dir}
+            OUTPUT_VARIABLE git_head_hash
+            OUTPUT_STRIP_TRAILING_WHITESPACE
+        )
+
+        if (git_head_hash STREQUAL commitish_hash AND NOT force_checkout)
+            message(STATUS "[alp/git] ${short_repo_dir}: Already at ${PARAM_COMMITISH}. Skipping checkout.")
+        else()
+            _alp_git_checkout(${short_repo_dir} ${repo_dir} ${PARAM_COMMITISH})
+        endif()
+    else()
+        # either remote branch or commitish not recognised
+        message(STATUS "[alp/git] ${short_repo_dir}: Fetching updates.")
+
+        if(PARAM_DEEP_CLONE)
+            # Original deep‑clone logic: fetch everything (incl. all tags) deeply.
+            # message(STATUS "[alp/git] Deep clone, fetching all.")
+            execute_process(
+                COMMAND ${GIT_EXECUTABLE} fetch origin --tags
+                WORKING_DIRECTORY ${repo_dir}
+                RESULT_VARIABLE fetch_result
+                OUTPUT_QUIET
+                ERROR_QUIET
+            )
+        else()
+            # ── Shallow path ─────────────────────────
+            # 1. Try to fetch COMMITISH as a tag
+            # message(STATUS "[alp/git] Shallow clone, trying to fetch tag ${PARAM_COMMITISH}.")
+            execute_process(
+                COMMAND ${GIT_EXECUTABLE} fetch origin tag ${PARAM_COMMITISH} --depth 1
+                WORKING_DIRECTORY ${repo_dir}
+                RESULT_VARIABLE fetch_result
+                OUTPUT_QUIET
+                ERROR_QUIET
+            )
+
+            # 2. If that failed, try it as branch‑name or raw hash
+            if(NOT fetch_result EQUAL 0)
+                # message(STATUS "[alp/git] Shallow clone, failed to fetch tag ${PARAM_COMMITISH}. Probably it is a branch or hash. Trying again..")
+                set(_FETCH_REF "${PARAM_COMMITISH}")
+                string(REGEX REPLACE "^origin/(.+)" "\\1" _FETCH_REF "${_FETCH_REF}")
+                execute_process(
+                    COMMAND ${GIT_EXECUTABLE} fetch origin ${_FETCH_REF} --depth 1
+                    WORKING_DIRECTORY ${repo_dir}
+                    RESULT_VARIABLE fetch_result
+                    OUTPUT_QUIET
+                    ERROR_QUIET
+                )
+            endif()
+        endif()
+
+        if (fetch_result EQUAL 0)
+            # message(STATUS "[alp/git] Fetch successful for ${short_repo_dir}.")
+            execute_process(
+                COMMAND ${GIT_EXECUTABLE} branch --show-current
+                WORKING_DIRECTORY ${repo_dir}
+                OUTPUT_STRIP_TRAILING_WHITESPACE
+                OUTPUT_VARIABLE current_branch
+                RESULT_VARIABLE branch_result
+            )
+            if (NOT branch_result EQUAL 0)
+                message(FATAL_ERROR "[alp/git] ${short_repo_dir}: git branch --show-current failed")
+            endif()
+
+            if (current_branch STREQUAL "" OR force_checkout)
+                # not on a branch. that's what we usually have (detached head state)
+                _alp_git_checkout(${short_repo_dir} ${repo_dir} ${PARAM_COMMITISH})
+            else()
+                message(WARNING "[alp/git] ${short_repo_dir}: On branch ${current_branch}, leaving it there. NOT checking out ${PARAM_COMMITISH}! Use origin/main or similar if you want to stay up‑to‑date with upstream.")
+            endif()
+        else()
+            message(WARNING "[alp/git] ${short_repo_dir}: Unable to fetch updates for; ${PARAM_COMMITISH} not found locally or is a remote branch.")
+        endif()
+    endif()
+
+    if (NOT PARAM_DO_NOT_ADD_SUBPROJECT)
+        if (NOT PARAM_NOT_SYSTEM)
+            add_subdirectory(${repo_dir} ${CMAKE_BINARY_DIR}/alp_external/${name} SYSTEM)
+        else()
+            add_subdirectory(${repo_dir} ${CMAKE_BINARY_DIR}/alp_external/${name})
+        endif()
+    endif()
+endfunction()

cmake/CheckForScriptUpdates.cmake

@@ -0,0 +1,76 @@
+#############################################################################
+# AlpineMaps.org
+# Copyright (C) 2025 Adam Celarek <family name at cg tuwien ac at>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#############################################################################
+
+include_guard(GLOBAL)
+
+
+# Function to check if a local CMake script specified by file_path
+# differs from the version in the central AlpineMapsOrg/cmake_scripts repository.
+#
+# Arguments:
+#   file_path: Path to the CMake script
+
+
+if(NOT COMMAND alp_add_git_repository)
+    include(${CMAKE_CURRENT_LIST_DIR}/AddRepo.cmake)
+endif()
+
+if(NOT DEFINED _alp_check_for_script_updates_repo_flag)
+    set_property(GLOBAL PROPERTY _alp_check_for_script_updates_repo_flag FALSE)
+endif()
+
+function(alp_check_for_script_updates script_path)
+    get_filename_component(script_name "${script_path}" NAME)
+
+    get_property(_repo_done GLOBAL PROPERTY _alp_check_for_script_updates_repo_flag)
+    if(_repo_done)
+        get_property(cmake_scripts_SOURCE_DIR GLOBAL PROPERTY _alp_check_for_script_updates_script_repo)
+    else()
+        alp_add_git_repository(cmake_scripts
+                               URL "https://github.com/AlpineMapsOrg/cmake_scripts.git"
+                               COMMITISH origin/main
+                               DO_NOT_ADD_SUBPROJECT PRIVATE_DO_NOT_CHECK_FOR_SCRIPT_UPDATES)
+        set_property(GLOBAL PROPERTY _alp_check_for_script_updates_repo_flag TRUE)
+        set_property(GLOBAL PROPERTY _alp_check_for_script_updates_script_repo ${cmake_scripts_SOURCE_DIR})
+    endif()
+
+    set(external_script_path "${cmake_scripts_SOURCE_DIR}/${script_name}")
+    get_filename_component(absolute_script_path "${script_path}" REALPATH)
+
+    if(NOT EXISTS "${absolute_script_path}")
+        message(WARNING "alp_check_for_cmake_script_updates: Local script '${script_path}' (${absolute_script_path}) does not exist. Cannot compare.")
+        return()
+    endif()
+
+    if(NOT EXISTS "${external_script_path}")
+        message(WARNING "alp_check_for_cmake_script_updates: Corresponding external script '${external_script_path}' does not exist in the 'cmake_scripts' repository. Cannot compare.")
+        return()
+    endif()
+
+    file(READ "${script_path}" local_content)
+    file(READ "${external_script_path}" external_content)
+
+    if(NOT local_content STREQUAL external_content)
+        message(WARNING "alp_check_for_cmake_script_updates: The local script '${script_path}' has different content compared to the version in the central 'cmake_scripts' repository ('${external_script_path}'). Consider updating the local file or the repository.")
+    else()
+        message(STATUS "alp_check_for_cmake_script_updates: Local script '${script_path}' is up-to-date.")
+    endif()
+endfunction()
+
+alp_check_for_script_updates("${CMAKE_CURRENT_LIST_FILE}")
+