Upload folder using huggingface_hub

.gitattributes

@@ -34,3 +34,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
 zipdeepness/deepness/images/icon.png filter=lfs diff=lfs merge=lfs -text
+zipdeepness/images/icon.png filter=lfs diff=lfs merge=lfs -text

zipdeepness/README.md

@@ -0,0 +1,7 @@
+# Deepness: Deep Neural Remote Sensing
+
+Plugin for QGIS to perform map/image segmentation, regression and object detection with (ONNX) neural network models. 
+
+Please visit the documentation webpage for details: https://qgis-plugin-deepness.readthedocs.io/
+
+Or the repository: https://github.com/PUTvision/qgis-plugin-deepness 

zipdeepness/__init__.py

@@ -0,0 +1,19 @@
+"""Main plugin module - entry point for the plugin."""
+import os
+
+# increase limit of pixels (2^30), before importing cv2.
+# We are doing it here to make sure it will be done before importing cv2 for the first time
+os.environ["OPENCV_IO_MAX_IMAGE_PIXELS"] = pow(2, 40).__str__()
+
+
+# noinspection PyPep8Naming
+def classFactory(iface):  # pylint: disable=invalid-name
+    """Load Deepness class from file Deepness.
+    :param iface: A QGIS interface instance.
+    :type iface: QgsInterface
+    """
+    from deepness.dialogs.packages_installer import packages_installer_dialog
+    packages_installer_dialog.check_required_packages_and_install_if_necessary(iface=iface)
+
+    from deepness.deepness import Deepness
+    return Deepness(iface)

zipdeepness/common/__init__.py

@@ -0,0 +1,2 @@
+""" Submodule that contains the common functions for the deepness plugin.
+"""

zipdeepness/common/channels_mapping.py

@@ -0,0 +1,262 @@
+"""
+Raster layer (ortophoto) which is being processed consist of channels (usually Red, Green, Blue).
+The neural model expects input channels with some model-defined meaning.
+Channel mappings in this file define how the ortophoto channels translate to model inputs (e.g first model input is Red, second Green).
+"""
+
+import copy
+from typing import Dict, List
+
+
+class ImageChannel:
+    """
+    Defines an image channel - how is it being stored in the data source.
+    See note at top of this file for details.
+    """
+
+    def __init__(self, name):
+        self.name = name
+
+    def get_band_number(self):
+        raise NotImplementedError('Base class not implemented!')
+
+    def get_byte_number(self):
+        raise NotImplementedError('Base class not implemented!')
+
+
+class ImageChannelStandaloneBand(ImageChannel):
+    """
+    Defines an image channel, where each image channel is a separate band in the data source.
+    See note at top of this file for details.
+    """
+
+    def __init__(self, band_number: int, name: str):
+        super().__init__(name)
+        self.band_number = band_number  # index within bands (counted from one)
+
+    def __str__(self):
+        txt = f'ImageChannelStandaloneBand(name={self.name}, ' \
+              f'band_number={self.band_number})'
+        return txt
+
+    def get_band_number(self):
+        return self.band_number
+
+    def get_byte_number(self):
+        raise NotImplementedError('Something went wrong if we are here!')
+
+
+class ImageChannelCompositeByte(ImageChannel):
+    """
+    Defines an image channel, where each image channel is a smaller part of a bigger value (e.g. one byte within uint32 for each pixel).
+    See note at top of this file for details.
+    """
+
+    def __init__(self, byte_number: int, name: str):
+        super().__init__(name)
+        self.byte_number = byte_number  # position in composite byte (byte number in ARGB32, counted from zero)
+
+    def __str__(self):
+        txt = f'ImageChannelCompositeByte(name={self.name}, ' \
+              f'byte_number={self.byte_number})'
+        return txt
+
+    def get_band_number(self):
+        raise NotImplementedError('Something went wrong if we are here!')
+
+    def get_byte_number(self):
+        return self.byte_number
+
+
+class ChannelsMapping:
+    """
+    Defines mapping of model input channels to input image channels (bands).
+    See note at top of this file for details.
+    """
+
+    INVALID_INPUT_CHANNEL = -1
+
+    def __init__(self):
+        self._number_of_model_inputs = 0
+        self._number_of_model_output_channels = 0
+        self._image_channels = []  # type: List[ImageChannel]  # what channels are available from input image
+
+        # maps model channels to input image channels
+        # model_channel_number: image_channel_index (index in self._image_channels)
+        self._mapping = {}  # type: Dict[int, int]
+
+    def __str__(self):
+        txt = f'ChannelsMapping(' \
+              f'number_of_model_inputs={self._number_of_model_inputs}, ' \
+              f'image_channels = {self._image_channels}, ' \
+              f'mapping {self._mapping})'
+        return txt
+
+    def __eq__(self, other):
+        if self._number_of_model_inputs != other._number_of_model_inputs:
+            return False
+        return True
+
+    def get_as_default_mapping(self):
+        """
+        Get the same channels mapping as we have right now, but without the mapping itself
+        (so just a definition of inputs and outputs)
+
+        Returns
+        -------
+        ChannelsMapping
+        """
+        default_channels_mapping = copy.deepcopy(self)
+        default_channels_mapping._mapping = {}
+        return default_channels_mapping
+
+    def are_all_inputs_standalone_bands(self):
+        """
+        Checks whether all image_channels are standalone bands (ImageChannelStandaloneBand)
+        """
+        for image_channel in self._image_channels:
+            if not isinstance(image_channel, ImageChannelStandaloneBand):
+                return False
+        return True
+
+    def are_all_inputs_composite_byte(self):
+        """
+        Checks whether all image_channels are composite byte (ImageChannelCompositeByte)
+        """
+        for image_channel in self._image_channels:
+            if not isinstance(image_channel, ImageChannelCompositeByte):
+                return False
+        return True
+
+    def set_number_of_model_inputs(self, number_of_model_inputs: int):
+        """ Set how many input channels does the model has
+        Parameters
+        ----------
+        number_of_model_inputs : int
+        """
+        self._number_of_model_inputs = number_of_model_inputs
+
+    def set_number_of_model_output_channels(self, number_of_output_channels: int):
+        """ Set how many output channels does the model has
+
+        Parameters
+        ----------
+        number_of_output_channels : int
+        """
+        self._number_of_model_output_channels = number_of_output_channels
+
+    def set_number_of_model_inputs_same_as_image_channels(self):
+        """ Set the number of model input channels to be the same as number of image channels
+        """
+        self._number_of_model_inputs = len(self._image_channels)
+
+    def get_number_of_model_inputs(self) -> int:
+        """ Get number of model input channels
+
+        Returns
+        -------
+        int
+        """
+        return self._number_of_model_inputs
+
+    def get_number_of_model_output_channels(self) -> int:
+        """ Get number of model output channels
+
+        Returns
+        -------
+        int
+        """
+        return self._number_of_model_output_channels
+
+    def get_number_of_image_channels(self) -> int:
+        """ Get number of image input channels
+
+        Returns
+        -------
+        int
+        """
+        return len(self._image_channels)
+
+    def set_image_channels(self, image_channels: List[ImageChannel]):
+        """ Set what are the image channels
+
+        Parameters
+        ----------
+        image_channels : List[ImageChannel]
+            Image channels to set
+        """
+        self._image_channels = image_channels
+        if not self.are_all_inputs_standalone_bands() and not self.are_all_inputs_composite_byte():
+            raise Exception("Unsupported image channels composition!")
+
+    def get_image_channels(self) -> List[ImageChannel]:
+        """ Get the current image channels definition
+
+        Returns
+        -------
+        List[ImageChannel]
+        """
+        return self._image_channels
+
+    def get_image_channel_index_for_model_input(self, model_input_number) -> int:
+        """
+        Similar to 'get_image_channel_for_model_input', but return an index in array of inputs,
+        instead of ImageChannel
+        """
+        if len(self._image_channels) == 0:
+            raise Exception("No image channels!")
+
+        image_channel_index = self._mapping.get(model_input_number, model_input_number)
+        image_channel_index = min(image_channel_index, len(self._image_channels) - 1)
+        return image_channel_index
+
+    def get_image_channel_for_model_input(self, model_input_number: int) -> ImageChannel:
+        """
+        Get ImageChannel which should be used for the specified model input
+
+        Parameters
+        ----------
+        model_input_number : int
+            Model input number, counted from 0
+
+        Returns
+        -------
+        ImageChannel
+        """
+        image_channel_index = self.get_image_channel_index_for_model_input(model_input_number)
+        return self._image_channels[image_channel_index]
+
+    def set_image_channel_for_model_input(self, model_input_number: int, image_channel_index: int) -> ImageChannel:
+        """
+        Set image_channel_index which should be used for this model input
+        """
+        if image_channel_index >= len(self._image_channels):
+            raise Exception("Invalid image channel index!")
+        # image_channel = self._image_channels[image_channel_index]
+        self._mapping[model_input_number] = image_channel_index
+
+    def get_mapping_as_list(self) -> List[int]:
+        """ Get the mapping of model input channels to image channels, but as a list (e.g. to store it in QGis configuration)
+
+        Returns
+        -------
+        List[int]
+        """
+        mapping_list = []
+        for i in range(self._number_of_model_inputs):
+            if i in self._mapping:
+                mapping_list.append(self._mapping[i])
+            else:
+                mapping_list.append(-1)
+        return mapping_list
+
+    def load_mapping_from_list(self, mapping_list: List[int]):
+        """
+        Load self._mapping from a plain list of channels (which is saved in config)
+        """
+        for i in range(min(self._number_of_model_inputs), len(mapping_list)):
+            proposed_channel = mapping_list[i]
+            if proposed_channel == -1 or proposed_channel >= self._number_of_model_inputs:
+                continue
+
+            self._mapping[i] = proposed_channel

zipdeepness/common/config_entry_key.py

@@ -0,0 +1,95 @@
+"""
+This file contains utilities to write and read configuration parameters to the QGis Project configuration
+"""
+
+import enum
+
+from qgis.core import QgsProject
+
+from deepness.common.defines import PLUGIN_NAME
+
+
+class ConfigEntryKey(enum.Enum):
+    """
+    Entries to be stored in Project Configuration.
+    Second element of enum value (in tuple) is the default value for this field
+    """
+
+    MODEL_FILE_PATH = enum.auto(), ''  # Path to the model file
+    INPUT_LAYER_ID = enum.auto(), ''
+    PROCESSED_AREA_TYPE = enum.auto(), ''  # string of ProcessedAreaType, e.g. "ProcessedAreaType.VISIBLE_PART.value"
+    MODEL_TYPE = enum.auto(), ''  # string of ModelType enum, e.g. "ModelType.SEGMENTATION.value"
+    PREPROCESSING_RESOLUTION = enum.auto(), 3.0
+    MODEL_BATCH_SIZE = enum.auto(), 1
+    PROCESS_LOCAL_CACHE = enum.auto(), False
+    PREPROCESSING_TILES_OVERLAP = enum.auto(), 15
+
+    SEGMENTATION_PROBABILITY_THRESHOLD_ENABLED = enum.auto(), True
+    SEGMENTATION_PROBABILITY_THRESHOLD_VALUE = enum.auto(), 0.5
+    SEGMENTATION_REMOVE_SMALL_SEGMENT_ENABLED = enum.auto(), True
+    SEGMENTATION_REMOVE_SMALL_SEGMENT_SIZE = enum.auto(), 9
+
+    REGRESSION_OUTPUT_SCALING = enum.auto(), 1.0
+
+    DETECTION_CONFIDENCE = enum.auto(), 0.5
+    DETECTION_IOU = enum.auto(), 0.5
+    DETECTOR_TYPE = enum.auto(), 'YOLO_v5_v7_DEFAULT'
+
+    DATA_EXPORT_DIR = enum.auto(), ''
+    DATA_EXPORT_TILES_ENABLED = enum.auto(), True
+    DATA_EXPORT_SEGMENTATION_MASK_ENABLED = enum.auto(), False
+    DATA_EXPORT_SEGMENTATION_MASK_ID = enum.auto(), ''
+
+    INPUT_CHANNELS_MAPPING__ADVANCED_MODE = enum.auto, False
+    INPUT_CHANNELS_MAPPING__MAPPING_LIST_STR = enum.auto, []
+
+    def get(self):
+        """
+        Get the value store in config (or a default one) for the specified field
+        """
+        read_function = None
+
+        # check the default value to determine the entry type
+        default_value = self.value[1]  # second element in the 'value' tuple
+        if isinstance(default_value, int):
+            read_function = QgsProject.instance().readNumEntry
+        elif isinstance(default_value, float):
+            read_function = QgsProject.instance().readDoubleEntry
+        elif isinstance(default_value, bool):
+            read_function = QgsProject.instance().readBoolEntry
+        elif isinstance(default_value, str):
+            read_function = QgsProject.instance().readEntry
+        elif isinstance(default_value, str):
+            read_function = QgsProject.instance().readListEntry
+        else:
+            raise Exception("Unsupported entry type!")
+
+        value, _ = read_function(PLUGIN_NAME, self.name, default_value)
+        return value
+
+    def set(self, value):
+        """ Set the value store in config, for the specified field
+
+        Parameters
+        ----------
+        value :
+            Value to set in the configuration
+        """
+        write_function = None
+
+        # check the default value to determine the entry type
+        default_value = self.value[1]  # second element in the 'value' tuple
+        if isinstance(default_value, int):
+            write_function = QgsProject.instance().writeEntry
+        elif isinstance(default_value, float):
+            write_function = QgsProject.instance().writeEntryDouble
+        elif isinstance(default_value, bool):
+            write_function = QgsProject.instance().writeEntryBool
+        elif isinstance(default_value, str):
+            write_function = QgsProject.instance().writeEntry
+        elif isinstance(default_value, list):
+            write_function = QgsProject.instance().writeEntry
+        else:
+            raise Exception("Unsupported entry type!")
+
+        write_function(PLUGIN_NAME, self.name, value)

zipdeepness/common/defines.py

@@ -0,0 +1,12 @@
+"""
+This file contain common definitions used in the project
+"""
+
+import os
+
+PLUGIN_NAME = 'Deepness'
+LOG_TAB_NAME = PLUGIN_NAME
+
+
+# enable some debugging options (e.g. printing exceptions) - set in terminal before running qgis
+IS_DEBUG = os.getenv("IS_DEBUG", 'False').lower() in ('true', '1', 't')

zipdeepness/common/errors.py

@@ -0,0 +1,10 @@
+"""
+This file contains common exceptions used in the project
+"""
+
+
+class OperationFailedException(Exception):
+    """
+    Base class for a failed operation, in order to have a good error message to show for the user
+    """
+    pass

zipdeepness/common/lazy_package_loader.py

@@ -0,0 +1,24 @@
+"""
+This file contains utility to lazy import packages
+"""
+
+import importlib
+
+
+class LazyPackageLoader:
+    """ Allows to wrap python package into a lazy version, so that the package will be loaded once it is actually used
+
+    Usage:
+        cv2 = LazyPackageLoader('cv2')  # This will not import cv2 yet
+        ...
+        cv2.waitKey(3)  # here will be the actual import
+    """
+
+    def __init__(self, package_name):
+        self._package_name = package_name
+        self._package = None
+
+    def __getattr__(self, name):
+        if self._package is None:
+            self._package = importlib.import_module(self._package_name)
+        return getattr(self._package, name)

zipdeepness/common/misc.py

@@ -0,0 +1,9 @@
+"""
+This file contains miscellaneous stuff used in the project
+"""
+
+import os
+import tempfile
+
+_TMP_DIR = tempfile.TemporaryDirectory()
+TMP_DIR_PATH = os.path.join(_TMP_DIR.name, 'qgis')

zipdeepness/common/processing_overlap.py

@@ -0,0 +1,37 @@
+import enum
+from typing import Dict, List
+
+
+class ProcessingOverlapOptions(enum.Enum):
+    OVERLAP_IN_PIXELS = 'Overlap in pixels'
+    OVERLAP_IN_PERCENT = 'Overlap in percent'
+
+
+class ProcessingOverlap:
+    """ Represents overlap between tiles during processing
+    """
+    def __init__(self, selected_option: ProcessingOverlapOptions, percentage: float = None, overlap_px: int = None):
+        self.selected_option = selected_option
+        
+        if selected_option == ProcessingOverlapOptions.OVERLAP_IN_PERCENT and percentage is None:
+            raise Exception(f"Percentage must be specified when using {ProcessingOverlapOptions.OVERLAP_IN_PERCENT}")
+        if selected_option == ProcessingOverlapOptions.OVERLAP_IN_PIXELS and overlap_px is None:
+            raise Exception(f"Overlap in pixels must be specified when using {ProcessingOverlapOptions.OVERLAP_IN_PIXELS}")
+
+        if selected_option == ProcessingOverlapOptions.OVERLAP_IN_PERCENT:
+            self._percentage = percentage
+        elif selected_option == ProcessingOverlapOptions.OVERLAP_IN_PIXELS:
+            self._overlap_px = overlap_px
+        else:
+            raise Exception(f"Unknown option: {selected_option}")
+
+    def get_overlap_px(self, tile_size_px: int) -> int:
+        """ Returns the overlap in pixels
+
+        :param tile_size_px: Tile size in pixels
+        :return: Returns the overlap in pixels
+        """
+        if self.selected_option == ProcessingOverlapOptions.OVERLAP_IN_PIXELS:
+            return self._overlap_px
+        else:
+            return int(tile_size_px * self._percentage / 100 * 2) // 2  # TODO: check if this is correct

zipdeepness/common/processing_parameters/detection_parameters.py

@@ -0,0 +1,70 @@
+import enum
+from dataclasses import dataclass
+
+from deepness.common.processing_parameters.map_processing_parameters import MapProcessingParameters
+from deepness.processing.models.model_base import ModelBase
+
+
+@dataclass
+class DetectorTypeParameters:
+    """
+    Defines some model-specific parameters for each model 'type' (e.g. default YOLOv7 has different model output shape than the one trained with Ultralytics' YOLO)
+    """
+    has_inverted_output_shape: bool = False  # whether the output shape of the model is inverted (and we need to apply np.transpose(model_output, (1, 0)))
+    skipped_objectness_probability: bool = False  # whether the model output has has no 'objectness' probability, and only probability for each class
+    ignore_objectness_probability: bool = False  # if the model output has the 'objectness' probability, we can still ignore it (it is needeed sometimes, when the probability was always 1...). The behavior should be the same as with `skipped_objectness_probability` (of course one model output needs be skipped)
+
+
+class DetectorType(enum.Enum):
+    """ Type of the detector model """
+
+    YOLO_v5_v7_DEFAULT = 'YOLO_v5_or_v7_default'
+    YOLO_v6 = 'YOLO_v6'
+    YOLO_v9 = 'YOLO_v9'
+    YOLO_ULTRALYTICS = 'YOLO_Ultralytics'
+    YOLO_ULTRALYTICS_SEGMENTATION = 'YOLO_Ultralytics_segmentation'
+    YOLO_ULTRALYTICS_OBB = 'YOLO_Ultralytics_obb'
+
+    def get_parameters(self):
+        if self == DetectorType.YOLO_v5_v7_DEFAULT:
+            return DetectorTypeParameters()  # all default
+        elif self == DetectorType.YOLO_v6:
+            return DetectorTypeParameters(
+                ignore_objectness_probability=True,
+            )
+        elif self == DetectorType.YOLO_v9:
+            return DetectorTypeParameters(
+                has_inverted_output_shape=True,
+                skipped_objectness_probability=True,
+            )
+        elif self == DetectorType.YOLO_ULTRALYTICS or self == DetectorType.YOLO_ULTRALYTICS_SEGMENTATION or self == DetectorType.YOLO_ULTRALYTICS_OBB:
+            return DetectorTypeParameters(
+                has_inverted_output_shape=True,
+                skipped_objectness_probability=True,
+            )
+        else:
+            raise ValueError(f'Unknown detector type: {self}')
+
+    def get_formatted_description(self):
+        txt = ''
+        txt += ' ' * 10 + f'Inverted output shape: {self.get_parameters().has_inverted_output_shape}\n'
+        txt += ' ' * 10 + f'Skipped objectness : {self.get_parameters().skipped_objectness_probability}\n'
+        txt += ' ' * 10 + f'Ignore objectness: {self.get_parameters().ignore_objectness_probability}\n'
+        return txt
+
+    def get_all_display_values():
+        return [x.value for x in DetectorType]
+
+
+@dataclass
+class DetectionParameters(MapProcessingParameters):
+    """
+    Parameters for Inference of detection model (including pre/post-processing) obtained from UI.
+    """
+
+    model: ModelBase  # wrapper of the loaded model
+
+    confidence: float
+    iou_threshold: float
+
+    detector_type: DetectorType = DetectorType.YOLO_v5_v7_DEFAULT  # parameters specific for each model type

zipdeepness/common/processing_parameters/map_processing_parameters.py

@@ -0,0 +1,56 @@
+import enum
+from dataclasses import dataclass
+from typing import Optional
+
+from deepness.common.channels_mapping import ChannelsMapping
+from deepness.common.processing_overlap import ProcessingOverlap
+
+
+class ProcessedAreaType(enum.Enum):
+    VISIBLE_PART = 'Visible part'
+    ENTIRE_LAYER = 'Entire layer'
+    FROM_POLYGONS = 'From polygons'
+
+    @classmethod
+    def get_all_names(cls):
+        return [e.value for e in cls]
+
+@dataclass
+class MapProcessingParameters:
+    """
+    Common parameters for map processing obtained from UI.
+
+    TODO: Add default values here, to later set them in UI at startup
+    """
+
+    resolution_cm_per_px: float  # image resolution to used during processing
+    processed_area_type: ProcessedAreaType  # whether to perform operation on the entire field or part
+    tile_size_px: int  # Tile size for processing (model input size)
+    batch_size: int  # Batch size for processing
+    local_cache: bool  # Whether to use local cache for tiles (on disk, /tmp directory)
+
+    input_layer_id: str  # raster layer to process
+    mask_layer_id: Optional[str]  # Processing of masked layer - if processed_area_type is FROM_POLYGONS
+
+    processing_overlap: ProcessingOverlap  # aka "stride" - how much to overlap tiles during processing
+
+    input_channels_mapping: ChannelsMapping  # describes mapping of image channels to model inputs
+
+    @property
+    def tile_size_m(self):
+        return self.tile_size_px * self.resolution_cm_per_px / 100
+
+    @property
+    def processing_overlap_px(self) -> int:
+        """
+        Always divisible by 2, because overlap is on both sides of the tile
+        """
+        return self.processing_overlap.get_overlap_px(self.tile_size_px)
+
+    @property
+    def resolution_m_per_px(self):
+        return self.resolution_cm_per_px / 100
+
+    @property
+    def processing_stride_px(self):
+        return self.tile_size_px - self.processing_overlap_px

zipdeepness/common/processing_parameters/recognition_parameters.py

@@ -0,0 +1,17 @@
+import enum
+from dataclasses import dataclass
+from typing import Optional
+
+from deepness.common.processing_parameters.map_processing_parameters import \
+    MapProcessingParameters
+from deepness.processing.models.model_base import ModelBase
+
+
+@dataclass
+class RecognitionParameters(MapProcessingParameters):
+    """
+    Parameters for Inference of Recognition model (including pre/post-processing) obtained from UI.
+    """
+
+    query_image_path: str  # path to query image
+    model: ModelBase  # wrapper of the loaded model

zipdeepness/common/processing_parameters/regression_parameters.py

@@ -0,0 +1,14 @@
+from dataclasses import dataclass
+
+from deepness.common.processing_parameters.map_processing_parameters import MapProcessingParameters
+from deepness.processing.models.model_base import ModelBase
+
+
+@dataclass
+class RegressionParameters(MapProcessingParameters):
+    """
+    Parameters for Inference of Regression model (including pre/post-processing) obtained from UI.
+    """
+
+    output_scaling: float  # scaling factor for the model output (keep 1 if maximum model output value is 1)
+    model: ModelBase  # wrapper of the loaded model

zipdeepness/common/processing_parameters/segmentation_parameters.py

@@ -0,0 +1,16 @@
+from dataclasses import dataclass
+
+from deepness.common.processing_parameters.map_processing_parameters import MapProcessingParameters
+from deepness.processing.models.model_base import ModelBase
+
+
+@dataclass
+class SegmentationParameters(MapProcessingParameters):
+    """
+    Parameters for Inference of Segmentation model (including pre/post-processing) obtained from UI.
+    """
+
+    postprocessing_dilate_erode_size: int  # dilate/erode operation size, once we have a single class map. 0 if inactive. Implementation may use median filer instead of erode/dilate
+    model: ModelBase  # wrapper of the loaded model
+
+    pixel_classification__probability_threshold: float  # Minimum required class probability for pixel. 0 if disabled

zipdeepness/common/processing_parameters/standardization_parameters.py

@@ -0,0 +1,11 @@
+import numpy as np
+
+
+class StandardizationParameters:
+    def __init__(self, channels_number: int):
+        self.mean = np.array([0.0 for _ in range(channels_number)], dtype=np.float32)
+        self.std = np.array([1.0 for _ in range(channels_number)], dtype=np.float32)
+
+    def set_mean_std(self, mean: np.array, std: np.array):
+        self.mean = np.array(mean, dtype=np.float32)
+        self.std = np.array(std, dtype=np.float32)

zipdeepness/common/processing_parameters/superresolution_parameters.py

@@ -0,0 +1,18 @@
+import enum
+from dataclasses import dataclass
+from typing import Optional
+
+from deepness.common.channels_mapping import ChannelsMapping
+from deepness.common.processing_parameters.map_processing_parameters import MapProcessingParameters
+from deepness.processing.models.model_base import ModelBase
+
+
+@dataclass
+class SuperresolutionParameters(MapProcessingParameters):
+    """
+    Parameters for Inference of Super Resolution model (including pre/post-processing) obtained from UI.
+    """
+
+    output_scaling: float  # scaling factor for the model output (keep 1 if maximum model output value is 1)
+    model: ModelBase  # wrapper of the loaded model
+    scale_factor: int  # scale factor for the model output size

zipdeepness/common/processing_parameters/training_data_export_parameters.py

@@ -0,0 +1,15 @@
+from dataclasses import dataclass
+from typing import Optional
+
+from deepness.common.processing_parameters.map_processing_parameters import MapProcessingParameters
+
+
+@dataclass
+class TrainingDataExportParameters(MapProcessingParameters):
+    """
+    Parameters for Exporting Data obtained from UI.
+    """
+
+    export_image_tiles: bool  # whether to export input image tiles
+    segmentation_mask_layer_id: Optional[str]  # id for mask, to be exported as separate tiles
+    output_directory_path: str  # path where the output files will be saved

zipdeepness/common/temp_files_handler.py

@@ -0,0 +1,19 @@
+import os.path as path
+import shutil
+from tempfile import mkdtemp
+
+
+class TempFilesHandler:
+    def __init__(self) -> None:
+        self._temp_dir = mkdtemp()
+        
+        print(f'Created temp dir: {self._temp_dir} for processing')
+
+    def get_results_img_path(self):
+        return path.join(self._temp_dir, 'results.dat')
+
+    def get_area_mask_img_path(self):
+        return path.join(self._temp_dir, 'area_mask.dat')
+
+    def __del__(self):
+        shutil.rmtree(self._temp_dir)

zipdeepness/deepness.py

