Merge branch 'github-actions' into dev

.github/workflows/jobs.yml

+name: CI/CD Pipeline
+
+on:
+  push:
+    branches:
+      - main, dev
+  pull_request:
+    branches:
+      - main, dev
+
+jobs:
+  build:
+    name: ${{ matrix.os }}, Python 3.${{ matrix.python-minor-version }}, QGIS 3.${{ matrix.qgis-minor-version }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      max-parallel: 6
+      matrix:
+        ## Windows automatic testing is not functionnig yet
+        os: [ubuntu-latest , macos-latest]
+        # os: [ubuntu-latest , macos-latest , windows-latest]
+        python-minor-version: [11, 12]
+        qgis-minor-version: [34, 36, 38]
+          
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v3
+
+    - name: Set up Miniconda
+      uses: conda-incubator/setup-miniconda@v3
+      with:
+        python-version: 3.${{ matrix.python-minor-version }}
+        channels: conda-forge
+        auto-update-conda: true
+
+    - name: Set up Environment and Install Dependencies
+      run: |
+        conda create -n pytest python=3.${{ matrix.python-minor-version }} qgis=3.${{ matrix.qgis-minor-version }} --yes
+        conda install -n pytest --file requirements.txt --yes
+        conda install -n pytest pytest --yes
+      shell: bash -el {0}
+
+    - name: Run Tests
+      run: |
+        conda run -n pytest pytest tests/
+      shell: bash -el {0}

__init__.py

@@ -3,16 +3,24 @@ import inspect
 
 cmd_folder = os.path.split(inspect.getfile(inspect.currentframe()))[0]
 
+
 def classFactory(iface):
     from .dialogs.check_gpu import has_gpu
     from .dialogs.packages_installer import packages_installer_dialog
+
     device = has_gpu()
-    packages_installed_allready = packages_installer_dialog.check_required_packages_and_install_if_necessary(iface=iface, device=device)
+    packages_installed_allready = (
+        packages_installer_dialog.check_required_packages_and_install_if_necessary(
+            iface=iface, device=device
+        )
+    )
     # packages_installer_dialog.check_required_packages_and_install_if_necessary(iface=iface)
     if packages_installed_allready:
         from .iamap import IAMap
+
         return IAMap(iface, cmd_folder)
 
     else:
         from .dialogs.packages_installer.packages_installer_dialog import IAMapEmpty
+
         return IAMapEmpty(iface, cmd_folder)

clustering.py

@@ -3,17 +3,18 @@ from qgis.PyQt.QtCore import QCoreApplication
 from .utils.algo import SKAlgorithm
 from .icons import QIcon_ClusterTool
 
+
 class ClusterAlgorithm(SKAlgorithm):
-    """
-    """
-    TYPE = 'cluster'
-    TMP_DIR = 'iamap_cluster'
+    """ """
+
+    TYPE = "cluster"
+    TMP_DIR = "iamap_cluster"
 
     def tr(self, string):
         """
         Returns a translatable string with the self.tr() function.
         """
-        return QCoreApplication.translate('Processing', string)
+        return QCoreApplication.translate("Processing", string)
 
     def createInstance(self):
         return ClusterAlgorithm()
@@ -26,21 +27,21 @@ class ClusterAlgorithm(SKAlgorithm):
         lowercase alphanumeric characters only and no spaces or other
         formatting characters.
         """
-        return 'cluster'
+        return "cluster"
 
     def displayName(self):
         """
         Returns the translated algorithm name, which should be used for any
         user-visible display of the algorithm name.
         """
-        return self.tr('Clustering')
+        return self.tr("Clustering")
 
     def group(self):
         """
         Returns the name of the group this algorithm belongs to. This string
         should be localised.
         """
-        return self.tr('')
+        return self.tr("")
 
     def groupId(self):
         """
@@ -50,7 +51,7 @@ class ClusterAlgorithm(SKAlgorithm):
         contain lowercase alphanumeric characters only and no spaces or other
         formatting characters.
         """
-        return ''
+        return ""
 
     def shortHelpString(self):
         """
@@ -58,7 +59,9 @@ class ClusterAlgorithm(SKAlgorithm):
         should provide a basic description about what the algorithm does and the
         parameters and outputs associated with it..
         """
-        return self.tr(f"Cluster a raster. Only KMeans is thoughfully tested. Other algorithms are implemented as is by sklearn. {self.get_help_sk_methods()}")
+        return self.tr(
+            f"Cluster a raster. Only KMeans is thoughfully tested. Other algorithms are implemented as is by sklearn. {self.get_help_sk_methods()}"
+        )
 
     def icon(self):
         return QIcon_ClusterTool

dialogs/check_gpu.py

 import subprocess
 import platform
 
+
 def check_nvidia_gpu():
     try:
         # Run the nvidia-smi command and capture the output
-        output = subprocess.check_output(["nvidia-smi", "--query-gpu=name,driver_version", "--format=csv,noheader"], stderr=subprocess.STDOUT)
+        output = subprocess.check_output(
+            ["nvidia-smi", "--query-gpu=name,driver_version", "--format=csv,noheader"],
+            stderr=subprocess.STDOUT,
+        )
         output = output.decode("utf-8").strip()
-        
+
         # Parse the output
-        gpu_info = output.split(',')
+        gpu_info = output.split(",")
         gpu_name = gpu_info[0].strip()
-        
-        output_cuda_version = subprocess.run(['nvidia-smi'], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
-        for line in output_cuda_version.stdout.split('\n'):
-            if 'CUDA Version' in line:
-                cuda_version = line.split('CUDA Version: ')[1].split()[0]
-        
+
+        output_cuda_version = subprocess.run(
+            ["nvidia-smi"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True
+        )
+        for line in output_cuda_version.stdout.split("\n"):
+            if "CUDA Version" in line:
+                cuda_version = line.split("CUDA Version: ")[1].split()[0]
+
         return True, gpu_name, cuda_version
     except (subprocess.CalledProcessError, FileNotFoundError):
         return False, None, None
 
+
 def check_amd_gpu():
     try:
         if platform.system() == "Windows":
-            output = subprocess.check_output(["wmic", "path", "win32_videocontroller", "get", "name"], universal_newlines=True)
+            output = subprocess.check_output(
+                ["wmic", "path", "win32_videocontroller", "get", "name"],
+                universal_newlines=True,
+            )
             if "AMD" in output or "Radeon" in output:
                 return True
         elif platform.system() == "Linux":
@@ -31,17 +41,20 @@ def check_amd_gpu():
             if "AMD" in output or "Radeon" in output:
                 return True
         elif platform.system() == "Darwin":
-            output = subprocess.check_output(["system_profiler", "SPDisplaysDataType"], universal_newlines=True)
+            output = subprocess.check_output(
+                ["system_profiler", "SPDisplaysDataType"], universal_newlines=True
+            )
             if "AMD" in output or "Radeon" in output:
                 return True
     except subprocess.CalledProcessError:
         return False
     return False
 
+
 def has_gpu():
     has_nvidia, gpu_name, cuda_version = check_nvidia_gpu()
     if has_nvidia:
         return cuda_version
     if check_amd_gpu():
-        return 'amd'
-    return 'cpu'
+        return "amd"
+    return "cpu"

docs/source/conf.py

@@ -5,37 +5,63 @@
 
 # -- Project information -----------------------------------------------------
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information
+import os
+import re
 
-project = 'iamap'
-copyright = '2024, TRESSON Paul, TULET Hadrien, LE COZ Pierre'
-author = 'TRESSON Paul, TULET Hadrien, LE COZ Pierre'
-release = '0.5.9'
+
+metadata_file_path = os.path.join('..', '..', 'metadata.txt')
+metadata_file_path = os.path.abspath(metadata_file_path)
+with open(metadata_file_path, 'rt') as file:
+    file_content = file.read()
+try:
+    versions_from_metadata = re.findall(r'version=(.*)', file_content)[0]
+except Exception as e:
+    raise Exception("Failed to read version from metadata!")
+
+try:
+    author_from_metadata = re.findall(r'author=(.*)', file_content)[0]
+except Exception as e:
+    raise Exception("Failed to read author from metadata!")
+
+try:
+    name_from_metadata = re.findall(r'name=(.*)', file_content)[0]
+except Exception as e:
+    raise Exception("Failed to read name from metadata!")
+
+project = "iamap"
+copyright = "2024, TRESSON Paul, TULET Hadrien, LE COZ Pierre"
+author = author_from_metadata
+# The short X.Y version
+version = versions_from_metadata
+# The full version, including alpha/beta/rc tags
+release = version
 
 # -- General configuration ---------------------------------------------------
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration
 
-import pydata_sphinx_theme
+
+
+
 
 extensions = [
-    'sphinx.ext.autodoc',
-    'sphinx.ext.autosummary',
+    "sphinx.ext.autodoc",
+    "sphinx.ext.autosummary",
     "myst_parser",
     "sphinx_favicon",
 ]
 
-templates_path = ['_templates']
+templates_path = ["_templates"]
 exclude_patterns = []
 
 source_suffix = {
-    '.rst': 'restructuredtext',
-    '.md': 'markdown',
+    ".rst": "restructuredtext",
+    ".md": "markdown",
 }
 
 
 # -- Options for HTML output -------------------------------------------------
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output
 
-html_theme = 'pydata_sphinx_theme'
-html_static_path = ['_static']
+html_theme = "pydata_sphinx_theme"
+html_static_path = ["_static"]
 html_favicon = "./../../icons/favicon.svg"
-

iamap.py

 import processing
-from PyQt5.QtWidgets import (
-    QAction,
-    QToolBar,
-    QApplication,
-    QDialog
-)
+from PyQt5.QtWidgets import QAction, QToolBar
 from PyQt5.QtCore import pyqtSignal, QObject
 from qgis.core import QgsApplication
 from qgis.gui import QgisInterface
 from .provider import IAMapProvider
-from .icons import (QIcon_EncoderTool, 
-                    QIcon_ReductionTool, 
-                    QIcon_ClusterTool, 
-                    QIcon_SimilarityTool, 
-                    QIcon_RandomforestTool,
-                    )
+from .icons import (
+    QIcon_EncoderTool,
+    QIcon_ReductionTool,
+    QIcon_ClusterTool,
+    QIcon_SimilarityTool,
+    QIcon_RandomforestTool,
+)
 
 
 class IAMap(QObject):
@@ -32,34 +28,26 @@ class IAMap(QObject):
     def initGui(self):
         self.initProcessing()
 
-        self.toolbar: QToolBar = self.iface.addToolBar('IAMap Toolbar')
-        self.toolbar.setObjectName('IAMapToolbar')
-        self.toolbar.setToolTip('IAMap Toolbar')
+        self.toolbar: QToolBar = self.iface.addToolBar("IAMap Toolbar")
+        self.toolbar.setObjectName("IAMapToolbar")
+        self.toolbar.setToolTip("IAMap Toolbar")
 
         self.actionEncoder = QAction(
-            QIcon_EncoderTool,
-            "Deep Learning Image Encoder",
-            self.iface.mainWindow()
+            QIcon_EncoderTool, "Deep Learning Image Encoder", self.iface.mainWindow()
         )
         self.actionReducer = QAction(
-            QIcon_ReductionTool,
-            "Reduce dimensions",
-            self.iface.mainWindow()
+            QIcon_ReductionTool, "Reduce dimensions", self.iface.mainWindow()
         )
         self.actionCluster = QAction(
-            QIcon_ClusterTool,
-            "Cluster raster",
-            self.iface.mainWindow()
+            QIcon_ClusterTool, "Cluster raster", self.iface.mainWindow()
         )
         self.actionSimilarity = QAction(
-            QIcon_SimilarityTool,
-            "Compute similarity",
-            self.iface.mainWindow()
+            QIcon_SimilarityTool, "Compute similarity", self.iface.mainWindow()
         )
         self.actionRF = QAction(
             QIcon_RandomforestTool,
             "Fit Machine Learning algorithm",
-            self.iface.mainWindow()
+            self.iface.mainWindow(),
         )
         self.actionEncoder.setObjectName("mActionEncoder")
         self.actionReducer.setObjectName("mActionReducer")
@@ -67,16 +55,11 @@ class IAMap(QObject):
         self.actionSimilarity.setObjectName("mactionSimilarity")
         self.actionRF.setObjectName("mactionRF")
 
-        self.actionEncoder.setToolTip(
-            "Encode a raster with a deep learning backbone")
-        self.actionReducer.setToolTip(
-            "Reduce raster dimensions")
-        self.actionCluster.setToolTip(
-            "Cluster raster")
-        self.actionSimilarity.setToolTip(
-            "Compute similarity")
-        self.actionRF.setToolTip(
-            "Fit ML model")
+        self.actionEncoder.setToolTip("Encode a raster with a deep learning backbone")
+        self.actionReducer.setToolTip("Reduce raster dimensions")
+        self.actionCluster.setToolTip("Cluster raster")
+        self.actionSimilarity.setToolTip("Compute similarity")
+        self.actionRF.setToolTip("Fit ML model")
 
         self.actionEncoder.triggered.connect(self.encodeImage)
         self.actionReducer.triggered.connect(self.reduceImage)
@@ -107,119 +90,111 @@ class IAMap(QObject):
         QgsApplication.processingRegistry().removeProvider(self.provider)
 
     def encodeImage(self):
-        '''
-        '''
-        result = processing.execAlgorithmDialog('iamap:encoder', {})
+        """ """
+        result = processing.execAlgorithmDialog("iamap:encoder", {})
         print(result)
-                # Check if algorithm execution was successful
+        # Check if algorithm execution was successful
         if result:
             # Retrieve output parameters from the result dictionary
-            if 'OUTPUT_RASTER' in result:
-                output_raster_path = result['OUTPUT_RASTER']
-                output_layer_name = result['OUTPUT_LAYER_NAME']
+            if "OUTPUT_RASTER" in result:
+                output_raster_path = result["OUTPUT_RASTER"]
+                output_layer_name = result["OUTPUT_LAYER_NAME"]
 
                 # Add the output raster layer to the map canvas
-                self.iface.addRasterLayer(str(output_raster_path),output_layer_name)
+                self.iface.addRasterLayer(str(output_raster_path), output_layer_name)
             else:
                 # Handle missing or unexpected output
-                print('Output raster not found in algorithm result.')
+                print("Output raster not found in algorithm result.")
         else:
             # Handle algorithm execution failure or cancellation
-            print('Algorithm execution was not successful.')
+            print("Algorithm execution was not successful.")
         # processing.execAlgorithmDialog('', {})
         # self.close_all_dialogs()
 
-
     def reduceImage(self):
-        '''
-        '''
-        result = processing.execAlgorithmDialog('iamap:reduction', {})
+        """ """
+        result = processing.execAlgorithmDialog("iamap:reduction", {})
         print(result)
-                # Check if algorithm execution was successful
+        # Check if algorithm execution was successful
         if result:
             # Retrieve output parameters from the result dictionary
-            if 'OUTPUT_RASTER' in result:
-                output_raster_path = result['OUTPUT_RASTER']
-                output_layer_name = result['OUTPUT_LAYER_NAME']
+            if "OUTPUT_RASTER" in result:
+                output_raster_path = result["OUTPUT_RASTER"]
+                output_layer_name = result["OUTPUT_LAYER_NAME"]
 
                 # Add the output raster layer to the map canvas
                 self.iface.addRasterLayer(str(output_raster_path), output_layer_name)
             else:
                 # Handle missing or unexpected output
-                print('Output raster not found in algorithm result.')
+                print("Output raster not found in algorithm result.")
         else:
             # Handle algorithm execution failure or cancellation
-            print('Algorithm execution was not successful.')
+            print("Algorithm execution was not successful.")
         # processing.execAlgorithmDialog('', {})
 
-
     def clusterImage(self):
-        '''
-        '''
-        result = processing.execAlgorithmDialog('iamap:cluster', {})
+        """ """
+        result = processing.execAlgorithmDialog("iamap:cluster", {})
         print(result)
-                # Check if algorithm execution was successful
+        # Check if algorithm execution was successful
         if result:
             # Retrieve output parameters from the result dictionary
-            if 'OUTPUT_RASTER' in result:
-                output_raster_path = result['OUTPUT_RASTER']
-                output_layer_name = result['OUTPUT_LAYER_NAME']
+            if "OUTPUT_RASTER" in result:
+                output_raster_path = result["OUTPUT_RASTER"]
+                output_layer_name = result["OUTPUT_LAYER_NAME"]
 
                 # Add the output raster layer to the map canvas
                 self.iface.addRasterLayer(str(output_raster_path), output_layer_name)
             else:
                 # Handle missing or unexpected output
-                print('Output raster not found in algorithm result.')
+                print("Output raster not found in algorithm result.")
         else:
             # Handle algorithm execution failure or cancellation
-            print('Algorithm execution was not successful.')
+            print("Algorithm execution was not successful.")
         # processing.execAlgorithmDialog('', {})
 
-
     def similarityImage(self):
-        '''
-        '''
-        result = processing.execAlgorithmDialog('iamap:similarity', {})
+        """ """
+        result = processing.execAlgorithmDialog("iamap:similarity", {})
         print(result)
-                # Check if algorithm execution was successful
+        # Check if algorithm execution was successful
         if result:
             # Retrieve output parameters from the result dictionary
-            if 'OUTPUT_RASTER' in result:
-                output_raster_path = result['OUTPUT_RASTER']
-                output_layer_name = result['OUTPUT_LAYER_NAME']
-                used_shp = result['USED_SHP']
+            if "OUTPUT_RASTER" in result:
+                output_raster_path = result["OUTPUT_RASTER"]
+                output_layer_name = result["OUTPUT_LAYER_NAME"]
+                used_shp = result["USED_SHP"]
 
                 # Add the output raster layer to the map canvas
                 self.iface.addRasterLayer(str(output_raster_path), output_layer_name)
-                self.iface.addVectorLayer(str(used_shp), 'used points', "ogr")
+                self.iface.addVectorLayer(str(used_shp), "used points", "ogr")
             else:
                 # Handle missing or unexpected output
-                print('Output raster not found in algorithm result.')
+                print("Output raster not found in algorithm result.")
         else:
             # Handle algorithm execution failure or cancellation
-            print('Algorithm execution was not successful.')
+            print("Algorithm execution was not successful.")
         # processing.execAlgorithmDialog('', {})
-        
+
     def rfImage(self):
-        '''
-        '''
-        result = processing.execAlgorithmDialog('iamap:ml', {})
+        """ """
+        result = processing.execAlgorithmDialog("iamap:ml", {})
         print(result)
-                # Check if algorithm execution was successful
+        # Check if algorithm execution was successful
         if result:
             # Retrieve output parameters from the result dictionary
-            if 'OUTPUT_RASTER' in result:
-                output_raster_path = result['OUTPUT_RASTER']
-                output_layer_name = result['OUTPUT_LAYER_NAME']
-                used_shp = result['USED_SHP']
+            if "OUTPUT_RASTER" in result:
+                output_raster_path = result["OUTPUT_RASTER"]
+                output_layer_name = result["OUTPUT_LAYER_NAME"]
+                used_shp = result["USED_SHP"]
 
                 # Add the output raster layer to the map canvas
                 self.iface.addRasterLayer(str(output_raster_path), output_layer_name)
-                self.iface.addVectorLayer(str(used_shp), 'used points', "ogr")
+                self.iface.addVectorLayer(str(used_shp), "used points", "ogr")
             else:
                 # Handle missing or unexpected output
-                print('Output raster not found in algorithm result.')
+                print("Output raster not found in algorithm result.")
         else:
             # Handle algorithm execution failure or cancellation
-            print('Algorithm execution was not successful.')
+            print("Algorithm execution was not successful.")
         # processing.execAlgorithmDialog('', {})

icons/__init__.py

@@ -2,11 +2,11 @@ import os
 from PyQt5.QtGui import QIcon
 
 cwd = os.path.abspath(os.path.dirname(__file__))
-encoder_tool_path = os.path.join(cwd, 'encoder.svg')
-reduction_tool_path = os.path.join(cwd, 'proj.svg')
-cluster_tool_path = os.path.join(cwd, 'cluster.svg')
-similarity_tool_path = os.path.join(cwd, 'sim.svg')
-random_forest_tool_path = os.path.join(cwd, 'forest.svg')
+encoder_tool_path = os.path.join(cwd, "encoder.svg")
+reduction_tool_path = os.path.join(cwd, "proj.svg")
+cluster_tool_path = os.path.join(cwd, "cluster.svg")
+similarity_tool_path = os.path.join(cwd, "sim.svg")
+random_forest_tool_path = os.path.join(cwd, "forest.svg")
 
 QIcon_EncoderTool = QIcon(encoder_tool_path)
 QIcon_ReductionTool = QIcon(reduction_tool_path)

metadata.txt

@@ -2,7 +2,7 @@
 name=iamap
 description=Extract and manipulate deep learning features from rasters
 about= This plugin is still a work in progress, feel free to fill an issue on github.
-version=0.5.9
+version=0.6.0
 icon=icons/favicon.svg
 qgisMinimumVersion=3.12
 author=Paul Tresson, Pierre Lecoz, Hadrien Tulet

provider.py

@@ -9,7 +9,6 @@ from .icons import QIcon_EncoderTool
 
 
 class IAMapProvider(QgsProcessingProvider):
-
     def loadAlgorithms(self, *args, **kwargs):
         self.addAlgorithm(EncoderAlgorithm())
         self.addAlgorithm(ReductionAlgorithm())
@@ -25,7 +24,7 @@ class IAMapProvider(QgsProcessingProvider):
         This string should be a unique, short, character only string,
         eg "qgis" or "gdal". This string should not be localised.
         """
-        return 'iamap'
+        return "iamap"
 
     def name(self, *args, **kwargs):
         """The human friendly name of your plugin in Processing.
@@ -33,7 +32,7 @@ class IAMapProvider(QgsProcessingProvider):
         This string should be as short as possible (e.g. "Lastools", not
         "Lastools version 1.0.1 64-bit") and localised.
         """
-        return self.tr('IAMap')
+        return self.tr("IAMap")
 
     def icon(self):
         """Should return a QIcon which is used for your provider inside
@@ -43,4 +42,3 @@ class IAMapProvider(QgsProcessingProvider):
 
     def longName(self) -> str:
         return self.name()
-

reduction.py

-import os
-import tempfile
-import numpy as np
-from pathlib import Path
-from typing import Dict, Any
-import joblib
-import pandas as pd
-import psutil
-import json
-
-
-import rasterio
-from rasterio import windows
 from qgis.PyQt.QtCore import QCoreApplication
-from qgis.core import (Qgis,
-                       QgsGeometry,
-                       QgsProcessingParameterBoolean,
-                       QgsProcessingParameterEnum,
-                       QgsCoordinateTransform,
-                       QgsProcessingException,
-                       QgsProcessingAlgorithm,
-                       QgsProcessingParameterRasterLayer,
-                       QgsProcessingParameterFolderDestination,
-                       QgsProcessingParameterBand,
-                       QgsProcessingParameterNumber,
-                       QgsProcessingParameterExtent,
-                       QgsProcessingParameterCrs,
-                       QgsProcessingParameterDefinition,
-                       )
 
 
-from sklearn.preprocessing import StandardScaler
-from sklearn.decomposition import PCA, IncrementalPCA
-from sklearn.cluster import KMeans
-
-from .utils.misc import get_unique_filename
 from .utils.algo import SKAlgorithm
 
 from .icons import QIcon_ReductionTool
-#from umap.umap_ import UMAP
-
+# from umap.umap_ import UMAP
 
 
 class ReductionAlgorithm(SKAlgorithm):
-    """
-    """
+    """ """
 
     def tr(self, string):
         """
         Returns a translatable string with the self.tr() function.
         """
-        return QCoreApplication.translate('Processing', string)
+        return QCoreApplication.translate("Processing", string)
 
     def createInstance(self):
         return ReductionAlgorithm()
@@ -62,21 +27,21 @@ class ReductionAlgorithm(SKAlgorithm):
         lowercase alphanumeric characters only and no spaces or other
         formatting characters.
         """
-        return 'reduction'
+        return "reduction"
 
     def displayName(self):
         """
         Returns the translated algorithm name, which should be used for any
         user-visible display of the algorithm name.
         """
-        return self.tr('Dimension Reduction')
+        return self.tr("Dimension Reduction")
 
     def group(self):
         """
         Returns the name of the group this algorithm belongs to. This string
         should be localised.
         """
-        return self.tr('')
+        return self.tr("")
 
     def groupId(self):
         """
@@ -86,7 +51,7 @@ class ReductionAlgorithm(SKAlgorithm):
         contain lowercase alphanumeric characters only and no spaces or other
         formatting characters.
         """
-        return ''
+        return ""
 
     def shortHelpString(self):
         """
@@ -94,7 +59,9 @@ class ReductionAlgorithm(SKAlgorithm):
         should provide a basic description about what the algorithm does and the
         parameters and outputs associated with it..
         """
-        return self.tr(f"Reduce the dimension of deep learning features. Only PCA is thoughfully tested. Other algorithms are implemented as is by sklearn. {self.get_help_sk_methods()}")
+        return self.tr(
+            f"Reduce the dimension of deep learning features. Only PCA is thoughfully tested. Other algorithms are implemented as is by sklearn. {self.get_help_sk_methods()}"
+        )
 
     def icon(self):
         return QIcon_ReductionTool

requirements-ga.txt

+geopandas >= 0.14.4
+scikit-learn >= 1.5.1
+psutil >= 5.0.0
+# from torchgeo
+rasterio >= 1.2
+rtree >= 0.9
+einops >= 0.3
+fiona >= 1.8.19
+kornia >= 0.6.9
+numpy >= 1.19.3
+pyproj >= 3.3
+shapely >= 1.7.1
+timm >= 0.4.12
+pytest

requirements.txt

@@ -6,7 +6,7 @@ psutil >= 5.0.0
 # torchgeo == 0.5.2
 # from torchgeo
 rasterio >= 1.2
-rtree <= 0.9
+rtree >= 1
 einops >= 0.3
 fiona >= 1.8.19
 kornia >= 0.6.9

similarity.py

@@ -3,14 +3,12 @@ from .utils.algo import SHPAlgorithm
 from .icons import QIcon_SimilarityTool
 
 
-
 class SimilarityAlgorithm(SHPAlgorithm):
-
     def tr(self, string):
         """
         Returns a translatable string with the self.tr() function.
         """
-        return QCoreApplication.translate('Processing', string)
+        return QCoreApplication.translate("Processing", string)
 
     def createInstance(self):
         return SimilarityAlgorithm()
@@ -23,21 +21,21 @@ class SimilarityAlgorithm(SHPAlgorithm):
         lowercase alphanumeric characters only and no spaces or other
         formatting characters.
         """
-        return 'similarity'
+        return "similarity"
 
     def displayName(self):
         """
         Returns the translated algorithm name, which should be used for any
         user-visible display of the algorithm name.
         """
-        return self.tr('Similarity')
+        return self.tr("Similarity")
 
     def group(self):
         """
         Returns the name of the group this algorithm belongs to. This string
         should be localised.
         """
-        return self.tr('')
+        return self.tr("")
 
     def groupId(self):
         """
@@ -47,7 +45,7 @@ class SimilarityAlgorithm(SHPAlgorithm):
         contain lowercase alphanumeric characters only and no spaces or other
         formatting characters.
         """
-        return ''
+        return ""
 
     def shortHelpString(self):
         """

tests/__init__.py

@@ -3,7 +3,14 @@ import os
 
 PYTHON_VERSION = sys.version_info
 SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
-PLUGIN_ROOT_DIR = os.path.realpath(os.path.abspath(os.path.join(SCRIPT_DIR, '..')))
-PACKAGES_INSTALL_DIR = os.path.join(PLUGIN_ROOT_DIR, f'python{PYTHON_VERSION.major}.{PYTHON_VERSION.minor}')
+PLUGIN_ROOT_DIR = os.path.realpath(os.path.abspath(os.path.join(SCRIPT_DIR, "..")))
+QGIS_PYTHON_DIR = os.path.realpath(os.path.abspath(os.path.join(PLUGIN_ROOT_DIR, "..")))
+PACKAGES_INSTALL_DIR = os.path.join(
+    PLUGIN_ROOT_DIR, f"python{PYTHON_VERSION.major}.{PYTHON_VERSION.minor}"
+)
 
 sys.path.append(PACKAGES_INSTALL_DIR)  # TODO: check for a less intrusive way to do this
+
+qgis_python_path = os.getenv("PYTHONPATH")
+if qgis_python_path and qgis_python_path not in sys.path:
+    sys.path.append(qgis_python_path)

tests/test_common.py

 import os
+import pytest
 from pathlib import Path
 import tempfile
 import unittest
 from qgis.core import (
-        QgsProcessingContext, 
-        QgsProcessingFeedback,
-        )
+    QgsProcessingContext,
+    QgsProcessingFeedback,
+)
 
 from ..ml import MLAlgorithm
 from ..similarity import SimilarityAlgorithm
 from ..clustering import ClusterAlgorithm
 from ..reduction import ReductionAlgorithm
 from ..utils.misc import get_file_md5_hash, remove_files_with_extensions
