v.3.3.0 (#16)

* Updated submodule to match upstream

* Cleanup algorithm src files

* update test package and github test

* troubleshoot tests noot running

* typo in github actions

* errors in github action

* remove latest from test

* update workflow

* edit workflow

* update workflow

* workflow

* Skip points outside the raster bounds in submodule

* update tests

* introduce postProcess to handle layers

* update tests for impactmap

* bump version

* update metadata

* bump version

* update typo in metadata

* enable on qgis-qt6

* Chore: Fix qgs minimum version to support qgis4 and qt6

* chore: update metadata to reflect new version bump

* chore: update github workflow

* chore: update docker tags

* Update test_plugin.yml

chore: update workflow

* Update test_plugin.yml

Chore: delete obsolete commands

* Update test_plugin.yml

chore: fixing workflow

* Update test_plugin.yml

chore: update workflow

* Update test_plugin.yml

chore: update test runner path

* Update test_plugin.yml

chore: change test workflow

* Update test_plugin.yml

chore: update paths in test workflow

* Update test_plugin.yml

fix: fix config for testing

* Create conftest.py

fix: add conftest

* Update test_plugin.yml

fix: formatting errors

* Update conftest.py

fix: error in pytest_qgis

* Update test_plugin.yml

* Update test_plugin.yml

* Update test_plugin.yml

* chore: tidi up test requirements

* feature: Create atlas coverage along centerline

* fix: import error

* chore: Update readme and add example image

* chore: add centerline to testdata

* chore: add setup bootstrap

* fix: bug in the setup process

* Add tests for Create Atlas Coverage algorithm (#14)

* fix: Typo when doing \n in a help string

* Centralize plugin version metadata (#15)

* Add pyproject version metadata and sync tooling

* Improve plugin version resolution

* Chore: update versioning and metadata

---------

Co-authored-by: Daniel <[email protected]>

Author: danpejobo

.github/workflows/test_plugin.yml

@@ -8,20 +8,20 @@ on:
     paths:
     - "geovita_processing_plugin/**"
     - ".github/workflows/test_plugin.yml"
+    - "conftest.py"
   pull_request:
     branches:
       - main
       - dev
     paths:
     - "geovita_processing_plugin/**"
     - ".github/workflows/test_plugin.yml"
+    - "conftest.py"
   workflow_dispatch:
 
 env:
   # plugin name/directory where the code for the plugin is stored
   PLUGIN_NAME: geovita_processing_plugin
-  # python notation to test running inside plugin
-  TESTS_RUN_FUNCTION: geovita_processing_plugin.test_suite.test_package
   # Docker settings
   DOCKER_IMAGE: qgis/qgis
 
@@ -33,7 +33,7 @@ jobs:
 
     strategy:
       matrix:
-        docker_tags: [release-3_28, release-3_36]
+        docker_tags: [3.36, 3.44.4, latest]
 
     steps:
 
@@ -49,11 +49,12 @@ jobs:
 
       - name: Docker set up QGIS
         run: |
-          docker exec qgis-testing-environment sh -c "qgis_setup.sh $PLUGIN_NAME"
-          docker exec qgis-testing-environment sh -c "cat /root/.local/share/QGIS/QGIS3/profiles/default/QGIS/QGIS3.ini"
+          docker exec qgis-testing-environment sh -c "mkdir -p /root/.local/share/QGIS/QGIS3/profiles/default/python/plugins/"
           docker exec qgis-testing-environment sh -c "rm -f /root/.local/share/QGIS/QGIS3/profiles/default/python/plugins/$PLUGIN_NAME"
           docker exec qgis-testing-environment sh -c "ln -s /tests_directory/$PLUGIN_NAME /root/.local/share/QGIS/QGIS3/profiles/default/python/plugins/$PLUGIN_NAME"
-          docker exec qgis-testing-environment sh -c "pip3 install -r /tests_directory/REQUIREMENTS_TESTING.txt"
+          
+          # ENDRING HER: Lagt til 'pytest-qgis' eksplisitt for å være sikker
+          docker exec qgis-testing-environment sh -c "pip3 install --break-system-packages -r /tests_directory/REQUIREMENTS_TESTING.txt"
           
           docker exec qgis-testing-environment sh -c "ls -l /root/.local/share/QGIS/QGIS3/profiles/default/python/plugins/"
           docker exec qgis-testing-environment sh -c "ls -l /root/.local/share/QGIS/QGIS3/profiles/default/python/plugins/$PLUGIN_NAME"
@@ -63,15 +64,10 @@ jobs:
           docker exec qgis-testing-environment sh -c "touch /tests_directory/$PLUGIN_NAME/REMEDY_GIS_RiskTool/__init__.py"
           docker exec qgis-testing-environment ls -la /tests_directory/$PLUGIN_NAME/REMEDY_GIS_RiskTool  
   
-      - name: Install and start Xvfb inside Docker container
-        run: |
-          docker exec qgis-testing-environment apt update
-          docker exec qgis-testing-environment apt install -y xvfb
-          docker exec qgis-testing-environment Xvfb :99 -screen 0 1024x768x24 &
-
       - name: Docker run plugin tests
         run: |
-          docker exec qgis-testing-environment sh -c "export DISPLAY=:99; qgis_testrunner.sh $TESTS_RUN_FUNCTION"
+          # ENDRING HER: Kjører 'python3 -m pytest' for å sikre riktig miljø
+          docker exec qgis-testing-environment sh -c "cd /tests_directory && xvfb-run python3 -m pytest"
 
   Check-code-quality:
     runs-on: ubuntu-latest
@@ -95,4 +91,4 @@ jobs:
         run: make pylint
 
       - name: Pycodestyle
-        run: make pycodestyle
+        run: make pycodestyle

README.md

@@ -15,21 +15,36 @@ QGIS Plugin
 
 This provider functions as a QGIS plugin (for QGIS >= 3.28) and is available via the standard QGIS plugins repository, so you can install it directly from within QGIS itself.
 
-The plugin adds a new group to the Processing Toolbox for "Geovita", containing sub-groups with tools and algorithms to perform different geotechnical tasks.
+The plugin adds a new group to the Processing Toolbox for "Geovita", containing sub-groups with tools and algorithms to perform different tasks.
 
 If you enconter bugs of any sort, PLEASE consider reporting them through [the bugtracker at GitHub](https://github.com/danpejobo/geovita_processing_plugin/issues). Everyone benefits!
 
 Check it out [here!](/geovita_processing_plugin/)
 
 Overview
 ========
-- Implemented [REMEDY GIS RiskTool](https://github.com/norwegian-geotechnical-institute/REMEDY_GIS_RiskTool) to run from QGIS processing
+### REMEDY GIS RiskTool-subgroup
 
-  - REMEDY_GIS_RiskTool is an open-source GIS-based tool using the GIBV method to quantify building damage risks from deep excavation, analyzing settlements due to wall deformation and groundwater drawdown, developed under the REMEDY/Begrens Skade 2 research project (2017–2022).
+  - [REMEDY_GIS_RiskTool](https://github.com/norwegian-geotechnical-institute/REMEDY_GIS_RiskTool) is an open-source GIS-based tool using the GIBV method to quantify building damage risks from deep excavation, analyzing settlements due to wall deformation and groundwater drawdown, developed under the REMEDY/Begrens Skade 2 research project (2017–2022).
 
 ## Example results from the REMEDY GIS RiskTool
 The following images show some example results. Both the excavation and the tunnel algorithm produces results for short and/or longterm settlements, but uses different calculation methods. The impact map calculates and illustrate total settlements in the impaced soil around the excavation.
 
 | Loaded Layers | Short term | Long term | Impact map |
 |---------------|------------|-----------|------------|
 | ![Loaded layers](resources/example-short-term-layers.png) <br><br> The symbology of the loaded layers | ![Short term](resources/example-short-term.png) <br><br> Blue hatch is the excavation. Status of corners, walls and buildings | ![Long term](resources/example-long-short-term.png) <br><br> Blue hatch is the excavation. Dark background is the depth to bedrock raster used for long term settlements. | ![Impact map](resources/example-impact-map.png) <br><br> Red hatch is the excavation. The impact map for total settlements around the excavation. |
+
+---
+
+### Geovita-subgroup
+
+#### Create Atlas Coverage
+This algorithm automates the creation of a coverage layer for use with the QGIS Atlas feature, which is ideal for generating multi-page "strip maps" along a route (like a road or tunnel).
+
+The tool takes a single line (e.g., a road centerline), your desired map scale, and your paper dimensions to generate two key output layers:
+
+   - Atlas Points: A point layer where each point represents the center of a map sheet. This layer contains a crucial angle field, which is automatically calculated to ensure the "long axis" of your paper is aligned with the road.
+
+   - Atlas Coverage Polygons: A polygon layer that shows the footprint (the exact rectangular coverage) of each map sheet. This is perfect for creating an index or key map.
+
+<img src="resources\example-create-atlas-coverage.png" alt="Atlas Coverage" width="800"/>

REQUIREMENTS_TESTING.txt

@@ -3,4 +3,6 @@ deepdiff
 mock
 flake8
 pep257
-pylint
+pylint
+coverage 
+pytest-qgis

conftest.py

@@ -0,0 +1,52 @@
+import pytest
+from qgis.core import QgsApplication
+import os
+import sys
+
+# Fortell pytest at den skal laste pytest-qgis-pluginen
+pytest_plugins = "pytest_qgis"
+
+# Legg til prosjekt-roten OG submodule-mappen i sys.path
+# slik at importer som 'import geovita_processing_plugin' og 'import Utils' fungerer
+project_root = os.path.abspath(os.path.dirname(__file__))
+submodule_path = os.path.join(project_root, "geovita_processing_plugin", "REMEDY_GIS_RiskTool")
+
+sys.path.insert(0, project_root)
+sys.path.insert(0, submodule_path)
+
+@pytest.fixture(scope="session", autouse=True)
+def init_qgis_processing(qgis_app):
+    """Initialiserer QGIS Processing framework og registrerer plugin-provider."""
+    
+    print("Initializing QGIS Processing Framework...")
+    try:
+        from processing.core.Processing import Processing
+        Processing.initialize()
+        print("Processing Framework Initialized.")
+    except ImportError as e:
+        print(f"Could not import Processing: {e}")
+        pytest.skip(f"Failed to import QGIS Processing framework: {e}")
+
+    print("Registering Geovita provider...")
+    try:
+        # Nå som prosjekt-roten er i sys.path, kan vi importere den direkte
+        from geovita_processing_plugin.geovita_processing_plugin_provider import Geovita_processing_pluginProvider
+        provider = Geovita_processing_pluginProvider()
+        
+        if QgsApplication.processingRegistry().addProvider(provider):
+            print(f"Successfully added provider: {provider.id()}")
+        else:
+            print("Failed to add provider.")
+            pytest.skip("Failed to add Geovita provider")
+    except ImportError as e:
+        print(f"Could not import Geovita provider: {e}")
+        pytest.skip(f"Failed to import Geovita provider: {e}")
+
+    yield
+
+    # Nedrigging
+    print("Deinitializing Processing Framework...")
+    # Vi må sjekke om 'provider' ble definert i tilfelle importen feilet
+    if 'provider' in locals() and provider:
+        QgsApplication.processingRegistry().removeProvider(provider.id())
+    Processing.deinitialize()

geovita_processing_plugin/README.md

@@ -2,8 +2,12 @@ Introduction
 =====
 Processing providers and algorithms overview
 
-Status and Limitations
+
+REMEDY GIS RiskTool group
 =====
+---
+
+### Status and limitations
 - [REMEDY GIS RiskTool](https://github.com/norwegian-geotechnical-institute/REMEDY_GIS_RiskTool)
   - REMEDY_GIS_RiskTool is an open-source GIS-based tool using the GIBV method to quantify building damage risks from deep excavation, analyzing settlements due to wall deformation and groundwater drawdown, developed under the REMEDY/Begrens Skade 2 research project (2017–2022).
 
@@ -13,15 +17,14 @@ Status and Limitations
   - Projection of layers:
     - All layers `are reprojected on the fly` as they need the same projection
 
-Tools
-=====
+### Tools
+
 - **REMEDY GIS RiskTool** - These algorithms create a log directory in this location `%user%/Downloads/REMEDY`. For the moment this is hardcoded.
   - `Begrens Skade - Excavation` Analyzes building settlement risks in soft clays caused by deep excavation wall deformation, using the GIBV method to calculate vertical greenfield settlements based on empirical data from retaining wall behavior (developed under the REMEDY/Begrens Skade 2 project).
   - `Begrens Skade - ImpactMap` Quantifies short- and long-term consolidation settlements from groundwater drawdown during construction pit establishment, employing the GIBV method and empirical datasets to model spatiotemporal risk distribution in soft clays (part of the NFR-funded REMEDY initiative).
   - `Begrens Skade - Tunnel` Evaluates subsidence and inclination risks in buildings adjacent to tunnel excavations, leveraging the GIBV framework to predict settlements induced by tunneling activities in soft clay environments (developed through the REMEDY/Begrens Skade 2 research collaboration).
 
-Specifications
-==============
+### Specifications
 
 It is crucial to understand the limitations of the [REMEDY GIS RiskTool](https://github.com/norwegian-geotechnical-institute/REMEDY_GIS_RiskTool) calculation methods. I would highly suggest reading the paper and the manual within the REMEDY repository.
 
@@ -44,3 +47,41 @@ If you want to enable `vulnerability analysis` you will need some information on
 | D     | Wooden piles                                            | Masonry                          | Bad                    |
 | D     | Trepeler                                                | D - Murstein eller spesiell type | D - Dårlig             |
 | D     | D - På løsmasser - Punkt- og trefundamenter (banketter) | -                                | -                      |
+
+---
+
+Geovita group
+===
+
+---
+
+### `Create Atlas Coverage`
+
+This algorithm automates the creation of a coverage layer for use with the QGIS Atlas feature, which is ideal for generating multi-page "strip maps" along a route (like a road or tunnel).
+
+The tool takes a single line (e.g., a road centerline), your desired map scale, and your paper dimensions to generate two key output layers:
+
+1.  **`Atlas Points`**: A point layer where each point represents the center of a map sheet. This layer contains a crucial **`angle`** field, which is automatically calculated to ensure the "long axis" of your paper is aligned with the road.
+2.  **`Atlas Coverage Polygons`**: A polygon layer that shows the footprint (the exact rectangular coverage) of each map sheet. This is perfect for creating an index or key map.
+
+#### How to use the output:
+
+1.  In your QGIS Print Layout, open the **Atlas** panel.
+2.  Set the **Coverage layer** to the **`Atlas Points`** layer generated by this tool.
+3.  In your map item's **Item Properties**:
+    * Check **Controlled by atlas**.
+    * Set **Scale** to a **Fixed scale** (e.g., `1000` to match the tool input).
+    * Click the **Data-defined override** icon (ε) for **Rotation** and set it to the field `angle` (or `"angle" + 90` to make the road horizontal).
+
+#### Parameters:
+
+* **`Input Centerline`**: The line layer (e.g., road, rail, tunnel) to follow.
+* **`Map Scale`**: The denominator of your desired output scale (e.g., `1000` for 1:1000).
+* **`Paper Long Axis (Usable mm)`**: The *usable* length of your paper's long side (in mm). For A3 (420 mm) with 5mm margins, you would enter `410`. This side will be aligned with the road.
+* **`Paper Short Axis (Usable mm)`**: The *usable* length of your paper's short side (in mm). For A3 (297 mm) with 5mm margins, you would enter `287`.
+* **`Overlap (in meters)`**: The real-world distance you want each map sheet to overlap the previous one (e.g., `50`).
+
+#### Outputs:
+
+* **`Atlas Points`**: The point layer to use as your atlas coverage layer.
+* **`Atlas Coverage Polygons`**: The polygon footprints of each map, for use in an index map.

geovita_processing_plugin/__init__.py

@@ -26,10 +26,73 @@
 __date__ = '2024-01-17'
 __copyright__ = '(C) 2024 by DPE'
 
-__version__ = "3.2.1"
-
 import sys
+import configparser
 from pathlib import Path
+from importlib import metadata
+
+
+PACKAGE_NAME = 'geovita-processing-plugin'
+_FALLBACK_VERSION = '0.0.0'
+_PLUGIN_DIR = Path(__file__).resolve().parent
+_PYPROJECT_CANDIDATES = (
+    _PLUGIN_DIR / 'pyproject.toml',
+    _PLUGIN_DIR.parent / 'pyproject.toml',
+)
+_METADATA_FILE = _PLUGIN_DIR / 'metadata.txt'
+
+
+def _read_version_from_pyproject() -> str | None:
+    """Return the version declared in pyproject.toml if available."""
+
+    try:
+        import tomllib  # type: ignore[attr-defined]
+    except ModuleNotFoundError:  # pragma: no cover - only on Python <3.11 without tomli
+        try:
+            import tomli as tomllib  # type: ignore[no-redef]
+        except ModuleNotFoundError:
+            return None
+
+    for candidate in _PYPROJECT_CANDIDATES:
+        if not candidate.is_file():
+            continue
+        with candidate.open('rb') as fh:
+            data = tomllib.load(fh)
+        return data.get('project', {}).get('version')
+    return None
+
+
+def _read_version_from_metadata() -> str | None:
+    """Return the version declared in metadata.txt if available."""
+
+    if not _METADATA_FILE.is_file():
+        return None
+
+    parser = configparser.ConfigParser()
+    parser.optionxform = str
+    parser.read(_METADATA_FILE, encoding='utf-8')
+    try:
+        return parser.get('general', 'version')
+    except (configparser.NoSectionError, configparser.NoOptionError):
+        return None
+
+
+def _determine_version() -> str:
+    """Resolve the plugin version from packaging metadata or local files."""
+
+    try:
+        return metadata.version(PACKAGE_NAME)
+    except metadata.PackageNotFoundError:  # type: ignore[attr-defined]
+        pass
+
+    for reader in (_read_version_from_pyproject, _read_version_from_metadata):
+        version = reader()
+        if version:
+            return version
+    return _FALLBACK_VERSION
+
+
+__version__ = _determine_version()
 
 
 # noinspection PyPep8Naming