@@ -0,0 +1,317 @@
+"""Main plugin file - entry point for the plugin.
+
+Links the UI and the processing.
+
+Skeleton of this file was generate with the QGis plugin to create plugin skeleton - QGIS PluginBuilder
+"""
+
+import logging
+import traceback
+
+from qgis.core import Qgis, QgsApplication, QgsProject, QgsVectorLayer
+from qgis.gui import QgisInterface
+from qgis.PyQt.QtCore import QCoreApplication, Qt
+from qgis.PyQt.QtGui import QIcon
+from qgis.PyQt.QtWidgets import QAction, QMessageBox
+
+from deepness.common.defines import IS_DEBUG, PLUGIN_NAME
+from deepness.common.lazy_package_loader import LazyPackageLoader
+from deepness.common.processing_parameters.map_processing_parameters import MapProcessingParameters, ProcessedAreaType
+from deepness.common.processing_parameters.training_data_export_parameters import TrainingDataExportParameters
+from deepness.deepness_dockwidget import DeepnessDockWidget
+from deepness.dialogs.resizable_message_box import ResizableMessageBox
+from deepness.images.get_image_path import get_icon_path
+from deepness.processing.map_processor.map_processing_result import (MapProcessingResult, MapProcessingResultCanceled,
+                                                                     MapProcessingResultFailed,
+                                                                     MapProcessingResultSuccess)
+from deepness.processing.map_processor.map_processor_training_data_export import MapProcessorTrainingDataExport
+
+cv2 = LazyPackageLoader('cv2')
+
+
+class Deepness:
+    """ QGIS Plugin Implementation - main class of the plugin.
+    Creates the UI classes and processing models and links them together.
+    """
+
+    def __init__(self, iface: QgisInterface):
+        """
+        :param iface: An interface instance that will be passed to this class
+            which provides the hook by which you can manipulate the QGIS
+            application at run time.
+        :type iface: QgsInterface
+        """
+        self.iface = iface
+
+        # Declare instance attributes
+        self.actions = []
+        self.menu = self.tr(u'&Deepness')
+
+        self.toolbar = self.iface.addToolBar(u'Deepness')
+        self.toolbar.setObjectName(u'Deepness')
+
+        self.pluginIsActive = False
+        self.dockwidget = None
+        self._map_processor = None
+
+    # noinspection PyMethodMayBeStatic
+    def tr(self, message):
+        """Get the translation for a string using Qt translation API.
+
+        We implement this ourselves since we do not inherit QObject.
+
+        :param message: String for translation.
+        :type message: str, QString
+
+        :returns: Translated version of message.
+        :rtype: QString
+        """
+        # noinspection PyTypeChecker,PyArgumentList,PyCallByClass
+        return QCoreApplication.translate('Deepness', message)
+
+    def add_action(
+            self,
+            icon_path,
+            text,
+            callback,
+            enabled_flag=True,
+            add_to_menu=True,
+            add_to_toolbar=True,
+            status_tip=None,
+            whats_this=None,
+            parent=None):
+        """Add a toolbar icon to the toolbar.
+
+        :param icon_path: Path to the icon for this action. Can be a resource
+            path (e.g. ':/plugins/foo/bar.png') or a normal file system path.
+        :type icon_path: str
+
+        :param text: Text that should be shown in menu items for this action.
+        :type text: str
+
+        :param callback: Function to be called when the action is triggered.
+        :type callback: function
+
+        :param enabled_flag: A flag indicating if the action should be enabled
+            by default. Defaults to True.
+        :type enabled_flag: bool
+
+        :param add_to_menu: Flag indicating whether the action should also
+            be added to the menu. Defaults to True.
+        :type add_to_menu: bool
+
+        :param add_to_toolbar: Flag indicating whether the action should also
+            be added to the toolbar. Defaults to True.
+        :type add_to_toolbar: bool
+
+        :param status_tip: Optional text to show in a popup when mouse pointer
+            hovers over the action.
+        :type status_tip: str
+
+        :param parent: Parent widget for the new action. Defaults None.
+        :type parent: QWidget
+
+        :param whats_this: Optional text to show in the status bar when the
+            mouse pointer hovers over the action.
+
+        :returns: The action that was created. Note that the action is also
+            added to self.actions list.
+        :rtype: QAction
+        """
+
+        icon = QIcon(icon_path)
+        action = QAction(icon, text, parent)
+        action.triggered.connect(callback)
+        action.setEnabled(enabled_flag)
+
+        if status_tip is not None:
+            action.setStatusTip(status_tip)
+
+        if whats_this is not None:
+            action.setWhatsThis(whats_this)
+
+        if add_to_toolbar:
+            self.toolbar.addAction(action)
+
+        if add_to_menu:
+            self.iface.addPluginToMenu(
+                self.menu,
+                action)
+
+        self.actions.append(action)
+
+        return action
+
+    def initGui(self):
+        """Create the menu entries and toolbar icons inside the QGIS GUI."""
+
+        icon_path = get_icon_path()
+        self.add_action(
+            icon_path,
+            text=self.tr(u'Deepness'),
+            callback=self.run,
+            parent=self.iface.mainWindow())
+
+        if IS_DEBUG:
+            self.run()
+
+    def onClosePlugin(self):
+        """Cleanup necessary items here when plugin dockwidget is closed"""
+
+        # disconnects
+        self.dockwidget.closingPlugin.disconnect(self.onClosePlugin)
+
+        # remove this statement if dockwidget is to remain
+        # for reuse if plugin is reopened
+        # Commented next statement since it causes QGIS crashe
+        # when closing the docked window:
+        # self.dockwidget = None
+
+        self.pluginIsActive = False
+
+    def unload(self):
+        """Removes the plugin menu item and icon from QGIS GUI."""
+
+        for action in self.actions:
+            self.iface.removePluginMenu(
+                self.tr(u'&Deepness'),
+                action)
+            self.iface.removeToolBarIcon(action)
+        # remove the toolbar
+        del self.toolbar
+
+    def _layers_changed(self, _):
+        pass
+
+    def run(self):
+        """Run method that loads and starts the plugin"""
+
+        if not self.pluginIsActive:
+            self.pluginIsActive = True
+
+            # dockwidget may not exist if:
+            #    first run of plugin
+            #    removed on close (see self.onClosePlugin method)
+            if self.dockwidget is None:
+                # Create the dockwidget (after translation) and keep reference
+                self.dockwidget = DeepnessDockWidget(self.iface)
+                self._layers_changed(None)
+                QgsProject.instance().layersAdded.connect(self._layers_changed)
+                QgsProject.instance().layersRemoved.connect(self._layers_changed)
+
+            # connect to provide cleanup on closing of dockwidget
+            self.dockwidget.closingPlugin.connect(self.onClosePlugin)
+            self.dockwidget.run_model_inference_signal.connect(self._run_model_inference)
+            self.dockwidget.run_training_data_export_signal.connect(self._run_training_data_export)
+
+            self.iface.addDockWidget(Qt.RightDockWidgetArea, self.dockwidget)
+            self.dockwidget.show()
+
+    def _are_map_processing_parameters_are_correct(self, params: MapProcessingParameters):
+        if self._map_processor and self._map_processor.is_busy():
+            msg = "Error! Processing already in progress! Please wait or cancel previous task."
+            self.iface.messageBar().pushMessage(PLUGIN_NAME, msg, level=Qgis.Critical, duration=7)
+            return False
+
+        rlayer = QgsProject.instance().mapLayers()[params.input_layer_id]
+        if rlayer is None:
+            msg = "Error! Please select the layer to process first!"
+            self.iface.messageBar().pushMessage(PLUGIN_NAME, msg, level=Qgis.Critical, duration=7)
+            return False
+
+        if isinstance(rlayer, QgsVectorLayer):
+            msg = "Error! Please select a raster layer (vector layer selected)"
+            self.iface.messageBar().pushMessage(PLUGIN_NAME, msg, level=Qgis.Critical, duration=7)
+            return False
+
+        return True
+
+    def _display_processing_started_info(self):
+        msg = "Processing in progress... Cool! It's tea time!"
+        self.iface.messageBar().pushMessage(PLUGIN_NAME, msg, level=Qgis.Info, duration=2)
+
+    def _run_training_data_export(self, training_data_export_parameters: TrainingDataExportParameters):
+        if not self._are_map_processing_parameters_are_correct(training_data_export_parameters):
+            return
+
+        vlayer = None
+
+        rlayer = QgsProject.instance().mapLayers()[training_data_export_parameters.input_layer_id]
+        if training_data_export_parameters.processed_area_type == ProcessedAreaType.FROM_POLYGONS:
+            vlayer = QgsProject.instance().mapLayers()[training_data_export_parameters.mask_layer_id]
+
+        self._map_processor = MapProcessorTrainingDataExport(
+            rlayer=rlayer,
+            vlayer_mask=vlayer,  # layer with masks
+            map_canvas=self.iface.mapCanvas(),
+            params=training_data_export_parameters)
+        self._map_processor.finished_signal.connect(self._map_processor_finished)
+        self._map_processor.show_img_signal.connect(self._show_img)
+        QgsApplication.taskManager().addTask(self._map_processor)
+        self._display_processing_started_info()
+
+    def _run_model_inference(self, params: MapProcessingParameters):
+        from deepness.processing.models.model_types import ModelDefinition  # import here to avoid pulling external dependencies to early
+
+        if not self._are_map_processing_parameters_are_correct(params):
+            return
+
+        vlayer = None
+
+        rlayer = QgsProject.instance().mapLayers()[params.input_layer_id]
+        if params.processed_area_type == ProcessedAreaType.FROM_POLYGONS:
+            vlayer = QgsProject.instance().mapLayers()[params.mask_layer_id]
+
+        model_definition = ModelDefinition.get_definition_for_params(params)
+        map_processor_class = model_definition.map_processor_class
+
+        self._map_processor = map_processor_class(
+            rlayer=rlayer,
+            vlayer_mask=vlayer,
+            map_canvas=self.iface.mapCanvas(),
+            params=params)
+        self._map_processor.finished_signal.connect(self._map_processor_finished)
+        self._map_processor.show_img_signal.connect(self._show_img)
+        QgsApplication.taskManager().addTask(self._map_processor)
+        self._display_processing_started_info()
+
+    @staticmethod
+    def _show_img(img_rgb, window_name: str):
+        """ Helper function to show an image while developing and debugging the plugin """
+        # We are importing it here, because it is debug tool,
+        # and we don't want to have it in the main scope from the project startup
+        img_bgr = img_rgb[..., ::-1]
+        cv2.namedWindow(window_name, cv2.WINDOW_NORMAL)
+        cv2.resizeWindow(window_name, 800, 800)
+        cv2.imshow(window_name, img_bgr)
+        cv2.waitKey(1)
+
+    def _map_processor_finished(self, result: MapProcessingResult):
+        """ Slot for finished processing of the ortophoto """
+        if isinstance(result, MapProcessingResultFailed):
+            msg = f'Error! Processing error: "{result.message}"!'
+            self.iface.messageBar().pushMessage(PLUGIN_NAME, msg, level=Qgis.Critical, duration=14)
+            if result.exception is not None:
+                logging.error(msg)
+                trace = '\n'.join(traceback.format_tb(result.exception.__traceback__)[-1:])
+                msg = f'{msg}\n\n\n' \
+                      f'Details: ' \
+                      f'{str(result.exception.__class__.__name__)} - {result.exception}\n' \
+                      f'Last Traceback: \n' \
+                      f'{trace}'
+                QMessageBox.critical(self.dockwidget, "Unhandled exception", msg)
+        elif isinstance(result, MapProcessingResultCanceled):
+            msg = f'Info! Processing canceled by user!'
+            self.iface.messageBar().pushMessage(PLUGIN_NAME, msg, level=Qgis.Info, duration=7)
+        elif isinstance(result, MapProcessingResultSuccess):
+            msg = 'Processing finished!'
+            self.iface.messageBar().pushMessage(PLUGIN_NAME, msg, level=Qgis.Success, duration=3)
+            message_to_show = result.message
+
+            msgBox = ResizableMessageBox(self.dockwidget)
+            msgBox.setWindowTitle("Processing Result")
+            msgBox.setText(message_to_show)
+            msgBox.setStyleSheet("QLabel{min-width:800 px; font-size: 24px;} QPushButton{ width:250px; font-size: 18px; }")
+            msgBox.exec()
+
+        self._map_processor = None

zipdeepness/deepness_dockwidget.py

@@ -0,0 +1,603 @@
+"""
+This file contain the main widget of the plugin
+"""
+
+import logging
+import os
+from typing import Optional
+
+from qgis.core import Qgis, QgsMapLayerProxyModel, QgsProject
+from qgis.PyQt import QtWidgets, uic
+from qgis.PyQt.QtCore import pyqtSignal
+from qgis.PyQt.QtWidgets import QComboBox, QFileDialog, QMessageBox
+
+from deepness.common.config_entry_key import ConfigEntryKey
+from deepness.common.defines import IS_DEBUG, PLUGIN_NAME
+from deepness.common.errors import OperationFailedException
+from deepness.common.lazy_package_loader import LazyPackageLoader
+from deepness.common.processing_overlap import ProcessingOverlap, ProcessingOverlapOptions
+from deepness.common.processing_parameters.detection_parameters import DetectionParameters, DetectorType
+from deepness.common.processing_parameters.map_processing_parameters import MapProcessingParameters, ProcessedAreaType
+from deepness.common.processing_parameters.recognition_parameters import RecognitionParameters
+from deepness.common.processing_parameters.regression_parameters import RegressionParameters
+from deepness.common.processing_parameters.segmentation_parameters import SegmentationParameters
+from deepness.common.processing_parameters.superresolution_parameters import SuperresolutionParameters
+from deepness.common.processing_parameters.training_data_export_parameters import TrainingDataExportParameters
+from deepness.processing.models.model_base import ModelBase
+from deepness.widgets.input_channels_mapping.input_channels_mapping_widget import InputChannelsMappingWidget
+from deepness.widgets.training_data_export_widget.training_data_export_widget import TrainingDataExportWidget
+
+FORM_CLASS, _ = uic.loadUiType(os.path.join(
+    os.path.dirname(__file__), 'deepness_dockwidget.ui'))
+
+
+class DeepnessDockWidget(QtWidgets.QDockWidget, FORM_CLASS):
+    """
+    Main widget of the plugin.
+    'Dock' means it is a 'dcoked' widget, embedded in the QGis application window.
+
+    The UI design is defined in the `deepness_dockwidget.ui` fiel - recommended to be open in QtDesigner.
+    Note: Default values for ui edits are based on 'ConfigEntryKey' default value, not taken from the UI form.
+    """
+
+    closingPlugin = pyqtSignal()
+    run_model_inference_signal = pyqtSignal(MapProcessingParameters)  # run Segmentation or Detection
+    run_training_data_export_signal = pyqtSignal(TrainingDataExportParameters)
+
+    def __init__(self, iface, parent=None):
+        super(DeepnessDockWidget, self).__init__(parent)
+        self.iface = iface
+        self._model = None  # type: Optional[ModelBase]
+        self.setupUi(self)
+
+        self._input_channels_mapping_widget = InputChannelsMappingWidget(self)  # mapping of model and input ortophoto channels
+        self._training_data_export_widget = TrainingDataExportWidget(self)  # widget with UI for data export tool
+
+        self._create_connections()
+        self._setup_misc_ui()
+        self._load_ui_from_config()
+
+    def _show_debug_warning(self):
+        """ Show label with warning if we are running debug mode """
+        self.label_debugModeWarning.setVisible(IS_DEBUG)
+
+    def _load_ui_from_config(self):
+        """ Load the UI values from the project configuration
+        """
+        layers = QgsProject.instance().mapLayers()
+
+        try:
+            input_layer_id = ConfigEntryKey.INPUT_LAYER_ID.get()
+            if input_layer_id and input_layer_id in layers:
+                self.mMapLayerComboBox_inputLayer.setLayer(layers[input_layer_id])
+
+            processed_area_type_txt = ConfigEntryKey.PROCESSED_AREA_TYPE.get()
+            self.comboBox_processedAreaSelection.setCurrentText(processed_area_type_txt)
+
+            model_type_txt = ConfigEntryKey.MODEL_TYPE.get()
+            self.comboBox_modelType.setCurrentText(model_type_txt)
+
+            self._input_channels_mapping_widget.load_ui_from_config()
+            self._training_data_export_widget.load_ui_from_config()
+
+            # NOTE: load the model after setting the model_type above
+            model_file_path = ConfigEntryKey.MODEL_FILE_PATH.get()
+            if model_file_path:
+                self.lineEdit_modelPath.setText(model_file_path)
+                self._load_model_and_display_info(abort_if_no_file_path=True)  # to prepare other ui components
+
+            # needs to be loaded after the model is set up
+            self.doubleSpinBox_resolution_cm_px.setValue(ConfigEntryKey.PREPROCESSING_RESOLUTION.get())
+            self.spinBox_batchSize.setValue(ConfigEntryKey.MODEL_BATCH_SIZE.get())
+            self.checkBox_local_cache.setChecked(ConfigEntryKey.PROCESS_LOCAL_CACHE.get())
+            self.spinBox_processingTileOverlapPercentage.setValue(ConfigEntryKey.PREPROCESSING_TILES_OVERLAP.get())
+
+            self.doubleSpinBox_probabilityThreshold.setValue(
+                ConfigEntryKey.SEGMENTATION_PROBABILITY_THRESHOLD_VALUE.get())
+            self.checkBox_pixelClassEnableThreshold.setChecked(
+                ConfigEntryKey.SEGMENTATION_PROBABILITY_THRESHOLD_ENABLED.get())
+            self._set_probability_threshold_enabled()
+            self.spinBox_dilateErodeSize.setValue(
+                ConfigEntryKey.SEGMENTATION_REMOVE_SMALL_SEGMENT_SIZE.get())
+            self.checkBox_removeSmallAreas.setChecked(
+                ConfigEntryKey.SEGMENTATION_REMOVE_SMALL_SEGMENT_ENABLED.get())
+            self._set_remove_small_segment_enabled()
+
+            self.doubleSpinBox_regressionScaling.setValue(ConfigEntryKey.REGRESSION_OUTPUT_SCALING.get())
+
+            self.doubleSpinBox_confidence.setValue(ConfigEntryKey.DETECTION_CONFIDENCE.get())
+            self.doubleSpinBox_iouScore.setValue(ConfigEntryKey.DETECTION_IOU.get())
+            self.comboBox_detectorType.setCurrentText(ConfigEntryKey.DETECTOR_TYPE.get())
+        except Exception:
+            logging.exception("Failed to load the ui state from config!")
+
+    def _save_ui_to_config(self):
+        """ Save value from the UI forms to the project config
+        """
+        ConfigEntryKey.MODEL_FILE_PATH.set(self.lineEdit_modelPath.text())
+        ConfigEntryKey.INPUT_LAYER_ID.set(self._get_input_layer_id())
+        ConfigEntryKey.MODEL_TYPE.set(self.comboBox_modelType.currentText())
+        ConfigEntryKey.PROCESSED_AREA_TYPE.set(self.comboBox_processedAreaSelection.currentText())
+
+        ConfigEntryKey.PREPROCESSING_RESOLUTION.set(self.doubleSpinBox_resolution_cm_px.value())
+        ConfigEntryKey.MODEL_BATCH_SIZE.set(self.spinBox_batchSize.value())
+        ConfigEntryKey.PROCESS_LOCAL_CACHE.set(self.checkBox_local_cache.isChecked())
+        ConfigEntryKey.PREPROCESSING_TILES_OVERLAP.set(self.spinBox_processingTileOverlapPercentage.value())
+
+        ConfigEntryKey.SEGMENTATION_PROBABILITY_THRESHOLD_ENABLED.set(
+            self.checkBox_pixelClassEnableThreshold.isChecked())
+        ConfigEntryKey.SEGMENTATION_PROBABILITY_THRESHOLD_VALUE.set(self.doubleSpinBox_probabilityThreshold.value())
+        ConfigEntryKey.SEGMENTATION_REMOVE_SMALL_SEGMENT_ENABLED.set(
+            self.checkBox_removeSmallAreas.isChecked())
+        ConfigEntryKey.SEGMENTATION_REMOVE_SMALL_SEGMENT_SIZE.set(self.spinBox_dilateErodeSize.value())
+
+        ConfigEntryKey.REGRESSION_OUTPUT_SCALING.set(self.doubleSpinBox_regressionScaling.value())
+
+        ConfigEntryKey.DETECTION_CONFIDENCE.set(self.doubleSpinBox_confidence.value())
+        ConfigEntryKey.DETECTION_IOU.set(self.doubleSpinBox_iouScore.value())
+        ConfigEntryKey.DETECTOR_TYPE.set(self.comboBox_detectorType.currentText())
+
+        self._input_channels_mapping_widget.save_ui_to_config()
+        self._training_data_export_widget.save_ui_to_config()
+
+    def _rlayer_updated(self):
+        self._input_channels_mapping_widget.set_rlayer(self._get_input_layer())
+
+    def _setup_misc_ui(self):
+        """ Setup some misceleounous ui forms
+        """
+        from deepness.processing.models.model_types import \
+            ModelDefinition  # import here to avoid pulling external dependencies to early
+
+        self._show_debug_warning()
+        combobox = self.comboBox_processedAreaSelection
+        for name in ProcessedAreaType.get_all_names():
+            combobox.addItem(name)
+
+        self.verticalLayout_inputChannelsMapping.addWidget(self._input_channels_mapping_widget)
+        self.verticalLayout_trainingDataExport.addWidget(self._training_data_export_widget)
+
+        self.mMapLayerComboBox_inputLayer.setFilters(QgsMapLayerProxyModel.RasterLayer)
+        self.mMapLayerComboBox_areaMaskLayer.setFilters(QgsMapLayerProxyModel.VectorLayer)
+
+        self.mGroupBox_8.setCollapsed(True)  # collapse the group by default
+        self._set_processed_area_mask_options()
+        self._set_processing_overlap_enabled()
+
+        for model_definition in ModelDefinition.get_model_definitions():
+            self.comboBox_modelType.addItem(model_definition.model_type.value)
+
+        for detector_type in DetectorType.get_all_display_values():
+            self.comboBox_detectorType.addItem(detector_type)
+        self._detector_type_changed()
+
+        self._rlayer_updated()  # to force refresh the dependant ui elements
+
+    def _set_processed_area_mask_options(self):
+        show_mask_combobox = (self.get_selected_processed_area_type() == ProcessedAreaType.FROM_POLYGONS)
+        self.mMapLayerComboBox_areaMaskLayer.setVisible(show_mask_combobox)
+        self.label_areaMaskLayer.setVisible(show_mask_combobox)
+
+    def get_selected_processed_area_type(self) -> ProcessedAreaType:
+        combobox = self.comboBox_processedAreaSelection  # type: QComboBox
+        txt = combobox.currentText()
+        return ProcessedAreaType(txt)
+
+    def _create_connections(self):
+        self.pushButton_runInference.clicked.connect(self._run_inference)
+        self.pushButton_runTrainingDataExport.clicked.connect(self._run_training_data_export)
+        self.pushButton_browseQueryImagePath.clicked.connect(self._browse_query_image_path)
+        self.pushButton_browseModelPath.clicked.connect(self._browse_model_path)
+        self.comboBox_processedAreaSelection.currentIndexChanged.connect(self._set_processed_area_mask_options)
+        self.comboBox_modelType.currentIndexChanged.connect(self._model_type_changed)
+        self.comboBox_detectorType.currentIndexChanged.connect(self._detector_type_changed)
+        self.pushButton_reloadModel.clicked.connect(self._load_model_and_display_info)
+        self.pushButton_loadDefaultModelParameters.clicked.connect(self._load_default_model_parameters)
+        self.mMapLayerComboBox_inputLayer.layerChanged.connect(self._rlayer_updated)
+        self.checkBox_pixelClassEnableThreshold.stateChanged.connect(self._set_probability_threshold_enabled)
+        self.checkBox_removeSmallAreas.stateChanged.connect(self._set_remove_small_segment_enabled)
+        self.radioButton_processingTileOverlapPercentage.toggled.connect(self._set_processing_overlap_enabled)
+        self.radioButton_processingTileOverlapPixels.toggled.connect(self._set_processing_overlap_enabled)
+
+    def _model_type_changed(self):
+        from deepness.processing.models.model_types import \
+            ModelType  # import here to avoid pulling external dependencies to early
+
+        model_type = ModelType(self.comboBox_modelType.currentText())
+
+        segmentation_enabled = False
+        detection_enabled = False
+        regression_enabled = False
+        superresolution_enabled = False
+        recognition_enabled = False
+
+        if model_type == ModelType.SEGMENTATION:
+            segmentation_enabled = True
+        elif model_type == ModelType.DETECTION:
+            detection_enabled = True
+        elif model_type == ModelType.REGRESSION:
+            regression_enabled = True
+        elif model_type == ModelType.SUPERRESOLUTION:
+            superresolution_enabled = True
+        elif model_type == ModelType.RECOGNITION:
+            recognition_enabled = True
+        else:
+            raise Exception(f"Unsupported model type ({model_type})!")
+
+        self.mGroupBox_segmentationParameters.setVisible(segmentation_enabled)
+        self.mGroupBox_detectionParameters.setVisible(detection_enabled)
+        self.mGroupBox_regressionParameters.setVisible(regression_enabled)
+        self.mGroupBox_superresolutionParameters.setVisible(superresolution_enabled)
+        self.mGroupBox_recognitionParameters.setVisible(recognition_enabled)
+
+    def _detector_type_changed(self):
+        detector_type = DetectorType(self.comboBox_detectorType.currentText())
+        self.label_detectorTypeDescription.setText(detector_type.get_formatted_description())
+        
+    def _set_processing_overlap_enabled(self):
+        overlap_percentage_enabled = self.radioButton_processingTileOverlapPercentage.isChecked()
+        self.spinBox_processingTileOverlapPercentage.setEnabled(overlap_percentage_enabled)
+
+        overlap_pixels_enabled = self.radioButton_processingTileOverlapPixels.isChecked()
+        self.spinBox_processingTileOverlapPixels.setEnabled(overlap_pixels_enabled)
+
+    def _set_probability_threshold_enabled(self):
+        self.doubleSpinBox_probabilityThreshold.setEnabled(self.checkBox_pixelClassEnableThreshold.isChecked())
+
+    def _set_remove_small_segment_enabled(self):
+        self.spinBox_dilateErodeSize.setEnabled(self.checkBox_removeSmallAreas.isChecked())
+
+    def _browse_model_path(self):
+        file_path, _ = QFileDialog.getOpenFileName(
+            self,
+            'Select Model ONNX file...',
+            os.path.expanduser('~'),
+            'All files (*.*);; ONNX files (*.onnx)')
+        if file_path:
+            self.lineEdit_modelPath.setText(file_path)
+            self._load_model_and_display_info()
+
+    def _browse_query_image_path(self):
+        file_path, _ = QFileDialog.getOpenFileName(
+            self,
+            "Select image file...",
+            os.path.expanduser("~"),
+            "All files (*.*)",
+        )
+        if file_path:
+            self.lineEdit_recognitionPath.setText(file_path)
+
+    def _load_default_model_parameters(self):
+        """
+        Load the default parameters from model metadata
+        """
+        value = self._model.get_metadata_resolution()
+        if value is not None:
+            self.doubleSpinBox_resolution_cm_px.setValue(value)
+
+        value = self._model.get_model_batch_size()
+        if value is not None:
+            self.spinBox_batchSize.setValue(value)
+            self.spinBox_batchSize.setEnabled(False)
+        else:
+            self.spinBox_batchSize.setEnabled(True)
+
+        value = self._model.get_metadata_tile_size()
+        if value is not None:
+            self.spinBox_tileSize_px.setValue(value)
+
+        value = self._model.get_metadata_tiles_overlap()
+        if value is not None:
+            self.spinBox_processingTileOverlapPercentage.setValue(value)
+
+        value = self._model.get_metadata_model_type()
+        if value is not None:
+            print(f'{value =}')
+            self.comboBox_modelType.setCurrentText(value)
+
+        value = self._model.get_detector_type()
+        if value is not None:
+            self.comboBox_detectorType.setCurrentText(value)
+
+        value = self._model.get_metadata_segmentation_threshold()
+        if value is not None:
+            self.checkBox_pixelClassEnableThreshold.setChecked(bool(value != 0))
+            self.doubleSpinBox_probabilityThreshold.setValue(value)
+
+        value = self._model.get_metadata_segmentation_small_segment()
+        if value is not None:
+            self.checkBox_removeSmallAreas.setChecked(bool(value != 0))
+            self.spinBox_dilateErodeSize.setValue(value)
+
+        value = self._model.get_metadata_regression_output_scaling()
+        if value is not None:
+            self.doubleSpinBox_regressionScaling.setValue(value)
+
+        value = self._model.get_metadata_detection_confidence()
+        if value is not None:
+            self.doubleSpinBox_confidence.setValue(value)
+
+        value = self._model.get_metadata_detection_iou_threshold()
+        if value is not None:
+            self.doubleSpinBox_iouScore.setValue(value)
+
+    def _load_model_with_type_from_metadata(self, model_class_from_ui, file_path):
+        """
+        If model has model_type in metadata - use this type to create proper model class.
+        Otherwise model_class_from_ui will be used
+        """
+        from deepness.processing.models.model_types import (  # import here to avoid pulling external dependencies to early
+            ModelDefinition, ModelType)
+
+        model_class = model_class_from_ui
+
+        model_type_str_from_metadata = ModelBase.get_model_type_from_metadata(file_path)
+        if model_type_str_from_metadata is not None:
+            model_type = ModelType(model_type_str_from_metadata)
+            model_class = ModelDefinition.get_definition_for_type(model_type).model_class
+            self.comboBox_modelType.setCurrentText(model_type.value)
+
+        print(f'{model_type_str_from_metadata = }, {model_class = }')
+
+        model = model_class(file_path)
+        return model
+
+    def _load_model_and_display_info(self, abort_if_no_file_path: bool = False):
+        """
+        Tries to load the model and display its message.
+        """
+        import deepness.processing.models.detector as detector_module  # import here to avoid pulling external dependencies to early
+        from deepness.processing.models.model_types import \
+            ModelType  # import here to avoid pulling external dependencies to early
+
+        file_path = self.lineEdit_modelPath.text()
+
+        if not file_path and abort_if_no_file_path:
+            return
+
+        txt = ''
+
+        try:
+            model_definition = self.get_selected_model_class_definition()
+            model_class = model_definition.model_class
+            self._model = self._load_model_with_type_from_metadata(
+                model_class_from_ui=model_class,
+                file_path=file_path)
+            self._model.check_loaded_model_outputs()
+            input_0_shape = self._model.get_input_shape()
+            txt += 'Legend: [BATCH_SIZE, CHANNELS, HEIGHT, WIDTH]\n'
+            txt += 'Inputs:\n'
+            txt += f'\t- Input: {input_0_shape}\n'
+            input_size_px = input_0_shape[-1]
+            batch_size = self._model.get_model_batch_size()
+
+            txt += 'Outputs:\n'
+            
+            for i, output_shape in enumerate(self._model.get_output_shapes()):
+                txt += f'\t- Output {i}: {output_shape}\n'
+
+            # TODO idk how variable input will be handled
+            self.spinBox_tileSize_px.setValue(input_size_px)
+            self.spinBox_tileSize_px.setEnabled(False)
+
+            if batch_size is not None:
+                self.spinBox_batchSize.setValue(batch_size)
+                self.spinBox_batchSize.setEnabled(False)
+            else:
+                self.spinBox_batchSize.setEnabled(True)
+
+            self._input_channels_mapping_widget.set_model(self._model)
+
+            # super resolution
+            if model_class == ModelType.SUPERRESOLUTION:
+                output_0_shape = self._model.get_output_shape()
+                scale_factor = output_0_shape[-1] / input_size_px
+                self.doubleSpinBox_superresolutionScaleFactor.setValue(int(scale_factor))
+                # Disable output format options for super-resolution models
+        except Exception as e:
+            if IS_DEBUG:
+                raise e
+            txt = "Error! Failed to load the model!\n" \
+                  "Model may be not usable."
+            logging.exception(txt)
+            self.spinBox_tileSize_px.setEnabled(True)
+            self.spinBox_batchSize.setEnabled(True)
+            length_limit = 300
+            exception_msg = (str(e)[:length_limit] + '..') if len(str(e)) > length_limit else str(e)
+            msg = txt + f'\n\nException: {exception_msg}'
+            QMessageBox.critical(self, "Error!", msg)
+
+        self.label_modelInfo.setText(txt)
+
+        if isinstance(self._model, detector_module.Detector):
+            detector_type = DetectorType(self.comboBox_detectorType.currentText())
+            self._model.set_model_type_param(detector_type)
+
+    def get_mask_layer_id(self):
+        if not self.get_selected_processed_area_type() == ProcessedAreaType.FROM_POLYGONS:
+            return None
+
+        mask_layer_id = self.mMapLayerComboBox_areaMaskLayer.currentLayer().id()
+        return mask_layer_id
+
+    def _get_input_layer(self):
+        return self.mMapLayerComboBox_inputLayer.currentLayer()
+
+    def _get_input_layer_id(self):
+        layer = self._get_input_layer()
+        if layer:
+            return layer.id()
+        else:
+            return ''
+
+    def _get_overlap_parameter(self):
+        if self.radioButton_processingTileOverlapPercentage.isChecked():
+            return ProcessingOverlap(
+                selected_option=ProcessingOverlapOptions.OVERLAP_IN_PERCENT,
+                percentage=self.spinBox_processingTileOverlapPercentage.value(),
+            )
+        elif self.radioButton_processingTileOverlapPixels.isChecked():
+            return ProcessingOverlap(
+                selected_option=ProcessingOverlapOptions.OVERLAP_IN_PIXELS,
+                overlap_px=self.spinBox_processingTileOverlapPixels.value(),
+            )
+        else:
+            raise Exception('Something goes wrong. No overlap parameter selected!')
+
+    def _get_pixel_classification_threshold(self):
+        if not self.checkBox_pixelClassEnableThreshold.isChecked():
+            return 0
+        return self.doubleSpinBox_probabilityThreshold.value()
+
+    def get_selected_model_class_definition(self):   # -> ModelDefinition: # we cannot import it here yet
+        """
+        Get the currently selected model class (in UI)
+        """
+        from deepness.processing.models.model_types import (  # import here to avoid pulling external dependencies to early
+            ModelDefinition, ModelType)
+
+        model_type_txt = self.comboBox_modelType.currentText()
+        model_type = ModelType(model_type_txt)
+        model_definition = ModelDefinition.get_definition_for_type(model_type)
+        return model_definition
+
+    def get_inference_parameters(self) -> MapProcessingParameters:
+        """ Get the parameters for the model interface.
+        The returned type is derived from `MapProcessingParameters` class, depending on the selected model type.
+        """
+        from deepness.processing.models.model_types import \
+            ModelType  # import here to avoid pulling external dependencies to early
+
+        map_processing_parameters = self._get_map_processing_parameters()
+
+        if self._model is None:
+            raise OperationFailedException("Please select and load a model first!")
+
+        model_type = self.get_selected_model_class_definition().model_type
+        if model_type == ModelType.SEGMENTATION:
+            params = self.get_segmentation_parameters(map_processing_parameters)
+        elif model_type == ModelType.REGRESSION:
+            params = self.get_regression_parameters(map_processing_parameters)
+        elif model_type == ModelType.SUPERRESOLUTION:
+            params = self.get_superresolution_parameters(map_processing_parameters)
+        elif model_type == ModelType.RECOGNITION:
+            params = self.get_recognition_parameters(map_processing_parameters)
+        elif model_type == ModelType.DETECTION:
+            params = self.get_detection_parameters(map_processing_parameters)
+
+        else:
+            raise Exception(f"Unknown model type '{model_type}'!")
+
+        return params
+
+    def get_segmentation_parameters(self, map_processing_parameters: MapProcessingParameters) -> SegmentationParameters:
+        postprocessing_dilate_erode_size = self.spinBox_dilateErodeSize.value() \
+            if self.checkBox_removeSmallAreas.isChecked() else 0
+
+        params = SegmentationParameters(
+            **map_processing_parameters.__dict__,
+            postprocessing_dilate_erode_size=postprocessing_dilate_erode_size,
+            pixel_classification__probability_threshold=self._get_pixel_classification_threshold(),
+            model=self._model,
+        )
+        return params
+
+    def get_regression_parameters(self, map_processing_parameters: MapProcessingParameters) -> RegressionParameters:
+        params = RegressionParameters(
+            **map_processing_parameters.__dict__,
+            output_scaling=self.doubleSpinBox_regressionScaling.value(),
+            model=self._model,
+        )
+        return params
+
+    def get_superresolution_parameters(self, map_processing_parameters: MapProcessingParameters) -> SuperresolutionParameters:
+        params = SuperresolutionParameters(
+            **map_processing_parameters.__dict__,
+            model=self._model,
+            scale_factor=self.doubleSpinBox_superresolutionScaleFactor.value(),
+            output_scaling=self.doubleSpinBox_superresolutionScaling.value(),
+        )
+        return params
+
+    def get_recognition_parameters(self, map_processing_parameters: MapProcessingParameters) -> RecognitionParameters:
+        params = RecognitionParameters(
+            **map_processing_parameters.__dict__,
+            model=self._model,
+            query_image_path=self.lineEdit_recognitionPath.text(),
+        )
+        return params
+
+    def get_detection_parameters(self, map_processing_parameters: MapProcessingParameters) -> DetectionParameters:
+
+        params = DetectionParameters(
+            **map_processing_parameters.__dict__,
+            confidence=self.doubleSpinBox_confidence.value(),
+            iou_threshold=self.doubleSpinBox_iouScore.value(),
+            model=self._model,
+            detector_type=DetectorType(self.comboBox_detectorType.currentText()),
+        )
+
+        return params
+
+    def _get_map_processing_parameters(self) -> MapProcessingParameters:
+        """
+        Get common parameters for inference and exporting
+        """
+        processed_area_type = self.get_selected_processed_area_type()
+        params = MapProcessingParameters(
+            resolution_cm_per_px=self.doubleSpinBox_resolution_cm_px.value(),
+            tile_size_px=self.spinBox_tileSize_px.value(),
+            batch_size=self.spinBox_batchSize.value(),
+            local_cache=self.checkBox_local_cache.isChecked(),
+            processed_area_type=processed_area_type,
+            mask_layer_id=self.get_mask_layer_id(),
+            input_layer_id=self._get_input_layer_id(),
+            processing_overlap=self._get_overlap_parameter(),
+            input_channels_mapping=self._input_channels_mapping_widget.get_channels_mapping(),
+        )
+        return params
+
+    def _run_inference(self):
+        # check_required_packages_and_install_if_necessary()
+        try:
+            params = self.get_inference_parameters()
+
+            if not params.input_layer_id:
+                raise OperationFailedException("Please select an input layer first!")
+        except OperationFailedException as e:
+            msg = str(e)
+            self.iface.messageBar().pushMessage(PLUGIN_NAME, msg, level=Qgis.Warning, duration=7)
+            logging.exception(msg)
+            QMessageBox.critical(self, "Error!", msg)
+            return
+
+        self._save_ui_to_config()
+        self.run_model_inference_signal.emit(params)
+
+    def _run_training_data_export(self):
+        # check_required_packages_and_install_if_necessary()
+        try:
+            map_processing_parameters = self._get_map_processing_parameters()
+            training_data_export_parameters = self._training_data_export_widget.get_training_data_export_parameters(
+                map_processing_parameters)
+
+            if not map_processing_parameters.input_layer_id:
+                raise OperationFailedException("Please select an input layer first!")
+
+            # Overwrite common parameter - we don't want channels mapping as for the model,
+            # but just to take all channels
+            training_data_export_parameters.input_channels_mapping = \
+                self._input_channels_mapping_widget.get_channels_mapping_for_training_data_export()
+        except OperationFailedException as e:
+            msg = str(e)
+            self.iface.messageBar().pushMessage(PLUGIN_NAME, msg, level=Qgis.Warning)
+            logging.exception(msg)
+            QMessageBox.critical(self, "Error!", msg)
+            return
+
+        self._save_ui_to_config()
+        self.run_training_data_export_signal.emit(training_data_export_parameters)
+
+    def closeEvent(self, event):
+        self.closingPlugin.emit()
+        event.accept()