+from ..utils.geo import validate_geotiff
+
 
-INPUT = os.path.join(Path(__file__).parent.parent.absolute(), 'assets', 'test.tif')
+INPUT = os.path.join(Path(__file__).parent.parent.absolute(), "assets", "test.tif")
 OUTPUT = os.path.join(tempfile.gettempdir(), "iamap_test")
-EXTENSIONS_TO_RM = ['.tif', '.pkl', '.json', '.shp', '.shx', '.prj', '.dbf', '.cpg']
-TEMPLATE = os.path.join(Path(__file__).parent.parent.absolute(), 'assets', 'template.shp')
-TEMPLATE_RF = os.path.join(Path(__file__).parent.parent.absolute(), 'assets', 'ml_poly.shp')
-GT_COL = 'Type'
+EXTENSIONS_TO_RM = [".tif", ".pkl", ".json", ".shp", ".shx", ".prj", ".dbf", ".cpg"]
+TEMPLATE = os.path.join(
+    Path(__file__).parent.parent.absolute(), "assets", "template.shp"
+)
+TEMPLATE_RF = os.path.join(
+    Path(__file__).parent.parent.absolute(), "assets", "ml_poly.shp"
+)
+GT_COL = "Type"
+
 
 class TestReductionAlgorithm(unittest.TestCase):
     """
     Base test class, other will inherit from this
     """
+
     algorithm = ReductionAlgorithm()
-    default_parameters = {'INPUT': INPUT,'OUTPUT': OUTPUT}
+    default_parameters = {"INPUT": INPUT, "OUTPUT": OUTPUT}
     possible_hashes = [
-            'd7a32c6b7a4cee1af9c73607561d7b25',
-            'e04f8c86d9aad81dd9c625b9cd8f9824',
-                       ]
-    out_name = 'proj.tif'
+        "d7a32c6b7a4cee1af9c73607561d7b25",
+        "e04f8c86d9aad81dd9c625b9cd8f9824",
+    ]
+    output_size = 4405122
+    output_wh = (968,379)
+    out_name = "proj.tif"
 
     def setUp(self):
         self.context = QgsProcessingContext()
@@ -38,41 +49,51 @@ class TestReductionAlgorithm(unittest.TestCase):
 
     def test_valid_parameters(self):
         self.algorithm.initAlgorithm()
-        result = self.algorithm.processAlgorithm(self.default_parameters, self.context, self.feedback)
-        expected_result_path = os.path.join(self.algorithm.output_dir,self.out_name)
-        result_file_hash = get_file_md5_hash(expected_result_path)
+        _ = self.algorithm.processAlgorithm(
+            self.default_parameters, self.context, self.feedback
+        )
+        expected_result_path = os.path.join(self.algorithm.output_dir, self.out_name)
+        @pytest.mark.parametrize("output_file", expected_result_path, "expected_output_size", self.output_size, "expected_wh", self.output_wh)
+        def test_geotiff_validity(output_file):
+            validate_geotiff(output_file)
         remove_files_with_extensions(self.algorithm.output_dir, EXTENSIONS_TO_RM)