zipdeepness/deepness_dockwidget.ui

@@ -0,0 +1,893 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>DeepnessDockWidgetBase</class>
+ <widget class="QDockWidget" name="DeepnessDockWidgetBase">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>486</width>
+    <height>1368</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Deepness</string>
+  </property>
+  <widget class="QWidget" name="dockWidgetContents">
+   <layout class="QGridLayout" name="gridLayout">
+    <item row="0" column="0">
+     <widget class="QScrollArea" name="scrollArea">
+      <property name="widgetResizable">
+       <bool>true</bool>
+      </property>
+      <widget class="QWidget" name="scrollAreaWidgetContents">
+       <property name="geometry">
+        <rect>
+         <x>0</x>
+         <y>-268</y>
+         <width>452</width>
+         <height>1564</height>
+        </rect>
+       </property>
+       <layout class="QVBoxLayout" name="verticalLayout_3">
+        <property name="leftMargin">
+         <number>0</number>
+        </property>
+        <property name="rightMargin">
+         <number>0</number>
+        </property>
+        <property name="bottomMargin">
+         <number>0</number>
+        </property>
+        <item>
+         <widget class="QLabel" name="label_debugModeWarning">
+          <property name="font">
+           <font>
+            <pointsize>9</pointsize>
+            <bold>true</bold>
+           </font>
+          </property>
+          <property name="styleSheet">
+           <string notr="true">color:rgb(198, 70, 0)</string>
+          </property>
+          <property name="text">
+           <string>WARNING: Running plugin in DEBUG mode
+(because env variable IS_DEBUG=true)</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QgsCollapsibleGroupBox" name="mGroupBox_3">
+          <property name="sizePolicy">
+           <sizepolicy hsizetype="Preferred" vsizetype="Maximum">
+            <horstretch>0</horstretch>
+            <verstretch>0</verstretch>
+           </sizepolicy>
+          </property>
+          <property name="title">
+           <string>Input data:</string>
+          </property>
+          <layout class="QGridLayout" name="gridLayout_5">
+           <item row="0" column="1" colspan="2">
+            <widget class="QgsMapLayerComboBox" name="mMapLayerComboBox_inputLayer">
+             <property name="toolTip">
+              <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;span style=&quot; font-weight:600;&quot;&gt;Layer which will be processed.&lt;/span&gt;&lt;/p&gt;&lt;p&gt;Most probably this is your ortophoto or map source (like satellite image from google earth).&lt;br/&gt;Needs to be a raster layer.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+             </property>
+            </widget>
+           </item>
+           <item row="1" column="1" colspan="2">
+            <widget class="QComboBox" name="comboBox_processedAreaSelection">
+             <property name="toolTip">
+              <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Defines what part of the &amp;quot;Input layer&amp;quot; should be processed.&lt;/p&gt;&lt;p&gt;&lt;br/&gt; - &amp;quot;&lt;span style=&quot; font-style:italic;&quot;&gt;Visible Part&lt;/span&gt;&amp;quot; allows to process the part currently visible on the map canvas.&lt;br/&gt; - &amp;quot;&lt;span style=&quot; font-style:italic;&quot;&gt;Entire Layer&lt;/span&gt;&amp;quot; allows to process the entire ortophoto file&lt;br/&gt; - &amp;quot;&lt;span style=&quot; font-style:italic;&quot;&gt;From Polygons&lt;/span&gt;&amp;quot; allows to select a polygon describing the area to be processed (e.g. if the processed field is a polygon, and we don't want to process outside of it)&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+             </property>
+            </widget>
+           </item>
+           <item row="0" column="0">
+            <widget class="QLabel" name="label_10">
+             <property name="text">
+              <string>Input layer:</string>
+             </property>
+            </widget>
+           </item>
+           <item row="1" column="0">
+            <widget class="QLabel" name="label_11">
+             <property name="text">
+              <string>Processed area mask:</string>
+             </property>
+            </widget>
+           </item>
+           <item row="2" column="0">
+            <widget class="QLabel" name="label_areaMaskLayer">
+             <property name="text">
+              <string>Area mask layer:</string>
+             </property>
+            </widget>
+           </item>
+           <item row="2" column="1" colspan="2">
+            <widget class="QgsMapLayerComboBox" name="mMapLayerComboBox_areaMaskLayer">
+             <property name="toolTip">
+              <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Defines the layer which is being used as a mask for the processing of &amp;quot;Input layer&amp;quot;. &lt;br/&gt;Only pixels within this mask layer will be processed.&lt;/p&gt;&lt;p&gt;Needs to be a vector layer.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+             </property>
+            </widget>
+           </item>
+          </layout>
+         </widget>
+        </item>
+        <item>
+         <widget class="QgsCollapsibleGroupBox" name="mGroupBox">
+          <property name="sizePolicy">
+           <sizepolicy hsizetype="Preferred" vsizetype="Maximum">
+            <horstretch>0</horstretch>
+            <verstretch>0</verstretch>
+           </sizepolicy>
+          </property>
+          <property name="title">
+           <string>ONNX Model</string>
+          </property>
+          <layout class="QGridLayout" name="gridLayout_7">
+           <item row="1" column="1">
+            <widget class="QLineEdit" name="lineEdit_modelPath">
+             <property name="enabled">
+              <bool>true</bool>
+             </property>
+             <property name="toolTip">
+              <string>Path to the model file</string>
+             </property>
+            </widget>
+           </item>
+           <item row="1" column="0">
+            <widget class="QLabel" name="label_4">
+             <property name="text">
+              <string>Model file path:</string>
+             </property>
+            </widget>
+           </item>
+           <item row="1" column="2">
+            <widget class="QPushButton" name="pushButton_browseModelPath">
+             <property name="enabled">
+              <bool>true</bool>
+             </property>
+             <property name="text">
+              <string>Browse...</string>
+             </property>
+            </widget>
+           </item>
+           <item row="0" column="0">
+            <widget class="QLabel" name="label_5">
+             <property name="text">
+              <string>Model type:</string>
+             </property>
+            </widget>
+           </item>
+           <item row="0" column="1">
+            <widget class="QComboBox" name="comboBox_modelType">
+             <property name="toolTip">
+              <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Type of the model (model class) which you want to use.&lt;br/&gt;You should obtain this information along with the model file.&lt;/p&gt;&lt;p&gt;Please refer to the plugin documentation for more details.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+             </property>
+            </widget>
+           </item>
+           <item row="4" column="0">
+            <widget class="QLabel" name="label_3">
+             <property name="text">
+              <string>Model info:</string>
+             </property>
+            </widget>
+           </item>
+           <item row="4" column="1" rowspan="2" colspan="2">
+            <widget class="QLabel" name="label_modelInfo">
+             <property name="font">
+              <font>
+               <pointsize>7</pointsize>
+              </font>
+             </property>
+             <property name="styleSheet">
+              <string notr="true">color: rgb(135, 135, 133);</string>
+             </property>
+             <property name="text">
+              <string>Model not loaded! Please select its path and click &quot;Load Model&quot; button above first!</string>
+             </property>
+             <property name="wordWrap">
+              <bool>true</bool>
+             </property>
+            </widget>
+           </item>
+           <item row="3" column="0" colspan="3">
+            <layout class="QHBoxLayout" name="horizontalLayout_10">
+             <item>
+              <widget class="QPushButton" name="pushButton_reloadModel">
+               <property name="toolTip">
+                <string>Reload the model given in the line edit above</string>
+               </property>
+               <property name="text">
+                <string>Reload Model</string>
+               </property>
+              </widget>
+             </item>
+             <item>
+              <widget class="QPushButton" name="pushButton_loadDefaultModelParameters">
+               <property name="toolTip">
+                <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;span style=&quot; font-weight:600;&quot;&gt;Load default model parameters.&lt;/span&gt;&lt;/p&gt;&lt;p&gt;ONNX Models can have metadata, which can be parsed and used to set default value for fields in UI, w.g. for tile_size or confidence threshold&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+               </property>
+               <property name="text">
+                <string>Load default parameters</string>
+               </property>
+              </widget>
+             </item>
+            </layout>
+           </item>
+          </layout>
+         </widget>
+        </item>
+        <item>
+         <widget class="QgsCollapsibleGroupBox" name="mGroupBox_2">
+          <property name="sizePolicy">
+           <sizepolicy hsizetype="Preferred" vsizetype="Maximum">
+            <horstretch>0</horstretch>
+            <verstretch>0</verstretch>
+           </sizepolicy>
+          </property>
+          <property name="title">
+           <string>Input channels mapping</string>
+          </property>
+          <layout class="QGridLayout" name="gridLayout_4">
+           <item row="1" column="0">
+            <layout class="QVBoxLayout" name="verticalLayout_inputChannelsMapping"/>
+           </item>
+           <item row="0" column="0">
+            <widget class="QLabel" name="label_12">
+             <property name="font">
+              <font>
+               <bold>true</bold>
+              </font>
+             </property>
+             <property name="text">
+              <string>NOTE: This configuration is depending on the input layer and model type. Please make sure to select the &quot;Input layer&quot; and load the model first!</string>
+             </property>
+             <property name="wordWrap">
+              <bool>true</bool>
+             </property>
+            </widget>
+           </item>
+          </layout>
+         </widget>
+        </item>
+        <item>
+         <widget class="QgsCollapsibleGroupBox" name="mGroupBox_4">
+          <property name="sizePolicy">
+           <sizepolicy hsizetype="Preferred" vsizetype="Maximum">
+            <horstretch>0</horstretch>
+            <verstretch>0</verstretch>
+           </sizepolicy>
+          </property>
+          <property name="title">
+           <string>Processing parameters</string>
+          </property>
+          <layout class="QGridLayout" name="gridLayout_8">
+           <item row="6" column="0" colspan="3">
+            <widget class="QGroupBox" name="groupBox">
+             <property name="title">
+              <string>Tiles overlap:</string>
+             </property>
+             <layout class="QGridLayout" name="gridLayout_3">
+              <item row="0" column="3">
+               <widget class="QRadioButton" name="radioButton_processingTileOverlapPixels">
+                <property name="text">
+                 <string>[px]</string>
+                </property>
+               </widget>
+              </item>
+              <item row="0" column="2">
+               <spacer name="horizontalSpacer_2">
+                <property name="orientation">
+                 <enum>Qt::Horizontal</enum>
+                </property>
+                <property name="sizeHint" stdset="0">
+                 <size>
+                  <width>40</width>
+                  <height>20</height>
+                 </size>
+                </property>
+               </spacer>
+              </item>
+              <item row="0" column="1">
+               <widget class="QSpinBox" name="spinBox_processingTileOverlapPercentage">
+                <property name="sizePolicy">
+                 <sizepolicy hsizetype="MinimumExpanding" vsizetype="Fixed">
+                  <horstretch>0</horstretch>
+                  <verstretch>0</verstretch>
+                 </sizepolicy>
+                </property>
+                <property name="minimumSize">
+                 <size>
+                  <width>80</width>
+                  <height>0</height>
+                 </size>
+                </property>
+                <property name="toolTip">
+                 <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Defines how much tiles should overlap on their neighbours during processing.&lt;/p&gt;&lt;p&gt;Especially required for model which introduce distortions on the edges of images, so that it can be removed in postprocessing.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+                </property>
+                <property name="suffix">
+                 <string/>
+                </property>
+                <property name="value">
+                 <number>15</number>
+                </property>
+               </widget>
+              </item>
+              <item row="0" column="4">
+               <widget class="QSpinBox" name="spinBox_processingTileOverlapPixels">
+                <property name="sizePolicy">
+                 <sizepolicy hsizetype="MinimumExpanding" vsizetype="Fixed">
+                  <horstretch>0</horstretch>
+                  <verstretch>0</verstretch>
+                 </sizepolicy>
+                </property>
+                <property name="minimumSize">
+                 <size>
+                  <width>80</width>
+                  <height>0</height>
+                 </size>
+                </property>
+                <property name="maximum">
+                 <number>9999999</number>
+                </property>
+               </widget>
+              </item>
+              <item row="0" column="0">
+               <widget class="QRadioButton" name="radioButton_processingTileOverlapPercentage">
+                <property name="text">
+                 <string>[%]</string>
+                </property>
+                <property name="checked">
+                 <bool>true</bool>
+                </property>
+               </widget>
+              </item>
+             </layout>
+            </widget>
+           </item>
+           <item row="2" column="1">
+            <widget class="QSpinBox" name="spinBox_tileSize_px">
+             <property name="enabled">
+              <bool>true</bool>
+             </property>
+             <property name="toolTip">
+              <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Size of the images passed to the model.&lt;/p&gt;&lt;p&gt;Usually needs to be the same as the one used during training.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+             </property>
+             <property name="maximum">
+              <number>99999</number>
+             </property>
+             <property name="value">
+              <number>512</number>
+             </property>
+            </widget>
+           </item>
+           <item row="1" column="1">
+            <widget class="QDoubleSpinBox" name="doubleSpinBox_resolution_cm_px">
+             <property name="toolTip">
+              <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Defines the processing resolution of the &amp;quot;Input layer&amp;quot;.&lt;/p&gt;&lt;p&gt;&lt;br/&gt;&lt;/p&gt;&lt;p&gt;Determines the resolution of images fed into the model, allowing to scale the input images.&lt;/p&gt;&lt;p&gt;Should be similar as the resolution used to train the model.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+             </property>
+             <property name="decimals">
+              <number>2</number>
+             </property>
+             <property name="minimum">
+              <double>0.000000000000000</double>
+             </property>
+             <property name="maximum">
+              <double>999999.000000000000000</double>
+             </property>
+             <property name="value">
+              <double>3.000000000000000</double>
+             </property>
+            </widget>
+           </item>
+           <item row="2" column="0">
+            <widget class="QLabel" name="label_8">
+             <property name="text">
+              <string>Tile size [px]:</string>
+             </property>
+            </widget>
+           </item>
+           <item row="1" column="0">
+            <widget class="QLabel" name="label">
+             <property name="text">
+              <string>Resolution [cm/px]:</string>
+             </property>
+            </widget>
+           </item>
+           <item row="0" column="0" colspan="3">
+            <widget class="QLabel" name="label_13">
+             <property name="font">
+              <font>
+               <italic>false</italic>
+               <bold>true</bold>
+              </font>
+             </property>
+             <property name="text">
+              <string>NOTE: These options may be a fixed value for some models</string>
+             </property>
+             <property name="wordWrap">
+              <bool>true</bool>
+             </property>
+            </widget>
+           </item>
+           <item row="3" column="0">
+            <widget class="QLabel" name="label_19">
+             <property name="text">
+              <string>Batch size:</string>
+             </property>
+            </widget>
+           </item>
+           <item row="3" column="1">
+            <widget class="QSpinBox" name="spinBox_batchSize">
+             <property name="toolTip">
+              <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;The size of the data batch in the model.&lt;/p&gt;&lt;p&gt;The size depends on the computing resources, in particular the available RAM / GPU memory.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+             </property>
+             <property name="minimum">
+              <number>1</number>
+             </property>
+             <property name="maximum">
+              <number>9999999</number>
+             </property>
+            </widget>
+           </item>
+           <item row="4" column="0">
+            <widget class="QCheckBox" name="checkBox_local_cache">
+             <property name="toolTip">
+              <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;If True, local memory caching is performed - this is helpful when large area maps are processed, but is probably slower than processing in RAM.&lt;/p&gt;&lt;p&gt;&lt;br/&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+             </property>
+             <property name="text">
+              <string>Process using local cache</string>
+             </property>
+            </widget>
+           </item>
+          </layout>
+         </widget>
+        </item>
+        <item>
+         <widget class="QgsCollapsibleGroupBox" name="mGroupBox_segmentationParameters">
+          <property name="sizePolicy">
+           <sizepolicy hsizetype="Preferred" vsizetype="Maximum">
+            <horstretch>0</horstretch>
+            <verstretch>0</verstretch>
+           </sizepolicy>
+          </property>
+          <property name="title">
+           <string>Segmentation parameters</string>
+          </property>
+          <layout class="QGridLayout" name="gridLayout_10">
+           <item row="2" column="2">
+            <widget class="QDoubleSpinBox" name="doubleSpinBox_probabilityThreshold">
+             <property name="toolTip">
+              <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Minimum required probability for the class to be considered as belonging to this class.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+             </property>
+             <property name="decimals">
+              <number>2</number>
+             </property>
+             <property name="maximum">
+              <double>1.000000000000000</double>
+             </property>
+             <property name="singleStep">
+              <double>0.050000000000000</double>
+             </property>
+             <property name="value">
+              <double>0.500000000000000</double>
+             </property>
+            </widget>
+           </item>
+           <item row="1" column="1">
+            <widget class="QCheckBox" name="checkBox_pixelClassArgmaxEnabled">
+             <property name="enabled">
+              <bool>false</bool>
+             </property>
+             <property name="toolTip">
+              <string/>
+             </property>
+             <property name="text">
+              <string>Argmax (most probable class only)</string>
+             </property>
+             <property name="checked">
+              <bool>true</bool>
+             </property>
+            </widget>
+           </item>
+           <item row="2" column="1">
+            <widget class="QCheckBox" name="checkBox_pixelClassEnableThreshold">
+             <property name="text">
+              <string>Apply class probability threshold:</string>
+             </property>
+             <property name="checked">
+              <bool>true</bool>
+             </property>
+            </widget>
+           </item>
+           <item row="3" column="2">
+            <widget class="QSpinBox" name="spinBox_dilateErodeSize">
+             <property name="toolTip">
+              <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Postprocessing option, to remove small areas (small clusters of pixels) belonging to each class, smoothing the predictions.&lt;/p&gt;&lt;p&gt;The actual size (in meters) of the smoothing can be calculated as &amp;quot;Resolution&amp;quot; * &amp;quot;value of this parameter&amp;quot;.&lt;br/&gt;Works as application of dilate and erode operation (twice, in reverse order).&lt;br/&gt;Similar effect to median filter.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+             </property>
+             <property name="value">
+              <number>9</number>
+             </property>
+            </widget>
+           </item>
+           <item row="0" column="1" colspan="2">
+            <widget class="QLabel" name="label_2">
+             <property name="font">
+              <font>
+               <bold>true</bold>
+              </font>
+             </property>
+             <property name="text">
+              <string>NOTE: Applicable only if a segmentation model is used</string>
+             </property>
+            </widget>
+           </item>
+           <item row="3" column="1">
+            <widget class="QCheckBox" name="checkBox_removeSmallAreas">
+             <property name="text">
+              <string>Remove small segment 
+ areas (dilate/erode size) [px]:</string>
+             </property>
+             <property name="checked">
+              <bool>true</bool>
+             </property>
+            </widget>
+           </item>
+          </layout>
+         </widget>
+        </item>
+        <item>
+         <widget class="QgsCollapsibleGroupBox" name="mGroupBox_superresolutionParameters">
+          <property name="sizePolicy">
+           <sizepolicy hsizetype="Preferred" vsizetype="Maximum">
+            <horstretch>0</horstretch>
+            <verstretch>0</verstretch>
+           </sizepolicy>
+          </property>
+          <property name="title">
+           <string>Superresolution Parameters</string>
+          </property>
+          <layout class="QGridLayout" name="gridLayout_6">
+           <item row="0" column="0">
+            <widget class="QLabel" name="label_7">
+             <property name="text">
+              <string>Upscaling Factor</string>
+             </property>
+            </widget>
+           </item>
+           <item row="0" column="1">
+            <widget class="QgsSpinBox" name="doubleSpinBox_superresolutionScaleFactor">
+             <property name="minimum">
+              <number>2</number>
+             </property>
+            </widget>
+           </item>
+           <item row="1" column="1">
+            <widget class="QgsDoubleSpinBox" name="doubleSpinBox_superresolutionScaling">
+             <property name="maximum">
+              <double>100000000000.000000000000000</double>
+             </property>
+             <property name="value">
+              <double>255.000000000000000</double>
+             </property>
+            </widget>
+           </item>
+           <item row="1" column="0">
+            <widget class="QLabel" name="label_14">
+             <property name="text">
+              <string>Output scaling</string>
+             </property>
+            </widget>
+           </item>
+          </layout>
+         </widget>
+        </item>
+        <item>
+         <widget class="QgsCollapsibleGroupBox" name="mGroupBox_regressionParameters">
+          <property name="sizePolicy">
+           <sizepolicy hsizetype="Preferred" vsizetype="Maximum">
+            <horstretch>0</horstretch>
+            <verstretch>0</verstretch>
+           </sizepolicy>
+          </property>
+          <property name="title">
+           <string>Regression parameters</string>
+          </property>
+          <layout class="QGridLayout" name="gridLayout_11">
+           <item row="1" column="1">
+            <widget class="QDoubleSpinBox" name="doubleSpinBox_regressionScaling">
+             <property name="toolTip">
+              <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Scaling factor for model output values.&lt;/p&gt;&lt;p&gt;Each pixel value will be multiplied by this factor.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+             </property>
+             <property name="decimals">
+              <number>3</number>
+             </property>
+             <property name="maximum">
+              <double>9999.000000000000000</double>
+             </property>
+             <property name="value">
+              <double>1.000000000000000</double>
+             </property>
+            </widget>
+           </item>
+           <item row="1" column="0">
+            <widget class="QLabel" name="label_6">
+             <property name="text">
+              <string>Output scaling 
+(keep 1.00 if max output value is 1):</string>
+             </property>
+            </widget>
+           </item>
+          </layout>
+         </widget>
+        </item>
+        <item>
+         <widget class="QgsCollapsibleGroupBox" name="mGroupBox_recognitionParameters">
+          <property name="sizePolicy">
+           <sizepolicy hsizetype="Preferred" vsizetype="Maximum">
+            <horstretch>0</horstretch>
+            <verstretch>0</verstretch>
+           </sizepolicy>
+          </property>
+          <property name="title">
+           <string>Recognition parameters</string>
+          </property>
+          <layout class="QGridLayout" name="gridLayout_12">
+           <item row="1" column="1" colspan="2">
+            <widget class="QLabel" name="label_23">
+             <property name="font">
+              <font>
+               <bold>true</bold>
+              </font>
+             </property>
+             <property name="text">
+              <string>NOTE: Applicable only if a recognition model is used</string>
+             </property>
+            </widget>
+           </item>
+           <item row="3" column="1" colspan="2">
+            <widget class="QLabel" name="label_24">
+             <property name="text">
+              <string>Image to localize path:</string>
+             </property>
+            </widget>
+           </item>
+           <item row="4" column="1">
+            <widget class="QLineEdit" name="lineEdit_recognitionPath"/>
+           </item>
+           <item row="4" column="2">
+            <widget class="QPushButton" name="pushButton_browseQueryImagePath">
+             <property name="text">
+              <string>Browse</string>
+             </property>
+            </widget>
+           </item>
+          </layout>
+         </widget>
+        </item>
+        <item>
+         <widget class="QgsCollapsibleGroupBox" name="mGroupBox_detectionParameters">
+          <property name="title">
+           <string>Detection parameters</string>
+          </property>
+          <layout class="QGridLayout" name="gridLayout_9">
+           <item row="3" column="0">
+            <widget class="QLabel" name="label_21">
+             <property name="text">
+              <string>Confidence:</string>
+             </property>
+            </widget>
+           </item>
+           <item row="1" column="0">
+            <widget class="QLabel" name="label_16">
+             <property name="text">
+              <string>Detector type:</string>
+             </property>
+            </widget>
+           </item>
+           <item row="1" column="1">
+            <widget class="QComboBox" name="comboBox_detectorType"/>
+           </item>
+           <item row="5" column="0">
+            <widget class="QLabel" name="label_22">
+             <property name="text">
+              <string>IoU threshold:</string>
+             </property>
+            </widget>
+           </item>
+           <item row="3" column="1">
+            <widget class="QDoubleSpinBox" name="doubleSpinBox_confidence">
+             <property name="toolTip">
+              <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Minimal confidence of the potential detection, to consider it as a detection.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+             </property>
+             <property name="decimals">
+              <number>2</number>
+             </property>
+             <property name="maximum">
+              <double>1.000000000000000</double>
+             </property>
+             <property name="singleStep">
+              <double>0.050000000000000</double>
+             </property>
+            </widget>
+           </item>
+           <item row="0" column="0" colspan="2">
+            <widget class="QLabel" name="label_20">
+             <property name="font">
+              <font>
+               <bold>true</bold>
+              </font>
+             </property>
+             <property name="text">
+              <string>NOTE: Applicable only if a detection model is used</string>
+             </property>
+            </widget>
+           </item>
+           <item row="2" column="0" colspan="2">
+            <widget class="QLabel" name="label_detectorTypeDescription">
+             <property name="font">
+              <font>
+               <pointsize>9</pointsize>
+              </font>
+             </property>
+             <property name="text">
+              <string>Here goes a longer description of detector type...</string>
+             </property>
+            </widget>
+           </item>
+           <item row="5" column="1">
+            <widget class="QDoubleSpinBox" name="doubleSpinBox_iouScore">
+             <property name="toolTip">
+              <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Parameter used in Non Maximum Suppression in post processing.&lt;/p&gt;&lt;p&gt;Defines the threshold of overlap between to neighbouring detections, to consider them as the same object.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+             </property>
+             <property name="decimals">
+              <number>2</number>
+             </property>
+             <property name="maximum">
+              <double>1.000000000000000</double>
+             </property>
+             <property name="singleStep">
+              <double>0.050000000000000</double>
+             </property>
+            </widget>
+           </item>
+          </layout>
+         </widget>
+        </item>
+        <item>
+         <widget class="QgsCollapsibleGroupBox" name="mGroupBox_8">
+          <property name="sizePolicy">
+           <sizepolicy hsizetype="Preferred" vsizetype="Maximum">
+            <horstretch>0</horstretch>
+            <verstretch>0</verstretch>
+           </sizepolicy>
+          </property>
+          <property name="title">
+           <string>Training data export</string>
+          </property>
+          <property name="checkable">
+           <bool>false</bool>
+          </property>
+          <layout class="QVBoxLayout" name="verticalLayout_4">
+           <item>
+            <widget class="QLabel" name="label_15">
+             <property name="text">
+              <string>Note: This group allows to export the data for the training process, with similar data as during inference.</string>
+             </property>
+             <property name="wordWrap">
+              <bool>true</bool>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <layout class="QVBoxLayout" name="verticalLayout_trainingDataExport"/>
+           </item>
+           <item>
+            <layout class="QHBoxLayout" name="horizontalLayout_2">
+             <item>
+              <spacer name="horizontalSpacer">
+               <property name="orientation">
+                <enum>Qt::Horizontal</enum>
+               </property>
+               <property name="sizeHint" stdset="0">
+                <size>
+                 <width>40</width>
+                 <height>20</height>
+                </size>
+               </property>
+              </spacer>
+             </item>
+             <item>
+              <widget class="QPushButton" name="pushButton_runTrainingDataExport">
+               <property name="toolTip">
+                <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Run the export of the data&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+               </property>
+               <property name="text">
+                <string>Export training data</string>
+               </property>
+              </widget>
+             </item>
+            </layout>
+           </item>
+           <item>
+            <widget class="QWidget" name="widget_3" native="true">
+             <layout class="QHBoxLayout" name="horizontalLayout">
+              <property name="leftMargin">
+               <number>0</number>
+              </property>
+              <property name="topMargin">
+               <number>0</number>
+              </property>
+              <property name="rightMargin">
+               <number>0</number>
+              </property>
+              <property name="bottomMargin">
+               <number>0</number>
+              </property>
+             </layout>
+            </widget>
+           </item>
+          </layout>
+         </widget>
+        </item>
+        <item>
+         <spacer name="verticalSpacer">
+          <property name="orientation">
+           <enum>Qt::Vertical</enum>
+          </property>
+          <property name="sizeHint" stdset="0">
+           <size>
+            <width>20</width>
+            <height>40</height>
+           </size>
+          </property>
+         </spacer>
+        </item>
+       </layout>
+      </widget>
+     </widget>
+    </item>
+    <item row="1" column="0">
+     <layout class="QVBoxLayout" name="verticalLayout">
+      <item>
+       <widget class="QPushButton" name="pushButton_runInference">
+        <property name="toolTip">
+         <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Run the inference, for the selected above paraeters.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+        </property>
+        <property name="text">
+         <string>Run</string>
+        </property>
+       </widget>
+      </item>
+     </layout>
+    </item>
+   </layout>
+  </widget>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>QgsCollapsibleGroupBox</class>
+   <extends>QGroupBox</extends>
+   <header>qgscollapsiblegroupbox.h</header>
+   <container>1</container>
+  </customwidget>
+  <customwidget>
+   <class>QgsDoubleSpinBox</class>
+   <extends>QDoubleSpinBox</extends>
+   <header>qgsdoublespinbox.h</header>
+  </customwidget>
+  <customwidget>
+   <class>QgsMapLayerComboBox</class>
+   <extends>QComboBox</extends>
+   <header>qgsmaplayercombobox.h</header>
+  </customwidget>
+  <customwidget>
+   <class>QgsSpinBox</class>
+   <extends>QSpinBox</extends>
+   <header>qgsspinbox.h</header>
+  </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections/>
+</ui>

zipdeepness/dialogs/packages_installer/packages_installer_dialog.py

@@ -0,0 +1,359 @@
+"""
+This QGIS plugin requires some Python packages to be installed and available.
+This tool allows to install them in a local directory, if they are not installed yet.
+"""
+
+import importlib
+import logging
+import os
+import subprocess
+import sys
+import traceback
+import urllib
+from dataclasses import dataclass
+from pathlib import Path
+from threading import Thread
+from typing import List
+
+from qgis.PyQt import QtCore, uic
+from qgis.PyQt.QtCore import pyqtSignal
+from qgis.PyQt.QtGui import QCloseEvent
+from qgis.PyQt.QtWidgets import QDialog, QMessageBox, QTextBrowser
+
+from deepness.common.defines import PLUGIN_NAME
+
+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}')
+
+
+FORM_CLASS, _ = uic.loadUiType(os.path.join(
+    os.path.dirname(__file__), 'packages_installer_dialog.ui'))
+
+_ERROR_COLOR = '#ff0000'
+
+
+@dataclass
+class PackageToInstall:
+    name: str
+    version: str
+    import_name: str  # name while importing package
+
+    def __str__(self):
+        return f'{self.name}{self.version}'
+
+
+REQUIREMENTS_PATH = os.path.join(PLUGIN_ROOT_DIR, 'python_requirements/requirements.txt')
+
+with open(REQUIREMENTS_PATH, 'r') as f:
+    raw_txt = f.read()
+
+libraries_versions = {}
+
+for line in raw_txt.split('\n'):
+    if line.startswith('#') or not line.strip():
+        continue
+
+    line = line.split(';')[0]
+
+    if '==' in line:
+        lib, version = line.split('==')
+        libraries_versions[lib] = '==' + version
+    elif '>=' in line:
+        lib, version = line.split('>=')
+        libraries_versions[lib] = '>=' + version
+    elif '<=' in line:
+        lib, version = line.split('<=')
+        libraries_versions[lib] = '<=' + version
+    else:
+        libraries_versions[line] = ''
+
+
+packages_to_install = [
+    PackageToInstall(name='opencv-python-headless', version=libraries_versions['opencv-python-headless'], import_name='cv2'),
+]
+
+if sys.platform == "linux" or sys.platform == "linux2":
+    packages_to_install += [
+        PackageToInstall(name='onnxruntime-gpu', version=libraries_versions['onnxruntime-gpu'], import_name='onnxruntime'),
+    ]
+    PYTHON_EXECUTABLE_PATH = sys.executable
+elif sys.platform == "darwin":  # MacOS
+    packages_to_install += [
+        PackageToInstall(name='onnxruntime', version=libraries_versions['onnxruntime-gpu'], import_name='onnxruntime'),
+    ]
+    PYTHON_EXECUTABLE_PATH = str(Path(sys.prefix) / 'bin' / 'python3')  # sys.executable yields QGIS in macOS
+elif sys.platform == "win32":
+    packages_to_install += [
+        PackageToInstall(name='onnxruntime', version=libraries_versions['onnxruntime-gpu'], import_name='onnxruntime'),
+    ]
+    PYTHON_EXECUTABLE_PATH = 'python'  # sys.executable yields QGis.exe in Windows
+else:
+    raise Exception("Unsupported operating system!")
+
+
+class PackagesInstallerDialog(QDialog, FORM_CLASS):
+    """
+    Dialog witch controls the installation process of packages.
+    UI design defined in the `packages_installer_dialog.ui` file.
+    """
+
+    signal_log_line = pyqtSignal(str)  # we need to use signal because we cannot edit GUI from another thread
+
+    INSTALLATION_IN_PROGRESS = False  # to make sure we will not start the installation twice
+
+    def __init__(self, iface, parent=None):
+        super(PackagesInstallerDialog, self).__init__(parent)
+        self.setupUi(self)
+        self.iface = iface
+        self.tb = self.textBrowser_log  # type: QTextBrowser
+        self._create_connections()
+        self._setup_message()
+        self.aborted = False
+        self.thread = None
+
+    def move_to_top(self):
+        """ Move the window to the top.
+        Although if installed from plugin manager, the plugin manager will move itself to the top anyway.
+        """
+        self.setWindowState((self.windowState() & ~QtCore.Qt.WindowMinimized) | QtCore.Qt.WindowActive)
+
+        if sys.platform == "linux" or sys.platform == "linux2":
+            pass
+        elif sys.platform == "darwin":  # MacOS
+            self.raise_()  # FIXME: this does not really work, the window is still behind the plugin manager
+        elif sys.platform == "win32":
+            self.activateWindow()
+        else:
+            raise Exception("Unsupported operating system!")
+
+    def _create_connections(self):
+        self.pushButton_close.clicked.connect(self.close)
+        self.pushButton_install_packages.clicked.connect(self._run_packages_installation)
+        self.signal_log_line.connect(self._log_line)
+
+    def _log_line(self, txt):
+        txt = txt \
+            .replace('  ', '&nbsp;&nbsp;') \
+            .replace('\n', '<br>')
+        self.tb.append(txt)
+
+    def log(self, txt):
+        self.signal_log_line.emit(txt)
+
+    def _setup_message(self) -> None:
+          
+        self.log(f'<h2><span style="color: #000080;"><strong>  '
+                 f'Plugin {PLUGIN_NAME} - Packages installer </strong></span></h2> \n'
+                 f'\n'
+                 f'<b>This plugin requires the following Python packages to be installed:</b>')
+        
+        for package in packages_to_install:
+            self.log(f'\t- {package.name}{package.version}')
+
+        self.log('\n\n'
+                 f'If this packages are not installed in the global environment '
+                 f'(or environment in which QGIS is started) '
+                 f'you can install these packages in the local directory (which is included to the Python path).\n\n'
+                 f'This Dialog does it for you! (Though you can still install these packages manually instead).\n'
+                 f'<b>Please click "Install packages" button below to install them automatically, </b>'
+                 f'or "Test and Close" if you installed them manually...\n')
+
+    def _run_packages_installation(self):
+        if self.INSTALLATION_IN_PROGRESS:
+            self.log(f'Error! Installation already in progress, cannot start again!')
+            return
+        self.aborted = False
+        self.INSTALLATION_IN_PROGRESS = True
+        self.thread = Thread(target=self._install_packages)
+        self.thread.start()
+
+    def _install_packages(self) -> None:
+        self.log('\n\n')
+        self.log('=' * 60)
+        self.log(f'<h3><b>Attempting to install required packages...</b></h3>')
+        os.makedirs(PACKAGES_INSTALL_DIR, exist_ok=True)
+
+        self._install_pip_if_necessary()
+
+        self.log(f'<h3><b>Attempting to install required packages...</b></h3>\n')
+        try:
+            self._pip_install_packages(packages_to_install)
+        except Exception as e:
+            msg = (f'\n <span style="color: {_ERROR_COLOR};"><b> '
+                   f'Packages installation failed with exception: {e}!\n'
+                   f'Please try to install the packages again. </b></span>'
+                   f'\nCheck if there is no error related to system packages, '
+                   f'which may be required to be installed by your system package manager, e.g. "apt". '
+                   f'Copy errors from the stack above and google for possible solutions. '
+                   f'Please report these as an issue on the plugin repository tracker!')
+            self.log(msg)
+
+        # finally, validate the installation, if there was no error so far...
+        self.log('\n\n <b>Installation of required packages finished. Validating installation...</b>')
+        self._check_packages_installation_and_log()
+        self.INSTALLATION_IN_PROGRESS = False
+
+    def reject(self) -> None:
+        self.close()
+
+    def closeEvent(self, event: QCloseEvent):
+        self.aborted = True
+        if self._check_packages_installation_and_log():
+            event.accept()
+            return
+
+        res = QMessageBox.question(self.iface.mainWindow(),
+                                   f'{PLUGIN_NAME} - skip installation?',
+                                   'Are you sure you want to abort the installation of the required python packages? '
+                                   'The plugin may not function correctly without them!',
+                                   QMessageBox.No, QMessageBox.Yes)
+        log_msg = 'User requested to close the dialog, but the packages are not installed correctly!\n'
+        if res == QMessageBox.Yes:
+            log_msg += 'And the user confirmed to close the dialog, knowing the risk!'
+            event.accept()
+        else:
+            log_msg += 'The user reconsidered their decision, and will try to install the packages again!'
+            event.ignore()
+        log_msg += '\n'
+        self.log(log_msg)
+
+    def _install_pip_if_necessary(self):
+        """
+        Install pip if not present.
+        It happens e.g. in flatpak applications.
+
+        TODO - investigate whether we can also install pip in local directory
+        """
+
+        self.log(f'<h4><b>Making sure pip is installed...</b></h4>')
+        if check_pip_installed():
+            self.log(f'<em>Pip is installed, skipping installation...</em>\n')
+            return
+
+        install_pip_command = [PYTHON_EXECUTABLE_PATH, '-m', 'ensurepip']
+        self.log(f'<em>Running command to install pip: \n  $ {" ".join(install_pip_command)} </em>')
+        with subprocess.Popen(install_pip_command,
+                              stdout=subprocess.PIPE,
+                              universal_newlines=True,
+                              stderr=subprocess.STDOUT,
+                              env={'SETUPTOOLS_USE_DISTUTILS': 'stdlib'}) as process:
+            try:
+                self._do_process_output_logging(process)
+            except InterruptedError as e:
+                self.log(str(e))
+                return False
+
+        if process.returncode != 0:
+            msg = (f'<span style="color: {_ERROR_COLOR};"><b>'
+                   f'pip installation failed! Consider installing it manually.'
+                   f'<b></span>')
+            self.log(msg)
+        self.log('\n')
+
+    def _pip_install_packages(self, packages: List[PackageToInstall]) -> None:
+        cmd = [PYTHON_EXECUTABLE_PATH, '-m', 'pip', 'install', '-U', f'--target={PACKAGES_INSTALL_DIR}']        
+        cmd_string = ' '.join(cmd)
+        
+        for pck in packages:
+            cmd.append(f"{pck}")
+            cmd_string += f"{pck}"
+        
+        self.log(f'<em>Running command: \n  $ {cmd_string} </em>')
+        with subprocess.Popen(cmd,
+                              stdout=subprocess.PIPE,
+                              universal_newlines=True,
+                              stderr=subprocess.STDOUT) as process:
+            self._do_process_output_logging(process)
+
+        if process.returncode != 0:
+            raise RuntimeError('Installation with pip failed')
+
+        msg = (f'\n<b>'
+               f'Packages installed correctly!'
+               f'<b>\n\n')
+        self.log(msg)
+
+    def _do_process_output_logging(self, process: subprocess.Popen) -> None:
+        """
+        :param process: instance of 'subprocess.Popen'
+        """
+        for stdout_line in iter(process.stdout.readline, ""):
+            if stdout_line.isspace():
+                continue
+            txt = f'<span style="color: #999999;">{stdout_line.rstrip(os.linesep)}</span>'
+            self.log(txt)
+            if self.aborted:
+                raise InterruptedError('Installation aborted by user')
+
+    def _check_packages_installation_and_log(self) -> bool:
+        packages_ok = are_packages_importable()
+        self.pushButton_install_packages.setEnabled(not packages_ok)
+
+        if packages_ok:
+            msg1 = f'All required packages are importable! You can close this window now!'
+            self.log(msg1)
+            return True
+
+        try:
+            import_packages()
+            raise Exception("Unexpected successful import of packages?!? It failed a moment ago, we shouldn't be here!")
+        except Exception:
+            msg_base = '<b>Python packages required by the plugin could not be loaded due to the following error:</b>'
+            logging.exception(msg_base)
+            tb = traceback.format_exc()
+            msg1 = (f'<span style="color: {_ERROR_COLOR};">'
+                    f'{msg_base} \n '
+                    f'{tb}\n\n'
+                    f'<b>Please try installing the packages again.<b>'
+                    f'</span>')
+            self.log(msg1)
+
+        return False
+
+
+dialog = None
+
+
+def import_package(package: PackageToInstall):
+    importlib.import_module(package.import_name)
+
+
+def import_packages():
+    for package in packages_to_install:
+        import_package(package)
+
+
+def are_packages_importable() -> bool:
+    try:
+        import_packages()
+    except Exception:
+        logging.exception(f'Python packages required by the plugin could not be loaded due to the following error:')
+        return False
+
+    return True
+
+
+def check_pip_installed() -> bool:
+    try:
+        subprocess.check_output([PYTHON_EXECUTABLE_PATH, '-m', 'pip', '--version'])
+        return True
+    except subprocess.CalledProcessError:
+        return False
+
+
+def check_required_packages_and_install_if_necessary(iface):
+    os.makedirs(PACKAGES_INSTALL_DIR, exist_ok=True)
+    if PACKAGES_INSTALL_DIR not in sys.path:
+        sys.path.append(PACKAGES_INSTALL_DIR)  # TODO: check for a less intrusive way to do this
+
+    if are_packages_importable():
+        # if packages are importable we are fine, nothing more to do then
+        return
+
+    global dialog
+    dialog = PackagesInstallerDialog(iface)
+    dialog.setWindowModality(QtCore.Qt.WindowModal)
+    dialog.show()
+    dialog.move_to_top()