-        assert result_file_hash in self.possible_hashes
-        
 
 
 class TestClusteringAlgorithm(TestReductionAlgorithm):
     algorithm = ClusterAlgorithm()
-    possible_hashes = ['0c47b0c4b4c13902db5da3ee6e5d4aef']
-    out_name = 'cluster.tif'
+    # possible_hashes = ["0c47b0c4b4c13902db5da3ee6e5d4aef"]
+    out_name = "cluster.tif"
+    output_size = 4405122
 
 
 class TestSimAlgorithm(TestReductionAlgorithm):
     algorithm = SimilarityAlgorithm()
-    default_parameters = {'INPUT': INPUT,'OUTPUT': OUTPUT,'TEMPLATE':TEMPLATE}
-    possible_hashes = ['f76eb1f0469725b49fe0252cfe86829a']
-    out_name = 'similarity.tif'
+    default_parameters = {"INPUT": INPUT, "OUTPUT": OUTPUT, "TEMPLATE": TEMPLATE}
+    # possible_hashes = ["f76eb1f0469725b49fe0252cfe86829a"]
+    out_name = "similarity.tif"
+    output_size = 1468988
 
 
 class TestMLAlgorithm(TestReductionAlgorithm):
     algorithm = MLAlgorithm()
-    default_parameters = {'INPUT': INPUT,'OUTPUT': OUTPUT,'TEMPLATE':TEMPLATE_RF,'GT_COL': GT_COL}
-    possible_hashes = ['bd22d66180347e043fca58d494876184']
-    out_name = 'ml.tif'
+    default_parameters = {
+        "INPUT": INPUT,
+        "OUTPUT": OUTPUT,
+        "TEMPLATE": TEMPLATE_RF,
+        "GT_COL": GT_COL,
+    }
+    # possible_hashes = ["bd22d66180347e043fca58d494876184"]
+    out_name = "ml.tif"
+    output_size = 367520
 
-if __name__ == "__main__":
 
+if __name__ == "__main__":
     for algo in [
-            TestReductionAlgorithm(),
-            TestClusteringAlgorithm(),
-            TestSimAlgorithm(),
-            TestMLAlgorithm(),
-            ]:
+        TestReductionAlgorithm(),
+        TestClusteringAlgorithm(),
+        TestSimAlgorithm(),
+        TestMLAlgorithm(),
+    ]:
         algo.setUp()
         print(algo.algorithm)
         algo.test_valid_parameters()

tests/test_encoder.py

@@ -4,146 +4,132 @@ from pathlib import Path
 import unittest
 import pytest
 from qgis.core import (
-        QgsProcessingContext, 
-        QgsProcessingFeedback,
-        )
+    QgsProcessingContext,
+    QgsProcessingFeedback,
+)
 
 import timm
 import torch
+
 # from torchgeo.datasets import RasterDataset
-from..tg.datasets import RasterDataset
+from ..tg.datasets import RasterDataset
 
 from ..encoder import EncoderAlgorithm
 from ..utils.misc import get_file_md5_hash
+from ..utils.geo import validate_geotiff
 
 
-INPUT = os.path.join(Path(__file__).parent.parent.absolute(), 'assets', 'test.tif')
+INPUT = os.path.join(Path(__file__).parent.parent.absolute(), "assets", "test.tif")
 OUTPUT = os.path.join(tempfile.gettempdir(), "iamap_test")
 