zipdeepness/dialogs/packages_installer/packages_installer_dialog.ui

@@ -0,0 +1,65 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>PackagesInstallerDialog</class>
+ <widget class="QDialog" name="PackagesInstallerDialog">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>693</width>
+    <height>494</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Deepness - Packages Installer Dialog</string>
+  </property>
+  <layout class="QGridLayout" name="gridLayout_2">
+   <item row="0" column="0">
+    <layout class="QGridLayout" name="gridLayout">
+     <item row="0" column="0">
+      <widget class="QTextBrowser" name="textBrowser_log"/>
+     </item>
+    </layout>
+   </item>
+   <item row="1" column="0">
+    <layout class="QHBoxLayout" name="horizontalLayout">
+     <item>
+      <spacer name="horizontalSpacer">
+       <property name="orientation">
+        <enum>Qt::Horizontal</enum>
+       </property>
+       <property name="sizeHint" stdset="0">
+        <size>
+         <width>40</width>
+         <height>20</height>
+        </size>
+       </property>
+      </spacer>
+     </item>
+     <item>
+      <widget class="QPushButton" name="pushButton_install_packages">
+       <property name="font">
+        <font>
+         <weight>75</weight>
+         <bold>true</bold>
+        </font>
+       </property>
+       <property name="text">
+        <string>Install packages</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QPushButton" name="pushButton_close">
+       <property name="text">
+        <string>Test and Close</string>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

zipdeepness/dialogs/resizable_message_box.py

@@ -0,0 +1,20 @@
+from qgis.PyQt.QtWidgets import QMessageBox, QTextEdit
+
+
+class ResizableMessageBox(QMessageBox):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.setSizeGripEnabled(True)
+
+    def event(self, event):
+        if event.type() in (event.LayoutRequest, event.Resize):
+            if event.type() == event.Resize:
+                res = super().event(event)
+            else:
+                res = False
+            details = self.findChild(QTextEdit)
+            if details:
+                details.setMaximumSize(16777215, 16777215)
+            self.setMaximumSize(16777215, 16777215)
+            return res
+        return super().event(event)

zipdeepness/images/get_image_path.py

@@ -0,0 +1,29 @@
+"""
+This file contains image related functionalities
+"""
+
+import os
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+
+
+def get_icon_path() -> str:
+    """ Get path to the file with the main plugin icon
+
+    Returns
+    -------
+    str
+        Path to the icon
+    """
+    return get_image_path('icon.png')
+
+
+def get_image_path(image_name) -> str:
+    """ Get path to an image resource, accessing it just by the name of the file (provided it is in the common directory)
+
+    Returns
+    -------
+    str
+        file path
+    """
+    return os.path.join(SCRIPT_DIR, image_name)

zipdeepness/landcover_model.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:12ae15a9bcc5e28f675e9c829cacbf2ab81776382f92e28645b2f91de3491d93
+size 12336500

zipdeepness/metadata.txt

@@ -0,0 +1,56 @@
+# This file contains metadata for your plugin.
+
+# This file should be included when you package your plugin.# Mandatory items:
+
+[general]
+name=Deepness: Deep Neural Remote Sensing
+qgisMinimumVersion=3.22
+description=Inference of deep neural network models (ONNX) for segmentation, detection and regression
+version=0.7.0
+author=PUT Vision
+email=przemyslaw.aszkowski@gmail.com
+
+about=
+    Deepness plugin allows to easily perform segmentation, detection and regression on raster ortophotos with custom ONNX Neural Network models, bringing the power of deep learning to casual users.
+    Features highlights:
+     - processing any raster layer (custom ortophoto from file or layers from online providers, e.g Google Satellite)
+     - limiting processing range to predefined area (visible part or area defined by vector layer polygons)
+     - common types of models are supported: segmentation, regression, detection
+     - integration with layers (both for input data and model output layers). Once an output layer is created, it can be saved as a file manually
+     - model ZOO under development (planes detection on Bing Aerial, Corn field damage, Oil Storage tanks detection, cars detection, ...)
+     - training data Export Tool - exporting raster and mask as small tiles
+     - parametrization of the processing for advanced users (spatial resolution, overlap, postprocessing)
+    Plugin requires external python packages to be installed. After the first plugin startup, a Dialog will show, to assist in this process. Please visit plugin the documentation for details.
+
+tracker=https://github.com/PUTvision/qgis-plugin-deepness/issues
+repository=https://github.com/PUTvision/qgis-plugin-deepness
+# End of mandatory metadata
+
+# Recommended items:
+
+hasProcessingProvider=no
+# Uncomment the following line and add your changelog:
+# changelog=
+
+# Tags are comma separated with spaces allowed
+tags=segmentation,detection,classification,machine learning,onnx,neural network,deep learning,regression,deepness,analysis,remote sensing,supervised classification
+
+homepage=https://qgis-plugin-deepness.readthedocs.io/
+category=Plugins
+icon=images/icon.png
+# experimental flag
+experimental=False
+
+# deprecated flag (applies to the whole plugin, not just a single version)
+deprecated=False
+
+# Since QGIS 3.8, a comma separated list of plugins to be installed
+# (or upgraded) can be specified.
+# Check the documentation for more information.
+# plugin_dependencies=
+
+Category of the plugin: Raster, Vector, Database or Web
+# category=
+
+# If the plugin can run on QGIS Server.
+server=False

zipdeepness/processing/__init__.py

@@ -0,0 +1,2 @@
+""" Main submodule for image processing and deep learning things.
+"""

zipdeepness/processing/extent_utils.py