-class TestEncoderAlgorithm(unittest.TestCase):
 
+class TestEncoderAlgorithm(unittest.TestCase):
     def setUp(self):
         self.context = QgsProcessingContext()
         self.feedback = QgsProcessingFeedback()
         self.algorithm = EncoderAlgorithm()
         self.default_parameters = {
-                'BACKBONE_CHOICE': '', 
-                'BACKBONE_OPT': 0, 
-                'BANDS': None, 
-                'BATCH_SIZE': 1, 
-                'CKPT': 'NULL', 
-                'CRS': None, 
-                'CUDA': True, 
-                'CUDA_ID': 0, 
-                'EXTENT': None, 
-                'FEAT_OPTION': True, 
-                'INPUT': INPUT,
-                'MERGE_METHOD': 0, 
-                'OUTPUT': OUTPUT,
-                'PAUSES': 0, 
-                'QUANT': True, 
-                'REMOVE_TEMP_FILES': True, 
-                'RESOLUTION': None, 
-                'SIZE': 224, 
-                'STRIDE': 224, 
-                'TEMP_FILES_CLEANUP_FREQ': 1000, 
-                'WORKERS': 0,
-                'JSON_PARAM': 'NULL', 
-                'OUT_DTYPE': 0, 
-                      }
+            "BACKBONE_CHOICE": "",
+            "BACKBONE_OPT": 0,
+            "BANDS": None,
+            "BATCH_SIZE": 1,
+            "CKPT": "NULL",
+            "CRS": None,
+            "CUDA": True,
+            "CUDA_ID": 0,
+            "EXTENT": None,
+            "FEAT_OPTION": True,
+            "INPUT": INPUT,
+            "MERGE_METHOD": 0,
+            "OUTPUT": OUTPUT,
+            "PAUSES": 0,
+            "QUANT": True,
+            "REMOVE_TEMP_FILES": True,
+            "RESOLUTION": None,
+            "SIZE": 224,
+            "STRIDE": 224,
+            "TEMP_FILES_CLEANUP_FREQ": 1000,
+            "WORKERS": 0,
+            "JSON_PARAM": "NULL",
+            "OUT_DTYPE": 0,
+        }
 
     def test_valid_parameters(self):
-
         self.algorithm.initAlgorithm()
-        _ = self.algorithm.processAlgorithm(self.default_parameters, self.context, self.feedback)
-        expected_result_path = os.path.join(self.algorithm.output_subdir,'merged.tif')
-        result_file_hash = get_file_md5_hash(expected_result_path)
-
-        ## different rasterio versions lead to different hashes ? 
-        ## GPU and quantization as well
-        possible_hashes = [
-                '0fb32cc57a0dd427d9f0165ec6d5418f',
-                '48c3a78773dbc2c4c7bb7885409284ab',
-                '431e034b842129679b99a067f2bd3ba4',
-                '60153535214eaa44458db4e297af72b9',
-                'f1394d1950f91e4f8277a8667ae77e85',
-                'a23837caa3aca54aaca2974d546c5123',
-                           ]
-        assert result_file_hash in possible_hashes
-        os.remove(expected_result_path)
-
-    @pytest.mark.slow
-    def test_data_types(self):
-
-        self.algorithm.initAlgorithm()
-        parameters = self.default_parameters
-        parameters['OUT_DTYPE'] = 1
-        _ = self.algorithm.processAlgorithm(parameters, self.context, self.feedback)
-        expected_result_path = os.path.join(self.algorithm.output_subdir,'merged.tif')
-        result_file_hash = get_file_md5_hash(expected_result_path)
-
-        ## different rasterio versions lead to different hashes ? 
-        possible_hashes = [
-                'ef0c4b0d57f575c1cd10c0578c7114c0',
-                'ebfad32752de71c5555bda2b40c19b2e',
-                'd3705c256320b7190dd4f92ad2087247',
-                '65fa46916d6d0d08ad9656d7d7fabd01',
-                           ]
-        assert result_file_hash in possible_hashes
+        _ = self.algorithm.processAlgorithm(
+            self.default_parameters, self.context, self.feedback
+        )
+        expected_result_path = os.path.join(self.algorithm.output_subdir, "merged.tif")
+        @pytest.mark.parametrize("output_file", expected_result_path)
+        def test_geotiff_validity(output_file):
+            validate_geotiff(output_file)
         os.remove(expected_result_path)
 
 
     def test_timm_create_model(self):