@@ -0,0 +1,219 @@
+"""
+This file contains utilities related to Extent processing
+"""
+
+import logging
+
+from qgis.core import QgsCoordinateTransform, QgsRasterLayer, QgsRectangle, QgsVectorLayer
+from qgis.gui import QgsMapCanvas
+
+from deepness.common.errors import OperationFailedException
+from deepness.common.processing_parameters.map_processing_parameters import MapProcessingParameters, ProcessedAreaType
+from deepness.processing.processing_utils import BoundingBox, convert_meters_to_rlayer_units
+
+
+def round_extent_to_rlayer_grid(extent: QgsRectangle, rlayer: QgsRasterLayer) -> QgsRectangle:
+    """
+    Round to rlayer "grid" for pixels.
+    Grid starts at rlayer_extent.xMinimum & yMinimum
+    with resolution of rlayer_units_per_pixel
+
+    :param extent: Extent to round, needs to be in rlayer CRS units
+    :param rlayer: layer detemining the grid
+    """
+    # For some ortophotos grid spacing is close to (1.0, 1.0), while it shouldn't be.
+    # Seems like it is some bug or special "feature" that I do not understand.
+    # In that case, just return the extent as it is
+    grid_spacing = rlayer.rasterUnitsPerPixelX(), rlayer.rasterUnitsPerPixelY()
+    if abs(grid_spacing[0] - 1.0) < 0.0001 and abs(grid_spacing[1] - 1.0) < 0.0001:
+        logging.warning('Grid spacing is close to 1.0, which is suspicious, returning extent as it is. It shouldn not be a problem for most cases.')
+        return extent
+
+    grid_start = rlayer.extent().xMinimum(), rlayer.extent().yMinimum()
+
+    x_min = grid_start[0] + int((extent.xMinimum() - grid_start[0]) / grid_spacing[0]) * grid_spacing[0]
+    x_max = grid_start[0] + int((extent.xMaximum() - grid_start[0]) / grid_spacing[0]) * grid_spacing[0]
+    y_min = grid_start[1] + int((extent.yMinimum() - grid_start[1]) / grid_spacing[1]) * grid_spacing[1]
+    y_max = grid_start[1] + int((extent.yMaximum() - grid_start[1]) / grid_spacing[1]) * grid_spacing[1]
+
+    new_extent = QgsRectangle(x_min, y_min, x_max, y_max)
+    return new_extent
+
+
+def calculate_extended_processing_extent(base_extent: QgsRectangle,
+                                         params: MapProcessingParameters,
+                                         rlayer: QgsVectorLayer,
+                                         rlayer_units_per_pixel: float) -> QgsRectangle:
+    """Calculate the "extended" processing extent, which is the full processing area, rounded to the tile size and overlap
+
+    Parameters
+    ----------
+    base_extent : QgsRectangle
+        Base extent of the processed ortophoto, which is not rounded to the tile size
+    params : MapProcessingParameters
+        Processing parameters
+    rlayer : QgsVectorLayer
+        mask layer
+    rlayer_units_per_pixel : float
+        how many rlayer CRS units are in 1 pixel
+
+    Returns
+    -------
+    QgsRectangle
+        The "extended" processing extent
+    """
+
+    # first try to add pixels at every border - same as half-overlap for other tiles
+    additional_pixels = params.processing_overlap_px // 2
+    additional_pixels_in_units = additional_pixels * rlayer_units_per_pixel
+
+    tmp_extent = QgsRectangle(
+        base_extent.xMinimum() - additional_pixels_in_units,
+        base_extent.yMinimum() - additional_pixels_in_units,
+        base_extent.xMaximum() + additional_pixels_in_units,
+        base_extent.yMaximum() + additional_pixels_in_units,
+    )
+
+    rlayer_extent_infinite = rlayer.extent().isEmpty()  # empty extent for infinite layers
+    if not rlayer_extent_infinite:
+        tmp_extent = tmp_extent.intersect(rlayer.extent())
+
+    # then add borders to have the extent be equal to  N * stride + tile_size, where N is a natural number
+    tile_size_px = params.tile_size_px
+    stride_px = params.processing_stride_px  # stride in pixels
+
+    current_x_pixels = round(tmp_extent.width() / rlayer_units_per_pixel)
+    if current_x_pixels <= tile_size_px:
+        missing_pixels_x = tile_size_px - current_x_pixels  # just one tile
+    else:
+        pixels_in_last_stride_x = (current_x_pixels - tile_size_px) % stride_px
+        missing_pixels_x = (stride_px - pixels_in_last_stride_x) % stride_px
+
+    current_y_pixels = round(tmp_extent.height() / rlayer_units_per_pixel)
+    if current_y_pixels <= tile_size_px:
+        missing_pixels_y = tile_size_px - current_y_pixels  # just one tile
+    else:
+        pixels_in_last_stride_y = (current_y_pixels - tile_size_px) % stride_px
+        missing_pixels_y = (stride_px - pixels_in_last_stride_y) % stride_px
+
+    missing_pixels_x_in_units = missing_pixels_x * rlayer_units_per_pixel
+    missing_pixels_y_in_units = missing_pixels_y * rlayer_units_per_pixel
+    tmp_extent.setXMaximum(tmp_extent.xMaximum() + missing_pixels_x_in_units)
+    tmp_extent.setYMaximum(tmp_extent.yMaximum() + missing_pixels_y_in_units)
+
+    extended_extent = tmp_extent
+    return extended_extent
+
+
+def is_extent_infinite_or_too_big(rlayer: QgsRasterLayer) -> bool:
+    """Check whether layer covers whole earth (infinite extent) or or is too big for processing"""
+    rlayer_extent = rlayer.extent()
+
+    # empty extent happens for infinite layers
+    if rlayer_extent.isEmpty():
+        return True
+
+    rlayer_area_m2 = rlayer_extent.area() * (1 / convert_meters_to_rlayer_units(rlayer, 1)) ** 2
+
+    if rlayer_area_m2 > (1606006962349394 // 10):  # so 1/3 of the earth (this magic value is from bing aerial map area)
+        return True
+
+    return False
+
+
+def calculate_base_processing_extent_in_rlayer_crs(map_canvas: QgsMapCanvas,
+                                                   rlayer: QgsRasterLayer,
+                                                   vlayer_mask: QgsVectorLayer,
+                                                   params: MapProcessingParameters) -> QgsRectangle:
+    """ Determine the Base Extent of processing (Extent (rectangle) in which the actual required area is contained)
+
+    Parameters
+    ----------
+    map_canvas : QgsMapCanvas
+        currently visible map in the UI
+    rlayer : QgsRasterLayer
+        ortophotomap which is being processed
+    vlayer_mask : QgsVectorLayer
+        mask layer containing the processed area
+    params : MapProcessingParameters
+        Processing parameters
+
+    Returns
+    -------
+    QgsRectangle
+        Base Extent of processing
+    """
+
+    rlayer_extent = rlayer.extent()
+    processed_area_type = params.processed_area_type
+    rlayer_extent_infinite = is_extent_infinite_or_too_big(rlayer)
+
+    if processed_area_type == ProcessedAreaType.ENTIRE_LAYER:
+        expected_extent = rlayer_extent
+        if rlayer_extent_infinite:
+            msg = "Cannot process entire layer - layer extent is not defined or too big. " \
+                  "Make sure you are not processing 'Entire layer' which covers entire earth surface!!"
+            raise OperationFailedException(msg)
+    elif processed_area_type == ProcessedAreaType.FROM_POLYGONS:
+        expected_extent_in_vlayer_crs = vlayer_mask.extent()
+        if vlayer_mask.crs() == rlayer.crs():
+            expected_extent = expected_extent_in_vlayer_crs
+        else:
+            t = QgsCoordinateTransform()
+            t.setSourceCrs(vlayer_mask.crs())
+            t.setDestinationCrs(rlayer.crs())
+            expected_extent = t.transform(expected_extent_in_vlayer_crs)
+    elif processed_area_type == ProcessedAreaType.VISIBLE_PART:
+        # transform visible extent from mapCanvas CRS to layer CRS
+        active_extent_in_canvas_crs = map_canvas.extent()
+        canvas_crs = map_canvas.mapSettings().destinationCrs()
+        t = QgsCoordinateTransform()
+        t.setSourceCrs(canvas_crs)
+        t.setDestinationCrs(rlayer.crs())
+        expected_extent = t.transform(active_extent_in_canvas_crs)
+    else:
+        raise Exception("Invalid processed are type!")
+
+    expected_extent = round_extent_to_rlayer_grid(extent=expected_extent, rlayer=rlayer)
+
+    if rlayer_extent_infinite:
+        base_extent = expected_extent
+    else:
+        base_extent = expected_extent.intersect(rlayer_extent)
+
+    return base_extent
+
+
+def calculate_base_extent_bbox_in_full_image(image_size_y: int,
+                                             base_extent: QgsRectangle,
+                                             extended_extent: QgsRectangle,
+                                             rlayer_units_per_pixel) -> BoundingBox:
+    """Calculate how the base extent fits in extended_extent in terms of pixel position
+
+    Parameters
+    ----------
+    image_size_y : int
+        Size of the image in y axis in pixels
+    base_extent : QgsRectangle
+        Base Extent of processing
+    extended_extent : QgsRectangle
+        Extended extent of processing
+    rlayer_units_per_pixel : _type_
+        Number of layer units per a single image pixel
+
+    Returns
+    -------
+    BoundingBox
+        Bounding box describing position of base extent in the extended extent
+    """
+    base_extent = base_extent
+    extended_extent = extended_extent
+
+    # should round without a rest anyway, as extends are aligned to rlayer grid
+    base_extent_bbox_in_full_image = BoundingBox(
+        x_min=round((base_extent.xMinimum() - extended_extent.xMinimum()) / rlayer_units_per_pixel),
+        y_min=image_size_y - 1 - round((base_extent.yMaximum() - extended_extent.yMinimum()) / rlayer_units_per_pixel - 1),
+        x_max=round((base_extent.xMaximum() - extended_extent.xMinimum()) / rlayer_units_per_pixel) - 1,
+        y_max=image_size_y - 1 - round((base_extent.yMinimum() - extended_extent.yMinimum()) / rlayer_units_per_pixel),
+    )
+    return base_extent_bbox_in_full_image

zipdeepness/processing/map_processor/map_processing_result.py

@@ -0,0 +1,47 @@
+""" This file defines possible outcomes of map processing
+"""
+
+
+from typing import Callable, Optional
+
+
+class MapProcessingResult:
+    """
+    Base class for signaling finished processing result
+    """
+
+    def __init__(self, message: str, gui_delegate: Optional[Callable] = None):
+        """
+        :param message: message to be shown to the user
+        :param gui_delegate: function to be called in GUI thread, as it is not safe to call GUI functions from other threads
+        """
+        self.message = message
+        self.gui_delegate = gui_delegate
+
+
+class MapProcessingResultSuccess(MapProcessingResult):
+    """
+    Processing result on success
+    """
+
+    def __init__(self, message: str = '', gui_delegate: Optional[Callable] = None):
+        super().__init__(message=message, gui_delegate=gui_delegate)
+
+
+class MapProcessingResultFailed(MapProcessingResult):
+    """
+    Processing result on error
+    """
+
+    def __init__(self, error_message: str, exception=None):
+        super().__init__(error_message)
+        self.exception = exception
+
+
+class MapProcessingResultCanceled(MapProcessingResult):
+    """
+    Processing when processing was aborted
+    """
+
+    def __init__(self):
+        super().__init__(message='')

zipdeepness/processing/map_processor/map_processor.py

@@ -0,0 +1,237 @@
+""" This file implements core map processing logic """
+
+import logging
+from typing import List, Optional, Tuple
+
+import numpy as np
+from qgis.core import QgsRasterLayer, QgsTask, QgsVectorLayer
+from qgis.gui import QgsMapCanvas
+from qgis.PyQt.QtCore import pyqtSignal
+
+from deepness.common.defines import IS_DEBUG
+from deepness.common.lazy_package_loader import LazyPackageLoader
+from deepness.common.processing_parameters.map_processing_parameters import MapProcessingParameters, ProcessedAreaType
+from deepness.common.temp_files_handler import TempFilesHandler
+from deepness.processing import extent_utils, processing_utils
+from deepness.processing.map_processor.map_processing_result import MapProcessingResult, MapProcessingResultFailed
+from deepness.processing.tile_params import TileParams
+
+cv2 = LazyPackageLoader('cv2')
+
+
+class MapProcessor(QgsTask):
+    """
+    Base class for processing the ortophoto with parameters received from the UI.
+
+    Actual processing is done in specialized child classes. Here we have the "core" functionality,
+    like iterating over single tiles.
+
+    Objects of this class are created and managed by the 'Deepness'.
+    Work is done within QgsTask, for seamless integration with QGis GUI and logic.
+    """
+
+    # error message if finished with error, empty string otherwise
+    finished_signal = pyqtSignal(MapProcessingResult)
+    # request to show an image. Params: (image, window_name)
+    show_img_signal = pyqtSignal(object, str)
+
+    def __init__(self,
+                 rlayer: QgsRasterLayer,
+                 vlayer_mask: Optional[QgsVectorLayer],
+                 map_canvas: QgsMapCanvas,
+                 params: MapProcessingParameters):
+        """ init
+        Parameters
+        ----------
+        rlayer : QgsRasterLayer
+            Raster layer which is being processed
+        vlayer_mask : Optional[QgsVectorLayer]
+            Vector layer with outline of area which should be processed (within rlayer)
+        map_canvas : QgsMapCanvas
+            active map canvas (in the GUI), required if processing visible map area
+        params : MapProcessingParameters
+           see MapProcessingParameters
+        """
+        QgsTask.__init__(self, self.__class__.__name__)
+        self._processing_finished = False
+        self.rlayer = rlayer
+        self.vlayer_mask = vlayer_mask
+        self.params = params
+        self._assert_qgis_doesnt_need_reload()
+        self._processing_result = MapProcessingResultFailed('Failed to get processing result!')
+
+        self.stride_px = self.params.processing_stride_px  # stride in pixels
+        self.rlayer_units_per_pixel = processing_utils.convert_meters_to_rlayer_units(
+            self.rlayer, self.params.resolution_m_per_px)  # number of rlayer units for one tile pixel
+
+        self.file_handler = TempFilesHandler() if self.params.local_cache else None
+
+        # extent in which the actual required area is contained, without additional extensions, rounded to rlayer grid
+        self.base_extent = extent_utils.calculate_base_processing_extent_in_rlayer_crs(
+            map_canvas=map_canvas,
+            rlayer=self.rlayer,
+            vlayer_mask=self.vlayer_mask,
+            params=self.params)
+
+        # extent which should be used during model inference, as it includes extra margins to have full tiles,
+        # rounded to rlayer grid
+        self.extended_extent = extent_utils.calculate_extended_processing_extent(
+            base_extent=self.base_extent,
+            rlayer=self.rlayer,
+            params=self.params,
+            rlayer_units_per_pixel=self.rlayer_units_per_pixel)
+
+        # processed rlayer dimensions (for extended_extent)
+        self.img_size_x_pixels = round(self.extended_extent.width() / self.rlayer_units_per_pixel)  # how many columns (x)
+        self.img_size_y_pixels = round(self.extended_extent.height() / self.rlayer_units_per_pixel)  # how many rows (y)
+
+        # Coordinate of base image within extended image (images for base_extent and extended_extent)
+        self.base_extent_bbox_in_full_image = extent_utils.calculate_base_extent_bbox_in_full_image(
+            image_size_y=self.img_size_y_pixels,
+            base_extent=self.base_extent,
+            extended_extent=self.extended_extent,
+            rlayer_units_per_pixel=self.rlayer_units_per_pixel)
+
+        # Number of tiles in x and y dimensions which will be used during processing
+        # As we are using "extended_extent" this should divide without any rest
+        self.x_bins_number = round((self.img_size_x_pixels - self.params.tile_size_px) / self.stride_px) + 1
+        self.y_bins_number = round((self.img_size_y_pixels - self.params.tile_size_px) / self.stride_px) + 1
+
+        # Mask determining area to process (within extended_extent coordinates)
+        self.area_mask_img = processing_utils.create_area_mask_image(
+            vlayer_mask=self.vlayer_mask,
+            rlayer=self.rlayer,
+            extended_extent=self.extended_extent,
+            rlayer_units_per_pixel=self.rlayer_units_per_pixel,
+            image_shape_yx=(self.img_size_y_pixels, self.img_size_x_pixels),
+            files_handler=self.file_handler)  # type: Optional[np.ndarray]
+
+        self._result_img = None
+
+    def set_results_img(self, img):
+        if self._result_img is not None:
+            raise Exception("Result image already created!")
+
+        self._result_img = img
+
+    def get_result_img(self):
+        if self._result_img is None:
+            raise Exception("Result image not yet created!")
+
+        return self._result_img
+
+    def _assert_qgis_doesnt_need_reload(self):
+        """ If the plugin is somehow invalid, it cannot compare the enums correctly
+        I suppose it could be fixed somehow, but no need to investigate it now,
+        it affects only the development
+        """
+
+        if self.params.processed_area_type.__class__ != ProcessedAreaType:
+            raise Exception("Disable plugin, restart QGis and enable plugin again!")
+
+    def run(self):
+        try:
+            self._processing_result = self._run()
+        except Exception as e:
+            logging.exception("Error occurred in MapProcessor:")
+            msg = "Unhandled exception occurred. See Python Console for details"
+            self._processing_result = MapProcessingResultFailed(msg, exception=e)
+            if IS_DEBUG:
+                raise e
+
+        self._processing_finished = True
+        return True
+
+    def _run(self) -> MapProcessingResult:
+        raise NotImplementedError('Base class not implemented!')
+
+    def finished(self, result: bool):
+        if result:
+            gui_delegate = self._processing_result.gui_delegate
+            if gui_delegate is not None:
+                gui_delegate()
+        else:
+            self._processing_result = MapProcessingResultFailed("Unhandled processing error!")
+        self.finished_signal.emit(self._processing_result)
+
+    @staticmethod
+    def is_busy():
+        return True
+
+    def _show_image(self, img, window_name='img'):
+        self.show_img_signal.emit(img, window_name)
+
+    def limit_extended_extent_image_to_base_extent_with_mask(self, full_img):
+        """
+        Limit an image which is for extended_extent to the base_extent image.
+        If a limiting polygon was used for processing, it will be also applied.
+        :param full_img:
+        :return:
+        """
+        # TODO look for some inplace operation to save memory
+        # cv2.copyTo(src=full_img, mask=area_mask_img, dst=full_img)  # this doesn't work due to implementation details
+
+        for i in range(full_img.shape[0]):
+            full_img[i] = cv2.copyTo(src=full_img[i], mask=self.area_mask_img)
+
+        b = self.base_extent_bbox_in_full_image
+        result_img = full_img[:, b.y_min:b.y_max+1, b.x_min:b.x_max+1]
+        return result_img
+
+    def _get_array_or_mmapped_array(self, final_shape_px):
+        if self.file_handler is not None:
+            full_result_img = np.memmap(
+                self.file_handler.get_results_img_path(),
+                dtype=np.uint8,
+                mode='w+',
+                shape=final_shape_px)
+        else:
+            full_result_img = np.zeros(final_shape_px, np.uint8)
+
+        return full_result_img
+
+    def tiles_generator(self) -> Tuple[np.ndarray, TileParams]:
+        """
+        Iterate over all tiles, as a Python generator function
+        """
+        total_tiles = self.x_bins_number * self.y_bins_number
+
+        for y_bin_number in range(self.y_bins_number):
+            for x_bin_number in range(self.x_bins_number):
+                tile_no = y_bin_number * self.x_bins_number + x_bin_number
+                progress = tile_no / total_tiles * 100
+                self.setProgress(progress)
+                print(f" Processing tile {tile_no} / {total_tiles} [{progress:.2f}%]")
+                tile_params = TileParams(
+                    x_bin_number=x_bin_number, y_bin_number=y_bin_number,
+                    x_bins_number=self.x_bins_number, y_bins_number=self.y_bins_number,
+                    params=self.params,
+                    processing_extent=self.extended_extent,
+                    rlayer_units_per_pixel=self.rlayer_units_per_pixel)
+
+                if not tile_params.is_tile_within_mask(self.area_mask_img):
+                    continue  # tile outside of mask - to be skipped
+
+                tile_img = processing_utils.get_tile_image(
+                    rlayer=self.rlayer, extent=tile_params.extent, params=self.params)
+
+                yield tile_img, tile_params
+
+    def tiles_generator_batched(self) -> Tuple[np.ndarray, List[TileParams]]:
+        """
+        Iterate over all tiles, as a Python generator function, but return them in batches
+        """
+
+        tile_img_batch, tile_params_batch = [], []
+
+        for tile_img, tile_params in self.tiles_generator():
+            tile_img_batch.append(tile_img)
+            tile_params_batch.append(tile_params)
+
+            if len(tile_img_batch) >= self.params.batch_size:
+                yield np.array(tile_img_batch), tile_params_batch
+                tile_img_batch, tile_params_batch = [], []
+
+        if len(tile_img_batch) > 0:
+            yield np.array(tile_img_batch), tile_params_batch
+            tile_img_batch, tile_params_batch = [], []

zipdeepness/processing/map_processor/map_processor_detection.py

@@ -0,0 +1,288 @@
+""" This file implements map processing for detection model """
+from typing import List
+
+import cv2
+import numpy as np
+from qgis.core import QgsFeature, QgsGeometry, QgsProject, QgsVectorLayer
+from qgis.PyQt.QtCore import QVariant
+from qgis.core import QgsFields, QgsField
+
+from deepness.common.processing_parameters.detection_parameters import DetectionParameters
+from deepness.processing import processing_utils
+from deepness.processing.map_processor.map_processing_result import (MapProcessingResult, MapProcessingResultCanceled,
+                                                                     MapProcessingResultSuccess)
+from deepness.processing.map_processor.map_processor_with_model import MapProcessorWithModel
+from deepness.processing.map_processor.utils.ckdtree import cKDTree
+from deepness.processing.models.detector import Detection, Detector
+from deepness.processing.tile_params import TileParams
+from deepness.processing.models.detector import DetectorType
+
+
+class MapProcessorDetection(MapProcessorWithModel):
+    """
+    MapProcessor specialized for detecting objects (where there is a finite list of detected objects
+    of different classes, which area (bounding boxes) may overlap)
+    """
+
+    def __init__(self,
+                 params: DetectionParameters,
+                 **kwargs):
+        super().__init__(
+            params=params,
+            model=params.model,
+            **kwargs)
+        self.detection_parameters = params
+        self.model = params.model  # type: Detector
+        self.model.set_inference_params(
+            confidence=params.confidence,
+            iou_threshold=params.iou_threshold
+        )
+        self.model.set_model_type_param(model_type=params.detector_type)
+        self._all_detections = None
+
+    def get_all_detections(self) -> List[Detection]:
+        return self._all_detections
+
+    def _run(self) -> MapProcessingResult:
+        all_bounding_boxes = []  # type: List[Detection]
+        for tile_img_batched, tile_params_batched in self.tiles_generator_batched():
+            if self.isCanceled():
+                return MapProcessingResultCanceled()
+
+            bounding_boxes_in_tile_batched = self._process_tile(tile_img_batched, tile_params_batched)
+            all_bounding_boxes += [d for det in bounding_boxes_in_tile_batched for d in det]
+
+        with_rot = self.detection_parameters.detector_type == DetectorType.YOLO_ULTRALYTICS_OBB
+
+        if len(all_bounding_boxes) > 0:
+            all_bounding_boxes_nms = self.remove_overlaping_detections(all_bounding_boxes, iou_threshold=self.detection_parameters.iou_threshold, with_rot=with_rot)
+            all_bounding_boxes_restricted = self.limit_bounding_boxes_to_processed_area(all_bounding_boxes_nms)
+        else:
+            all_bounding_boxes_restricted = []
+
+        gui_delegate = self._create_vlayer_for_output_bounding_boxes(all_bounding_boxes_restricted)
+
+        result_message = self._create_result_message(all_bounding_boxes_restricted)
+        self._all_detections = all_bounding_boxes_restricted
+        return MapProcessingResultSuccess(
+            message=result_message,
+            gui_delegate=gui_delegate,
+        )
+
+    def limit_bounding_boxes_to_processed_area(self, bounding_boxes: List[Detection]) -> List[Detection]:
+        """
+        Limit all bounding boxes to the constrained area that we process.
+        E.g. if we are detecting peoples in a circle, we don't want to count peoples in the entire rectangle
+
+        :return:
+        """
+        bounding_boxes_restricted = []
+        for det in bounding_boxes:
+            # if bounding box is not in the area_mask_img (at least in some percentage) - remove it
+
+            if self.area_mask_img is not None:
+                det_slice = det.bbox.get_slice()
+                area_subimg = self.area_mask_img[det_slice]
+                pixels_in_area = np.count_nonzero(area_subimg)
+            else:
+                det_bounding_box = det.bbox
+                pixels_in_area = self.base_extent_bbox_in_full_image.calculate_overlap_in_pixels(det_bounding_box)
+            total_pixels = det.bbox.get_area()
+            coverage = pixels_in_area / total_pixels
+            if coverage > 0.5:  # some arbitrary value, 50% seems reasonable
+                bounding_boxes_restricted.append(det)
+
+        return bounding_boxes_restricted
+
+    def _create_result_message(self, bounding_boxes: List[Detection]) -> str:
+        # hack, allways one output
+        model_outputs = self._get_indexes_of_model_output_channels_to_create()
+        channels = range(model_outputs[0])
+
+        counts_mapping = {}
+        total_counts = 0
+        for channel_id in channels:
+            filtered_bounding_boxes = [det for det in bounding_boxes if det.clss == channel_id]
+            counts = len(filtered_bounding_boxes)
+            counts_mapping[channel_id] = counts
+            total_counts += counts
+
+        txt = f'Detection done for {len(channels)} model output classes, with the following statistics:\n'
+        for channel_id in channels:
+            counts = counts_mapping[channel_id]
+
+            if total_counts:
+                counts_percentage = counts / total_counts * 100
+            else:
+                counts_percentage = 0
+
+            txt += f' - {self.model.get_channel_name(0, channel_id)}: counts = {counts} ({counts_percentage:.2f} %)\n'
+
+        return txt
+
+    def _create_vlayer_for_output_bounding_boxes(self, bounding_boxes: List[Detection]):
+        vlayers = []
+
+        # hack, allways one output
+        model_outputs = self._get_indexes_of_model_output_channels_to_create()
+        channels = range(model_outputs[0])
+
+        for channel_id in channels:
+            filtered_bounding_boxes = [det for det in bounding_boxes if det.clss == channel_id]
+            print(f'Detections for class {channel_id}: {len(filtered_bounding_boxes)}')
+            
+            vlayer = QgsVectorLayer("multipolygon", self.model.get_channel_name(0, channel_id), "memory")
+            vlayer.setCrs(self.rlayer.crs())
+            prov = vlayer.dataProvider()
+            prov.addAttributes([QgsField("confidence", QVariant.Double)])
+            vlayer.updateFields()
+
+            features = []
+            for det in filtered_bounding_boxes:
+                feature = QgsFeature()
+                if det.mask is None:
+                    bbox_corners_pixels = det.bbox.get_4_corners()
+                    bbox_corners_crs = processing_utils.transform_points_list_xy_to_target_crs(
+                        points=bbox_corners_pixels,
+                        extent=self.extended_extent,
+                        rlayer_units_per_pixel=self.rlayer_units_per_pixel,
+                    )
+                    #feature = QgsFeature() #move outside of the if block
+                    polygon_xy_vec_vec = [
+                        bbox_corners_crs
+                    ]
+                    geometry = QgsGeometry.fromPolygonXY(polygon_xy_vec_vec)
+                    #feature.setGeometry(geometry)
+                    #features.append(feature)
+                else:
+                    contours, _ = cv2.findContours(det.mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+                    contours = sorted(contours, key=cv2.contourArea, reverse=True)
+
+                    x_offset, y_offset = det.mask_offsets
+
+                    if len(contours) > 0:
+                        countur = contours[0]
+
+                        corners = []
+                        for point in countur:
+                            corners.append(int(point[0][0]) + x_offset)
+                            corners.append(int(point[0][1]) + y_offset)
+
+                        mask_corners_pixels = cv2.convexHull(np.array(corners).reshape((-1, 2))).squeeze()
+
+                        mask_corners_crs = processing_utils.transform_points_list_xy_to_target_crs(
+                            points=mask_corners_pixels,
+                            extent=self.extended_extent,
+                            rlayer_units_per_pixel=self.rlayer_units_per_pixel,
+                        )
+
+                        #feature = QgsFeature()
+                        polygon_xy_vec_vec = [
+                            mask_corners_crs
+                        ]
+                        geometry = QgsGeometry.fromPolygonXY(polygon_xy_vec_vec)
+                        #feature.setGeometry(geometry)
+                        #features.append(feature)
+                feature.setGeometry(geometry)
+                feature.setAttributes([float(det.conf)])
+                features.append(feature)
+            
+            #vlayer = QgsVectorLayer("multipolygon", self.model.get_channel_name(0, channel_id), "memory")
+            #vlayer.setCrs(self.rlayer.crs())
+            #prov = vlayer.dataProvider()
+
+            color = vlayer.renderer().symbol().color()
+            OUTPUT_VLAYER_COLOR_TRANSPARENCY = 80
+            color.setAlpha(OUTPUT_VLAYER_COLOR_TRANSPARENCY)
+            vlayer.renderer().symbol().setColor(color)
+            # TODO - add also outline for the layer (thicker black border)
+
+            prov.addFeatures(features)
+            vlayer.updateExtents()
+
+            vlayers.append(vlayer)
+
+        # accessing GUI from non-GUI thread is not safe, so we need to delegate it to the GUI thread
+        def add_to_gui():
+            group = QgsProject.instance().layerTreeRoot().insertGroup(0, 'model_output')
+            for vlayer in vlayers:
+                QgsProject.instance().addMapLayer(vlayer, False)
+                group.addLayer(vlayer)
+
+        return add_to_gui
+
+    @staticmethod
+    def remove_overlaping_detections(bounding_boxes: List[Detection], iou_threshold: float, with_rot: bool = False) -> List[Detection]:
+        bboxes = []
+        probs = []
+        for det in bounding_boxes:
+            if with_rot:
+                bboxes.append(det.get_bbox_xyxy_rot())
+            else:
+                bboxes.append(det.get_bbox_xyxy())
+            probs.append(det.conf)
+
+        bboxes = np.array(bboxes)
+        probs = np.array(probs)
+
+        pick_ids = Detector.non_max_suppression_fast(boxes=bboxes, probs=probs, iou_threshold=iou_threshold, with_rot=with_rot)
+
+        filtered_bounding_boxes = [x for i, x in enumerate(bounding_boxes) if i in pick_ids]
+        filtered_bounding_boxes = sorted(filtered_bounding_boxes, reverse=True)
+        
+        pick_ids_kde = MapProcessorDetection.non_max_kdtree(filtered_bounding_boxes, iou_threshold)
+
+        filtered_bounding_boxes = [x for i, x in enumerate(filtered_bounding_boxes) if i in pick_ids_kde]
+
+        return filtered_bounding_boxes
+
+    @staticmethod
+    def non_max_kdtree(bounding_boxes: List[Detection], iou_threshold: float) -> List[int]:
+        """ Remove overlapping bounding boxes using kdtree
+
+        :param bounding_boxes: List of bounding boxes in (xyxy format)
+        :param iou_threshold: Threshold for intersection over union
+        :return: Pick ids to keep
+        """
+
+        centers = np.array([det.get_bbox_center() for det in bounding_boxes])
+
+        kdtree = cKDTree(centers)
+        pick_ids = set()
+        removed_ids = set()
+
+        for i, bbox in enumerate(bounding_boxes):
+            if i in removed_ids:
+                continue
+
+            indices = kdtree.query(bbox.get_bbox_center(), k=min(10, len(bounding_boxes)))
+
+            for j in indices:
+                if j in removed_ids:
+                    continue
+
+                if i == j:
+                    continue
+
+                iou = bbox.bbox.calculate_intersection_over_smaler_area(bounding_boxes[j].bbox)
+
+                if iou > iou_threshold:
+                    removed_ids.add(j)
+
+            pick_ids.add(i)
+
+        return pick_ids
+
+    @staticmethod
+    def convert_bounding_boxes_to_absolute_positions(bounding_boxes_relative: List[Detection],
+                                                     tile_params: TileParams):
+        for det in bounding_boxes_relative:
+            det.convert_to_global(offset_x=tile_params.start_pixel_x, offset_y=tile_params.start_pixel_y)
+
+    def _process_tile(self, tile_img: np.ndarray, tile_params_batched: List[TileParams]) -> np.ndarray:
+        bounding_boxes_batched: List[Detection] = self.model.process(tile_img)
+
+        for bounding_boxes, tile_params in zip(bounding_boxes_batched, tile_params_batched):
+            self.convert_bounding_boxes_to_absolute_positions(bounding_boxes, tile_params)
+
+        return bounding_boxes_batched

zipdeepness/processing/map_processor/map_processor_recognition.py

@@ -0,0 +1,221 @@
+""" This file implements map processing for Recognition model """
+
+import os
+import uuid
+from typing import List
+
+import numpy as np
+from numpy.linalg import norm
+from osgeo import gdal, osr
+from qgis.core import QgsProject, QgsRasterLayer
+
+from deepness.common.defines import IS_DEBUG
+from deepness.common.lazy_package_loader import LazyPackageLoader
+from deepness.common.misc import TMP_DIR_PATH
+from deepness.common.processing_parameters.recognition_parameters import RecognitionParameters
+from deepness.processing.map_processor.map_processing_result import (MapProcessingResult, MapProcessingResultCanceled,
+                                                                     MapProcessingResultFailed,
+                                                                     MapProcessingResultSuccess)
+from deepness.processing.map_processor.map_processor_with_model import MapProcessorWithModel
+
+cv2 = LazyPackageLoader('cv2')
+
+
+class MapProcessorRecognition(MapProcessorWithModel):
+    """
+    MapProcessor specialized for Recognition model
+    """
+
+    def __init__(self, params: RecognitionParameters, **kwargs):
+        super().__init__(params=params, model=params.model, **kwargs)
+        self.recognition_parameters = params
+        self.model = params.model
+
+    def _run(self) -> MapProcessingResult:
+        try:
+            query_img = cv2.imread(self.recognition_parameters.query_image_path)
+            assert query_img is not None, f"Error occurred while reading query image: {self.recognition_parameters.query_image_path}"
+        except Exception as e:
+            return MapProcessingResultFailed(f"Error occurred while reading query image: {e}")
+
+        # some hardcoded code for recognition model
+        query_img = cv2.cvtColor(query_img, cv2.COLOR_BGR2RGB)
+        query_img_resized = cv2.resize(query_img, self.model.get_input_shape()[2:4][::-1])
+        query_img_batched = np.array([query_img_resized])
+
+        query_img_emb = self.model.process(query_img_batched)[0][0]
+
+        final_shape_px = (
+            self.img_size_y_pixels,
+            self.img_size_x_pixels,
+        )
+
+        stride = self.stride_px
+        full_result_img = np.zeros(final_shape_px, np.float32)
+        mask = np.zeros_like(full_result_img, dtype=np.int16)
+        highest = 0
+        for tile_img_batched, tile_params_batched in self.tiles_generator_batched():
+            if self.isCanceled():
+                return MapProcessingResultCanceled()
+
+            tile_result_batched = self._process_tile(tile_img_batched)[0]
+
+            for tile_result, tile_params in zip(tile_result_batched, tile_params_batched):
+                cossim = np.dot(query_img_emb, tile_result)/(norm(query_img_emb)*norm(tile_result))
+
+                x_bin = tile_params.x_bin_number
+                y_bin = tile_params.y_bin_number
+                size = self.params.tile_size_px
+
+                if cossim > highest:
+                    highest = cossim
+                    x_high = x_bin
+                    y_high = y_bin
+
+                full_result_img[y_bin*stride:y_bin*stride+size, x_bin*stride:x_bin*stride + size] += cossim
+                mask[y_bin*stride:y_bin*stride+size, x_bin*stride:x_bin*stride + size] += 1
+
+        full_result_img = full_result_img/mask
+        self.set_results_img(full_result_img)
+
+        gui_delegate = self._create_rlayers_from_images_for_base_extent(self.get_result_img(), x_high, y_high, size, stride)
+        result_message = self._create_result_message(self.get_result_img(), x_high*self.params.tile_size_px, y_high*self.params.tile_size_px)
+        return MapProcessingResultSuccess(
+            message=result_message,
+            gui_delegate=gui_delegate,
+        )
+
+    def _create_result_message(self, result_img: List[np.ndarray], x_high, y_high) -> str:
+        txt = f"Recognition ended, best result found at {x_high}, {y_high}, {result_img.shape}"
+        return txt
+
+    def limit_extended_extent_image_to_base_extent_with_mask(self, full_img):
+        """
+        Limit an image which is for extended_extent to the base_extent image.
+        If a limiting polygon was used for processing, it will be also applied.
+        :param full_img:
+        :return:
+        """
+        # TODO look for some inplace operation to save memory
+        # cv2.copyTo(src=full_img, mask=area_mask_img, dst=full_img)  # this doesn't work due to implementation details
+        # full_img = cv2.copyTo(src=full_img, mask=self.area_mask_img)
+
+        b = self.base_extent_bbox_in_full_image
+        result_img = full_img[
+            int(b.y_min * self.recognition_parameters.scale_factor): int(
+                b.y_max * self.recognition_parameters.scale_factor
+            ),
+            int(b.x_min * self.recognition_parameters.scale_factor): int(
+                b.x_max * self.recognition_parameters.scale_factor
+            ),
+            :,
+        ]
+        return result_img
+
+    def load_rlayer_from_file(self, file_path):
+        """
+        Create raster layer from tif file
+        """
+        file_name = os.path.basename(file_path)
+        base_file_name = file_name.split("___")[
+            0
+        ]  # we remove the random_id string we created a moment ago
+        rlayer = QgsRasterLayer(file_path, base_file_name)
+        if rlayer.width() == 0:
+            raise Exception(
+                "0 width - rlayer not loaded properly. Probably invalid file path?"
+            )
+        rlayer.setCrs(self.rlayer.crs())
+        return rlayer
+
+    def _create_rlayers_from_images_for_base_extent(
+        self, result_img: np.ndarray,
+        x_high,
+        y_high,
+        size,
+        stride
+    ):
+        y = y_high * stride
+        x = x_high * stride
+
+        result_img[y, x:x+size-1] = 1
+        result_img[y+size-1, x:x+size-1] = 1
+        result_img[y:y+size-1, x] = 1
+        result_img[y:y+size-1, x+size-1] = 1
+
+        # TODO: We are creating a new file for each layer.
+        # Maybe can we pass ownership of this file to QGis?
+        # Or maybe even create vlayer directly from array, without a file?
+
+        random_id = str(uuid.uuid4()).replace("-", "")
+        file_path = os.path.join(TMP_DIR_PATH, f"{random_id}.tif")
+        self.save_result_img_as_tif(file_path=file_path, img=np.expand_dims(result_img, axis=2))
+
+        rlayer = self.load_rlayer_from_file(file_path)
+        OUTPUT_RLAYER_OPACITY = 0.5
+        rlayer.renderer().setOpacity(OUTPUT_RLAYER_OPACITY)
+
+        # accessing GUI from non-GUI thread is not safe, so we need to delegate it to the GUI thread
+        def add_to_gui():
+            group = (
+                QgsProject.instance()
+                .layerTreeRoot()
+                .insertGroup(0, "Cosine similarity score")
+            )
+            QgsProject.instance().addMapLayer(rlayer, False)
+            group.addLayer(rlayer)
+
+        return add_to_gui
+
+    def save_result_img_as_tif(self, file_path: str, img: np.ndarray):
+        """
+        As we cannot pass easily an numpy array to be displayed as raster layer, we create temporary geotif files,
+        which will be loaded as layer later on
+
+        Partially based on example from:
+        https://gis.stackexchange.com/questions/82031/gdal-python-set-projection-of-a-raster-not-working
+        """
+        os.makedirs(os.path.dirname(file_path), exist_ok=True)
+
+        extent = self.base_extent
+        crs = self.rlayer.crs()
+
+        geo_transform = [
+            extent.xMinimum(),
+            self.rlayer_units_per_pixel,
+            0,
+            extent.yMaximum(),
+            0,
+            -self.rlayer_units_per_pixel,
+        ]
+
+        driver = gdal.GetDriverByName("GTiff")
+        n_lines = img.shape[0]
+        n_cols = img.shape[1]
+        n_chanels = img.shape[2]
+        # data_type = gdal.GDT_Byte
+        data_type = gdal.GDT_Float32
+        grid_data = driver.Create(
+            "grid_data", n_cols, n_lines, n_chanels, data_type
+        )  # , options)
+        # loop over chanels
+        for i in range(1, img.shape[2] + 1):
+            grid_data.GetRasterBand(i).WriteArray(img[:, :, i - 1])
+
+        # crs().srsid()  - maybe we can use the ID directly - but how?
+        # srs.ImportFromEPSG()
+        srs = osr.SpatialReference()
+        srs.SetFromUserInput(crs.authid())
+
+        grid_data.SetProjection(srs.ExportToWkt())
+        grid_data.SetGeoTransform(geo_transform)
+        driver.CreateCopy(file_path, grid_data, 0)
+
+    def _process_tile(self, tile_img: np.ndarray) -> np.ndarray:
+        result = self.model.process(tile_img)
+
+        # NOTE - currently we are saving result as float32, so we are losing some accuraccy.
+        # result = np.clip(result, 0, 255)  # old version with uint8_t - not used anymore
+        # result = result.astype(np.float32)
+
+        return result

zipdeepness/processing/map_processor/map_processor_regression.py

@@ -0,0 +1,174 @@
+""" This file implements map processing for regression model """
+
+import os
+import uuid
+from typing import List
+
+import numpy as np
+from osgeo import gdal, osr
+from qgis.core import QgsProject, QgsRasterLayer
+
+from deepness.common.misc import TMP_DIR_PATH
+from deepness.common.processing_parameters.regression_parameters import RegressionParameters
+from deepness.processing.map_processor.map_processing_result import (MapProcessingResult, MapProcessingResultCanceled,
+                                                                     MapProcessingResultSuccess)
+from deepness.processing.map_processor.map_processor_with_model import MapProcessorWithModel
+
+
+class MapProcessorRegression(MapProcessorWithModel):
+    """
+    MapProcessor specialized for Regression model (where each pixel has a value representing some feature intensity)
+    """
+
+    def __init__(self,
+                 params: RegressionParameters,
+                 **kwargs):
+        super().__init__(
+            params=params,
+            model=params.model,
+            **kwargs)
+        self.regression_parameters = params
+        self.model = params.model
+
+    def _run(self) -> MapProcessingResult:
+        number_of_output_channels = len(self._get_indexes_of_model_output_channels_to_create())
+        final_shape_px = (number_of_output_channels, self.img_size_y_pixels, self.img_size_x_pixels)
+
+        # NOTE: consider whether we can use float16/uint16 as datatype
+        full_result_imgs = self._get_array_or_mmapped_array(final_shape_px)
+
+        for tile_img_batched, tile_params_batched in self.tiles_generator_batched():
+            if self.isCanceled():
+                return MapProcessingResultCanceled()
+
+            tile_results_batched = self._process_tile(tile_img_batched)
+
+            for tile_results, tile_params in zip(tile_results_batched, tile_params_batched):
+                tile_params.set_mask_on_full_img(
+                    tile_result=tile_results,
+                    full_result_img=full_result_imgs)
+
+        # plt.figure(); plt.imshow(full_result_img); plt.show(block=False); plt.pause(0.001)
+        full_result_imgs = self.limit_extended_extent_images_to_base_extent_with_mask(full_imgs=full_result_imgs)
+        self.set_results_img(full_result_imgs)
+
+        gui_delegate = self._create_rlayers_from_images_for_base_extent(self.get_result_img())
+        result_message = self._create_result_message(self.get_result_img())
+        return MapProcessingResultSuccess(
+            message=result_message,
+            gui_delegate=gui_delegate,
+        )
+
+    def _create_result_message(self, result_imgs: List[np.ndarray]) -> str:
+        txt = f'Regression done, with the following statistics:\n'
+        for output_id, _ in enumerate(self._get_indexes_of_model_output_channels_to_create()):
+            result_img = result_imgs[output_id]
+
+            average_value = np.mean(result_img)
+            std = np.std(result_img)
+
+            txt += f' - {self.model.get_channel_name(output_id, 0)}: average_value = {average_value:.2f} (std = {std:.2f}, ' \
+                   f'min={np.min(result_img)}, max={np.max(result_img)})\n'
+
+        return txt
+
+    def limit_extended_extent_images_to_base_extent_with_mask(self, full_imgs: List[np.ndarray]):
+        """
+        Same as 'limit_extended_extent_image_to_base_extent_with_mask' but for a list of images.
+        See `limit_extended_extent_image_to_base_extent_with_mask` for details.
+        :param full_imgs:
+        :return:
+        """
+        return self.limit_extended_extent_image_to_base_extent_with_mask(full_img=full_imgs)
+
+    def load_rlayer_from_file(self, file_path):
+        """
+        Create raster layer from tif file
+        """
+        file_name = os.path.basename(file_path)
+        base_file_name = file_name.split('___')[0]  # we remove the random_id string we created a moment ago
+        rlayer = QgsRasterLayer(file_path, base_file_name)
+        if rlayer.width() == 0:
+            raise Exception("0 width - rlayer not loaded properly. Probably invalid file path?")
+        rlayer.setCrs(self.rlayer.crs())
+        return rlayer
+
+    def _create_rlayers_from_images_for_base_extent(self, result_imgs: List[np.ndarray]):
+        # TODO: We are creating a new file for each layer.
+        # Maybe can we pass ownership of this file to QGis?
+        # Or maybe even create vlayer directly from array, without a file?
+        rlayers = []
+
+        for output_id, _ in enumerate(self._get_indexes_of_model_output_channels_to_create()):
+
+            random_id = str(uuid.uuid4()).replace('-', '')
+            file_path = os.path.join(TMP_DIR_PATH, f'{self.model.get_channel_name(output_id, 0)}__{random_id}.tif')
+            self.save_result_img_as_tif(file_path=file_path, img=result_imgs[output_id])
+
+            rlayer = self.load_rlayer_from_file(file_path)
+            OUTPUT_RLAYER_OPACITY = 0.5
+            rlayer.renderer().setOpacity(OUTPUT_RLAYER_OPACITY)
+            rlayers.append(rlayer)
+
+        def add_to_gui():
+            group = QgsProject.instance().layerTreeRoot().insertGroup(0, 'model_output')
+            for rlayer in rlayers:
+                QgsProject.instance().addMapLayer(rlayer, False)
+                group.addLayer(rlayer)
+
+        return add_to_gui
+
+    def save_result_img_as_tif(self, file_path: str, img: np.ndarray):
+        """
+        As we cannot pass easily an numpy array to be displayed as raster layer, we create temporary geotif files,
+        which will be loaded as layer later on
+
+        Partially based on example from:
+        https://gis.stackexchange.com/questions/82031/gdal-python-set-projection-of-a-raster-not-working
+        """
+        os.makedirs(os.path.dirname(file_path), exist_ok=True)
+
+        extent = self.base_extent
+        crs = self.rlayer.crs()
+
+        geo_transform = [extent.xMinimum(), self.rlayer_units_per_pixel, 0,
+                         extent.yMaximum(), 0, -self.rlayer_units_per_pixel]
+
+        driver = gdal.GetDriverByName('GTiff')
+        n_lines = img.shape[0]
+        n_cols = img.shape[1]
+        # data_type = gdal.GDT_Byte
+        data_type = gdal.GDT_Float32
+        grid_data = driver.Create('grid_data', n_cols, n_lines, 1, data_type)  # , options)
+        grid_data.GetRasterBand(1).WriteArray(img)
+
+        # crs().srsid()  - maybe we can use the ID directly - but how?
+        # srs.ImportFromEPSG()
+        srs = osr.SpatialReference()
+        srs.SetFromUserInput(crs.authid())
+
+        grid_data.SetProjection(srs.ExportToWkt())
+        grid_data.SetGeoTransform(geo_transform)
+        driver.CreateCopy(file_path, grid_data, 0)
+        print(f'***** {file_path = }')
+
+    def _process_tile(self, tile_img: np.ndarray) -> np.ndarray:
+        many_result = self.model.process(tile_img)
+        many_outputs = []
+
+        for result in many_result:
+            result[np.isnan(result)] = 0
+            result *= self.regression_parameters.output_scaling
+
+            # NOTE - currently we are saving result as float32, so we are losing some accuraccy.
+            # result = np.clip(result, 0, 255)  # old version with uint8_t - not used anymore
+            result = result.astype(np.float32)
+
+            if len(result.shape) == 3:
+                result = np.expand_dims(result, axis=1)
+
+            many_outputs.append(result[:, 0])
+
+        many_outputs = np.array(many_outputs).transpose((1, 0, 2, 3))
+
+        return many_outputs

zipdeepness/processing/map_processor/map_processor_segmentation.py

@@ -0,0 +1,386 @@
+""" This file implements map processing for segmentation model """
+
+from typing import Callable
+
+import numpy as np
+from qgis.core import QgsProject, QgsVectorLayer, QgsCoordinateTransform, QgsCoordinateReferenceSystem, QgsField, QgsFeature, QgsGeometry, QgsMessageLog
+from deepness.common.lazy_package_loader import LazyPackageLoader
+from deepness.common.processing_parameters.segmentation_parameters import SegmentationParameters
+from deepness.processing import processing_utils
+from deepness.processing.map_processor.map_processing_result import (MapProcessingResult, MapProcessingResultCanceled,
+                                                                     MapProcessingResultSuccess)
+from deepness.processing.map_processor.map_processor_with_model import MapProcessorWithModel
+from deepness.processing.tile_params import TileParams
+import geopandas as gpd
+import traceback
+import pandas as pd
+from rasterio.features import shapes
+from affine import Affine
+from shapely.geometry import shape
+
+cv2 = LazyPackageLoader('cv2')
+
+
+class MapProcessorSegmentation(MapProcessorWithModel):
+    """
+    MapProcessor specialized for Segmentation model (where each pixel is assigned to one class).
+    """
+
+    def __init__(self,
+                 params: SegmentationParameters,
+                 **kwargs):
+        super().__init__(
+            params=params,
+            model=params.model,
+            **kwargs)
+        self.segmentation_parameters = params
+        self.model = params.model
+        self.new_class_names = {
+                            "0": "background",
+                            "2": "zone-verte",
+                            "3": "eau",
+                            "4": "route",
+                            "5": "non-residentiel",
+                            "6": "Villa",
+                            "7": "traditionnel",
+                            "8": "appartement",
+                            "9": "autre"
+                        }
+
+
+    def tile_mask_to_gdf_latlon(self,tile: TileParams, mask: np.ndarray, raster_layer_crs=None):
+
+
+        # remove channel if exists
+        if mask.ndim == 3:
+            mask = mask[0]
+
+        H, W = mask.shape
+
+        mask_binary = mask != 0
+
+        x_min = tile.extent.xMinimum()
+        y_max = tile.extent.yMaximum()
+        pixel_size = tile.rlayer_units_per_pixel
+        transform = Affine(pixel_size, 0, x_min, 0, -pixel_size, y_max)
+
+
+        results = (
+            {"properties": {"class_id": int(v)}, "geometry": s}
+            for s, v in shapes(mask.astype(np.int16), mask=mask_binary, transform=transform)
+        )
+        geoms = []
+        for r in results:
+            class_id = r["properties"]["class_id"]
+            class_name = self.new_class_names.get(str(class_id), "unknown")
+            geom = shape(r["geometry"])
+            geoms.append({"geometry": geom, "class_id": class_id, "class_name": class_name})
+        if geoms:
+            gdf = gpd.GeoDataFrame(geoms, geometry="geometry", crs=raster_layer_crs.authid() if raster_layer_crs else "EPSG:3857")
+        else:
+            # empty GeoDataFrame with the right columns
+            gdf = gpd.GeoDataFrame(columns=["geometry", "class_id", "class_name"], geometry="geometry", crs=raster_layer_crs.authid() if raster_layer_crs else "EPSG:3857")
+
+# Transform to lat/lon if needed
+        if not gdf.empty:
+            gdf = gdf.to_crs("EPSG:4326")
+
+        gdf = gpd.GeoDataFrame(geoms, geometry="geometry", crs=raster_layer_crs.authid() if raster_layer_crs else "EPSG:3857")
+
+        # Transform to lat/lon if needed
+        gdf = gdf.to_crs("EPSG:4326")
+
+        # # compute CRS coordinates for each pixel
+        # xs = x_min + np.arange(W) * pixel_size
+        # ys = y_max - np.arange(H) * pixel_size  # Y decreases downward
+
+        # xs_grid, ys_grid = np.meshgrid(xs, ys)
+
+        # # flatten
+        # xs_flat = xs_grid.flatten()
+        # ys_flat = ys_grid.flatten()
+        # classes_flat = mask.flatten()
+
+        # # create points
+        # points = [Point(x, y) for x, y in zip(xs_flat, ys_flat)]
+
+        # gdf = gpd.GeoDataFrame({'class': classes_flat}, geometry=points)
+
+        # # set CRS
+        # if raster_layer_crs is None:
+        #     raster_layer_crs = QgsCoordinateReferenceSystem("EPSG:3857")  # fallback
+        # gdf.set_crs(raster_layer_crs.authid(), inplace=True)
+
+        # # transform to lat/lon (EPSG:4326)
+        # transformer = QgsCoordinateTransform(raster_layer_crs, QgsCoordinateReferenceSystem("EPSG:4326"), QgsProject.instance())
+        # gdf['geometry'] = gdf['geometry'].apply(lambda pt: Point(*transformer.transform(pt.x, pt.y)))
+        # # transformed_coords = [transformer.transform(pt.x, pt.y) for pt in gdf.geometry]
+        # # gdf['geometry'] = [Point(x, y) for x, y in transformed_coords]
+        
+
+        return gdf
+
+
+    def _run(self) -> MapProcessingResult:
+        final_shape_px = (len(self._get_indexes_of_model_output_channels_to_create()), self.img_size_y_pixels, self.img_size_x_pixels)
+
+        full_result_img = self._get_array_or_mmapped_array(final_shape_px)
+        gdf_list = []
+        raster_layer = QgsProject.instance().mapLayer(self.params.input_layer_id)
+        raster_layer_crs = raster_layer.crs() if raster_layer else QgsCoordinateReferenceSystem("EPSG:3857")
+
+        for tile_img_batched, tile_params_batched in self.tiles_generator_batched():
+            if self.isCanceled():
+                return MapProcessingResultCanceled()
+
+            tile_result_batched = self._process_tile(tile_img_batched)
+
+            for tile_result, tile_params in zip(tile_result_batched, tile_params_batched):
+                tile_params.set_mask_on_full_img(
+                    tile_result=tile_result,
+                    full_result_img=full_result_img)
+                try:
+                    gdf_tile = self.tile_mask_to_gdf_latlon(
+                        tile=tile_params,
+                        mask=tile_result,
+                        raster_layer_crs=raster_layer_crs,
+                    )
+                    gdf_list.append(gdf_tile)
+                    QgsMessageLog.logMessage(f"Tile {tile_params.x_bin_number},{tile_params.y_bin_number}: got {len(gdf_tile)} points", "Segmentation", 0)
+                except Exception as e:
+                    QgsMessageLog.logMessage(f"Tile {tile_params.x_bin_number},{tile_params.y_bin_number} failed: {e}", "Segmentation", 2)
+                    QgsMessageLog.logMessage(traceback.format_exc(), "Segmentation", 2)
+
+        blur_size = int(self.segmentation_parameters.postprocessing_dilate_erode_size // 2) * 2 + 1  # needs to be odd
+
+        for i in range(full_result_img.shape[0]):
+            full_result_img[i] = cv2.medianBlur(full_result_img[i], blur_size)
+
+        full_result_img = self.limit_extended_extent_image_to_base_extent_with_mask(full_img=full_result_img)
+
+        self.set_results_img(full_result_img)
+        if gdf_list:
+            final_gdf = gpd.GeoDataFrame(pd.concat(gdf_list, ignore_index=True), crs=gdf_list[0].crs)
+            csv_file = r"C:\Users\carin\Documents\segmen.csv"
+            final_gdf.to_csv(csv_file, index=False)
+        else:
+            final_gdf = None
+            print("No GeoDataFrame generated.")
+        
+
+        gui_delegate = self._create_vlayer_from_mask_for_base_extent(self.get_result_img())
+
+        result_message = self._create_result_message(self.get_result_img())
+        return MapProcessingResultSuccess(
+            message=result_message,
+            gui_delegate=gui_delegate,
+        )
+
+    def _check_output_layer_is_sigmoid_and_has_more_than_one_name(self, output_id: int) -> bool:
+        if self.model.outputs_names is None or self.model.outputs_are_sigmoid is None:
+            return False
+
+        return len(self.model.outputs_names[output_id]) > 1 and self.model.outputs_are_sigmoid[output_id]
+
+    def _create_result_message(self, result_img: np.ndarray) -> str:
+
+        txt = f'Segmentation done, with the following statistics:\n'
+
+        for output_id, layer_sizes in enumerate(self._get_indexes_of_model_output_channels_to_create()):
+
+            txt += f'Channels for output {output_id}:\n'
+
+            unique, counts = np.unique(result_img[output_id], return_counts=True)
+            counts_map = {}
+            for i in range(len(unique)):
+                counts_map[unique[i]] = counts[i]
+
+            # # we cannot simply take image dimensions, because we may have irregular processing area from polygon
+            number_of_pixels_in_processing_area = np.sum([counts_map[k] for k in counts_map.keys()])
+            total_area = number_of_pixels_in_processing_area * self.params.resolution_m_per_px**2
+
+            for channel_id in range(layer_sizes):
+                pixels_count = counts_map.get(channel_id + 1, 0) # we add 1 to avoid 0 values, find the MADD1 code for explanation
+                area = pixels_count * self.params.resolution_m_per_px**2
+
+                if total_area > 0 and not np.isnan(total_area) and not np.isinf(total_area):
+                    area_percentage = area / total_area * 100
+                else:
+                    area_percentage = 0.0
+                    # TODO
+
+                txt += f'\t- {self.model.get_channel_name(output_id, channel_id)}: area = {area:.2f} m^2 ({area_percentage:.2f} %)\n'
+
+        return txt
+
+    def _create_vlayer_from_mask_for_base_extent(self, mask_img, vector_gdf: gpd.GeoDataFrame = None) -> Callable:
+        """ create vector layer with polygons from the mask image
+        :return: function to be called in GUI thread
+        """
+        vlayers = []
+
+        for output_id, layer_sizes in enumerate(self._get_indexes_of_model_output_channels_to_create()):
+            output_vlayers = []
+            for channel_id in range(layer_sizes):
+                local_mask_img = np.uint8(mask_img[output_id] == (channel_id + 1)) # we add 1 to avoid 0 values, find the MADD1 code for explanation
+
+                contours, hierarchy = cv2.findContours(local_mask_img, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
+                contours = processing_utils.transform_contours_yx_pixels_to_target_crs(
+                    contours=contours,
+                    extent=self.base_extent,
+                    rlayer_units_per_pixel=self.rlayer_units_per_pixel)
+                features = []
+
+                if len(contours):
+                    processing_utils.convert_cv_contours_to_features(
+                        features=features,
+                        cv_contours=contours,
+                        hierarchy=hierarchy[0],
+                        is_hole=False,
+                        current_holes=[],
+                        current_contour_index=0)
+                else:
+                    pass  # just nothing, we already have an empty list of features
+
+                layer_name = self.model.get_channel_name(output_id, channel_id)
+                vlayer = QgsVectorLayer("multipolygon", layer_name, "memory")
+                vlayer.setCrs(self.rlayer.crs())
+                prov = vlayer.dataProvider()
+
+                color = vlayer.renderer().symbol().color()
+                OUTPUT_VLAYER_COLOR_TRANSPARENCY = 80
+                color.setAlpha(OUTPUT_VLAYER_COLOR_TRANSPARENCY)
+                vlayer.renderer().symbol().setColor(color)
+                # TODO - add also outline for the layer (thicker black border)
+
+                prov.addFeatures(features)
+                vlayer.updateExtents()
+
+                output_vlayers.append(vlayer)
+
+            vlayers.append(output_vlayers)
+
+        # accessing GUI from non-GUI thread is not safe, so we need to delegate it to the GUI thread
+        def add_to_gui():
+            group = QgsProject.instance().layerTreeRoot().insertGroup(0, 'model_output')
+
+            if len(vlayers) == 1:
+                for vlayer in vlayers[0]:
+                    QgsProject.instance().addMapLayer(vlayer, False)
+                    group.addLayer(vlayer)
+            else:
+                for i, output_vlayers in enumerate(vlayers):
+                    output_group = group.insertGroup(0, f'output_{i}')
+                    for vlayer in output_vlayers:
+                        QgsProject.instance().addMapLayer(vlayer, False)
+                        output_group.addLayer(vlayer)
+
+        return add_to_gui
+    
+    def _process_tile(self, tile_img_batched: np.ndarray) -> np.ndarray:
+    
+        res = self.model.process(tile_img_batched)
+
+        # Thresholding optional (apply only on non-background)
+        threshold = self.segmentation_parameters.pixel_classification__probability_threshold
+        # onnx_classes = np.argmax(build, axis=1)[0].astype(np.int8)
+        # confidences = np.max(build, axis=1)[0]
+
+        # onnx_classes[confidences < threshold] = 0 
+        # BUILDING_ID = 1
+
+        # final_mask = onnx_classes.copy()
+
+        # final_mask[onnx_classes == BUILDING_ID] = type_build[onnx_classes == BUILDING_ID]
+
+        # final_mask = np.expand_dims(final_mask, axis=(0, 1)) 
+        final_mask = self.process_dual_batch(res, threshold)
+
+        return final_mask
+    
+    def process_dual_batch(self, result, threshold=0.0):
+
+        N = result[0].shape[0]
+        threshold = self.segmentation_parameters.pixel_classification__probability_threshold
+
+        # Run the dual model
+        res = result[0]          # (N, num_classes, H, W)
+        segmentation_maps = result[1]  # list of N segmentation maps (H, W)
+
+        # Prepare output batch
+        final_batch_masks = np.zeros((N, 1, 512, 512), dtype=np.int8)
+        individual_masks = []
+
+        new_class = {0: 0, 1: 5, 2: 6, 3: 7, 4: 8}
+        BUILDING_ID = 1
+
+        for i in range(N):
+            seg_map = segmentation_maps[i]  # (H, W)
+
+            # Map old classes to building classes
+            build_mask = np.zeros_like(seg_map, dtype=np.int8)
+            for k, v in new_class.items():
+                build_mask[seg_map == k] = v
+
+            # ONNX class predictions and confidences
+            onnx_classes = np.argmax(res[i], axis=0).astype(np.int8)  # (H, W)
+            confidences = np.max(res[i], axis=0)                       # (H, W)
+
+            # Threshold low-confidence predictions
+            onnx_classes[confidences < threshold] = 0
+
+            # Merge building predictions with type mask
+            final_mask = onnx_classes.copy()
+            final_mask[onnx_classes == BUILDING_ID] = build_mask[onnx_classes == BUILDING_ID]
+
+            # Save results
+            
+            final_batch_masks[i, 0] = final_mask
+
+        return final_batch_masks
+
+
+    # def _process_tile(self, tile_img_batched: np.ndarray) -> np.ndarray:
+    #     many_result = self.model.process(tile_img_batched)
+    #     many_outputs = []
+
+    #     for result in many_result:
+    #         result[result < self.segmentation_parameters.pixel_classification__probability_threshold] = 0.0
+
+    #         if len(result.shape) == 3:
+    #             result = np.expand_dims(result, axis=1)
+
+    #         if (result.shape[1] == 1):
+    #             result = (result != 0).astype(int) + 1 # we add 1 to avoid 0 values, find the MADD1 code for explanation
+    #         else:
+    #             shape = result.shape
+    #             result = np.argmax(result, axis=1).reshape(shape[0], 1, shape[2], shape[3]) + 1 # we add 1 to avoid 0 values, find the MADD1 code for explanation
+
+    #         assert len(result.shape) == 4
+    #         assert result.shape[1] == 1
+
+    #         many_outputs.append(result[:, 0])
+
+    #     many_outputs = np.array(many_outputs).transpose((1, 0, 2, 3))
+
+    #     return many_outputs
+
+    # def _process_tile(self, tile_img_batched: np.ndarray) -> np.ndarray:
+    
+    #     merged_probs = self.model.process(tile_img_batched)
+
+    #     # Thresholding optional (apply only on non-background)
+    #     threshold = self.segmentation_parameters.pixel_classification__probability_threshold
+    #     merged_probs[:, 1:, :, :][merged_probs[:, 1:, :, :] < threshold] = 0.0
+
+    #     # Argmax over channels to get single-channel mask
+    #     single_channel_mask = np.argmax(merged_probs, axis=1).astype(np.uint8)  # shape: (1, H, W)
+
+    #     # Remove 'other' class pixels
+    #     single_channel_mask[single_channel_mask == 1] = 0
+    #     single_channel_mask = np.expand_dims(single_channel_mask, axis=1)
+
+    #     return single_channel_mask
+
+
+        

zipdeepness/processing/map_processor/map_processor_superresolution.py

@@ -0,0 +1,175 @@
+""" This file implements map processing for Super Resolution model """
+
+import os
+import uuid
+from typing import List
+
+import numpy as np
+from osgeo import gdal, osr
+from qgis.core import QgsProject, QgsRasterLayer
+
+from deepness.common.misc import TMP_DIR_PATH
+from deepness.common.processing_parameters.superresolution_parameters import SuperresolutionParameters
+from deepness.processing.map_processor.map_processing_result import (MapProcessingResult, MapProcessingResultCanceled,
+                                                                     MapProcessingResultSuccess)
+from deepness.processing.map_processor.map_processor_with_model import MapProcessorWithModel
+
+
+class MapProcessorSuperresolution(MapProcessorWithModel):
+    """
+    MapProcessor specialized for Super Resolution model (whic is is used to upscale the input image to a higher resolution)
+    """
+
+    def __init__(self,
+                 params: SuperresolutionParameters,
+                 **kwargs):
+        super().__init__(
+            params=params,
+            model=params.model,
+            **kwargs)
+        self.superresolution_parameters = params
+        self.model = params.model
+
+    def _run(self) -> MapProcessingResult:
+        number_of_output_channels = self.model.get_number_of_output_channels()
+        
+        # always one output
+        number_of_output_channels = number_of_output_channels[0]
+        
+        final_shape_px = (int(self.img_size_y_pixels*self.superresolution_parameters.scale_factor), int(self.img_size_x_pixels*self.superresolution_parameters.scale_factor), number_of_output_channels)
+
+        # NOTE: consider whether we can use float16/uint16 as datatype
+        full_result_imgs = self._get_array_or_mmapped_array(final_shape_px)
+
+        for tile_img_batched, tile_params_batched in self.tiles_generator_batched():
+            if self.isCanceled():
+                return MapProcessingResultCanceled()
+
+            tile_results_batched = self._process_tile(tile_img_batched)
+
+            for tile_results, tile_params in zip(tile_results_batched, tile_params_batched):
+                full_result_imgs[int(tile_params.start_pixel_y*self.superresolution_parameters.scale_factor):int((tile_params.start_pixel_y+tile_params.stride_px)*self.superresolution_parameters.scale_factor),
+                                int(tile_params.start_pixel_x*self.superresolution_parameters.scale_factor):int((tile_params.start_pixel_x+tile_params.stride_px)*self.superresolution_parameters.scale_factor),
+                                :] = tile_results.transpose(1, 2, 0)  # transpose to chanels last
+
+        # plt.figure(); plt.imshow(full_result_img); plt.show(block=False); plt.pause(0.001)
+        full_result_imgs = self.limit_extended_extent_image_to_base_extent_with_mask(full_img=full_result_imgs)
+        self.set_results_img(full_result_imgs)
+
+        gui_delegate = self._create_rlayers_from_images_for_base_extent(self.get_result_img())
+        result_message = self._create_result_message(self.get_result_img())
+        return MapProcessingResultSuccess(
+            message=result_message,
+            gui_delegate=gui_delegate,
+        )
+
+    def _create_result_message(self, result_img: List[np.ndarray]) -> str:
+        channels = self._get_indexes_of_model_output_channels_to_create()
+        txt = f'Super-resolution done \n'
+
+        if len(channels) > 0:
+            total_area = result_img.shape[0] * result_img.shape[1] * (self.params.resolution_m_per_px / self.superresolution_parameters.scale_factor)**2
+            txt += f'Total are is {total_area:.2f} m^2'
+        return txt
+
+    def limit_extended_extent_image_to_base_extent_with_mask(self, full_img):
+        """
+        Limit an image which is for extended_extent to the base_extent image.
+        If a limiting polygon was used for processing, it will be also applied.
+        :param full_img:
+        :return:
+        """
+        # TODO look for some inplace operation to save memory
+        # cv2.copyTo(src=full_img, mask=area_mask_img, dst=full_img)  # this doesn't work due to implementation details
+        # full_img = cv2.copyTo(src=full_img, mask=self.area_mask_img)
+
+        b = self.base_extent_bbox_in_full_image
+        result_img = full_img[int(b.y_min*self.superresolution_parameters.scale_factor):int(b.y_max*self.superresolution_parameters.scale_factor),
+                              int(b.x_min*self.superresolution_parameters.scale_factor):int(b.x_max*self.superresolution_parameters.scale_factor),
+                              :]
+        return result_img
+
+    def load_rlayer_from_file(self, file_path):
+        """
+        Create raster layer from tif file
+        """
+        file_name = os.path.basename(file_path)
+        base_file_name = file_name.split('___')[0]  # we remove the random_id string we created a moment ago
+        rlayer = QgsRasterLayer(file_path, base_file_name)
+        if rlayer.width() == 0:
+            raise Exception("0 width - rlayer not loaded properly. Probably invalid file path?")
+        rlayer.setCrs(self.rlayer.crs())
+        return rlayer
+
+    def _create_rlayers_from_images_for_base_extent(self, result_imgs: List[np.ndarray]):
+        # TODO: We are creating a new file for each layer.
+        # Maybe can we pass ownership of this file to QGis?
+        # Or maybe even create vlayer directly from array, without a file?
+        rlayers = []
+
+        for i, channel_id in enumerate(['Super Resolution']):
+            result_img = result_imgs
+            random_id = str(uuid.uuid4()).replace('-', '')
+            file_path = os.path.join(TMP_DIR_PATH, f'{channel_id}___{random_id}.tif')
+            self.save_result_img_as_tif(file_path=file_path, img=result_img)
+
+            rlayer = self.load_rlayer_from_file(file_path)
+            OUTPUT_RLAYER_OPACITY = 0.5
+            rlayer.renderer().setOpacity(OUTPUT_RLAYER_OPACITY)
+            rlayers.append(rlayer)
+
+        def add_to_gui():
+            group = QgsProject.instance().layerTreeRoot().insertGroup(0, 'Super Resolution Results')
+            for rlayer in rlayers:
+                QgsProject.instance().addMapLayer(rlayer, False)
+                group.addLayer(rlayer)
+
+        return add_to_gui
+
+    def save_result_img_as_tif(self, file_path: str, img: np.ndarray):
+        """
+        As we cannot pass easily an numpy array to be displayed as raster layer, we create temporary geotif files,
+        which will be loaded as layer later on
+
+        Partially based on example from:
+        https://gis.stackexchange.com/questions/82031/gdal-python-set-projection-of-a-raster-not-working
+        """
+        os.makedirs(os.path.dirname(file_path), exist_ok=True)
+
+        extent = self.base_extent
+        crs = self.rlayer.crs()
+
+        geo_transform = [extent.xMinimum(), self.rlayer_units_per_pixel/self.superresolution_parameters.scale_factor, 0,
+                         extent.yMaximum(), 0, -self.rlayer_units_per_pixel/self.superresolution_parameters.scale_factor]
+
+        driver = gdal.GetDriverByName('GTiff')
+        n_lines = img.shape[0]
+        n_cols = img.shape[1]
+        n_chanels = img.shape[2]
+        # data_type = gdal.GDT_Byte
+        data_type = gdal.GDT_Float32
+        grid_data = driver.Create('grid_data', n_cols, n_lines, n_chanels, data_type)  # , options)
+        # loop over chanels
+        for i in range(1, img.shape[2]+1):
+            grid_data.GetRasterBand(i).WriteArray(img[:, :, i-1])
+
+        # crs().srsid()  - maybe we can use the ID directly - but how?
+        # srs.ImportFromEPSG()
+        srs = osr.SpatialReference()
+        srs.SetFromUserInput(crs.authid())
+
+        grid_data.SetProjection(srs.ExportToWkt())
+        grid_data.SetGeoTransform(geo_transform)
+        driver.CreateCopy(file_path, grid_data, 0)
+        print(f'***** {file_path = }')
+
+    def _process_tile(self, tile_img: np.ndarray) -> np.ndarray:
+        result = self.model.process(tile_img)
+        result[np.isnan(result)] = 0
+        result *= self.superresolution_parameters.output_scaling
+
+        # NOTE - currently we are saving result as float32, so we are losing some accuraccy.
+        # result = np.clip(result, 0, 255)  # old version with uint8_t - not used anymore
+        result = result.astype(np.float32)
+
+        return result

zipdeepness/processing/map_processor/map_processor_training_data_export.py

@@ -0,0 +1,95 @@
+""" This file implements map processing for the Training Data Export Tool """
+
+import datetime
+import os
+
+import numpy as np
+from qgis.core import QgsProject
+
+from deepness.common.lazy_package_loader import LazyPackageLoader
+from deepness.common.processing_parameters.training_data_export_parameters import TrainingDataExportParameters
+from deepness.processing import processing_utils
+from deepness.processing.map_processor.map_processing_result import (MapProcessingResultCanceled,
+                                                                     MapProcessingResultSuccess)
+from deepness.processing.map_processor.map_processor import MapProcessor
+from deepness.processing.tile_params import TileParams
+
+cv2 = LazyPackageLoader('cv2')
+
+
+class MapProcessorTrainingDataExport(MapProcessor):
+    """
+    Map Processor specialized in exporting training data, not doing any prediction with model.
+    Exports tiles for the ortophoto and a mask layer.
+    """
+
+    def __init__(self,
+                 params: TrainingDataExportParameters,
+                 **kwargs):
+        super().__init__(
+            params=params,
+            **kwargs)
+        self.params = params
+        self.output_dir_path = self._create_output_dir()
+
+    def _create_output_dir(self) -> str:
+        datetime_string = datetime.datetime.now().strftime("%d%m%Y_%H%M%S")
+        full_path = os.path.join(self.params.output_directory_path, datetime_string)
+        os.makedirs(full_path, exist_ok=True)
+        return full_path
+
+    def _run(self):
+        export_segmentation_mask = self.params.segmentation_mask_layer_id is not None
+        if export_segmentation_mask:
+            vlayer_segmentation = QgsProject.instance().mapLayers()[self.params.segmentation_mask_layer_id]
+            vlayer_segmentation.setCrs(self.rlayer.crs())
+            segmentation_mask_full = processing_utils.create_area_mask_image(
+                rlayer=self.rlayer,
+                vlayer_mask=vlayer_segmentation,
+                extended_extent=self.extended_extent,
+                rlayer_units_per_pixel=self.rlayer_units_per_pixel,
+                image_shape_yx=(self.img_size_y_pixels, self.img_size_x_pixels),
+                files_handler=self.file_handler)
+            
+            segmentation_mask_full = segmentation_mask_full[np.newaxis, ...]
+
+        number_of_written_tiles = 0
+        for tile_img, tile_params in self.tiles_generator():
+            if self.isCanceled():
+                return MapProcessingResultCanceled()
+
+            tile_params = tile_params  # type: TileParams
+
+            if self.params.export_image_tiles:
+                file_name = f'tile_img_{tile_params.x_bin_number}_{tile_params.y_bin_number}.png'
+                file_path = os.path.join(self.output_dir_path, file_name)
+
+                if tile_img.dtype in [np.uint32, np.int32]:
+                    print(f'Exporting image with data type {tile_img.dtype} is not supported. Trimming to uint16. Consider changing the data type in the source image.')
+                    tile_img = tile_img.astype(np.uint16)
+
+                if tile_img.shape[-1] == 4:
+                    tile_img = cv2.cvtColor(tile_img, cv2.COLOR_RGBA2BGRA)
+                elif tile_img.shape[-1] == 3:
+                    tile_img = cv2.cvtColor(tile_img, cv2.COLOR_RGB2BGR)
+
+                cv2.imwrite(file_path, tile_img)
+                number_of_written_tiles += 1
+
+            if export_segmentation_mask:
+                segmentation_mask_for_tile = tile_params.get_entire_tile_from_full_img(segmentation_mask_full)
+                
+                file_name = f'tile_mask_{tile_params.x_bin_number}_{tile_params.y_bin_number}.png'
+                file_path = os.path.join(self.output_dir_path, file_name)
+                
+                cv2.imwrite(file_path, segmentation_mask_for_tile[0])
+
+        result_message = self._create_result_message(number_of_written_tiles)
+        return MapProcessingResultSuccess(result_message)
+
+    def _create_result_message(self, number_of_written_tiles) -> str:
+        total_area = self.img_size_x_pixels * self.img_size_y_pixels * self.params.resolution_m_per_px**2
+        return f'Exporting data finished!\n' \
+               f'Exported {number_of_written_tiles} tiles.\n' \
+               f'Total processed area: {total_area:.2f} m^2\n' \
+               f'Directory: "{self.output_dir_path}"'

zipdeepness/processing/map_processor/map_processor_with_model.py

@@ -0,0 +1,27 @@
+
+""" This file implements map processing functions common for all map processors using nural model """
+
+from typing import List
+
+from deepness.processing.map_processor.map_processor import MapProcessor
+from deepness.processing.models.model_base import ModelBase
+
+
+class MapProcessorWithModel(MapProcessor):
+    """
+    Common base class for MapProcessor with models
+    """
+
+    def __init__(self,
+                 model: ModelBase,
+                 **kwargs):
+        super().__init__(
+            **kwargs)
+        self.model = model
+
+    def _get_indexes_of_model_output_channels_to_create(self) -> List[int]:
+        """
+        Decide what model output channels/classes we want to use at presentation level
+        (e.g. for which channels create a layer with results)
+        """
+        return self.model.get_number_of_output_channels()

zipdeepness/processing/map_processor/utils/ckdtree.py

@@ -0,0 +1,62 @@
+import heapq
+
+import numpy as np
+
+
+class cKDTree:
+    def __init__(self, data):
+        self.data = np.asarray(data)
+        self.tree = self._build_kdtree(np.arange(len(data)))
+
+    def _build_kdtree(self, indices, depth=0):
+        if len(indices) == 0:
+            return None
+        axis = depth % self.data.shape[1]  # alternate between x and y dimensions
+        
+        sorted_indices = indices[np.argsort(self.data[indices, axis])]
+        mid = len(sorted_indices) // 2
+        node = {
+            'index': sorted_indices[mid],
+            'left': self._build_kdtree(sorted_indices[:mid], depth + 1),
+            'right': self._build_kdtree(sorted_indices[mid + 1:], depth + 1)
+        }
+        return node
+
+    def query(self, point: np.ndarray, k: int):
+        if type(point) is not np.ndarray:
+            point = np.array(point)
+        
+        return [index for _, index in self._query(point, k, self.tree)]
+    
+    def _query(self, point, k, node, depth=0, best_indices=None, best_distances=None):
+        if node is None:
+            return None
+        
+        axis = depth % self.data.shape[1]
+        
+        if point[axis] < self.data[node['index']][axis]:
+            next_node = node['left']
+            other_node = node['right']
+        else:
+            next_node = node['right']
+            other_node = node['left']
+        
+        if best_indices is None:
+            best_indices = []
+            best_distances = []
+        
+        current_distance = np.linalg.norm(self.data[node['index']] - point)
+        
+        if len(best_indices) < k:
+            heapq.heappush(best_indices, (-current_distance, node['index']))
+        elif current_distance < -best_indices[0][0]:
+            heapq.heappop(best_indices)
+            heapq.heappush(best_indices, (-current_distance, node['index']))
+        
+        if point[axis] < self.data[node['index']][axis] or len(best_indices) < k or abs(point[axis] - self.data[node['index']][axis]) < -best_indices[0][0]:
+            self._query(point, k, next_node, depth + 1, best_indices, best_distances)
+        
+        if point[axis] >= self.data[node['index']][axis] or len(best_indices) < k or abs(point[axis] - self.data[node['index']][axis]) < -best_indices[0][0]:
+            self._query(point, k, other_node, depth + 1, best_indices, best_distances)
+            
+        return best_indices

zipdeepness/processing/models/__init__.py

@@ -0,0 +1,2 @@
+""" Module including classes implemetations for the deep learning inference and related functions
+"""

zipdeepness/processing/models/buildings_type_MA.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4e7c06401e20f6791e272f5ec694d4ae285c79ed6ceb9213875972114869b90f
+size 464134848

zipdeepness/processing/models/detector.py

@@ -0,0 +1,709 @@
+""" Module including the class for the object detection task and related functions
+"""
+from dataclasses import dataclass
+from typing import List, Optional, Tuple
+from qgis.core import Qgis, QgsGeometry, QgsRectangle, QgsPointXY
+
+import cv2
+import numpy as np
+
+from deepness.common.processing_parameters.detection_parameters import DetectorType
+from deepness.processing.models.model_base import ModelBase
+from deepness.processing.processing_utils import BoundingBox
+
+
+@dataclass
+class Detection:
+    """Class that represents single detection result in object detection model
+
+    Parameters
+    ----------
+    bbox : BoundingBox
+        bounding box describing the detection rectangle
+    conf : float
+        confidence of the detection
+    clss : int
+        class of the detected object
+    """
+
+    bbox: BoundingBox
+    """BoundingBox: bounding box describing the detection rectangle"""
+    conf: float
+    """float: confidence of the detection"""
+    clss: int
+    """int: class of the detected object"""
+    mask: Optional[np.ndarray] = None
+    """np.ndarray: mask of the detected object"""
+    mask_offsets: Optional[Tuple[int, int]] = None
+    """Tuple[int, int]: offsets of the mask"""
+
+    def convert_to_global(self, offset_x: int, offset_y: int):
+        """Apply (x,y) offset to bounding box coordinates
+
+        Parameters
+        ----------
+        offset_x : int
+            _description_
+        offset_y : int
+            _description_
+        """
+        self.bbox.apply_offset(offset_x=offset_x, offset_y=offset_y)
+
+        if self.mask is not None:
+            self.mask_offsets = (offset_x, offset_y)
+
+    def get_bbox_xyxy(self) -> np.ndarray:
+        """Convert stored bounding box into x1y1x2y2 format
+
+        Returns
+        -------
+        np.ndarray
+            Array in (x1, y1, x2, y2) format
+        """
+        return self.bbox.get_xyxy()
+    
+    def get_bbox_xyxy_rot(self) -> np.ndarray:
+        """Convert stored bounding box into x1y1x2y2r format
+
+        Returns
+        -------
+        np.ndarray
+            Array in (x1, y1, x2, y2, r) format
+        """
+        return self.bbox.get_xyxy_rot()
+
+    def get_bbox_center(self) -> Tuple[int, int]:
+        """Get center of the bounding box
+
+        Returns
+        -------
+        Tuple[int, int]
+            Center of the bounding box
+        """
+        return self.bbox.get_center()
+
+    def __lt__(self, other):
+        return self.bbox.get_area() < other.bbox.get_area()
+
+
+class Detector(ModelBase):
+    """Class implements object detection features
+
+    Detector model is used for detection of objects in images. It is based on YOLOv5/YOLOv7 models style.
+    """
+
+    def __init__(self, model_file_path: str):
+        """Initialize object detection model
+
+        Parameters
+        ----------
+        model_file_path : str
+            Path to model file"""
+        super(Detector, self).__init__(model_file_path)
+
+        self.confidence = None
+        """float: Confidence threshold"""
+        self.iou_threshold = None
+        """float: IoU threshold"""
+        self.model_type: Optional[DetectorType] = None
+        """DetectorType: Model type"""
+
+    def set_inference_params(self, confidence: float, iou_threshold: float):
+        """Set inference parameters
+
+        Parameters
+        ----------
+        confidence : float
+            Confidence threshold
+        iou_threshold : float
+            IoU threshold
+        """
+        self.confidence = confidence
+        self.iou_threshold = iou_threshold
+
+    def set_model_type_param(self, model_type: DetectorType):
+        """Set model type parameters
+
+        Parameters
+        ----------
+        model_type : str
+            Model type
+        """
+        self.model_type = model_type
+
+    @classmethod
+    def get_class_display_name(cls):
+        """Get class display name
+
+        Returns
+        -------
+        str
+            Class display name"""
+        return cls.__name__
+
+    def get_number_of_output_channels(self):
+        """Get number of output channels
+
+        Returns
+        -------
+        int
+            Number of output channels
+        """
+        class_names = self.get_outputs_channel_names()[0]
+        if class_names is not None:
+            return [len(class_names)]  # If class names are specified, we expect to have exactly this number of channels as specidied
+
+        model_type_params = self.model_type.get_parameters()
+
+        shape_index = -2 if model_type_params.has_inverted_output_shape else -1
+
+        if len(self.outputs_layers) == 1:
+            # YOLO_ULTRALYTICS_OBB
+            if self.model_type == DetectorType.YOLO_ULTRALYTICS_OBB:
+                return [self.outputs_layers[0].shape[shape_index] - 4 - 1]
+            
+            elif model_type_params.skipped_objectness_probability:
+                return [self.outputs_layers[0].shape[shape_index] - 4]
+            
+            return [self.outputs_layers[0].shape[shape_index] - 4 - 1]  # shape - 4 bboxes - 1 conf
+        
+        # YOLO_ULTRALYTICS_SEGMENTATION
+        elif len(self.outputs_layers) == 2 and self.model_type == DetectorType.YOLO_ULTRALYTICS_SEGMENTATION:
+            return [self.outputs_layers[0].shape[shape_index] - 4 - self.outputs_layers[1].shape[1]]
+        
+        else:
+            raise NotImplementedError("Model with multiple output layer is not supported! Use only one output layer.")
+
+    def postprocessing(self, model_output):
+        """Postprocess model output
+
+            NOTE: Maybe refactor this, as it has many added layers of checks which can be simplified.
+
+        Parameters
+        ----------
+        model_output : list
+            Model output
+
+        Returns
+        -------
+        list
+            Batch of lists of detections
+        """
+        if self.confidence is None or self.iou_threshold is None:
+            return Exception(
+                "Confidence or IOU threshold is not set for model. Use self.set_inference_params"
+            )
+
+        if self.model_type is None:
+            return Exception(
+                "Model type is not set for model. Use self.set_model_type_param"
+            )
+
+        batch_detection = []
+        outputs_range = len(model_output)
+        
+        if self.model_type == DetectorType.YOLO_ULTRALYTICS_SEGMENTATION or self.model_type == DetectorType.YOLO_v9:
+            outputs_range = len(model_output[0])
+
+        for i in range(outputs_range):
+            masks = None
+            rots = None
+            detections = []
+
+            if self.model_type == DetectorType.YOLO_v5_v7_DEFAULT:
+                boxes, conf, classes = self._postprocessing_YOLO_v5_v7_DEFAULT(model_output[0][i])
+            elif self.model_type == DetectorType.YOLO_v6:
+                boxes, conf, classes = self._postprocessing_YOLO_v6(model_output[0][i])
+            elif self.model_type == DetectorType.YOLO_v9:
+                boxes, conf, classes = self._postprocessing_YOLO_v9(model_output[0][i])
+            elif self.model_type == DetectorType.YOLO_ULTRALYTICS:
+                boxes, conf, classes = self._postprocessing_YOLO_ULTRALYTICS(model_output[0][i])
+            elif self.model_type == DetectorType.YOLO_ULTRALYTICS_SEGMENTATION:
+                boxes, conf, classes, masks = self._postprocessing_YOLO_ULTRALYTICS_SEGMENTATION(model_output[0][i], model_output[1][i])
+            elif self.model_type == DetectorType.YOLO_ULTRALYTICS_OBB:
+                boxes, conf, classes, rots = self._postprocessing_YOLO_ULTRALYTICS_OBB(model_output[0][i])
+            else:
+                raise NotImplementedError(f"Model type not implemented! ('{self.model_type}')")
+
+            masks = masks if masks is not None else [None] * len(boxes)
+            rots = rots if rots is not None else [0.0] * len(boxes)
+
+            for b, c, cl, m, r in zip(boxes, conf, classes, masks, rots):
+                det = Detection(
+                    bbox=BoundingBox(
+                        x_min=b[0],
+                        x_max=b[2],
+                        y_min=b[1],
+                        y_max=b[3],
+                        rot=r),
+                    conf=c,
+                    clss=cl,
+                    mask=m,
+                )
+                detections.append(det)
+
+            batch_detection.append(detections)
+
+        return batch_detection
+
+    def _postprocessing_YOLO_v5_v7_DEFAULT(self, model_output):
+        outputs_filtered = np.array(
+            list(filter(lambda x: x[4] >= self.confidence, model_output))
+        )
+
+        if len(outputs_filtered.shape) < 2:
+            return [], [], []
+
+        probabilities = outputs_filtered[:, 4]
+
+        outputs_x1y1x2y2 = self.xywh2xyxy(outputs_filtered)
+
+        pick_indxs = self.non_max_suppression_fast(
+            outputs_x1y1x2y2,
+            probs=probabilities,
+            iou_threshold=self.iou_threshold)
+
+        outputs_nms = outputs_x1y1x2y2[pick_indxs]
+
+        boxes = np.array(outputs_nms[:, :4], dtype=int)
+        conf = outputs_nms[:, 4]
+        classes = np.argmax(outputs_nms[:, 5:], axis=1)
+
+        return boxes, conf, classes
+
+    def _postprocessing_YOLO_v6(self, model_output):
+        outputs_filtered = np.array(
+            list(filter(lambda x: np.max(x[5:]) >= self.confidence, model_output))
+        )
+
+        if len(outputs_filtered.shape) < 2:
+            return [], [], []
+
+        probabilities = outputs_filtered[:, 4]
+
+        outputs_x1y1x2y2 = self.xywh2xyxy(outputs_filtered)
+
+        pick_indxs = self.non_max_suppression_fast(
+            outputs_x1y1x2y2,
+            probs=probabilities,
+            iou_threshold=self.iou_threshold)
+
+        outputs_nms = outputs_x1y1x2y2[pick_indxs]
+
+        boxes = np.array(outputs_nms[:, :4], dtype=int)
+        conf = np.max(outputs_nms[:, 5:], axis=1)
+        classes = np.argmax(outputs_nms[:, 5:], axis=1)
+
+        return boxes, conf, classes
+
+    def _postprocessing_YOLO_v9(self, model_output):
+        model_output = np.transpose(model_output, (1, 0))
+
+        outputs_filtered = np.array(
+            list(filter(lambda x: np.max(x[4:]) >= self.confidence, model_output))
+        )
+
+        if len(outputs_filtered.shape) < 2:
+            return [], [], []
+
+        probabilities = np.max(outputs_filtered[:, 4:], axis=1)
+
+        outputs_x1y1x2y2 = self.xywh2xyxy(outputs_filtered)
+
+        pick_indxs = self.non_max_suppression_fast(
+            outputs_x1y1x2y2,
+            probs=probabilities,
+            iou_threshold=self.iou_threshold)
+
+        outputs_nms = outputs_x1y1x2y2[pick_indxs]
+
+        boxes = np.array(outputs_nms[:, :4], dtype=int)
+        conf = np.max(outputs_nms[:, 4:], axis=1)
+        classes = np.argmax(outputs_nms[:, 4:], axis=1)
+
+        return boxes, conf, classes
+
+    def _postprocessing_YOLO_ULTRALYTICS(self, model_output):
+        model_output = np.transpose(model_output, (1, 0))
+
+        outputs_filtered = np.array(
+            list(filter(lambda x: np.max(x[4:]) >= self.confidence, model_output))
+        )
+
+        if len(outputs_filtered.shape) < 2:
+            return [], [], []
+
+        probabilities = np.max(outputs_filtered[:, 4:], axis=1)
+
+        outputs_x1y1x2y2 = self.xywh2xyxy(outputs_filtered)
+
+        pick_indxs = self.non_max_suppression_fast(
+            outputs_x1y1x2y2,
+            probs=probabilities,
+            iou_threshold=self.iou_threshold)
+
+        outputs_nms = outputs_x1y1x2y2[pick_indxs]
+
+        boxes = np.array(outputs_nms[:, :4], dtype=int)
+        conf = np.max(outputs_nms[:, 4:], axis=1)
+        classes = np.argmax(outputs_nms[:, 4:], axis=1)
+
+        return boxes, conf, classes
+
+    def _postprocessing_YOLO_ULTRALYTICS_SEGMENTATION(self, detections, protos):        
+        detections = np.transpose(detections, (1, 0))
+        
+        number_of_class = self.get_number_of_output_channels()[0]
+        mask_start_index = 4 + number_of_class
+        
+        outputs_filtered = np.array(
+            list(filter(lambda x: np.max(x[4:4+number_of_class]) >= self.confidence, detections))
+        )
+
+        if len(outputs_filtered.shape) < 2:
+            return [], [], [], []
+        
+        probabilities = np.max(outputs_filtered[:, 4:4+number_of_class], axis=1)
+
+        outputs_x1y1x2y2 = self.xywh2xyxy(outputs_filtered)
+
+        pick_indxs = self.non_max_suppression_fast(
+            outputs_x1y1x2y2,
+            probs=probabilities,
+            iou_threshold=self.iou_threshold)
+
+        outputs_nms = outputs_x1y1x2y2[pick_indxs]
+
+        boxes = np.array(outputs_nms[:, :4], dtype=int)
+        conf = np.max(outputs_nms[:, 4:4+number_of_class], axis=1)
+        classes = np.argmax(outputs_nms[:, 4:4+number_of_class], axis=1)
+        masks_in = np.array(outputs_nms[:, mask_start_index:], dtype=float)
+        
+        masks = self.process_mask(protos, masks_in, boxes)
+
+        return boxes, conf, classes, masks
+    
+    def _postprocessing_YOLO_ULTRALYTICS_OBB(self, model_output):
+        model_output = np.transpose(model_output, (1, 0))
+
+        outputs_filtered = np.array(
+            list(filter(lambda x: np.max(x[4:-1]) >= self.confidence, model_output))
+        )
+
+        if len(outputs_filtered.shape) < 2:
+            return [], [], [], []
+
+        probabilities = np.max(outputs_filtered[:, 4:-1], axis=1)
+        rotations = outputs_filtered[:, -1]
+
+        outputs_x1y1x2y2_rot = self.xywhr2xyxyr(outputs_filtered, rotations)
+
+        pick_indxs = self.non_max_suppression_fast(
+            outputs_x1y1x2y2_rot,
+            probs=probabilities,
+            iou_threshold=self.iou_threshold,
+            with_rot=True)
+        
+        outputs_nms = outputs_x1y1x2y2_rot[pick_indxs]
+
+        boxes = np.array(outputs_nms[:, :4], dtype=int)
+        conf = np.max(outputs_nms[:, 4:-1], axis=1)
+        classes = np.argmax(outputs_nms[:, 4:-1], axis=1)
+        rots = outputs_nms[:, -1]
+
+        return boxes, conf, classes, rots
+
+    # based on https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/ops.py#L638C1-L638C67
+    def process_mask(self, protos, masks_in, bboxes):
+        c, mh, mw = protos.shape  # CHW
+        ih, iw = self.input_shape[2:]
+
+        masks = self.sigmoid(np.matmul(masks_in, protos.astype(float).reshape(c, -1))).reshape(-1, mh, mw)
+
+        downsampled_bboxes = bboxes.copy().astype(float)
+        downsampled_bboxes[:, 0] *= mw / iw
+        downsampled_bboxes[:, 2] *= mw / iw
+        downsampled_bboxes[:, 3] *= mh / ih
+        downsampled_bboxes[:, 1] *= mh / ih
+
+        masks = self.crop_mask(masks, downsampled_bboxes)
+        scaled_masks = np.zeros((len(masks), ih, iw))
+
+        for i in range(len(masks)):
+            scaled_masks[i] = cv2.resize(masks[i], (iw, ih), interpolation=cv2.INTER_LINEAR)
+
+        masks = np.uint8(scaled_masks >= 0.5)
+            
+        return masks
+
+    @staticmethod
+    def sigmoid(x):
+        return 1 / (1 + np.exp(-x))
+
+    @staticmethod
+    # based on https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/ops.py#L598C1-L614C65
+    def crop_mask(masks, boxes):
+        n, h, w = masks.shape
+        x1, y1, x2, y2 = np.split(boxes[:, :, None], 4, axis=1)  # x1 shape(n,1,1)
+        r = np.arange(w, dtype=x1.dtype)[None, None, :]  # rows shape(1,1,w)
+        c = np.arange(h, dtype=x1.dtype)[None, :, None]  # cols shape(1,h,1)
+
+        return masks * ((r >= x1) * (r < x2) * (c >= y1) * (c < y2))
+
+    @staticmethod
+    def xywh2xyxy(x: np.ndarray) -> np.ndarray:
+        """Convert bounding box from (x,y,w,h) to (x1,y1,x2,y2) format
+
+        Parameters
+        ----------
+        x : np.ndarray
+            Bounding box in (x,y,w,h) format with classes' probabilities
+
+        Returns
+        -------
+        np.ndarray
+            Bounding box in (x1,y1,x2,y2) format
+        """
+        y = np.copy(x)
+        y[:, 0] = x[:, 0] - x[:, 2] / 2  # top left x
+        y[:, 1] = x[:, 1] - x[:, 3] / 2  # top left y
+        y[:, 2] = x[:, 0] + x[:, 2] / 2  # bottom right x
+        y[:, 3] = x[:, 1] + x[:, 3] / 2  # bottom right y
+        return y
+
+    @staticmethod
+    def xywhr2xyxyr(bbox: np.ndarray, rot: np.ndarray) -> np.ndarray:
+        """Convert bounding box from (x,y,w,h,r) to (x1,y1,x2,y2,r) format, keeping rotated boxes in range [0, pi/2]
+
+        Parameters
+        ----------
+        bbox : np.ndarray
+            Bounding box in (x,y,w,h) format with classes' probabilities and rotations
+
+        Returns
+        -------
+        np.ndarray
+            Bounding box in (x1,y1,x2,y2,r) format, keep classes' probabilities
+        """
+        x, y, w, h = bbox[:, 0], bbox[:, 1], bbox[:, 2], bbox[:, 3]
+
+        w_ = np.where(w > h, w, h)
+        h_ = np.where(w > h, h, w)
+        r_ = np.where(w > h, rot, rot + np.pi / 2) % np.pi
+
+        new_bbox_xywh = np.stack([x, y, w_, h_], axis=1)
+        new_bbox_xyxy = Detector.xywh2xyxy(new_bbox_xywh)
+
+        return np.concatenate([new_bbox_xyxy, bbox[:, 4:-1], r_[:, None]], axis=1)
+
+
+    @staticmethod
+    def non_max_suppression_fast(boxes: np.ndarray, probs: np.ndarray, iou_threshold: float, with_rot: bool = False) -> List:
+        """Apply non-maximum suppression to bounding boxes
+
+        Based on:
+        https://github.com/amusi/Non-Maximum-Suppression/blob/master/nms.py
+
+        Parameters
+        ----------
+        boxes : np.ndarray
+            Bounding boxes in (x1,y1,x2,y2) format or (x1,y1,x2,y2,r) format if with_rot is True
+        probs : np.ndarray
+            Confidence scores
+        iou_threshold : float
+            IoU threshold
+        with_rot: bool
+            If True, use rotated IoU
+
+        Returns
+        -------
+        List
+            List of indexes of bounding boxes to keep
+        """
+        # If no bounding boxes, return empty list
+        if len(boxes) == 0:
+            return []
+
+        # Bounding boxes
+        boxes = np.array(boxes)
+
+        # coordinates of bounding boxes
+        start_x = boxes[:, 0]
+        start_y = boxes[:, 1]
+        end_x = boxes[:, 2]
+        end_y = boxes[:, 3]
+
+        if with_rot:
+            # Rotations of bounding boxes
+            rotations = boxes[:, 4]
+
+        # Confidence scores of bounding boxes
+        score = np.array(probs)
+
+        # Picked bounding boxes
+        picked_boxes = []
+
+        # Compute areas of bounding boxes
+        areas = (end_x - start_x + 1) * (end_y - start_y + 1)
+
+        # Sort by confidence score of bounding boxes
+        order = np.argsort(score)
+
+        # Iterate bounding boxes
+        while order.size > 0:
+            # The index of largest confidence score
+            index = order[-1]
+
+            # Pick the bounding box with largest confidence score
+            picked_boxes.append(index)
+
+            if not with_rot:
+                ratio = Detector.compute_iou(index, order, start_x, start_y, end_x, end_y, areas)
+            else:
+                ratio = Detector.compute_rotated_iou(index, order, start_x, start_y, end_x, end_y, rotations, areas)
+
+            left = np.where(ratio < iou_threshold)
+            order = order[left]
+
+        return picked_boxes
+
+    @staticmethod
+    def compute_iou(index: int, order: np.ndarray, start_x: np.ndarray, start_y: np.ndarray, end_x: np.ndarray, end_y: np.ndarray, areas: np.ndarray) -> np.ndarray:
+        """Compute IoU for bounding boxes
+        
+        Parameters
+        ----------
+        index : int
+            Index of the bounding box
+        order : np.ndarray
+            Order of bounding boxes
+        start_x : np.ndarray
+            Start x coordinate of bounding boxes
+        start_y : np.ndarray
+            Start y coordinate of bounding boxes
+        end_x : np.ndarray
+            End x coordinate of bounding boxes
+        end_y : np.ndarray
+            End y coordinate of bounding boxes
+        areas : np.ndarray
+            Areas of bounding boxes
+
+        Returns
+        -------
+        np.ndarray
+            IoU values
+        """
+        
+        # Compute ordinates of intersection-over-union(IOU)
+        x1 = np.maximum(start_x[index], start_x[order[:-1]])
+        x2 = np.minimum(end_x[index], end_x[order[:-1]])
+        y1 = np.maximum(start_y[index], start_y[order[:-1]])
+        y2 = np.minimum(end_y[index], end_y[order[:-1]])
+
+        # Compute areas of intersection-over-union
+        w = np.maximum(0.0, x2 - x1 + 1)
+        h = np.maximum(0.0, y2 - y1 + 1)
+        intersection = w * h
+
+        # Compute the ratio between intersection and union
+        return intersection / (areas[index] + areas[order[:-1]] - intersection)
+    
+
+    @staticmethod
+    def compute_rotated_iou(index: int, order: np.ndarray, start_x: np.ndarray, start_y: np.ndarray, end_x: np.ndarray, end_y: np.ndarray, rotations: np.ndarray, areas: np.ndarray) -> np.ndarray:
+        """Compute IoU for rotated bounding boxes
+        
+        Parameters
+        ----------
+        index : int
+            Index of the bounding box
+        order : np.ndarray
+            Order of bounding boxes
+        start_x : np.ndarray
+            Start x coordinate of bounding boxes
+        start_y : np.ndarray
+            Start y coordinate of bounding boxes
+        end_x : np.ndarray
+            End x coordinate of bounding boxes
+        end_y : np.ndarray
+            End y coordinate of bounding boxes
+        rotations : np.ndarray
+            Rotations of bounding boxes (in radians, around the center)
+        areas : np.ndarray
+            Areas of bounding boxes
+
+        Returns
+        -------
+        np.ndarray
+            IoU values
+        """
+
+        def create_rotated_geom(x1, y1, x2, y2, rotation):
+            """Helper function to create a rotated QgsGeometry rectangle"""
+            # Define the corners of the box before rotation
+            center_x = (x1 + x2) / 2
+            center_y = (y1 + y2) / 2
+
+            # Create a rectangle using QgsRectangle
+            rect = QgsRectangle(QgsPointXY(x1, y1), QgsPointXY(x2, y2))
+            
+            # Convert to QgsGeometry
+            geom = QgsGeometry.fromRect(rect)
+            
+            # Rotate the geometry around its center
+            result = geom.rotate(np.degrees(rotation), QgsPointXY(center_x, center_y))
+
+            if result == Qgis.GeometryOperationResult.Success:
+                return geom
+            else:
+                return QgsGeometry()
+
+        # Create the rotated geometry for the current bounding box
+        geom1 = create_rotated_geom(start_x[index], start_y[index], end_x[index], end_y[index], rotations[index])
+        
+        iou_values = []
+        
+        # Iterate over the rest of the boxes in order and calculate IoU
+        for i in range(len(order) - 1):
+            # Create the rotated geometry for the other boxes in the order
+            geom2 = create_rotated_geom(start_x[order[i]], start_y[order[i]], end_x[order[i]], end_y[order[i]], rotations[order[i]])
+            
+            # Compute the intersection geometry
+            intersection_geom = geom1.intersection(geom2)
+
+            # Check if intersection is empty
+            if intersection_geom.isEmpty():
+                intersection_area = 0.0
+            else:
+                # Compute the intersection area
+                intersection_area = intersection_geom.area()
+            
+            # Compute the union area
+            union_area = areas[index] + areas[order[i]] - intersection_area
+            
+            # Compute IoU
+            iou = intersection_area / union_area if union_area > 0 else 0.0
+            iou_values.append(iou)
+        
+        return np.array(iou_values)
+
+
+    def check_loaded_model_outputs(self):
+        """Check if model outputs are valid.
+        Valid model are:
+            - has 1 or 2 outputs layer
+            - output layer shape length is 3
+            - batch size is 1
+        """
+
+        if len(self.outputs_layers) == 1 or len(self.outputs_layers) == 2:
+            shape = self.outputs_layers[0].shape
+
+            if len(shape) != 3:
+                raise Exception(
+                    f"Detection model output should have 3 dimensions: (Batch_size, detections, values). "
+                    f"Actually has: {shape}"
+                )
+
+        else:
+            raise NotImplementedError("Model with multiple output layer is not supported! Use only one output layer.")

zipdeepness/processing/models/dual.py

@@ -0,0 +1,168 @@
+from deepness.processing.models.segmentor import Segmentor
+import numpy as np
+import cv2
+import onnxruntime as ort
+import os
+from typing import List
+
+class DualModel(Segmentor):
+
+    def __init__(self, model_file_path: str):
+        super().__init__(model_file_path)
+        current_dir = os.path.dirname(os.path.abspath(__file__))
+            # Both models are in the same folder
+        self.second_model_file_path = os.path.join(current_dir, "buildings_type_MA.onnx")
+        self.second_model = ort.InferenceSession(self.second_model_file_path, providers=["CUDAExecutionProvider", "CPUExecutionProvider"])
+
+
+
+
+    def preprocess_tiles_ade20k(self,tiles_batched: np.ndarray) -> np.ndarray:
+        # ADE20K mean/std in 0-1 range
+        ADE_MEAN = np.array([123.675, 116.280, 103.530]) / 255.0
+        ADE_STD = np.array([58.395, 57.120, 57.375]) / 255.0
+
+        tiles = tiles_batched.astype(np.float32) / 255.0  # 0-1
+
+        # Standardize per channel
+        tiles = (tiles - ADE_MEAN) / ADE_STD  # broadcasting over (N,H,W,C)
+
+        # Ensure 3D channels (if grayscale)
+        if tiles.ndim == 3:  # (H,W,C) single image
+            tiles = np.expand_dims(tiles, axis=0)  # add batch dim
+
+        if tiles.shape[-1] == 1:  # if only 1 channel
+            tiles = np.repeat(tiles, 3, axis=-1)
+
+        # NHWC -> NCHW
+        tiles = np.transpose(tiles, (0, 3, 1, 2))
+
+        return tiles.astype(np.float32)
+
+
+
+
+    def stable_sigmoid(self, x):
+        out = np.empty_like(x, dtype=np.float32)
+        positive_mask = x >= 0
+        negative_mask = ~positive_mask
+
+        out[positive_mask] = 1 / (1 + np.exp(-x[positive_mask]))
+        exp_x = np.exp(x[negative_mask])
+        out[negative_mask] = exp_x / (1 + exp_x)
+        return out
+
+
+    def stable_softmax(self, x, axis=-1):
+        max_x = np.max(x, axis=axis, keepdims=True)
+        exp_x = np.exp(x - max_x)
+        return exp_x / np.sum(exp_x, axis=axis, keepdims=True)
+
+
+    def post_process_semantic_segmentation_numpy(self, class_queries_logits, masks_queries_logits, target_sizes=None):
+        # Softmax over classes (remove null class)
+        masks_classes = self.stable_softmax(class_queries_logits, axis=-1)[..., :-1]
+
+        # Sigmoid for masks
+        masks_probs = self.stable_sigmoid(masks_queries_logits)
+
+        # Combine: torch.einsum("bqc,bqhw->bchw")
+        segmentation = np.einsum("bqc,bqhw->bchw", masks_classes, masks_probs)
+
+        semantic_segmentation = []
+        if target_sizes is not None:
+            if len(target_sizes) != class_queries_logits.shape[0]:
+                raise ValueError("target_sizes length must match batch size")
+
+            for idx in range(len(target_sizes)):
+                out_h, out_w = target_sizes[idx]
+                logits_resized = np.zeros((segmentation.shape[1], out_h, out_w), dtype=np.float32)
+                for c in range(segmentation.shape[1]):
+                    logits_resized[c] = cv2.resize(
+                        segmentation[idx, c],
+                        (out_w, out_h),
+                        interpolation=cv2.INTER_LINEAR
+                    )
+                semantic_map = np.argmax(logits_resized, axis=0)
+                semantic_segmentation.append(semantic_map.astype(np.int32))
+        else:
+            for idx in range(segmentation.shape[0]):
+                semantic_map = np.argmax(segmentation[idx], axis=0)
+                semantic_segmentation.append(semantic_map.astype(np.int32))
+
+        return semantic_segmentation
+    
+    def return_probs_mask2former(self,
+        class_queries_logits,
+        masks_queries_logits,
+        target_sizes=None):
+    
+        # Softmax over classes (remove null class)
+        masks_classes = self.stable_softmax(class_queries_logits, axis=-1)[..., :-1]
+
+        # Sigmoid for masks
+        masks_probs = self.stable_sigmoid(masks_queries_logits)
+
+        # Combine: einsum bqc,bqhw -> bchw
+        segmentation = np.einsum("bqc,bqhw->bchw", masks_classes, masks_probs)
+
+        # Resize if target_sizes is given
+        if target_sizes is not None:
+            if len(target_sizes) != segmentation.shape[0]:
+                raise ValueError("target_sizes length must match batch size")
+
+            segmentation_resized = np.zeros(
+                (segmentation.shape[0], segmentation.shape[1], target_sizes[0][0], target_sizes[0][1]),
+                dtype=np.float32
+            )
+
+            for idx in range(segmentation.shape[0]):
+                out_h, out_w = target_sizes[idx]
+                for c in range(segmentation.shape[1]):
+                    segmentation_resized[idx, c] = cv2.resize(
+                        segmentation[idx, c],
+                        (out_w, out_h),
+                        interpolation=cv2.INTER_LINEAR
+                    )
+            segmentation = segmentation_resized
+
+
+        return segmentation  # shape: (B, C, H, W)
+
+
+
+
+
+    def process(self, tiles_batched: np.ndarray):
+        input_batch = self.preprocessing(tiles_batched)
+        input_building_batch = self.preprocess_tiles_ade20k(tiles_batched)
+
+        model_output = self.sess.run(
+                output_names=None,
+                input_feed={self.input_name: input_batch})
+        res = self.postprocessing(model_output)
+        logits_np, masks_np = self.second_model.run(["logits", "outputs_mask.35"], {"pixel_values": input_building_batch})
+        target_sizes=[(512, 512)]*logits_np.shape[0]
+        predicted_seg = self.post_process_semantic_segmentation_numpy(
+            class_queries_logits=logits_np,
+            masks_queries_logits=masks_np,
+            target_sizes=target_sizes
+        )
+        # new_class = {0:0, 1:5, 2:6, 3:7, 4:8}
+        # build_mask = np.zeros((512,512), dtype=np.int8)
+        # segmentation_map = predicted_seg[0]
+        # for k,v in new_class.items():
+        #     build_mask[segmentation_map == k] = v
+
+        return res[0], predicted_seg
+
+
+    def get_number_of_output_channels(self) -> List[int]:
+            return [9]
+    
+    def get_output_shapes(self) -> List[tuple]:
+        return [("N", 9, 512, 512)]
+
+
+
+

zipdeepness/processing/models/model_base.py

@@ -0,0 +1,444 @@
+""" Module including the base model interfaces and utilities"""
+import ast
+import json
+from typing import List, Optional
+
+import numpy as np
+
+from deepness.common.lazy_package_loader import LazyPackageLoader
+from deepness.common.processing_parameters.standardization_parameters import StandardizationParameters
+
+ort = LazyPackageLoader('onnxruntime')
+
+
+class ModelBase:
+    """
+    Wraps the ONNX model used during processing into a common interface
+    """
+
+    def __init__(self, model_file_path: str):
+        """
+
+        Parameters
+        ----------
+        model_file_path : str
+            Path to the model file
+        """
+        self.model_file_path = model_file_path
+
+        options = ort.SessionOptions()
+        options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
+
+        providers = [
+            'CUDAExecutionProvider',
+            'CPUExecutionProvider'
+        ]
+
+        self.sess = ort.InferenceSession(self.model_file_path, options=options, providers=providers)
+        inputs = self.sess.get_inputs()
+        if len(inputs) > 1:
+            raise Exception("ONNX model: unsupported number of inputs")
+        input_0 = inputs[0]
+
+        self.input_shape = input_0.shape
+        self.input_name = input_0.name
+
+        self.outputs_layers = self.sess.get_outputs()
+        self.standardization_parameters: StandardizationParameters = self.get_metadata_standarization_parameters()
+        
+        self.outputs_names = self.get_outputs_channel_names()
+
+    @classmethod
+    def get_model_type_from_metadata(cls, model_file_path: str) -> Optional[str]:
+        """ Get model type from metadata
+
+        Parameters
+        ----------
+        model_file_path : str
+            Path to the model file
+
+        Returns
+        -------
+        Optional[str]
+            Model type or None if not found
+        """
+        model = cls(model_file_path)
+        return model.get_metadata_model_type()
+
+    def get_input_shape(self) -> tuple:
+        """ Get shape of the input for the model
+
+        Returns
+        -------
+        tuple
+            Shape of the input (batch_size, channels, height, width)
+        """
+        return self.input_shape
+
+    def get_output_shapes(self) -> List[tuple]:
+        """ Get shapes of the outputs for the model
+
+        Returns
+        -------
+        List[tuple]
+            Shapes of the outputs (batch_size, channels, height, width)
+        """
+        return [output.shape for output in self.outputs_layers]
+
+    def get_model_batch_size(self) -> Optional[int]:
+        """ Get batch size of the model
+
+        Returns
+        -------
+        Optional[int] | None
+            Batch size or None if not found (dynamic batch size)
+        """
+        bs = self.input_shape[0]
+
+        if isinstance(bs, str):
+            return None
+        else:
+            return bs
+
+    def get_input_size_in_pixels(self) -> int:
+        """ Get number of input pixels in x and y direction (the same value)
+
+        Returns
+        -------
+        int
+            Number of pixels in x and y direction
+        """
+        return self.input_shape[-2:]
+
+    def get_outputs_channel_names(self) -> Optional[List[List[str]]]:
+        """ Get class names from metadata
+
+        Returns
+        -------
+        List[List[str]] | None
+            List of class names for each model output or None if not found
+        """
+        meta = self.sess.get_modelmeta()
+
+        allowed_key_names = ['class_names', 'names']  # support both names for backward compatibility
+        for name in allowed_key_names:
+            if name not in meta.custom_metadata_map:
+                continue
+
+            txt = meta.custom_metadata_map[name]
+            try:
+                class_names = json.loads(txt)  # default format recommended in the documentation - classes encoded as json
+            except json.decoder.JSONDecodeError:
+                class_names = ast.literal_eval(txt)  # keys are integers instead of strings - use ast
+
+            if isinstance(class_names, dict):
+                class_names = [class_names]
+
+            sorted_by_key = [sorted(cn.items(), key=lambda kv: int(kv[0])) for cn in class_names]
+
+            all_names = []
+            
+            for output_index in range(len(sorted_by_key)):
+                output_names = []
+                class_counter = 0
+            
+                for key, value in sorted_by_key[output_index]:
+                    if int(key) != class_counter:
+                        raise Exception("Class names in the model metadata are not consecutive (missing class label)")
+                    class_counter += 1
+                    output_names.append(value)
+                all_names.append(output_names)
+
+            return all_names
+
+        return None
+
+    def get_channel_name(self, layer_id: int, channel_id: int) -> str:
+        """ Get channel name by id if exists in model metadata
+
+        Parameters
+        ----------
+        channel_id : int
+            Channel id (means index in the output tensor)
+
+        Returns
+        -------
+        str
+            Channel name or empty string if not found
+        """
+        
+        channel_id_str = str(channel_id)
+        default_return = f'channel_{channel_id_str}'
+
+        if self.outputs_names is None:
+            return default_return
+        
+        if layer_id >= len(self.outputs_names):
+            raise Exception(f'Layer id {layer_id} is out of range of the model outputs')
+        
+        if channel_id >= len(self.outputs_names[layer_id]):
+            raise Exception(f'Channel id {channel_id} is out of range of the model outputs')
+        
+        return f'{self.outputs_names[layer_id][channel_id]}'
+
+    def get_metadata_model_type(self) -> Optional[str]:
+        """ Get model type from metadata
+
+        Returns
+        -------
+        Optional[str]
+            Model type or None if not found
+        """
+        meta = self.sess.get_modelmeta()
+        name = 'model_type'
+        if name in meta.custom_metadata_map:
+            value = json.loads(meta.custom_metadata_map[name])
+            return str(value).capitalize()
+        return None
+
+    def get_metadata_standarization_parameters(self) -> Optional[StandardizationParameters]:
+        """ Get standardization parameters from metadata if exists
+
+        Returns
+        -------
+        Optional[StandardizationParameters]
+            Standardization parameters or None if not found
+        """
+        meta = self.sess.get_modelmeta()
+        name_mean = 'standardization_mean'
+        name_std = 'standardization_std'
+
+        param = StandardizationParameters(channels_number=self.get_input_shape()[-3])
+
+        if name_mean in meta.custom_metadata_map and name_std in meta.custom_metadata_map:
+            mean = json.loads(meta.custom_metadata_map[name_mean])
+            std = json.loads(meta.custom_metadata_map[name_std])
+
+            mean = [float(x) for x in mean]
+            std = [float(x) for x in std]
+
+            param.set_mean_std(mean=mean, std=std)
+
+            return param
+
+        return param  # default, no standardization
+
+    def get_metadata_resolution(self) -> Optional[float]:
+        """ Get resolution from metadata if exists
+
+        Returns
+        -------
+        Optional[float]
+            Resolution or None if not found
+        """
+        meta = self.sess.get_modelmeta()
+        name = 'resolution'
+        if name in meta.custom_metadata_map:
+            value = json.loads(meta.custom_metadata_map[name])
+            return float(value)
+        return None
+
+    def get_metadata_tile_size(self) -> Optional[int]:
+        """ Get tile size from metadata if exists
+
+        Returns
+        -------
+        Optional[int]
+            Tile size or None if not found
+        """
+        meta = self.sess.get_modelmeta()
+        name = 'tile_size'
+        if name in meta.custom_metadata_map:
+            value = json.loads(meta.custom_metadata_map[name])
+            return int(value)
+        return None
+
+    def get_metadata_tiles_overlap(self) -> Optional[int]:
+        """ Get tiles overlap from metadata if exists
+
+        Returns
+        -------
+        Optional[int]
+            Tiles overlap or None if not found
+        """
+        meta = self.sess.get_modelmeta()
+        name = 'tiles_overlap'
+        if name in meta.custom_metadata_map:
+            value = json.loads(meta.custom_metadata_map[name])
+            return int(value)
+        return None
+
+    def get_metadata_segmentation_threshold(self) -> Optional[float]:
+        """ Get segmentation threshold from metadata if exists
+
+        Returns
+        -------
+        Optional[float]
+            Segmentation threshold or None if not found
+        """
+        meta = self.sess.get_modelmeta()
+        name = 'seg_thresh'
+        if name in meta.custom_metadata_map:
+            value = json.loads(meta.custom_metadata_map[name])
+            return float(value)
+        return None
+
+    def get_metadata_segmentation_small_segment(self) -> Optional[int]:
+        """ Get segmentation small segment from metadata if exists
+
+        Returns
+        -------
+        Optional[int]
+            Segmentation small segment or None if not found
+        """
+        meta = self.sess.get_modelmeta()
+        name = 'seg_small_segment'
+        if name in meta.custom_metadata_map:
+            value = json.loads(meta.custom_metadata_map[name])
+            return int(value)
+        return None
+
+    def get_metadata_regression_output_scaling(self) -> Optional[float]:
+        """ Get regression output scaling from metadata if exists
+
+        Returns
+        -------
+        Optional[float]
+            Regression output scaling or None if not found
+        """
+        meta = self.sess.get_modelmeta()
+        name = 'reg_output_scaling'
+        if name in meta.custom_metadata_map:
+            value = json.loads(meta.custom_metadata_map[name])
+            return float(value)
+        return None
+
+    def get_metadata_detection_confidence(self) -> Optional[float]:
+        """ Get detection confidence from metadata if exists
+
+        Returns
+        -------
+        Optional[float]
+            Detection confidence or None if not found
+        """
+        meta = self.sess.get_modelmeta()
+        name = 'det_conf'
+        if name in meta.custom_metadata_map:
+            value = json.loads(meta.custom_metadata_map[name])
+            return float(value)
+        return None
+
+    def get_detector_type(self) -> Optional[str]:
+        """ Get detector type from metadata if exists
+
+        Returns string value of DetectorType enum or None if not found
+        -------
+        Optional[str]
+            Detector type or None if not found
+        """
+        meta = self.sess.get_modelmeta()
+        name = 'det_type'
+        if name in meta.custom_metadata_map:
+            value = json.loads(meta.custom_metadata_map[name])
+            return str(value)
+        return None
+
+    def get_metadata_detection_iou_threshold(self) -> Optional[float]:
+        """ Get detection iou threshold from metadata if exists
+
+        Returns
+        -------
+        Optional[float]
+            Detection iou threshold or None if not found
+        """
+        meta = self.sess.get_modelmeta()
+        name = 'det_iou_thresh'
+        if name in meta.custom_metadata_map:
+            value = json.loads(meta.custom_metadata_map[name])
+            return float(value)
+        return None
+
+    def get_number_of_channels(self) -> int:
+        """ Returns number of channels in the input layer
+
+        Returns
+        -------
+        int
+            Number of channels in the input layer
+        """
+        return self.input_shape[-3]
+
+    def process(self, tiles_batched: np.ndarray):
+        """ Process a single tile image
+
+        Parameters
+        ----------
+        img : np.ndarray
+            Image to process ([TILE_SIZE x TILE_SIZE x channels], type uint8, values 0 to 255)
+
+        Returns
+        -------
+        np.ndarray
+            Single prediction
+        """
+        input_batch = self.preprocessing(tiles_batched)
+        model_output = self.sess.run(
+            output_names=None,
+            input_feed={self.input_name: input_batch})
+        res = self.postprocessing(model_output)
+        return res
+
+    def preprocessing(self, tiles_batched: np.ndarray) -> np.ndarray:
+        """ Preprocess the batch of images for the model (resize, normalization, etc)
+
+        Parameters
+        ----------
+        image : np.ndarray
+            Batch of images to preprocess (N,H,W,C), RGB, 0-255
+
+        Returns
+        -------
+        np.ndarray
+            Preprocessed batch of image (N,C,H,W), RGB, 0-1
+        """
+
+        # imported here, to avoid isseue with uninstalled dependencies during the first plugin start
+        # in other places we use LazyPackageLoader, but here it is not so easy
+        import deepness.processing.models.preprocessing_utils as preprocessing_utils
+
+        tiles_batched = preprocessing_utils.limit_channels_number(tiles_batched, limit=self.input_shape[-3])
+        tiles_batched = preprocessing_utils.normalize_values_to_01(tiles_batched)
+        tiles_batched = preprocessing_utils.standardize_values(tiles_batched, params=self.standardization_parameters)
+        tiles_batched = preprocessing_utils.transpose_nhwc_to_nchw(tiles_batched)
+
+        return tiles_batched
+
+    def postprocessing(self, outs: List) -> np.ndarray:
+        """ Abstract method for postprocessing
+
+        Parameters
+        ----------
+        outs : List
+            Output from the model (depends on the model type)
+
+        Returns
+        -------
+        np.ndarray
+            Postprocessed output
+        """
+        raise NotImplementedError('Base class not implemented!')
+
+    def get_number_of_output_channels(self) -> List[int]:
+        """ Abstract method for getting number of classes in the output layer
+
+        Returns
+        -------
+        int
+            Number of channels in the output layer"""
+        raise NotImplementedError('Base class not implemented!')
+
+    def check_loaded_model_outputs(self):
+        """ Abstract method for checking if the model outputs are valid
+
+        """
+        raise NotImplementedError('Base class not implemented!')

zipdeepness/processing/models/model_types.py

@@ -0,0 +1,93 @@
+import enum
+from dataclasses import dataclass
+
+from deepness.common.processing_parameters.detection_parameters import DetectionParameters
+from deepness.common.processing_parameters.map_processing_parameters import MapProcessingParameters
+from deepness.common.processing_parameters.recognition_parameters import RecognitionParameters
+from deepness.common.processing_parameters.regression_parameters import RegressionParameters
+from deepness.common.processing_parameters.segmentation_parameters import SegmentationParameters
+from deepness.common.processing_parameters.superresolution_parameters import SuperresolutionParameters
+from deepness.processing.map_processor.map_processor_detection import MapProcessorDetection
+from deepness.processing.map_processor.map_processor_recognition import MapProcessorRecognition
+from deepness.processing.map_processor.map_processor_regression import MapProcessorRegression
+from deepness.processing.map_processor.map_processor_segmentation import MapProcessorSegmentation
+from deepness.processing.map_processor.map_processor_superresolution import MapProcessorSuperresolution
+from deepness.processing.models.detector import Detector
+from deepness.processing.models.recognition import Recognition
+from deepness.processing.models.regressor import Regressor
+from deepness.processing.models.segmentor import Segmentor
+from deepness.processing.models.superresolution import Superresolution
+from deepness.processing.models.dual import DualModel
+
+
+class ModelType(enum.Enum):
+    SEGMENTATION = Segmentor.get_class_display_name()
+    REGRESSION = Regressor.get_class_display_name()
+    DETECTION = Detector.get_class_display_name()
+    SUPERRESOLUTION = Superresolution.get_class_display_name()
+    RECOGNITION = Recognition.get_class_display_name()
+
+
+@dataclass
+class ModelDefinition:
+    model_type: ModelType
+    model_class: type
+    parameters_class: type
+    map_processor_class: type
+
+    @classmethod
+    def get_model_definitions(cls):
+        return [
+            cls(
+                model_type=ModelType.SEGMENTATION,
+                model_class=DualModel,
+                parameters_class=SegmentationParameters,
+                map_processor_class=MapProcessorSegmentation,
+            ),
+            cls(
+                model_type=ModelType.REGRESSION,
+                model_class=Regressor,
+                parameters_class=RegressionParameters,
+                map_processor_class=MapProcessorRegression,
+            ),
+            cls(
+                model_type=ModelType.DETECTION,
+                model_class=Detector,
+                parameters_class=DetectionParameters,
+                map_processor_class=MapProcessorDetection,
+            ),  # superresolution
+            cls(
+                model_type=ModelType.SUPERRESOLUTION,
+                model_class=Superresolution,
+                parameters_class=SuperresolutionParameters,
+                map_processor_class=MapProcessorSuperresolution,
+            ),  # recognition
+            cls(
+                model_type=ModelType.RECOGNITION,
+                model_class=Recognition,
+                parameters_class=RecognitionParameters,
+                map_processor_class=MapProcessorRecognition,
+            )
+
+        ]
+
+    @classmethod
+    def get_definition_for_type(cls, model_type: ModelType):
+        model_definitions = cls.get_model_definitions()
+        for model_definition in model_definitions:
+            if model_definition.model_type == model_type:
+                return model_definition
+        raise Exception(f"Unknown model type: '{model_type}'!")
+
+    @classmethod
+    def get_definition_for_params(cls, params: MapProcessingParameters):
+        """ get model definition corresponding to the specified parameters """
+        model_definitions = cls.get_model_definitions()
+        for model_definition in model_definitions:
+            if type(params) == model_definition.parameters_class:
+                return model_definition
+
+        for model_definition in model_definitions:
+            if isinstance(params, model_definition.parameters_class):
+                return model_definition
+        raise Exception(f"Unknown model type for parameters: '{params}'!")