-
         archs = [
-                'vit_base_patch16_224.dino',
-                'vit_tiny_patch16_224.augreg_in21k',
-                'vit_base_patch16_224.mae',
-                'samvit_base_patch16.sa1b',
-                ]
+            "vit_base_patch16_224.dino",
+            "vit_tiny_patch16_224.augreg_in21k",
+            "vit_base_patch16_224.mae",
+            "samvit_base_patch16.sa1b",
+        ]
         expected_output_size = [
-                torch.Size([1,197,768]),
-                torch.Size([1,197,192]),
-                torch.Size([1,197,768]),
-                torch.Size([1, 256, 64, 64]),
-                ]
+            torch.Size([1, 197, 768]),
+            torch.Size([1, 197, 192]),
+            torch.Size([1, 197, 768]),
+            torch.Size([1, 256, 64, 64]),
+        ]
 
         for arch, exp_feat_size in zip(archs, expected_output_size):
-
             model = timm.create_model(
                 arch,
                 pretrained=True,
                 in_chans=6,
                 num_classes=0,
-                )
+            )
             model = model.eval()
 
             data_config = timm.data.resolve_model_data_config(model)
-            _, h, w, = data_config['input_size']
-            output = model.forward_features(torch.randn(1,6,h,w))
+            (
+                _,
+                h,
+                w,
+            ) = data_config["input_size"]
+            output = model.forward_features(torch.randn(1, 6, h, w))
 
             assert output.shape == exp_feat_size
 
-
     def test_RasterDataset(self):
-
         self.algorithm.initAlgorithm()
         parameters = {}
         self.algorithm.process_options(parameters, self.context, self.feedback)
         RasterDataset.filename_glob = self.algorithm.rlayer_name
         RasterDataset.all_bands = [
-            self.algorithm.rlayer.bandName(i_band) for i_band in range(1, self.algorithm.rlayer.bandCount()+1)
+            self.algorithm.rlayer.bandName(i_band)
+            for i_band in range(1, self.algorithm.rlayer.bandCount() + 1)
         ]
         # currently only support rgb bands
-        input_bands = [self.algorithm.rlayer.bandName(i_band)
-                       for i_band in self.algorithm.selected_bands]
+        input_bands = [
+            self.algorithm.rlayer.bandName(i_band)
+            for i_band in self.algorithm.selected_bands
+        ]
 
         if self.algorithm.crs == self.algorithm.rlayer.crs():
             dataset = RasterDataset(
-                paths=self.algorithm.rlayer_dir, crs=None, res=self.algorithm.res, bands=input_bands, cache=False)
+                paths=self.algorithm.rlayer_dir,
+                crs=None,
+                res=self.algorithm.res,
+                bands=input_bands,
+                cache=False,
+            )
         else:
             dataset = RasterDataset(
-                paths=self.algorithm.rlayer_dir, crs=self.algorithm.crs.toWkt(), res=self.algorithm.res, bands=input_bands, cache=False)
+                paths=self.algorithm.rlayer_dir,
+                crs=self.algorithm.crs.toWkt(),
+                res=self.algorithm.res,
+                bands=input_bands,
+                cache=False,
+            )
         del dataset
 
     def test_cuda(self):
@@ -151,15 +137,10 @@ class TestEncoderAlgorithm(unittest.TestCase):
             assert True
 
 
-
-
-
 if __name__ == "__main__":
-
     test_encoder = TestEncoderAlgorithm()
     test_encoder.setUp()
     test_encoder.test_timm_create_model()
     test_encoder.test_RasterDataset()
     test_encoder.test_valid_parameters()
-    test_encoder.test_data_types()
     test_encoder.test_cuda()

tg/datasets.py

-# modified from torchgeo code 
+# modified from torchgeo code
 
 """Base classes for all :mod:`torchgeo` datasets."""
 
@@ -390,10 +390,10 @@ class RasterDataset(GeoDataset):
         .. versionchanged:: 0.5
            *root* was renamed to *paths*.
         """
-        print('pre super.__init__')
+        print("pre super.__init__")
         super().__init__(transforms)
 
-        print('post super.__init__')
+        print("post super.__init__")
         self.paths = paths
         self.bands = bands or self.all_bands
         self.cache = cache
@@ -403,7 +403,7 @@ class RasterDataset(GeoDataset):
         filename_regex = re.compile(self.filename_regex, re.VERBOSE)
         for filepath in self.files:
             match = re.match(filename_regex, os.path.basename(filepath))
-            print('regex')
+            print("regex")
             if match is not None:
                 try:
                     with rasterio.open(filepath) as src:
@@ -580,7 +580,6 @@ class RasterDataset(GeoDataset):
             return src
 
 
-
 class IntersectionDataset(GeoDataset):
     """Dataset representing the intersection of two GeoDatasets.
 
@@ -882,4 +881,3 @@ class UnionDataset(GeoDataset):
         self._res = new_res
         self.datasets[0].res = new_res
         self.datasets[1].res = new_res
-