From d81e8bf38b6c1dd3ed49516f490c7fc3f1b7a516 Mon Sep 17 00:00:00 2001
From: Xavier Dumetz <xavier.dumetz@ign.fr>
Date: Wed, 18 Jan 2023 15:36:45 +0100
Subject: [PATCH 01/11] =?UTF-8?q?Initialisation=20des=20d=C3=A9veloppement?=
 =?UTF-8?q?s=20sur=20la=20librairie=20Raster.py?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 CHANGELOG.md         |  6 ++++++
 README.md            | 12 ++++++------
 rok4/Raster.py       |  7 +++++++
 tests/test_Raster.py |  7 +++++++
 4 files changed, 26 insertions(+), 6 deletions(-)
 create mode 100644 rok4/Raster.py
 create mode 100644 tests/test_Raster.py

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b9559b5..8abc4c8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -10,6 +10,12 @@ Prise en charge de plusieurs clusters S3 de stockage.
 
 * Librairie d'abstraction du stockage :
   * Prise en charge de plusieurs clusters S3. Les variables d'environnement pour le stockage S3 précisent plusieurs valeurs séparées par des virgules, et les noms des buckets peuvent être suffixés par "@{S3 cluster host}". Par défaut, le premier cluster défini est utilisé. L'hôte du cluster n'est jamais écrit dans le descripteur de pyramide ou le fichier liste (puisque stockés sur le cluster, on sait sur lequel sont les objets). Les objets symboliques ne le précisent pas non plus et ne peuvent être qu'au sein d'un cluster S3
+* Librairie de lecture de données raster :
+  * Squelette minimal avec test unitaire d'invocation du constructeur
+
+### [Changed]
+
+* Appels explicites à python3 dans le README, pour tenir compte des distributions où l'exécutable `python` correspond par défaut à Python 2.7.
 
 <!-- 
 ### [Added]
diff --git a/README.md b/README.md
index 68d3853..f6f21a7 100644
--- a/README.md
+++ b/README.md
@@ -4,20 +4,20 @@ Ces librairies Python sont utilisées par les outils python du dépôt [pytools]
 
 ## Compiler la librairie
 
-`VERSION=1.0.0 python setup.py bdist_wheel`
+`VERSION=1.0.0 python3 setup.py bdist_wheel`
 
 ## Installer la librairie
 
 ```sh
-apt install python3-rados
-python -m venv --system-site-packages venv
+apt install python3-rados python3-venv python3-pytest
+python3 -m venv --system-site-packages venv
 source venv/bin/activate
-pip install rok4lib-1.0.0-py3-none-any.whl
+python3 -m pip install dist/rok4lib-1.0.0-py3-none-any.whl
 ```
 
 ## Jouer les tests unitaires
 
-`pytest`
+`python3 -m pytest`
 
 ## Utiliser la librairie
 
@@ -34,6 +34,6 @@ except Exception as exc:
 
 ```bash
 source venv/bin/activate
-pip install pdoc3 
+python3 -m pip install pdoc3 
 VERSION=1.0.0 pdoc --html rok4
 ```
\ No newline at end of file
diff --git a/rok4/Raster.py b/rok4/Raster.py
new file mode 100644
index 0000000..2b32334
--- /dev/null
+++ b/rok4/Raster.py
@@ -0,0 +1,7 @@
+"""Provide functions to describe a raster image
+
+The Raster class provides read-only access to information about a given raster file or object.
+"""
+
+class Raster():
+    trash_variable = None;
diff --git a/tests/test_Raster.py b/tests/test_Raster.py
new file mode 100644
index 0000000..9f1b1c4
--- /dev/null
+++ b/tests/test_Raster.py
@@ -0,0 +1,7 @@
+from rok4.Raster import Raster
+
+import pytest
+
+def test_empty_constructor():
+    raster_object = Raster()
+

From cff15887e358e26b23d9eecd6ff9925b04d217c0 Mon Sep 17 00:00:00 2001
From: Xavier Dumetz <xavier.dumetz@ign.fr>
Date: Mon, 23 Jan 2023 17:20:53 +0100
Subject: [PATCH 02/11] =?UTF-8?q?WIP:=20impl=C3=A9mentation=20du=20constru?=
 =?UTF-8?q?cteur=20de=20la=20classe=20Raster.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 CHANGELOG.md         |  2 +-
 rok4/Raster.py       | 36 +++++++++++++++++++++++++++++++++---
 tests/test_Raster.py | 17 ++++++++++++++++-
 3 files changed, 50 insertions(+), 5 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8abc4c8..6e4543e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -11,7 +11,7 @@ Prise en charge de plusieurs clusters S3 de stockage.
 * Librairie d'abstraction du stockage :
   * Prise en charge de plusieurs clusters S3. Les variables d'environnement pour le stockage S3 précisent plusieurs valeurs séparées par des virgules, et les noms des buckets peuvent être suffixés par "@{S3 cluster host}". Par défaut, le premier cluster défini est utilisé. L'hôte du cluster n'est jamais écrit dans le descripteur de pyramide ou le fichier liste (puisque stockés sur le cluster, on sait sur lequel sont les objets). Les objets symboliques ne le précisent pas non plus et ne peuvent être qu'au sein d'un cluster S3
 * Librairie de lecture de données raster :
-  * Squelette minimal avec test unitaire d'invocation du constructeur
+  * Squelette minimal avec tests unitaires d'invocation du constructeur
 
 ### [Changed]
 
diff --git a/rok4/Raster.py b/rok4/Raster.py
index 2b32334..f443ff1 100644
--- a/rok4/Raster.py
+++ b/rok4/Raster.py
@@ -1,7 +1,37 @@
-"""Provide functions to describe a raster image
+"""Provide functions to read information on raster data from file path or object path
+
+The module contains the following class :
+
+    - 'Raster' - Structure describing raster data.
 
-The Raster class provides read-only access to information about a given raster file or object.
 """
 
+from osgeo import ogr
+
+# Enable GDAL/OGR exceptions
+ogr.UseExceptions()
+
+
 class Raster():
-    trash_variable = None;
+    """A structure describing raster data
+
+    Attributes :
+        path (str): path to the file/object
+        bbox (Tuple[float, float, float, float]): bounding rectange in the data projection
+        samples (int): number of color channels
+        mask (str): path to the associated mask file or object, if any (same name, but ".msk" extension)
+    """
+
+    def __init__(self, path: str) -> None:
+        """Basic constructor method
+
+        Args:
+            path (str): path to the file/object
+
+        """
+
+        self.path = path
+        self.bbox = ""
+        self.samples = 3
+        self.mask = ""
+
diff --git a/tests/test_Raster.py b/tests/test_Raster.py
index 9f1b1c4..5ae7e86 100644
--- a/tests/test_Raster.py
+++ b/tests/test_Raster.py
@@ -3,5 +3,20 @@
 import pytest
 
 def test_empty_constructor():
-    raster_object = Raster()
+    catched_error = False
+    try:
+        raster_object = Raster()
+    except TypeError as exc:
+        catched_error = True
+    finally:
+        assert catched_error
+
+def test_nominal_constructor():
+    path = "file:///tmp/image.jpg"
+    raster_object = Raster(path)
+    assert raster_object.path == path
+    assert raster_object.bbox is not None
+    assert raster_object.samples is not None
+    assert raster_object.mask is not None
+
 

From e71ae56486b7809d7ff121075ba2d37d62c88c8e Mon Sep 17 00:00:00 2001
From: Xavier Dumetz <XDmz@protonmail.com>
Date: Tue, 24 Jan 2023 17:06:34 +0100
Subject: [PATCH 03/11] =?UTF-8?q?Impl=C3=A9mentation=20du=20constructeur?=
 =?UTF-8?q?=20rok4.Raster.Raster()=20Le=20constructeur=20fait=20pour=20le?=
 =?UTF-8?q?=20moment=20appel=20=C3=A0=20des=20fonctions=20non=20impl=C3=A9?=
 =?UTF-8?q?ment=C3=A9es=20pour=20calculer=20la=20BBox=20et=20le=20nombre?=
 =?UTF-8?q?=20de=20canaux=20de=20l'image.=20les=20attributs=20'path'=20at?=
 =?UTF-8?q?=20'mask'=20sont=20remplis=20apr=C3=A8s=20diff=C3=A9rentes=20v?=
 =?UTF-8?q?=C3=A9rifications=20sur=20les=20objets=20ou=20fichiers=20d'imag?=
 =?UTF-8?q?e=20et=20de=20masque=20associ=C3=A9.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 CHANGELOG.md         |   3 +-
 rok4/Raster.py       |  67 ++++++++-
 tests/test_Raster.py | 331 ++++++++++++++++++++++++++++++++++++++++---
 3 files changed, 377 insertions(+), 24 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index ef688f9..c74954a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -12,7 +12,8 @@ Prise en charge de plusieurs clusters S3 de stockage.
   * Chargement de données vecteur pour des fichiers shapefile, Geopackage, CSV et GeoJSON
   * Ecriture des tests unitaires
 * Librairie de lecture de données raster :
-  * Squelette minimal avec tests unitaires d'invocation du constructeur
+  * Constructeur implémenté
+    * Ce dernier fait appel à des fonctions internes qui ne sont pas encore implémentées.
 
 ### [Changed]
 
diff --git a/rok4/Raster.py b/rok4/Raster.py
index f443ff1..6bd510e 100644
--- a/rok4/Raster.py
+++ b/rok4/Raster.py
@@ -6,7 +6,12 @@
 
 """
 
-from osgeo import ogr
+import re
+import tempfile
+
+from osgeo import ogr, gdal
+
+from rok4.Storage import get_data_str, exists, get_infos_from_path, copy, StorageType
 
 # Enable GDAL/OGR exceptions
 ogr.UseExceptions()
@@ -16,10 +21,10 @@ class Raster():
     """A structure describing raster data
 
     Attributes :
-        path (str): path to the file/object
+        path (str): path to the file/object (ex: file:///path/to/image.tif or s3://bucket/path/to/image.tif)
         bbox (Tuple[float, float, float, float]): bounding rectange in the data projection
         samples (int): number of color channels
-        mask (str): path to the associated mask file or object, if any (same name, but ".msk" extension)
+        mask (str): path to the associated mask file or object, if any, or None (same path as the image, but with a ".msk" extension and TIFF format. ex: file:///path/to/image.msk or s3://bucket/path/to/image.msk)
     """
 
     def __init__(self, path: str) -> None:
@@ -28,10 +33,60 @@ def __init__(self, path: str) -> None:
         Args:
             path (str): path to the file/object
 
+        Raises:
+            RuntimeError: raised by OGR/GDAL if anything goes wrong
+            MissingEnvironmentError: Missing object storage informations
+            StorageError: Storage read issue
         """
 
+        if not exists(path):
+            raise Exception(f"No file or object found at path '{path}'.")
+
+        image_info = get_infos_from_path(path)
+
+        tmp_image_file = None
+        work_image_path = None
+        if image_info[0] == StorageType.FILE:
+            work_image_path = image_info[1]
+        else:
+            tmp_image_file = tempfile.NamedTemporaryFile(mode='r', delete=False)
+            tmp_image_file.close()
+            work_image_path = tmp_image_file.name
+            copy(path, f"file://{work_image_path}")
+
+        image_datasource = gdal.Open(work_image_path)
         self.path = path
-        self.bbox = ""
-        self.samples = 3
-        self.mask = ""
+
+        path_pattern = re.compile('(/[^/]+?)\.[a-zA-Z0-9_-]+$')
+        mask_path = path_pattern.sub('\\1.msk', path)
+
+        tmp_mask_file = None
+        work_mask_path = None
+        if exists(mask_path):
+            if image_info[0] == StorageType.FILE:
+                work_mask_path = path_pattern.sub('\\1.msk', image_info[1])
+            else:
+                tmp_mask_file = tempfile.NamedTemporaryFile(mode='r', delete=False)
+                tmp_mask_file.close()
+                work_mask_path = tmp_mask_file.name
+                copy(mask_path, f"file://{work_mask_path}") 
+            
+            ogr.GetDriverByName('GTiff').Open(work_mask_path)
+
+            self.mask = mask_path
+        else:
+            self.mask = None
+
+        self.bbox = _compute_bbox()
+        self.samples = _compute_samples()
+
+        tmp_image_file = None
+
+
+def _compute_bbox() -> tuple:
+    return None
+
+
+def _compute_samples() -> int:
+    return None
 
diff --git a/tests/test_Raster.py b/tests/test_Raster.py
index 5ae7e86..4cc7c55 100644
--- a/tests/test_Raster.py
+++ b/tests/test_Raster.py
@@ -1,22 +1,319 @@
-from rok4.Raster import Raster
+"""Describes unit tests for the rok4.Raster module."""
+
+from rok4.Raster import *
+from rok4.Storage import StorageType
 
 import pytest
+from unittest.mock import *
+from unittest import mock, TestCase, skip
+
+class TestConstructorCommon(TestCase):
+    """Test class for the rok4.Raster.Raster(path) class constructor, for any storage type."""
+
+    def test_empty(self):
+        """Test case : Constructor called without the expected path argument."""
+
+        with pytest.raises(TypeError):
+            Raster()
+
+
+    @mock.patch('rok4.Raster.exists', return_value=False)
+    def test_image_not_found(self, mocked_exists):
+        """Test case : Constructor called on a path matching no file or object."""
+
+        path = "file:///home/user/image.tif"
+
+        with pytest.raises(Exception):
+            Raster(path)
+
+        mocked_exists.assert_called_once_with(path)
+
+
+
+class TestConstructorFile(TestCase):
+    """Test class for the rok4.Raster.Raster(path) class constructor, used with file storage."""
+
+    def setUp(self):
+        self.path = {
+            'protocol': 'file://',
+            'base_location': '/home/user',
+            'base_name': 'image',
+            'image': {},
+            'mask': {}
+        }
+        self.path['image']['system'] = f"{self.path['base_location']}/{self.path['base_name']}.tif"
+        self.path['mask']['system'] = f"{self.path['base_location']}/{self.path['base_name']}.msk"
+        self.path['image']['full'] = f"{self.path['protocol']}{self.path['image']['system']}"
+        self.path['mask']['full'] = f"{self.path['protocol']}{self.path['mask']['system']}"
+        
+        self.get_infos_from_path = (StorageType.FILE, self.path['image']['system'], self.path['base_location'], self.path['base_name'])
+
+
+    @mock.patch('rok4.Raster.get_infos_from_path')
+    @mock.patch('rok4.Raster.gdal.Open')
+    @mock.patch('rok4.Raster._compute_samples', return_value=3)
+    @mock.patch('rok4.Raster._compute_bbox', return_value=[-5.4, 41.3, 9.8, 51.3])
+    @mock.patch('rok4.Raster.exists', side_effect=[True, False])
+    def test_image(self, mocked_exists, mocked_compute_bbox, mocked_compute_samples, mocked_gdal_open, mocked_get_infos_from_path):
+        """Test case : Constructor called nominally on an image without mask."""
+
+        mocked_get_infos_from_path.return_value = self.get_infos_from_path
+
+        raster_object = Raster( self.path['image']['full'] )
+
+        mocked_exists.assert_has_calls([ call(self.path['image']['full']), call(self.path['mask']['full']) ])
+        mocked_get_infos_from_path.assert_called_once_with( self.path['image']['full'] )
+        mocked_gdal_open.assert_called_once_with( self.path['image']['system'] )
+        assert raster_object.path == self.path['image']['full']
+        assert raster_object.mask is None
+
+        mocked_compute_bbox.assert_called_once()
+        assert raster_object.bbox == [-5.4, 41.3, 9.8, 51.3]
+
+        mocked_compute_samples.assert_called_once()
+        assert raster_object.samples == 3
+
+
+    @mock.patch('rok4.Raster.ogr.GetDriverByName')
+    @mock.patch('rok4.Raster.get_infos_from_path')
+    @mock.patch('rok4.Raster.gdal.Open')
+    @mock.patch('rok4.Raster._compute_samples', return_value=3)
+    @mock.patch('rok4.Raster._compute_bbox', return_value=[-5.4, 41.3, 9.8, 51.3])
+    @mock.patch('rok4.Raster.exists', side_effect=[True, True])
+    def test_image_and_mask(self, mocked_exists, mocked_compute_bbox, mocked_compute_samples, mocked_gdal_open, mocked_get_infos_from_path, mocked_get_driver):
+        """Test case : Constructor called nominally on an image with mask."""
+
+        mocked_get_infos_from_path.return_value = self.get_infos_from_path
+        # This next line emulates the return of ogr.GetDriverByName()
+        # TODO : manage to implent this using unittest.mock
+        mocked_get_driver.return_value = type('', (object,), {'Open': mocked_gdal_open})
+
+        raster_object = Raster(self.path['image']['full'])
+
+        mocked_exists.assert_has_calls([ call(self.path['image']['full']), call(self.path['mask']['full']) ])
+        mocked_get_infos_from_path.assert_called_once_with(self.path['image']['full'])
+        mocked_get_driver.assert_called_once_with('GTiff')
+        mocked_gdal_open.assert_has_calls([ call(self.path['image']['system']), call(self.path['mask']['system']) ])
+        assert raster_object.path == self.path['image']['full']
+        assert raster_object.mask == self.path['mask']['full']
+
+        mocked_compute_bbox.assert_called_once()
+        assert raster_object.bbox == [-5.4, 41.3, 9.8, 51.3]
+
+        mocked_compute_samples.assert_called_once()
+        assert raster_object.samples == 3
+
+
+    @mock.patch('rok4.Raster.get_infos_from_path')
+    @mock.patch('rok4.Raster.gdal.Open', side_effect=RuntimeError)
+    @mock.patch('rok4.Raster.exists', side_effect=[True, False])
+    def test_unsupported_image_format(self, mocked_exists, mocked_gdal_open, mocked_get_infos_from_path):
+        """Test case : Constructor called on an unsupported 'image' file or object."""
+
+        mocked_get_infos_from_path.return_value = self.get_infos_from_path
+
+        with pytest.raises(RuntimeError):
+            Raster(self.path['image']['full'])
+
+        mocked_exists.assert_called_once_with(self.path['image']['full'])
+        mocked_gdal_open.assert_called_once_with(self.path['image']['system'])
+
+
+    @mock.patch('rok4.Raster.ogr.GetDriverByName')
+    @mock.patch('rok4.Raster.get_infos_from_path')
+    @mock.patch('rok4.Raster.gdal.Open', side_effect=[None, RuntimeError])
+    @mock.patch('rok4.Raster.exists', side_effect=[True, True])
+    def test_unsupported_mask_format(self, mocked_exists, mocked_gdal_open, mocked_get_infos_from_path, mocked_get_driver):
+        """Test case : Constructor called on an unsupported mask file or object."""
+
+        mocked_get_infos_from_path.return_value = self.get_infos_from_path
+        # This next line emulates the return of ogr.GetDriverByName()
+        # TODO : manage to implent this using unittest.mock
+        mocked_get_driver.return_value = type('', (object,), {'Open': mocked_gdal_open})
+
+        with pytest.raises(RuntimeError):
+            Raster(self.path['image']['full'])      
+
+        mocked_exists.assert_has_calls([call(self.path['image']['full']), call(self.path['mask']['full'])])
+        mocked_get_driver.assert_called_once_with('GTiff')
+        mocked_gdal_open.assert_has_calls([ call(self.path['image']['system']), call(self.path['mask']['system']) ])
+
+
+
+class TestConstructorObject(TestCase):
+    """Test class for the rok4.Raster.Raster(path) class constructor, used with object storage."""
+
+    def setUp(self):
+        self.path = {
+            'protocol': 's3://',
+            'base_location': 'bucket',
+            'base_name': 'basename',
+            'image': {},
+            'mask': {}
+        }
+        self.path['image']['system'] = f"{self.path['base_location']}/{self.path['base_name']}.tif"
+        self.path['mask']['system'] = f"{self.path['base_location']}/{self.path['base_name']}.msk"
+        self.path['image']['full'] = f"{self.path['protocol']}{self.path['image']['system']}"
+        self.path['mask']['full'] = f"{self.path['protocol']}{self.path['mask']['system']}"
+
+        self.get_infos_from_path = (StorageType.S3, self.path['image']['system'], self.path['base_location'], self.path['base_name'])
+
+        self.tmp_path = {
+            'image': {
+                'system': '/tmp/tempimage'
+            },
+            'mask': {
+                'system': '/tmp/tempmask'
+            },
+        }
+        self.tmp_path['image']['full'] = f"file://{self.tmp_path['image']['system']}"
+        self.tmp_path['mask']['full'] = f"file://{self.tmp_path['mask']['system']}"
+
+
+    @mock.patch('rok4.Raster.copy')
+    @mock.patch('rok4.Raster.tempfile.NamedTemporaryFile')
+    @mock.patch('rok4.Raster.get_infos_from_path')
+    @mock.patch('rok4.Raster.gdal.Open')
+    @mock.patch('rok4.Raster._compute_samples', return_value=3)
+    @mock.patch('rok4.Raster._compute_bbox', return_value=[-5.4, 41.3, 9.8, 51.3])
+    @mock.patch('rok4.Raster.exists', side_effect=[True, False])
+    def test_image(self, mocked_exists, mocked_compute_bbox, mocked_compute_samples, mocked_gdal_open, mocked_get_infos_from_path, mocked_create_temporary_file, mocked_copy):
+        """Test case : Constructor called nominally on an image without mask."""
+        
+        mocked_get_infos_from_path.return_value = self.get_infos_from_path
+        mocked_tmp_file_close = Mock()
+        # This next line emulates the return of tempfile.NamedTemporaryFile()
+        # TODO : manage to implent this using unittest.mock
+        mocked_create_temporary_file.return_value = type('', (object,), {'name': self.tmp_path['image']['system'], 'close': mocked_tmp_file_close})
+
+        raster_object = Raster(self.path['image']['full'])
+
+        mocked_exists.assert_has_calls([call(self.path['image']['full']), call(self.path['mask']['full'])])
+        mocked_get_infos_from_path.assert_called_once_with(self.path['image']['full'])
+        mocked_create_temporary_file.assert_called_once_with(mode='r', delete=False)
+        mocked_copy.assert_called_once_with(self.path['image']['full'], self.tmp_path['image']['full'])
+        mocked_gdal_open.assert_called_once_with(self.tmp_path['image']['system'])
+        assert raster_object.path == self.path['image']['full']
+        assert raster_object.mask is None
+
+        mocked_compute_bbox.assert_called_once()
+        assert raster_object.bbox == [-5.4, 41.3, 9.8, 51.3]
+
+        mocked_compute_samples.assert_called_once()
+        assert raster_object.samples == 3
+
+
+    @mock.patch('rok4.Raster.ogr.GetDriverByName')
+    @mock.patch('rok4.Raster.copy')
+    @mock.patch('rok4.Raster.tempfile.NamedTemporaryFile')
+    @mock.patch('rok4.Raster.get_infos_from_path')
+    @mock.patch('rok4.Raster.gdal.Open')
+    @mock.patch('rok4.Raster._compute_samples', return_value=3)
+    @mock.patch('rok4.Raster._compute_bbox', return_value=[-5.4, 41.3, 9.8, 51.3])
+    @mock.patch('rok4.Raster.exists', side_effect=[True, True])
+    def test_image_and_mask(self, mocked_exists, mocked_compute_bbox, mocked_compute_samples, mocked_gdal_open, mocked_get_infos_from_path, mocked_create_temporary_file, mocked_copy, mocked_get_driver):
+        """Test case : Constructor called nominally on an image with mask."""
+        
+        mocked_get_infos_from_path.return_value = self.get_infos_from_path
+        mocked_tmp_file_close = Mock()
+        # This next instruction emulates the return of tempfile.NamedTemporaryFile()
+        # TODO : manage to implent this using unittest.mock
+        mocked_create_temporary_file.side_effect = [
+            type('', (object,), {'name': self.tmp_path['image']['system'], 'close': mocked_tmp_file_close}),
+            type('', (object,), {'name': self.tmp_path['mask']['system'], 'close': mocked_tmp_file_close})
+        ]
+        # This next line emulates the return of ogr.GetDriverByName()
+        # TODO : manage to implent this using unittest.mock
+        mocked_get_driver.return_value = type('', (object,), {'Open': mocked_gdal_open})
+
+        raster_object = Raster(self.path['image']['full'])
+
+        expected_copy_calls = [
+            call(self.path['image']['full'], self.tmp_path['image']['full']),
+            call(self.path['mask']['full'], self.tmp_path['mask']['full'])
+        ]
+        mocked_exists.assert_has_calls([call(self.path['image']['full']), call(self.path['mask']['full'])])
+        mocked_get_infos_from_path.assert_called_once_with(self.path['image']['full'])
+        mocked_create_temporary_file.assert_has_calls([call(mode='r', delete=False), call(mode='r', delete=False)])
+        mocked_copy.assert_has_calls(expected_copy_calls)
+        mocked_get_driver.assert_called_once_with('GTiff')
+        mocked_gdal_open.assert_has_calls([ call(self.tmp_path['image']['system']), call(self.tmp_path['mask']['system']) ])
+        assert raster_object.path == self.path['image']['full']
+        assert raster_object.mask == self.path['mask']['full']
+
+        mocked_compute_bbox.assert_called_once()
+        assert raster_object.bbox == [-5.4, 41.3, 9.8, 51.3]
+
+        mocked_compute_samples.assert_called_once()
+        assert raster_object.samples == 3
+
+    
+    @mock.patch('rok4.Raster.copy')
+    @mock.patch('rok4.Raster.tempfile.NamedTemporaryFile')
+    @mock.patch('rok4.Raster.get_infos_from_path')
+    @mock.patch('rok4.Raster.gdal.Open', side_effect=RuntimeError)
+    @mock.patch('rok4.Raster.exists', side_effect=[True, False])
+    def test_unsupported_image_format(self, mocked_exists, mocked_gdal_open, mocked_get_infos_from_path, mocked_create_temporary_file, mocked_copy):
+        """Test case : Constructor called on an unsupported 'image' file or object."""
+        
+        mocked_get_infos_from_path.return_value = self.get_infos_from_path
+        mocked_tmp_file_close = Mock()
+        # This next line emulates the return of tempfile.NamedTemporaryFile()
+        # TODO : manage to implent this using unittest.mock
+        mocked_create_temporary_file.return_value = type('', (object,), {'name': self.tmp_path['image']['system'], 'close': mocked_tmp_file_close})
+
+        with pytest.raises(RuntimeError):
+            Raster(self.path['image']['full'])
+
+        mocked_exists.assert_called_once_with(self.path['image']['full'])
+        mocked_get_infos_from_path.assert_called_once_with(self.path['image']['full'])
+        mocked_create_temporary_file.assert_called_once_with(mode='r', delete=False)
+        mocked_copy.assert_called_once_with(self.path['image']['full'], self.tmp_path['image']['full'])
+        mocked_gdal_open.assert_called_once_with(self.tmp_path['image']['system'])
+
+
+    @mock.patch('rok4.Raster.ogr.GetDriverByName')
+    @mock.patch('rok4.Raster.copy')
+    @mock.patch('rok4.Raster.tempfile.NamedTemporaryFile')
+    @mock.patch('rok4.Raster.get_infos_from_path')
+    @mock.patch('rok4.Raster.gdal.Open', side_effect=[None, RuntimeError])
+    @mock.patch('rok4.Raster.exists', side_effect=[True, True])
+    def test_unsupported_mask_format(self, mocked_exists, mocked_gdal_open, mocked_get_infos_from_path, mocked_create_temporary_file, mocked_copy, mocked_get_driver):
+        """Test case : Constructor called on an unsupported mask file or object."""
+        
+        mocked_get_infos_from_path.return_value = self.get_infos_from_path
+        mocked_tmp_file_close = Mock()
+        # This next instruction emulates the return of tempfile.NamedTemporaryFile()
+        # TODO : manage to implent this using unittest.mock
+        mocked_create_temporary_file.side_effect = [
+            type('', (object,), {'name': self.tmp_path['image']['system'], 'close': mocked_tmp_file_close}),
+            type('', (object,), {'name': self.tmp_path['mask']['system'], 'close': mocked_tmp_file_close})
+        ]
+        # This next line emulates the return of ogr.GetDriverByName()
+        # TODO : manage to implent this using unittest.mock
+        mocked_get_driver.return_value = type('', (object,), {'Open': mocked_gdal_open})
+
+        with pytest.raises(RuntimeError):
+            Raster(self.path['image']['full'])
+
+        expected_copy_calls = [
+            call(self.path['image']['full'], self.tmp_path['image']['full']),
+            call(self.path['mask']['full'], self.tmp_path['mask']['full'])
+        ]
+        mocked_exists.assert_has_calls([call(self.path['image']['full']), call(self.path['mask']['full'])])
+        mocked_get_infos_from_path.assert_called_once_with(self.path['image']['full'])
+        mocked_create_temporary_file.assert_has_calls([call(mode='r', delete=False), call(mode='r', delete=False)])
+        mocked_copy.assert_has_calls(expected_copy_calls)
+        mocked_get_driver.assert_called_once_with('GTiff')
+        mocked_gdal_open.assert_has_calls([ call(self.tmp_path['image']['system']), call(self.tmp_path['mask']['system']) ])
+
+
+
+class TestComputeBbox(TestCase):
+    """Test class for the rok4.Raster._compute_bbox function."""
+
 
-def test_empty_constructor():
-    catched_error = False
-    try:
-        raster_object = Raster()
-    except TypeError as exc:
-        catched_error = True
-    finally:
-        assert catched_error
-
-def test_nominal_constructor():
-    path = "file:///tmp/image.jpg"
-    raster_object = Raster(path)
-    assert raster_object.path == path
-    assert raster_object.bbox is not None
-    assert raster_object.samples is not None
-    assert raster_object.mask is not None
 
+class TestComputeSamples(TestCase):
+    """Test class for the rok4.Raster._compute_samples function."""
 

From a4120c562432cb7c11c0b407a65c7aabfbdd7d50 Mon Sep 17 00:00:00 2001
From: Xavier Dumetz <XDmz@protonmail.com>
Date: Thu, 2 Mar 2023 14:13:31 +0100
Subject: [PATCH 04/11] =?UTF-8?q?Impl=C3=A9mentation=20dans=20la=20lib=20R?=
 =?UTF-8?q?aster=20du=20calcul=20de=20la=20boundingbox=20et=20de=20la=20d?=
 =?UTF-8?q?=C3=A9termination=20du=20nombre=20de=20canaux.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 README.md            |   2 +-
 rok4/Raster.py       |  52 ++++++++++++---
 tests/test_Raster.py | 153 ++++++++++++++++++++++++++-----------------
 3 files changed, 137 insertions(+), 70 deletions(-)

diff --git a/README.md b/README.md
index 00a002e..cf017dd 100644
--- a/README.md
+++ b/README.md
@@ -10,7 +10,7 @@ Ces librairies Python sont utilisées par les outils python du dépôt [pytools]
 
 ```sh
 apt install python3-rados python3-gdal python3-venv python3-pytest
-python -m venv --system-site-packages venv
+python3 -m venv --system-site-packages venv
 source venv/bin/activate
 python3 -m pip install dist/rok4lib-1.0.0-py3-none-any.whl
 ```
diff --git a/rok4/Raster.py b/rok4/Raster.py
index 6bd510e..1fbb56c 100644
--- a/rok4/Raster.py
+++ b/rok4/Raster.py
@@ -57,7 +57,7 @@ def __init__(self, path: str) -> None:
         image_datasource = gdal.Open(work_image_path)
         self.path = path
 
-        path_pattern = re.compile('(/[^/]+?)\.[a-zA-Z0-9_-]+$')
+        path_pattern = re.compile('(/[^/]+?)[.][a-zA-Z0-9_-]+$')
         mask_path = path_pattern.sub('\\1.msk', path)
 
         tmp_mask_file = None
@@ -69,24 +69,60 @@ def __init__(self, path: str) -> None:
                 tmp_mask_file = tempfile.NamedTemporaryFile(mode='r', delete=False)
                 tmp_mask_file.close()
                 work_mask_path = tmp_mask_file.name
+
+                tmp_mask_file = None
                 copy(mask_path, f"file://{work_mask_path}") 
             
-            ogr.GetDriverByName('GTiff').Open(work_mask_path)
+            mask_driver = gdal.IdentifyDriver(work_mask_path).ShortName
+            if 'GTiff' != mask_driver:
+                raise Exception(f"Mask file '{mask_path}' is not a TIFF image. (GDAL driver : '{mask_driver}'")
 
             self.mask = mask_path
         else:
             self.mask = None
 
-        self.bbox = _compute_bbox()
-        self.samples = _compute_samples()
+        self.bbox = _compute_bbox(image_datasource)
+        self.samples = image_datasource.RasterCount
 
         tmp_image_file = None
 
 
-def _compute_bbox() -> tuple:
-    return None
+def _compute_bbox(source_dataset: gdal.Dataset) -> tuple:
+    """Image boundingbox computing method
+
+    Args:
+        source_dataset (gdal.Dataset): Dataset object created from the raster image
+
+    Raises:
+        AttributeError: source_dataset is not a gdal.Dataset instance.
+        Exception: The dataset does not contain transform data.
+    """
+
+    transform_vector = source_dataset.GetGeoTransform()
+
+    if transform_vector is None:
+        raise Exception(f"No transform vector found in the dataset created from the following file : {source_dataset.GetFileList()[0]}")
+
+    width = source_dataset.RasterXSize
+    height = source_dataset.RasterYSize
+
+    x_range = (
+        transform_vector[0],
+        transform_vector[0] + width * transform_vector[1] + height * transform_vector[2]
+    )
+
+    y_range = (
+        transform_vector[3],
+        transform_vector[3] + width * transform_vector[4] + height * transform_vector[5]
+    )
+
+    bbox = (
+            min(x_range),
+            min(y_range),
+            max(x_range),
+            max(y_range)
+    )
 
+    return bbox
 
-def _compute_samples() -> int:
-    return None
 
diff --git a/tests/test_Raster.py b/tests/test_Raster.py
index 4cc7c55..e4e196e 100644
--- a/tests/test_Raster.py
+++ b/tests/test_Raster.py
@@ -1,8 +1,11 @@
 """Describes unit tests for the rok4.Raster module."""
 
-from rok4.Raster import *
+from rok4.Raster import Raster, _compute_bbox
 from rok4.Storage import StorageType
 
+from osgeo import gdal
+import random
+
 import pytest
 from unittest.mock import *
 from unittest import mock, TestCase, skip
@@ -48,16 +51,19 @@ def setUp(self):
         
         self.get_infos_from_path = (StorageType.FILE, self.path['image']['system'], self.path['base_location'], self.path['base_name'])
 
+        self.bbox = (-5.4, 41.3, 9.8, 51.3)
+
 
     @mock.patch('rok4.Raster.get_infos_from_path')
     @mock.patch('rok4.Raster.gdal.Open')
-    @mock.patch('rok4.Raster._compute_samples', return_value=3)
-    @mock.patch('rok4.Raster._compute_bbox', return_value=[-5.4, 41.3, 9.8, 51.3])
+    @mock.patch('rok4.Raster._compute_bbox')
     @mock.patch('rok4.Raster.exists', side_effect=[True, False])
-    def test_image(self, mocked_exists, mocked_compute_bbox, mocked_compute_samples, mocked_gdal_open, mocked_get_infos_from_path):
+    def test_image(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open, mocked_get_infos_from_path):
         """Test case : Constructor called nominally on an image without mask."""
 
         mocked_get_infos_from_path.return_value = self.get_infos_from_path
+        mocked_compute_bbox.return_value = self.bbox
+        mocked_gdal_open.return_value = type('', (object,), {'RasterCount': 3})
 
         raster_object = Raster( self.path['image']['full'] )
 
@@ -68,39 +74,35 @@ def test_image(self, mocked_exists, mocked_compute_bbox, mocked_compute_samples,
         assert raster_object.mask is None
 
         mocked_compute_bbox.assert_called_once()
-        assert raster_object.bbox == [-5.4, 41.3, 9.8, 51.3]
-
-        mocked_compute_samples.assert_called_once()
+        assert raster_object.bbox == self.bbox
         assert raster_object.samples == 3
 
 
-    @mock.patch('rok4.Raster.ogr.GetDriverByName')
+    @mock.patch('rok4.Raster.gdal.IdentifyDriver')
     @mock.patch('rok4.Raster.get_infos_from_path')
     @mock.patch('rok4.Raster.gdal.Open')
-    @mock.patch('rok4.Raster._compute_samples', return_value=3)
-    @mock.patch('rok4.Raster._compute_bbox', return_value=[-5.4, 41.3, 9.8, 51.3])
+    @mock.patch('rok4.Raster._compute_bbox')
     @mock.patch('rok4.Raster.exists', side_effect=[True, True])
-    def test_image_and_mask(self, mocked_exists, mocked_compute_bbox, mocked_compute_samples, mocked_gdal_open, mocked_get_infos_from_path, mocked_get_driver):
+    def test_image_and_mask(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open, mocked_get_infos_from_path, mocked_identifydriver):
         """Test case : Constructor called nominally on an image with mask."""
 
         mocked_get_infos_from_path.return_value = self.get_infos_from_path
-        # This next line emulates the return of ogr.GetDriverByName()
-        # TODO : manage to implent this using unittest.mock
-        mocked_get_driver.return_value = type('', (object,), {'Open': mocked_gdal_open})
+        mocked_compute_bbox.return_value = self.bbox
+        mocked_gdal_open.return_value = type('', (object,), {'RasterCount': 3})
+        # This next line emulates the return of gdal.IdentifyDriver()
+        mocked_identifydriver.return_value = type('', (object,), {'ShortName': 'GTiff'})
 
         raster_object = Raster(self.path['image']['full'])
 
         mocked_exists.assert_has_calls([ call(self.path['image']['full']), call(self.path['mask']['full']) ])
         mocked_get_infos_from_path.assert_called_once_with(self.path['image']['full'])
-        mocked_get_driver.assert_called_once_with('GTiff')
-        mocked_gdal_open.assert_has_calls([ call(self.path['image']['system']), call(self.path['mask']['system']) ])
+        mocked_identifydriver.assert_called_once_with(self.path['mask']['system'])
+        mocked_gdal_open.assert_called_once_with(self.path['image']['system'])
         assert raster_object.path == self.path['image']['full']
         assert raster_object.mask == self.path['mask']['full']
 
         mocked_compute_bbox.assert_called_once()
-        assert raster_object.bbox == [-5.4, 41.3, 9.8, 51.3]
-
-        mocked_compute_samples.assert_called_once()
+        assert raster_object.bbox == self.bbox
         assert raster_object.samples == 3
 
 
@@ -119,24 +121,23 @@ def test_unsupported_image_format(self, mocked_exists, mocked_gdal_open, mocked_
         mocked_gdal_open.assert_called_once_with(self.path['image']['system'])
 
 
-    @mock.patch('rok4.Raster.ogr.GetDriverByName')
+    @mock.patch('rok4.Raster.gdal.IdentifyDriver')
     @mock.patch('rok4.Raster.get_infos_from_path')
-    @mock.patch('rok4.Raster.gdal.Open', side_effect=[None, RuntimeError])
+    @mock.patch('rok4.Raster.gdal.Open', side_effect=None)
     @mock.patch('rok4.Raster.exists', side_effect=[True, True])
-    def test_unsupported_mask_format(self, mocked_exists, mocked_gdal_open, mocked_get_infos_from_path, mocked_get_driver):
+    def test_unsupported_mask_format(self, mocked_exists, mocked_gdal_open, mocked_get_infos_from_path, mocked_identifydriver):
         """Test case : Constructor called on an unsupported mask file or object."""
 
         mocked_get_infos_from_path.return_value = self.get_infos_from_path
-        # This next line emulates the return of ogr.GetDriverByName()
-        # TODO : manage to implent this using unittest.mock
-        mocked_get_driver.return_value = type('', (object,), {'Open': mocked_gdal_open})
+        # This next line emulates the return of gdal.IdentifyDriver()
+        mocked_identifydriver.return_value = type('', (object,), {'ShortName': 'JPG'})
 
-        with pytest.raises(RuntimeError):
+        with pytest.raises(Exception):
             Raster(self.path['image']['full'])      
 
         mocked_exists.assert_has_calls([call(self.path['image']['full']), call(self.path['mask']['full'])])
-        mocked_get_driver.assert_called_once_with('GTiff')
-        mocked_gdal_open.assert_has_calls([ call(self.path['image']['system']), call(self.path['mask']['system']) ])
+        mocked_identifydriver.assert_called_once_with(self.path['mask']['system'])
+        mocked_gdal_open.assert_called_once_with(self.path['image']['system'])
 
 
 
@@ -169,21 +170,23 @@ def setUp(self):
         self.tmp_path['image']['full'] = f"file://{self.tmp_path['image']['system']}"
         self.tmp_path['mask']['full'] = f"file://{self.tmp_path['mask']['system']}"
 
+        self.bbox = (-5.4, 41.3, 9.8, 51.3)
+
 
     @mock.patch('rok4.Raster.copy')
     @mock.patch('rok4.Raster.tempfile.NamedTemporaryFile')
     @mock.patch('rok4.Raster.get_infos_from_path')
     @mock.patch('rok4.Raster.gdal.Open')
-    @mock.patch('rok4.Raster._compute_samples', return_value=3)
-    @mock.patch('rok4.Raster._compute_bbox', return_value=[-5.4, 41.3, 9.8, 51.3])
+    @mock.patch('rok4.Raster._compute_bbox')
     @mock.patch('rok4.Raster.exists', side_effect=[True, False])
-    def test_image(self, mocked_exists, mocked_compute_bbox, mocked_compute_samples, mocked_gdal_open, mocked_get_infos_from_path, mocked_create_temporary_file, mocked_copy):
+    def test_image(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open, mocked_get_infos_from_path, mocked_create_temporary_file, mocked_copy):
         """Test case : Constructor called nominally on an image without mask."""
         
         mocked_get_infos_from_path.return_value = self.get_infos_from_path
+        mocked_compute_bbox.return_value = self.bbox
         mocked_tmp_file_close = Mock()
+        mocked_gdal_open.return_value = type('', (object,), {'RasterCount': 3})
         # This next line emulates the return of tempfile.NamedTemporaryFile()
-        # TODO : manage to implent this using unittest.mock
         mocked_create_temporary_file.return_value = type('', (object,), {'name': self.tmp_path['image']['system'], 'close': mocked_tmp_file_close})
 
         raster_object = Raster(self.path['image']['full'])
@@ -197,34 +200,31 @@ def test_image(self, mocked_exists, mocked_compute_bbox, mocked_compute_samples,
         assert raster_object.mask is None
 
         mocked_compute_bbox.assert_called_once()
-        assert raster_object.bbox == [-5.4, 41.3, 9.8, 51.3]
-
-        mocked_compute_samples.assert_called_once()
+        assert raster_object.bbox == self.bbox
         assert raster_object.samples == 3
 
 
-    @mock.patch('rok4.Raster.ogr.GetDriverByName')
+    @mock.patch('rok4.Raster.gdal.IdentifyDriver')
     @mock.patch('rok4.Raster.copy')
     @mock.patch('rok4.Raster.tempfile.NamedTemporaryFile')
     @mock.patch('rok4.Raster.get_infos_from_path')
     @mock.patch('rok4.Raster.gdal.Open')
-    @mock.patch('rok4.Raster._compute_samples', return_value=3)
-    @mock.patch('rok4.Raster._compute_bbox', return_value=[-5.4, 41.3, 9.8, 51.3])
+    @mock.patch('rok4.Raster._compute_bbox')
     @mock.patch('rok4.Raster.exists', side_effect=[True, True])
-    def test_image_and_mask(self, mocked_exists, mocked_compute_bbox, mocked_compute_samples, mocked_gdal_open, mocked_get_infos_from_path, mocked_create_temporary_file, mocked_copy, mocked_get_driver):
+    def test_image_and_mask(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open, mocked_get_infos_from_path, mocked_create_temporary_file, mocked_copy, mocked_identifydriver):
         """Test case : Constructor called nominally on an image with mask."""
         
         mocked_get_infos_from_path.return_value = self.get_infos_from_path
+        mocked_compute_bbox.return_value = self.bbox
         mocked_tmp_file_close = Mock()
+        mocked_gdal_open.return_value = type('', (object,), {'RasterCount': 3})
         # This next instruction emulates the return of tempfile.NamedTemporaryFile()
-        # TODO : manage to implent this using unittest.mock
         mocked_create_temporary_file.side_effect = [
             type('', (object,), {'name': self.tmp_path['image']['system'], 'close': mocked_tmp_file_close}),
             type('', (object,), {'name': self.tmp_path['mask']['system'], 'close': mocked_tmp_file_close})
         ]
-        # This next line emulates the return of ogr.GetDriverByName()
-        # TODO : manage to implent this using unittest.mock
-        mocked_get_driver.return_value = type('', (object,), {'Open': mocked_gdal_open})
+        # This next line emulates the return of gdal.IdentifyDriver()
+        mocked_identifydriver.return_value = type('', (object,), {'ShortName': 'GTiff'})
 
         raster_object = Raster(self.path['image']['full'])
 
@@ -236,15 +236,13 @@ def test_image_and_mask(self, mocked_exists, mocked_compute_bbox, mocked_compute
         mocked_get_infos_from_path.assert_called_once_with(self.path['image']['full'])
         mocked_create_temporary_file.assert_has_calls([call(mode='r', delete=False), call(mode='r', delete=False)])
         mocked_copy.assert_has_calls(expected_copy_calls)
-        mocked_get_driver.assert_called_once_with('GTiff')
-        mocked_gdal_open.assert_has_calls([ call(self.tmp_path['image']['system']), call(self.tmp_path['mask']['system']) ])
+        mocked_identifydriver.assert_called_once_with(self.tmp_path['mask']['system'])
+        mocked_gdal_open.assert_called_once_with(self.tmp_path['image']['system'])
         assert raster_object.path == self.path['image']['full']
         assert raster_object.mask == self.path['mask']['full']
 
         mocked_compute_bbox.assert_called_once()
-        assert raster_object.bbox == [-5.4, 41.3, 9.8, 51.3]
-
-        mocked_compute_samples.assert_called_once()
+        assert raster_object.bbox == self.bbox
         assert raster_object.samples == 3
 
     
@@ -259,7 +257,6 @@ def test_unsupported_image_format(self, mocked_exists, mocked_gdal_open, mocked_
         mocked_get_infos_from_path.return_value = self.get_infos_from_path
         mocked_tmp_file_close = Mock()
         # This next line emulates the return of tempfile.NamedTemporaryFile()
-        # TODO : manage to implent this using unittest.mock
         mocked_create_temporary_file.return_value = type('', (object,), {'name': self.tmp_path['image']['system'], 'close': mocked_tmp_file_close})
 
         with pytest.raises(RuntimeError):
@@ -272,28 +269,26 @@ def test_unsupported_image_format(self, mocked_exists, mocked_gdal_open, mocked_
         mocked_gdal_open.assert_called_once_with(self.tmp_path['image']['system'])
 
 
-    @mock.patch('rok4.Raster.ogr.GetDriverByName')
+    @mock.patch('rok4.Raster.gdal.IdentifyDriver')
     @mock.patch('rok4.Raster.copy')
     @mock.patch('rok4.Raster.tempfile.NamedTemporaryFile')
     @mock.patch('rok4.Raster.get_infos_from_path')
-    @mock.patch('rok4.Raster.gdal.Open', side_effect=[None, RuntimeError])
+    @mock.patch('rok4.Raster.gdal.Open', side_effect=None)
     @mock.patch('rok4.Raster.exists', side_effect=[True, True])
-    def test_unsupported_mask_format(self, mocked_exists, mocked_gdal_open, mocked_get_infos_from_path, mocked_create_temporary_file, mocked_copy, mocked_get_driver):
+    def test_unsupported_mask_format(self, mocked_exists, mocked_gdal_open, mocked_get_infos_from_path, mocked_create_temporary_file, mocked_copy, mocked_identifydriver):
         """Test case : Constructor called on an unsupported mask file or object."""
         
         mocked_get_infos_from_path.return_value = self.get_infos_from_path
         mocked_tmp_file_close = Mock()
         # This next instruction emulates the return of tempfile.NamedTemporaryFile()
-        # TODO : manage to implent this using unittest.mock
         mocked_create_temporary_file.side_effect = [
             type('', (object,), {'name': self.tmp_path['image']['system'], 'close': mocked_tmp_file_close}),
             type('', (object,), {'name': self.tmp_path['mask']['system'], 'close': mocked_tmp_file_close})
         ]
-        # This next line emulates the return of ogr.GetDriverByName()
-        # TODO : manage to implent this using unittest.mock
-        mocked_get_driver.return_value = type('', (object,), {'Open': mocked_gdal_open})
+        # This next line emulates the return of gdal.IdentifyDriver()
+        mocked_identifydriver.return_value = type('', (object,), {'ShortName': 'JPG'})
 
-        with pytest.raises(RuntimeError):
+        with pytest.raises(Exception):
             Raster(self.path['image']['full'])
 
         expected_copy_calls = [
@@ -304,16 +299,52 @@ def test_unsupported_mask_format(self, mocked_exists, mocked_gdal_open, mocked_g
         mocked_get_infos_from_path.assert_called_once_with(self.path['image']['full'])
         mocked_create_temporary_file.assert_has_calls([call(mode='r', delete=False), call(mode='r', delete=False)])
         mocked_copy.assert_has_calls(expected_copy_calls)
-        mocked_get_driver.assert_called_once_with('GTiff')
-        mocked_gdal_open.assert_has_calls([ call(self.tmp_path['image']['system']), call(self.tmp_path['mask']['system']) ])
+        mocked_identifydriver.assert_called_once_with(self.tmp_path['mask']['system'])
+        mocked_gdal_open.assert_called_once_with(self.tmp_path['image']['system'])
 
 
 
 class TestComputeBbox(TestCase):
     """Test class for the rok4.Raster._compute_bbox function."""
 
+    def test_nominal(self):
+        mocked_datasource = MagicMock(gdal.Dataset)
+        random.seed()
+
+        image_size = (
+            random.randint(1, 1000),
+            random.randint(1, 1000)
+        )
+        mocked_datasource.RasterXSize = image_size[0]
+        mocked_datasource.RasterYSize = image_size[1]
+
+        transform_tuple = (
+            random.uniform(-10000000.0, 10000000.0),
+            random.uniform(-10000, 10000),
+            random.uniform(-10000, 10000),
+            random.uniform(-10000000.0, 10000000.0),
+            random.uniform(-10000, 10000),
+            random.uniform(-10000, 10000)
+        )
+        mocked_datasource.GetGeoTransform = Mock(return_value = transform_tuple)
+
+        x_range = (
+            transform_tuple[0],
+            transform_tuple[0] + image_size[0] * transform_tuple[1] + image_size[1] * transform_tuple[2]
+        )
+        y_range = (
+            transform_tuple[3],
+            transform_tuple[3] + image_size[0] * transform_tuple[4] + image_size[1] * transform_tuple[5]
+        )
+
+        expected = (
+            min(x_range),
+            min(y_range),
+            max(x_range),
+            max(y_range)
+        )
+        result = _compute_bbox(mocked_datasource)
+        assert expected == result
 
 
-class TestComputeSamples(TestCase):
-    """Test class for the rok4.Raster._compute_samples function."""
 

From 5cb20f61cc878a97c74e0894e09afbd5d8d7159c Mon Sep 17 00:00:00 2001
From: Xavier Dumetz <XDmz@protonmail.com>
Date: Tue, 21 Mar 2023 17:02:45 +0100
Subject: [PATCH 05/11] =?UTF-8?q?Impl=C3=A9mentation=20dans=20la=20lib=20R?=
 =?UTF-8?q?aster=20de=20la=20d=C3=A9termination=20du=20format=20de=20codag?=
 =?UTF-8?q?e=20des=20couleurs.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 CHANGELOG.md                 |   8 +-
 README.md                    |   6 +-
 {rok4 => src/rok4}/Raster.py |  63 ++++++++++++--
 tests/test_Raster.py         | 162 ++++++++++++++++++++++++++++++++---
 4 files changed, 218 insertions(+), 21 deletions(-)
 rename {rok4 => src/rok4}/Raster.py (53%)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 604aa39..e409281 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -11,6 +11,9 @@ Librairie de lecture d'une donnée raster.
     * Décodage d'une tuile vecteur avec `get_tile_data_vector` (le pendant vecteur de `get_tile_data_raster`) : le résultat est un "dictionnaire GeoJSON", et les coordonnées sont en relatif à la tuile (souvent entre 0 et 4096)
 * Utils
     * Ajout d'un cache pour la création de spatial reference (via la fonction `srs_to_spatialreference`)
+* Raster :
+  * Chargement des informations sur un fichier raster (chemin du fichier, chemin du fichier de masque si applicable, nombre de canaux, boundingbox de l'emprise géographique)
+  * Tests unitaires
 
 ### [Changed]
 
@@ -18,9 +21,8 @@ Librairie de lecture d'une donnée raster.
     * La lecture d'un fichier ou objet qui n'existe pas émet toujours une exception `FileNotFoundError`
 * Pyramid
     * Si la tuile que l'on veut lire est dans une dalle qui n'existe pas, on retourne `None`
-* Librairie "Raster" de lecture de données raster :
-  * Chargement des informations sur un fichier raster (chemin du fichier, chemin du fichier de masque si applicable, nombre de canaux, boundingbox de l'emprise géographique)
-  * Tests unitaires
+* README.md
+    * Modification du bloc code de compilation pour utiliser explicitement python3, et installer certaines dépendances.
 
 <!--
 ### [Added]
diff --git a/README.md b/README.md
index 400645d..fca66e4 100644
--- a/README.md
+++ b/README.md
@@ -36,14 +36,14 @@ except Exception as exc:
 ## Compiler la librairie
 
 ```sh
-apt install python3-venv
+apt install python3-venv python3-rados python3-gdal # user input required for gdal dependencies, unless DEBIAN_FRONTEND=noninteractive
 python3 -m venv .venv
 source .venv/bin/activate
 python3 -m pip install --upgrade build bump2version
 bump2version --allow-dirty --current-version 0.0.0 --new-version x.y.z patch pyproject.toml src/rok4/__init__.py
 
 # Run unit tests
-pip install -e .[test]
+python3 -m pip install -e .[test]
 # To use system installed modules rados and osgeo
 echo "/usr/lib/python3/dist-packages/" >.venv/lib/python3.10/site-packages/system.pth
 python -c 'import sys; print (sys.path)'
@@ -54,7 +54,7 @@ coverage report -m
 coverage html -d dist/tests/
 
 # Build documentation
-pip install -e .[doc]
+python3 -m pip install -e .[doc]
 pdoc3 --html --output-dir dist/ rok4
 
 # Build artefacts
diff --git a/rok4/Raster.py b/src/rok4/Raster.py
similarity index 53%
rename from rok4/Raster.py
rename to src/rok4/Raster.py
index 1fbb56c..ca8e006 100644
--- a/rok4/Raster.py
+++ b/src/rok4/Raster.py
@@ -8,14 +8,20 @@
 
 import re
 import tempfile
+from enum import Enum
 
 from osgeo import ogr, gdal
 
-from rok4.Storage import get_data_str, exists, get_infos_from_path, copy, StorageType
+from rok4.Storage import exists, get_infos_from_path, copy, StorageType
 
 # Enable GDAL/OGR exceptions
 ogr.UseExceptions()
 
+class ColorFormat(Enum):
+    BIT = 1
+    UINT8 = 8
+    FLOAT32 = 32
+
 
 class Raster():
     """A structure describing raster data
@@ -23,7 +29,8 @@ class Raster():
     Attributes :
         path (str): path to the file/object (ex: file:///path/to/image.tif or s3://bucket/path/to/image.tif)
         bbox (Tuple[float, float, float, float]): bounding rectange in the data projection
-        samples (int): number of color channels
+        bands (int): number of color bands (or channels)
+        format (ColorFormat): numeric variable format for color values. Bit depth, as bits per channel, can be derived from it.
         mask (str): path to the associated mask file or object, if any, or None (same path as the image, but with a ".msk" extension and TIFF format. ex: file:///path/to/image.msk or s3://bucket/path/to/image.msk)
     """
 
@@ -51,7 +58,7 @@ def __init__(self, path: str) -> None:
         else:
             tmp_image_file = tempfile.NamedTemporaryFile(mode='r', delete=False)
             tmp_image_file.close()
-            work_image_path = tmp_image_file.name
+            work_image_path = tmp_image_file.name # utiliser Storage.get_osgeo_path(real_path) quand disponible
             copy(path, f"file://{work_image_path}")
 
         image_datasource = gdal.Open(work_image_path)
@@ -68,7 +75,7 @@ def __init__(self, path: str) -> None:
             else:
                 tmp_mask_file = tempfile.NamedTemporaryFile(mode='r', delete=False)
                 tmp_mask_file.close()
-                work_mask_path = tmp_mask_file.name
+                work_mask_path = tmp_mask_file.name # utiliser Storage.get_osgeo_path(real_path) quand disponible
 
                 tmp_mask_file = None
                 copy(mask_path, f"file://{work_mask_path}") 
@@ -82,7 +89,20 @@ def __init__(self, path: str) -> None:
             self.mask = None
 
         self.bbox = _compute_bbox(image_datasource)
-        self.samples = image_datasource.RasterCount
+        self.bands = image_datasource.RasterCount
+        self.format = _compute_format(image_datasource, path)
+
+        # Pour l'obtenir sur un canal, deux méthodes (l'index du canal est compris entre 1 et RasterCount) :
+        # - gdal.GetDataTypeName(image_datasource.GetRasterBand(index).DataType)
+        # - gdal.GetDataTypeSize(image_datasource.GetRasterBand(index).DataType)
+        # La première solution donne le nom, par exemple "Byte" pour un entier 8 bits.
+        # La deuxième donne la taille en bits, "8" pour un entier 8 bits.
+        # Se base sur l'enum GDALDataType
+        # Les noms qui nous intéressent semblent être "Byte" pour "uint8", et "Float32" pour "float32".
+        # Comment faire pour les images 1 bit ? Il me faudrait un exemple de fichier.
+        # Exemple BDParcellaire fourni par Théo. tiffinfo détecte bien 1 canal 1 bit, mais gdal voit 1 canal 8 bits "Byte" avec palette 1 bit
+        # gdal.GetColorInterpretationName(ds.GetRasterBand(1).GetRasterColorInterpretation()) = Palette
+        # utiliser GetRasterColorInterpretation() et la fonction pour obtenir la compression ? (Celle-ci est "PACKBITS")
 
         tmp_image_file = None
 
@@ -126,3 +146,36 @@ def _compute_bbox(source_dataset: gdal.Dataset) -> tuple:
     return bbox
 
 
+def _compute_format(dataset: gdal.Dataset, path=None) -> ColorFormat:
+    """Image color format computing method
+
+    Args:
+        dataset (gdal.Dataset): Dataset object created from the raster image
+
+    Raises:
+        AttributeError: source_dataset is not a gdal.Dataset instance.
+        Exception: Image has no color band or its color format is unsupported.
+    """
+
+    format = None
+
+    if path is None:
+        path = dataset.GetFileList()[0]
+
+    if dataset.RasterCount < 1:
+        raise Exception(f"Image {path} contains no color band.")
+    
+    band_1_datatype = dataset.GetRasterBand(1).DataType
+    band_1_color_interpretation = dataset.GetRasterBand(1).GetRasterColorInterpretation()
+    compression_regex_match = re.search(r'COMPRESSION\s*=\s*PACKBITS', gdal.Info(dataset))
+
+    if gdal.GetDataTypeName(band_1_datatype) == "Byte" and gdal.GetDataTypeSize(band_1_datatype) == 8 and compression_regex_match and band_1_color_interpretation is not None and gdal.GetColorInterpretationName(band_1_color_interpretation) == "Palette":
+        format = ColorFormat.BIT
+    elif gdal.GetDataTypeName(band_1_datatype) == "Byte" and gdal.GetDataTypeSize(band_1_datatype) == 8:
+        format = ColorFormat.UINT8
+    elif gdal.GetDataTypeName(band_1_datatype) == "Float32" and gdal.GetDataTypeSize(band_1_datatype) == 32:
+        format = ColorFormat.FLOAT32
+    else:
+        raise Exception(f"Unsupported color format for image {path} : '{gdal.GetDataTypeName(band_1_datatype)}' ({gdal.GetDataTypeSize(band_1_datatype)} bits)")
+
+    return format
diff --git a/tests/test_Raster.py b/tests/test_Raster.py
index e4e196e..b122625 100644
--- a/tests/test_Raster.py
+++ b/tests/test_Raster.py
@@ -1,6 +1,6 @@
 """Describes unit tests for the rok4.Raster module."""
 
-from rok4.Raster import Raster, _compute_bbox
+from rok4.Raster import ColorFormat, Raster, _compute_bbox, _compute_format
 from rok4.Storage import StorageType
 
 from osgeo import gdal
@@ -8,7 +8,7 @@
 
 import pytest
 from unittest.mock import *
-from unittest import mock, TestCase, skip
+from unittest import mock, TestCase
 
 class TestConstructorCommon(TestCase):
     """Test class for the rok4.Raster.Raster(path) class constructor, for any storage type."""
@@ -54,11 +54,12 @@ def setUp(self):
         self.bbox = (-5.4, 41.3, 9.8, 51.3)
 
 
+    @mock.patch('rok4.Raster._compute_format', return_value=ColorFormat.UINT8)
     @mock.patch('rok4.Raster.get_infos_from_path')
     @mock.patch('rok4.Raster.gdal.Open')
     @mock.patch('rok4.Raster._compute_bbox')
     @mock.patch('rok4.Raster.exists', side_effect=[True, False])
-    def test_image(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open, mocked_get_infos_from_path):
+    def test_image(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open, mocked_get_infos_from_path, mocked_compute_format):
         """Test case : Constructor called nominally on an image without mask."""
 
         mocked_get_infos_from_path.return_value = self.get_infos_from_path
@@ -75,15 +76,18 @@ def test_image(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open, mocke
 
         mocked_compute_bbox.assert_called_once()
         assert raster_object.bbox == self.bbox
-        assert raster_object.samples == 3
+        assert raster_object.bands == 3
+        mocked_compute_format.assert_called_once()
+        assert raster_object.format == ColorFormat.UINT8
 
 
+    @mock.patch('rok4.Raster._compute_format', return_value=ColorFormat.UINT8)
     @mock.patch('rok4.Raster.gdal.IdentifyDriver')
     @mock.patch('rok4.Raster.get_infos_from_path')
     @mock.patch('rok4.Raster.gdal.Open')
     @mock.patch('rok4.Raster._compute_bbox')
     @mock.patch('rok4.Raster.exists', side_effect=[True, True])
-    def test_image_and_mask(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open, mocked_get_infos_from_path, mocked_identifydriver):
+    def test_image_and_mask(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open, mocked_get_infos_from_path, mocked_identifydriver, mocked_compute_format):
         """Test case : Constructor called nominally on an image with mask."""
 
         mocked_get_infos_from_path.return_value = self.get_infos_from_path
@@ -103,7 +107,9 @@ def test_image_and_mask(self, mocked_exists, mocked_compute_bbox, mocked_gdal_op
 
         mocked_compute_bbox.assert_called_once()
         assert raster_object.bbox == self.bbox
-        assert raster_object.samples == 3
+        assert raster_object.bands == 3
+        mocked_compute_format.assert_called_once()
+        assert raster_object.format == ColorFormat.UINT8
 
 
     @mock.patch('rok4.Raster.get_infos_from_path')
@@ -173,13 +179,14 @@ def setUp(self):
         self.bbox = (-5.4, 41.3, 9.8, 51.3)
 
 
+    @mock.patch('rok4.Raster._compute_format', return_value=ColorFormat.UINT8)
     @mock.patch('rok4.Raster.copy')
     @mock.patch('rok4.Raster.tempfile.NamedTemporaryFile')
     @mock.patch('rok4.Raster.get_infos_from_path')
     @mock.patch('rok4.Raster.gdal.Open')
     @mock.patch('rok4.Raster._compute_bbox')
     @mock.patch('rok4.Raster.exists', side_effect=[True, False])
-    def test_image(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open, mocked_get_infos_from_path, mocked_create_temporary_file, mocked_copy):
+    def test_image(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open, mocked_get_infos_from_path, mocked_create_temporary_file, mocked_copy, mocked_compute_format):
         """Test case : Constructor called nominally on an image without mask."""
         
         mocked_get_infos_from_path.return_value = self.get_infos_from_path
@@ -201,9 +208,12 @@ def test_image(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open, mocke
 
         mocked_compute_bbox.assert_called_once()
         assert raster_object.bbox == self.bbox
-        assert raster_object.samples == 3
+        assert raster_object.bands == 3
+        mocked_compute_format.assert_called_once()
+        assert raster_object.format == ColorFormat.UINT8
 
 
+    @mock.patch('rok4.Raster._compute_format', return_value=ColorFormat.UINT8)
     @mock.patch('rok4.Raster.gdal.IdentifyDriver')
     @mock.patch('rok4.Raster.copy')
     @mock.patch('rok4.Raster.tempfile.NamedTemporaryFile')
@@ -211,7 +221,7 @@ def test_image(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open, mocke
     @mock.patch('rok4.Raster.gdal.Open')
     @mock.patch('rok4.Raster._compute_bbox')
     @mock.patch('rok4.Raster.exists', side_effect=[True, True])
-    def test_image_and_mask(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open, mocked_get_infos_from_path, mocked_create_temporary_file, mocked_copy, mocked_identifydriver):
+    def test_image_and_mask(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open, mocked_get_infos_from_path, mocked_create_temporary_file, mocked_copy, mocked_identifydriver, mocked_compute_format):
         """Test case : Constructor called nominally on an image with mask."""
         
         mocked_get_infos_from_path.return_value = self.get_infos_from_path
@@ -243,7 +253,9 @@ def test_image_and_mask(self, mocked_exists, mocked_compute_bbox, mocked_gdal_op
 
         mocked_compute_bbox.assert_called_once()
         assert raster_object.bbox == self.bbox
-        assert raster_object.samples == 3
+        assert raster_object.bands == 3
+        mocked_compute_format.assert_called_once()
+        assert raster_object.format == ColorFormat.UINT8
 
     
     @mock.patch('rok4.Raster.copy')
@@ -347,4 +359,134 @@ def test_nominal(self):
         assert expected == result
 
 
+class TestComputeFormat(TestCase):
+    """Test class for the rok4.Raster._compute_format function."""
+
+    def setUp(self) -> None:
+        self.bit_gdalinfo = """Driver: GTiff/GeoTIFF
+Size is 10000, 10000
+Image Structure Metadata:
+  COMPRESSION=PACKBITS
+  INTERLEAVE=BAND
+  MINISWHITE=YES
+"""
+        self.common_gdalinfo = """Driver: GTiff/GeoTIFF
+Size is 10000, 10000
+Metadata:
+  AREA_OR_POINT=Area
+Image Structure Metadata:
+  INTERLEAVE=BAND
+"""
+        return super().setUp()
+
+    @mock.patch('rok4.Raster.gdal.Info')
+    @mock.patch('rok4.Raster.gdal.GetColorInterpretationName', return_value="Palette")
+    @mock.patch('rok4.Raster.gdal.GetDataTypeSize', return_value=8)
+    @mock.patch('rok4.Raster.gdal.GetDataTypeName', return_value="Byte")
+    def test_bit(self, mocked_GetDataTypeName, mocked_GetDataTypeSize, mocked_GetColorInterpretationName, mocked_Info):
+        mocked_datasource = MagicMock(gdal.Dataset)
+
+        mocked_datasource.RasterCount = 1
+        mocked_Info.return_value = self.bit_gdalinfo
+
+        result = _compute_format(mocked_datasource)
+        assert result == ColorFormat.BIT
+        mocked_GetDataTypeName.assert_called()
+        mocked_GetDataTypeSize.assert_called()
+        mocked_GetColorInterpretationName.assert_called()
+        mocked_Info.assert_called()
+
+    @mock.patch('rok4.Raster.gdal.Info')
+    @mock.patch('rok4.Raster.gdal.GetColorInterpretationName')
+    @mock.patch('rok4.Raster.gdal.GetDataTypeSize', return_value=8)
+    @mock.patch('rok4.Raster.gdal.GetDataTypeName', return_value="Byte")
+    def test_uint8(self, mocked_GetDataTypeName, mocked_GetDataTypeSize, mocked_GetColorInterpretationName, mocked_Info):
+        mocked_datasource = MagicMock(gdal.Dataset)
+        
+        band_number = random.randint(1, 4)
+        mocked_datasource.RasterCount = band_number
+        band_name = None
+        if band_number == 1 or band_number == 2:
+            band_name = "Gray"
+        elif band_number == 3 or band_number == 4:
+            band_name = "Red"
+        mocked_GetColorInterpretationName.return_value = band_name
+        mocked_Info.return_value = self.common_gdalinfo
+
+        result = _compute_format(mocked_datasource)
+
+        assert result == ColorFormat.UINT8
+        mocked_GetDataTypeName.assert_called()
+        mocked_GetDataTypeSize.assert_called()
+        mocked_GetColorInterpretationName.assert_not_called()
+        mocked_Info.assert_called()
+
+    @mock.patch('rok4.Raster.gdal.Info')
+    @mock.patch('rok4.Raster.gdal.GetColorInterpretationName')
+    @mock.patch('rok4.Raster.gdal.GetDataTypeSize', return_value=32)
+    @mock.patch('rok4.Raster.gdal.GetDataTypeName', return_value="Float32")
+    def test_float32(self, mocked_GetDataTypeName, mocked_GetDataTypeSize, mocked_GetColorInterpretationName, mocked_Info):
+        mocked_datasource = MagicMock(gdal.Dataset)
+        
+        band_number = random.randint(1, 4)
+        mocked_datasource.RasterCount = band_number
+        band_name = None
+        if band_number == 1 or band_number == 2:
+            band_name = "Gray"
+        elif band_number == 3 or band_number == 4:
+            band_name = "Red"
+        mocked_GetColorInterpretationName.return_value = band_name
+        mocked_Info.return_value = self.common_gdalinfo
+
+        result = _compute_format(mocked_datasource)
+
+        assert result == ColorFormat.FLOAT32
+        mocked_GetDataTypeName.assert_called()
+        mocked_GetDataTypeSize.assert_called()
+        mocked_GetColorInterpretationName.assert_not_called()
+        mocked_Info.assert_called()
+
+    @mock.patch('rok4.Raster.gdal.Info')
+    @mock.patch('rok4.Raster.gdal.GetColorInterpretationName')
+    @mock.patch('rok4.Raster.gdal.GetDataTypeSize', return_value=16)
+    @mock.patch('rok4.Raster.gdal.GetDataTypeName', return_value="UInt16")
+    def test_unsupported(self, mocked_GetDataTypeName, mocked_GetDataTypeSize, mocked_GetColorInterpretationName, mocked_Info):
+        mocked_datasource = MagicMock(gdal.Dataset)
+
+        band_number = random.randint(1, 4)
+        mocked_datasource.RasterCount = band_number
+        band_name = None
+        if band_number == 1 or band_number == 2:
+            band_name = "Gray"
+        elif band_number == 3 or band_number == 4:
+            band_name = "Red"
+        mocked_GetColorInterpretationName.return_value = band_name
+        mocked_Info.return_value = self.common_gdalinfo
+
+        with pytest.raises(Exception):
+            _compute_format(mocked_datasource)
+        
+        mocked_GetDataTypeName.assert_called()
+        mocked_GetDataTypeSize.assert_called()
+        mocked_GetColorInterpretationName.assert_not_called()
+        mocked_Info.assert_called()
+
+    @mock.patch('rok4.Raster.gdal.Info')
+    @mock.patch('rok4.Raster.gdal.GetColorInterpretationName')
+    @mock.patch('rok4.Raster.gdal.GetDataTypeSize', return_value=16)
+    @mock.patch('rok4.Raster.gdal.GetDataTypeName', return_value="UInt16")
+    def test_no_band(self, mocked_GetDataTypeName, mocked_GetDataTypeSize, mocked_GetColorInterpretationName, mocked_Info):
+        mocked_datasource = MagicMock(gdal.Dataset)
 
+        mocked_datasource.RasterCount = 0
+
+        with pytest.raises(Exception):
+            _compute_format(mocked_datasource)
+
+        mocked_GetDataTypeName.assert_not_called()
+        mocked_GetDataTypeSize.assert_not_called()
+        mocked_GetColorInterpretationName.assert_not_called()
+        mocked_Info.assert_not_called()
+
+
+    

From 55d88666a3e7f7711d9d0771ff666d410e4ca667 Mon Sep 17 00:00:00 2001
From: Xavier Dumetz <XDmz@protonmail.com>
Date: Wed, 22 Mar 2023 09:52:01 +0100
Subject: [PATCH 06/11] =?UTF-8?q?Remplacement=20du=20constructeur=20par=20?=
 =?UTF-8?q?d=C3=A9faut=20de=20la=20classe=20Raster=20par=20deux=20m=C3=A9t?=
 =?UTF-8?q?hodes=20'from=5Ffile'=20et=20'from=5Fparameters'.=20Ajout=20d'u?=
 =?UTF-8?q?ne=20propri=C3=A9t=C3=A9=20'dimensions'=20(largeur=20et=20haute?=
 =?UTF-8?q?ur=20en=20pixel=20de=20l'image)=20=C3=A0=20la=20classe=20Raster?=
 =?UTF-8?q?.=20Ajout=20d'un=20prototype=20vide=20de=20fonction=20'get=5Fos?=
 =?UTF-8?q?geo=5Fpath'=20au=20module=20Storage,=20et=20utilisation=20de=20?=
 =?UTF-8?q?cette=20fonction=20par=20la=20classe=20raster=20pour=20d=C3=A9t?=
 =?UTF-8?q?erminer=20le=20chemin=20des=20fichiers=20locaux=20de=20travail.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 CHANGELOG.md         |   1 +
 src/rok4/Raster.py   |  84 ++++----
 src/rok4/Storage.py  |   5 +
 tests/test_Raster.py | 463 +++++++++++++++----------------------------
 4 files changed, 207 insertions(+), 346 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index e409281..bc13745 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -19,6 +19,7 @@ Librairie de lecture d'une donnée raster.
 
 * Storage
     * La lecture d'un fichier ou objet qui n'existe pas émet toujours une exception `FileNotFoundError`
+    * Ajout d'un prototype vide de fonction 'get_osgeo_path', qui a terme, à partir d'un chemin complet vers une image, retournera le chemin système d'un fichier local de travail, créé si besoin.
 * Pyramid
     * Si la tuile que l'on veut lire est dans une dalle qui n'existe pas, on retourne `None`
 * README.md
diff --git a/src/rok4/Raster.py b/src/rok4/Raster.py
index ca8e006..449db2c 100644
--- a/src/rok4/Raster.py
+++ b/src/rok4/Raster.py
@@ -12,7 +12,7 @@
 
 from osgeo import ogr, gdal
 
-from rok4.Storage import exists, get_infos_from_path, copy, StorageType
+from rok4.Storage import exists, get_infos_from_path, copy, StorageType, get_osgeo_path
 
 # Enable GDAL/OGR exceptions
 ogr.UseExceptions()
@@ -32,34 +32,31 @@ class Raster():
         bands (int): number of color bands (or channels)
         format (ColorFormat): numeric variable format for color values. Bit depth, as bits per channel, can be derived from it.
         mask (str): path to the associated mask file or object, if any, or None (same path as the image, but with a ".msk" extension and TIFF format. ex: file:///path/to/image.msk or s3://bucket/path/to/image.msk)
+        dimensions (Tuple[int, int]): image width and height expressed in pixels
     """
 
-    def __init__(self, path: str) -> None:
-        """Basic constructor method
+    @classmethod
+    def from_file(cls, path: str) -> 'Raster':
+        """Creates a Raster object from an image
 
         Args:
-            path (str): path to the file/object
+            path (str): path to the image file/object
 
         Raises:
             RuntimeError: raised by OGR/GDAL if anything goes wrong
             MissingEnvironmentError: Missing object storage informations
             StorageError: Storage read issue
+
+        Returns:
+            Raster: a Raster instance
         """
 
         if not exists(path):
             raise Exception(f"No file or object found at path '{path}'.")
 
-        image_info = get_infos_from_path(path)
+        self = cls()
 
-        tmp_image_file = None
-        work_image_path = None
-        if image_info[0] == StorageType.FILE:
-            work_image_path = image_info[1]
-        else:
-            tmp_image_file = tempfile.NamedTemporaryFile(mode='r', delete=False)
-            tmp_image_file.close()
-            work_image_path = tmp_image_file.name # utiliser Storage.get_osgeo_path(real_path) quand disponible
-            copy(path, f"file://{work_image_path}")
+        work_image_path = get_osgeo_path(path)
 
         image_datasource = gdal.Open(work_image_path)
         self.path = path
@@ -67,19 +64,8 @@ def __init__(self, path: str) -> None:
         path_pattern = re.compile('(/[^/]+?)[.][a-zA-Z0-9_-]+$')
         mask_path = path_pattern.sub('\\1.msk', path)
 
-        tmp_mask_file = None
-        work_mask_path = None
-        if exists(mask_path):
-            if image_info[0] == StorageType.FILE:
-                work_mask_path = path_pattern.sub('\\1.msk', image_info[1])
-            else:
-                tmp_mask_file = tempfile.NamedTemporaryFile(mode='r', delete=False)
-                tmp_mask_file.close()
-                work_mask_path = tmp_mask_file.name # utiliser Storage.get_osgeo_path(real_path) quand disponible
-
-                tmp_mask_file = None
-                copy(mask_path, f"file://{work_mask_path}") 
-            
+        if exists(mask_path):            
+            work_mask_path = get_osgeo_path(mask_path)
             mask_driver = gdal.IdentifyDriver(work_mask_path).ShortName
             if 'GTiff' != mask_driver:
                 raise Exception(f"Mask file '{mask_path}' is not a TIFF image. (GDAL driver : '{mask_driver}'")
@@ -91,20 +77,39 @@ def __init__(self, path: str) -> None:
         self.bbox = _compute_bbox(image_datasource)
         self.bands = image_datasource.RasterCount
         self.format = _compute_format(image_datasource, path)
+        self.dimensions = (image_datasource.RasterXSize, image_datasource.RasterYSize)
+
+        return self
+
+    @classmethod
+    def from_parameters(cls, mask=None, **kwargs):
+        """Creates a Raster object from key/value parameters
+
+        Args:
+            **path (str): path to the file/object (ex: file:///path/to/image.tif or s3://bucket/path/to/image.tif)
+            **bbox (Tuple[float, float, float, float]): bounding rectange in the data projection
+            **bands (int): number of color bands (or channels)
+            **format (ColorFormat): numeric variable format for color values. Bit depth, as bits per channel, can be derived from it.
+            **mask (str, optionnal): path to the associated mask file or object, if any, or None (same path as the image, but with a ".msk" extension and TIFF format. ex: file:///path/to/image.msk or s3://bucket/path/to/image.msk)
+            **dimensions (Tuple[int, int]): image width and height expressed in pixels
+
+        Raises:
+            KeyError: a mandatory argument is missing
 
-        # Pour l'obtenir sur un canal, deux méthodes (l'index du canal est compris entre 1 et RasterCount) :
-        # - gdal.GetDataTypeName(image_datasource.GetRasterBand(index).DataType)
-        # - gdal.GetDataTypeSize(image_datasource.GetRasterBand(index).DataType)
-        # La première solution donne le nom, par exemple "Byte" pour un entier 8 bits.
-        # La deuxième donne la taille en bits, "8" pour un entier 8 bits.
-        # Se base sur l'enum GDALDataType
-        # Les noms qui nous intéressent semblent être "Byte" pour "uint8", et "Float32" pour "float32".
-        # Comment faire pour les images 1 bit ? Il me faudrait un exemple de fichier.
-        # Exemple BDParcellaire fourni par Théo. tiffinfo détecte bien 1 canal 1 bit, mais gdal voit 1 canal 8 bits "Byte" avec palette 1 bit
-        # gdal.GetColorInterpretationName(ds.GetRasterBand(1).GetRasterColorInterpretation()) = Palette
-        # utiliser GetRasterColorInterpretation() et la fonction pour obtenir la compression ? (Celle-ci est "PACKBITS")
+        Returns:
+            Raster: a Raster instance
+        """
+
+        self = cls()
+            
+        self.path = kwargs["path"]
+        self.mask = mask
+        self.bbox = kwargs["bbox"]
+        self.bands = kwargs["bands"]
+        self.format = kwargs["format"]
+        self.dimensions = kwargs["dimensions"]
 
-        tmp_image_file = None
+        return self
 
 
 def _compute_bbox(source_dataset: gdal.Dataset) -> tuple:
@@ -151,6 +156,7 @@ def _compute_format(dataset: gdal.Dataset, path=None) -> ColorFormat:
 
     Args:
         dataset (gdal.Dataset): Dataset object created from the raster image
+        path (str): path to the original file/object (optionnal)
 
     Raises:
         AttributeError: source_dataset is not a gdal.Dataset instance.
diff --git a/src/rok4/Storage.py b/src/rok4/Storage.py
index a10d1f8..9c2b2ac 100644
--- a/src/rok4/Storage.py
+++ b/src/rok4/Storage.py
@@ -830,3 +830,8 @@ def link(target_path: str, link_path: str, hard: bool = False) -> None:
 
     else:
         raise StorageError("UNKNOWN", "Unhandled storage type to make link")
+
+def get_osgeo_path(path: str) -> str:
+    """Stud for a future function    
+    """
+    return None
\ No newline at end of file
diff --git a/tests/test_Raster.py b/tests/test_Raster.py
index b122625..70afbc1 100644
--- a/tests/test_Raster.py
+++ b/tests/test_Raster.py
@@ -8,313 +8,7 @@
 
 import pytest
 from unittest.mock import *
-from unittest import mock, TestCase
-
-class TestConstructorCommon(TestCase):
-    """Test class for the rok4.Raster.Raster(path) class constructor, for any storage type."""
-
-    def test_empty(self):
-        """Test case : Constructor called without the expected path argument."""
-
-        with pytest.raises(TypeError):
-            Raster()
-
-
-    @mock.patch('rok4.Raster.exists', return_value=False)
-    def test_image_not_found(self, mocked_exists):
-        """Test case : Constructor called on a path matching no file or object."""
-
-        path = "file:///home/user/image.tif"
-
-        with pytest.raises(Exception):
-            Raster(path)
-
-        mocked_exists.assert_called_once_with(path)
-
-
-
-class TestConstructorFile(TestCase):
-    """Test class for the rok4.Raster.Raster(path) class constructor, used with file storage."""
-
-    def setUp(self):
-        self.path = {
-            'protocol': 'file://',
-            'base_location': '/home/user',
-            'base_name': 'image',
-            'image': {},
-            'mask': {}
-        }
-        self.path['image']['system'] = f"{self.path['base_location']}/{self.path['base_name']}.tif"
-        self.path['mask']['system'] = f"{self.path['base_location']}/{self.path['base_name']}.msk"
-        self.path['image']['full'] = f"{self.path['protocol']}{self.path['image']['system']}"
-        self.path['mask']['full'] = f"{self.path['protocol']}{self.path['mask']['system']}"
-        
-        self.get_infos_from_path = (StorageType.FILE, self.path['image']['system'], self.path['base_location'], self.path['base_name'])
-
-        self.bbox = (-5.4, 41.3, 9.8, 51.3)
-
-
-    @mock.patch('rok4.Raster._compute_format', return_value=ColorFormat.UINT8)
-    @mock.patch('rok4.Raster.get_infos_from_path')
-    @mock.patch('rok4.Raster.gdal.Open')
-    @mock.patch('rok4.Raster._compute_bbox')
-    @mock.patch('rok4.Raster.exists', side_effect=[True, False])
-    def test_image(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open, mocked_get_infos_from_path, mocked_compute_format):
-        """Test case : Constructor called nominally on an image without mask."""
-
-        mocked_get_infos_from_path.return_value = self.get_infos_from_path
-        mocked_compute_bbox.return_value = self.bbox
-        mocked_gdal_open.return_value = type('', (object,), {'RasterCount': 3})
-
-        raster_object = Raster( self.path['image']['full'] )
-
-        mocked_exists.assert_has_calls([ call(self.path['image']['full']), call(self.path['mask']['full']) ])
-        mocked_get_infos_from_path.assert_called_once_with( self.path['image']['full'] )
-        mocked_gdal_open.assert_called_once_with( self.path['image']['system'] )
-        assert raster_object.path == self.path['image']['full']
-        assert raster_object.mask is None
-
-        mocked_compute_bbox.assert_called_once()
-        assert raster_object.bbox == self.bbox
-        assert raster_object.bands == 3
-        mocked_compute_format.assert_called_once()
-        assert raster_object.format == ColorFormat.UINT8
-
-
-    @mock.patch('rok4.Raster._compute_format', return_value=ColorFormat.UINT8)
-    @mock.patch('rok4.Raster.gdal.IdentifyDriver')
-    @mock.patch('rok4.Raster.get_infos_from_path')
-    @mock.patch('rok4.Raster.gdal.Open')
-    @mock.patch('rok4.Raster._compute_bbox')
-    @mock.patch('rok4.Raster.exists', side_effect=[True, True])
-    def test_image_and_mask(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open, mocked_get_infos_from_path, mocked_identifydriver, mocked_compute_format):
-        """Test case : Constructor called nominally on an image with mask."""
-
-        mocked_get_infos_from_path.return_value = self.get_infos_from_path
-        mocked_compute_bbox.return_value = self.bbox
-        mocked_gdal_open.return_value = type('', (object,), {'RasterCount': 3})
-        # This next line emulates the return of gdal.IdentifyDriver()
-        mocked_identifydriver.return_value = type('', (object,), {'ShortName': 'GTiff'})
-
-        raster_object = Raster(self.path['image']['full'])
-
-        mocked_exists.assert_has_calls([ call(self.path['image']['full']), call(self.path['mask']['full']) ])
-        mocked_get_infos_from_path.assert_called_once_with(self.path['image']['full'])
-        mocked_identifydriver.assert_called_once_with(self.path['mask']['system'])
-        mocked_gdal_open.assert_called_once_with(self.path['image']['system'])
-        assert raster_object.path == self.path['image']['full']
-        assert raster_object.mask == self.path['mask']['full']
-
-        mocked_compute_bbox.assert_called_once()
-        assert raster_object.bbox == self.bbox
-        assert raster_object.bands == 3
-        mocked_compute_format.assert_called_once()
-        assert raster_object.format == ColorFormat.UINT8
-
-
-    @mock.patch('rok4.Raster.get_infos_from_path')
-    @mock.patch('rok4.Raster.gdal.Open', side_effect=RuntimeError)
-    @mock.patch('rok4.Raster.exists', side_effect=[True, False])
-    def test_unsupported_image_format(self, mocked_exists, mocked_gdal_open, mocked_get_infos_from_path):
-        """Test case : Constructor called on an unsupported 'image' file or object."""
-
-        mocked_get_infos_from_path.return_value = self.get_infos_from_path
-
-        with pytest.raises(RuntimeError):
-            Raster(self.path['image']['full'])
-
-        mocked_exists.assert_called_once_with(self.path['image']['full'])
-        mocked_gdal_open.assert_called_once_with(self.path['image']['system'])
-
-
-    @mock.patch('rok4.Raster.gdal.IdentifyDriver')
-    @mock.patch('rok4.Raster.get_infos_from_path')
-    @mock.patch('rok4.Raster.gdal.Open', side_effect=None)
-    @mock.patch('rok4.Raster.exists', side_effect=[True, True])
-    def test_unsupported_mask_format(self, mocked_exists, mocked_gdal_open, mocked_get_infos_from_path, mocked_identifydriver):
-        """Test case : Constructor called on an unsupported mask file or object."""
-
-        mocked_get_infos_from_path.return_value = self.get_infos_from_path
-        # This next line emulates the return of gdal.IdentifyDriver()
-        mocked_identifydriver.return_value = type('', (object,), {'ShortName': 'JPG'})
-
-        with pytest.raises(Exception):
-            Raster(self.path['image']['full'])      
-
-        mocked_exists.assert_has_calls([call(self.path['image']['full']), call(self.path['mask']['full'])])
-        mocked_identifydriver.assert_called_once_with(self.path['mask']['system'])
-        mocked_gdal_open.assert_called_once_with(self.path['image']['system'])
-
-
-
-class TestConstructorObject(TestCase):
-    """Test class for the rok4.Raster.Raster(path) class constructor, used with object storage."""
-
-    def setUp(self):
-        self.path = {
-            'protocol': 's3://',
-            'base_location': 'bucket',
-            'base_name': 'basename',
-            'image': {},
-            'mask': {}
-        }
-        self.path['image']['system'] = f"{self.path['base_location']}/{self.path['base_name']}.tif"
-        self.path['mask']['system'] = f"{self.path['base_location']}/{self.path['base_name']}.msk"
-        self.path['image']['full'] = f"{self.path['protocol']}{self.path['image']['system']}"
-        self.path['mask']['full'] = f"{self.path['protocol']}{self.path['mask']['system']}"
-
-        self.get_infos_from_path = (StorageType.S3, self.path['image']['system'], self.path['base_location'], self.path['base_name'])
-
-        self.tmp_path = {
-            'image': {
-                'system': '/tmp/tempimage'
-            },
-            'mask': {
-                'system': '/tmp/tempmask'
-            },
-        }
-        self.tmp_path['image']['full'] = f"file://{self.tmp_path['image']['system']}"
-        self.tmp_path['mask']['full'] = f"file://{self.tmp_path['mask']['system']}"
-
-        self.bbox = (-5.4, 41.3, 9.8, 51.3)
-
-
-    @mock.patch('rok4.Raster._compute_format', return_value=ColorFormat.UINT8)
-    @mock.patch('rok4.Raster.copy')
-    @mock.patch('rok4.Raster.tempfile.NamedTemporaryFile')
-    @mock.patch('rok4.Raster.get_infos_from_path')
-    @mock.patch('rok4.Raster.gdal.Open')
-    @mock.patch('rok4.Raster._compute_bbox')
-    @mock.patch('rok4.Raster.exists', side_effect=[True, False])
-    def test_image(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open, mocked_get_infos_from_path, mocked_create_temporary_file, mocked_copy, mocked_compute_format):
-        """Test case : Constructor called nominally on an image without mask."""
-        
-        mocked_get_infos_from_path.return_value = self.get_infos_from_path
-        mocked_compute_bbox.return_value = self.bbox
-        mocked_tmp_file_close = Mock()
-        mocked_gdal_open.return_value = type('', (object,), {'RasterCount': 3})
-        # This next line emulates the return of tempfile.NamedTemporaryFile()
-        mocked_create_temporary_file.return_value = type('', (object,), {'name': self.tmp_path['image']['system'], 'close': mocked_tmp_file_close})
-
-        raster_object = Raster(self.path['image']['full'])
-
-        mocked_exists.assert_has_calls([call(self.path['image']['full']), call(self.path['mask']['full'])])
-        mocked_get_infos_from_path.assert_called_once_with(self.path['image']['full'])
-        mocked_create_temporary_file.assert_called_once_with(mode='r', delete=False)
-        mocked_copy.assert_called_once_with(self.path['image']['full'], self.tmp_path['image']['full'])
-        mocked_gdal_open.assert_called_once_with(self.tmp_path['image']['system'])
-        assert raster_object.path == self.path['image']['full']
-        assert raster_object.mask is None
-
-        mocked_compute_bbox.assert_called_once()
-        assert raster_object.bbox == self.bbox
-        assert raster_object.bands == 3
-        mocked_compute_format.assert_called_once()
-        assert raster_object.format == ColorFormat.UINT8
-
-
-    @mock.patch('rok4.Raster._compute_format', return_value=ColorFormat.UINT8)
-    @mock.patch('rok4.Raster.gdal.IdentifyDriver')
-    @mock.patch('rok4.Raster.copy')
-    @mock.patch('rok4.Raster.tempfile.NamedTemporaryFile')
-    @mock.patch('rok4.Raster.get_infos_from_path')
-    @mock.patch('rok4.Raster.gdal.Open')
-    @mock.patch('rok4.Raster._compute_bbox')
-    @mock.patch('rok4.Raster.exists', side_effect=[True, True])
-    def test_image_and_mask(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open, mocked_get_infos_from_path, mocked_create_temporary_file, mocked_copy, mocked_identifydriver, mocked_compute_format):
-        """Test case : Constructor called nominally on an image with mask."""
-        
-        mocked_get_infos_from_path.return_value = self.get_infos_from_path
-        mocked_compute_bbox.return_value = self.bbox
-        mocked_tmp_file_close = Mock()
-        mocked_gdal_open.return_value = type('', (object,), {'RasterCount': 3})
-        # This next instruction emulates the return of tempfile.NamedTemporaryFile()
-        mocked_create_temporary_file.side_effect = [
-            type('', (object,), {'name': self.tmp_path['image']['system'], 'close': mocked_tmp_file_close}),
-            type('', (object,), {'name': self.tmp_path['mask']['system'], 'close': mocked_tmp_file_close})
-        ]
-        # This next line emulates the return of gdal.IdentifyDriver()
-        mocked_identifydriver.return_value = type('', (object,), {'ShortName': 'GTiff'})
-
-        raster_object = Raster(self.path['image']['full'])
-
-        expected_copy_calls = [
-            call(self.path['image']['full'], self.tmp_path['image']['full']),
-            call(self.path['mask']['full'], self.tmp_path['mask']['full'])
-        ]
-        mocked_exists.assert_has_calls([call(self.path['image']['full']), call(self.path['mask']['full'])])
-        mocked_get_infos_from_path.assert_called_once_with(self.path['image']['full'])
-        mocked_create_temporary_file.assert_has_calls([call(mode='r', delete=False), call(mode='r', delete=False)])
-        mocked_copy.assert_has_calls(expected_copy_calls)
-        mocked_identifydriver.assert_called_once_with(self.tmp_path['mask']['system'])
-        mocked_gdal_open.assert_called_once_with(self.tmp_path['image']['system'])
-        assert raster_object.path == self.path['image']['full']
-        assert raster_object.mask == self.path['mask']['full']
-
-        mocked_compute_bbox.assert_called_once()
-        assert raster_object.bbox == self.bbox
-        assert raster_object.bands == 3
-        mocked_compute_format.assert_called_once()
-        assert raster_object.format == ColorFormat.UINT8
-
-    
-    @mock.patch('rok4.Raster.copy')
-    @mock.patch('rok4.Raster.tempfile.NamedTemporaryFile')
-    @mock.patch('rok4.Raster.get_infos_from_path')
-    @mock.patch('rok4.Raster.gdal.Open', side_effect=RuntimeError)
-    @mock.patch('rok4.Raster.exists', side_effect=[True, False])
-    def test_unsupported_image_format(self, mocked_exists, mocked_gdal_open, mocked_get_infos_from_path, mocked_create_temporary_file, mocked_copy):
-        """Test case : Constructor called on an unsupported 'image' file or object."""
-        
-        mocked_get_infos_from_path.return_value = self.get_infos_from_path
-        mocked_tmp_file_close = Mock()
-        # This next line emulates the return of tempfile.NamedTemporaryFile()
-        mocked_create_temporary_file.return_value = type('', (object,), {'name': self.tmp_path['image']['system'], 'close': mocked_tmp_file_close})
-
-        with pytest.raises(RuntimeError):
-            Raster(self.path['image']['full'])
-
-        mocked_exists.assert_called_once_with(self.path['image']['full'])
-        mocked_get_infos_from_path.assert_called_once_with(self.path['image']['full'])
-        mocked_create_temporary_file.assert_called_once_with(mode='r', delete=False)
-        mocked_copy.assert_called_once_with(self.path['image']['full'], self.tmp_path['image']['full'])
-        mocked_gdal_open.assert_called_once_with(self.tmp_path['image']['system'])
-
-
-    @mock.patch('rok4.Raster.gdal.IdentifyDriver')
-    @mock.patch('rok4.Raster.copy')
-    @mock.patch('rok4.Raster.tempfile.NamedTemporaryFile')
-    @mock.patch('rok4.Raster.get_infos_from_path')
-    @mock.patch('rok4.Raster.gdal.Open', side_effect=None)
-    @mock.patch('rok4.Raster.exists', side_effect=[True, True])
-    def test_unsupported_mask_format(self, mocked_exists, mocked_gdal_open, mocked_get_infos_from_path, mocked_create_temporary_file, mocked_copy, mocked_identifydriver):
-        """Test case : Constructor called on an unsupported mask file or object."""
-        
-        mocked_get_infos_from_path.return_value = self.get_infos_from_path
-        mocked_tmp_file_close = Mock()
-        # This next instruction emulates the return of tempfile.NamedTemporaryFile()
-        mocked_create_temporary_file.side_effect = [
-            type('', (object,), {'name': self.tmp_path['image']['system'], 'close': mocked_tmp_file_close}),
-            type('', (object,), {'name': self.tmp_path['mask']['system'], 'close': mocked_tmp_file_close})
-        ]
-        # This next line emulates the return of gdal.IdentifyDriver()
-        mocked_identifydriver.return_value = type('', (object,), {'ShortName': 'JPG'})
-
-        with pytest.raises(Exception):
-            Raster(self.path['image']['full'])
-
-        expected_copy_calls = [
-            call(self.path['image']['full'], self.tmp_path['image']['full']),
-            call(self.path['mask']['full'], self.tmp_path['mask']['full'])
-        ]
-        mocked_exists.assert_has_calls([call(self.path['image']['full']), call(self.path['mask']['full'])])
-        mocked_get_infos_from_path.assert_called_once_with(self.path['image']['full'])
-        mocked_create_temporary_file.assert_has_calls([call(mode='r', delete=False), call(mode='r', delete=False)])
-        mocked_copy.assert_has_calls(expected_copy_calls)
-        mocked_identifydriver.assert_called_once_with(self.tmp_path['mask']['system'])
-        mocked_gdal_open.assert_called_once_with(self.tmp_path['image']['system'])
-
-
+from unittest import mock, TestCase, skip
 
 class TestComputeBbox(TestCase):
     """Test class for the rok4.Raster._compute_bbox function."""
@@ -489,4 +183,159 @@ def test_no_band(self, mocked_GetDataTypeName, mocked_GetDataTypeSize, mocked_Ge
         mocked_Info.assert_not_called()
 
 
+class TestFromFile(TestCase):
+    """Test class for the rok4.Raster.Raster.from_file(path) class constructor."""
+
+    def setUp(self):
+        self.source_image_path = "file:///home/user/image.tif"
+        self.source_mask_path = "file:///home/user/image.msk"
+        self.osgeo_image_path = "file:///home/user/image.tif"
+        self.osgeo_mask_path = "file:///home/user/image.msk"
+        self.bbox = (-5.4, 41.3, 9.8, 51.3)
+        self.image_size = (1920, 1080)
+        return super().setUp()
+
+    def test_empty(self):
+        """Test case : Constructor called without the expected path argument."""
+
+        with pytest.raises(TypeError):
+            Raster.from_file()
+
+    @mock.patch('rok4.Raster.exists', return_value=False)
+    def test_image_not_found(self, mocked_exists):
+        """Test case : Constructor called on a path matching no file or object."""
+
+        with pytest.raises(Exception):
+            Raster.from_file(self.source_image_path)
+
+        mocked_exists.assert_called_once_with(self.source_image_path)
+
+    @mock.patch('rok4.Raster.get_osgeo_path')
+    @mock.patch('rok4.Raster._compute_format', return_value=ColorFormat.UINT8)
+    @mock.patch('rok4.Raster.gdal.Open')
+    @mock.patch('rok4.Raster._compute_bbox')
+    @mock.patch('rok4.Raster.exists', side_effect=[True, False])
+    def test_image(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open, mocked_compute_format, mocked_get_osgeo_path):
+        """Test case : Constructor called nominally on an image without mask."""
+
+        mocked_compute_bbox.return_value = self.bbox
+        mocked_gdal_open.return_value = type('', (object,), {'RasterCount': 3, 'RasterXSize': self.image_size[0], 'RasterYSize': self.image_size[1]})
+        mocked_get_osgeo_path.return_value = self.osgeo_image_path
+
+        raster_object = Raster.from_file( self.source_image_path )
+
+        mocked_exists.assert_has_calls([ call(self.source_image_path), call(self.source_mask_path) ])
+        mocked_get_osgeo_path.assert_called_once_with(self.source_image_path)
+        mocked_gdal_open.assert_called_once_with( self.osgeo_image_path )
+        assert raster_object.path == self.source_image_path
+        assert raster_object.mask is None
+
+        mocked_compute_bbox.assert_called_once()
+        assert raster_object.bbox == self.bbox
+        assert raster_object.bands == 3
+        mocked_compute_format.assert_called_once()
+        assert raster_object.format == ColorFormat.UINT8
+        assert raster_object.dimensions == self.image_size
+
+    @mock.patch('rok4.Raster.get_osgeo_path')
+    @mock.patch('rok4.Raster._compute_format', return_value=ColorFormat.UINT8)
+    @mock.patch('rok4.Raster.gdal.IdentifyDriver')
+    @mock.patch('rok4.Raster.gdal.Open')
+    @mock.patch('rok4.Raster._compute_bbox')
+    @mock.patch('rok4.Raster.exists', side_effect=[True, True])
+    def test_image_and_mask(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open, mocked_identifydriver, mocked_compute_format, mocked_get_osgeo_path):
+        """Test case : Constructor called nominally on an image with mask."""
+
+        mocked_compute_bbox.return_value = self.bbox
+        mocked_gdal_open.return_value = type('', (object,), {'RasterCount': 3, 'RasterXSize': self.image_size[0], 'RasterYSize': self.image_size[1]})
+        mocked_get_osgeo_path.side_effect=[self.osgeo_image_path, self.osgeo_mask_path]
+        # This next line emulates the return of gdal.IdentifyDriver()
+        mocked_identifydriver.return_value = type('', (object,), {'ShortName': 'GTiff'})
+
+        raster_object = Raster.from_file(self.source_image_path)
+
+        mocked_exists.assert_has_calls([ call(self.source_image_path), call(self.source_mask_path) ])
+        mocked_get_osgeo_path.assert_has_calls([ call(self.source_image_path), call(self.source_mask_path) ])
+        mocked_identifydriver.assert_called_once_with(self.osgeo_mask_path)
+        mocked_gdal_open.assert_called_once_with(self.osgeo_image_path)
+        assert raster_object.path == self.source_image_path
+        assert raster_object.mask == self.source_mask_path
+
+        mocked_compute_bbox.assert_called_once()
+        assert raster_object.bbox == self.bbox
+        assert raster_object.bands == 3
+        mocked_compute_format.assert_called_once()
+        assert raster_object.format == ColorFormat.UINT8
+        assert raster_object.dimensions == self.image_size
+
+    @mock.patch('rok4.Raster.get_osgeo_path')
+    @mock.patch('rok4.Raster.gdal.Open', side_effect=RuntimeError)
+    @mock.patch('rok4.Raster.exists', side_effect=[True, False])
+    def test_unsupported_image_format(self, mocked_exists, mocked_gdal_open, mocked_get_osgeo_path):
+        """Test case : Constructor called on an unsupported 'image' file or object."""
+
+        mocked_get_osgeo_path.return_value = self.osgeo_image_path
+
+        with pytest.raises(RuntimeError):
+            Raster.from_file(self.source_image_path)
+
+        mocked_exists.assert_called_once_with(self.source_image_path)
+        mocked_get_osgeo_path.assert_called_once_with(self.source_image_path)
+        mocked_gdal_open.assert_called_once_with(self.osgeo_image_path)
+
+    @mock.patch('rok4.Raster.get_osgeo_path')
+    @mock.patch('rok4.Raster.gdal.IdentifyDriver')
+    @mock.patch('rok4.Raster.gdal.Open', side_effect=None)
+    @mock.patch('rok4.Raster.exists', side_effect=[True, True])
+    def test_unsupported_mask_format(self, mocked_exists, mocked_gdal_open, mocked_identifydriver, mocked_get_osgeo_path):
+        """Test case : Constructor called on an unsupported mask file or object."""
+
+        mocked_get_osgeo_path.side_effect=[self.osgeo_image_path, self.osgeo_mask_path]
+        # This next line emulates the return of gdal.IdentifyDriver()
+        mocked_identifydriver.return_value = type('', (object,), {'ShortName': 'JPG'})
+
+        with pytest.raises(Exception):
+            Raster.from_file(self.source_image_path)      
+
+        mocked_exists.assert_has_calls([ call(self.source_image_path), call(self.source_mask_path) ])
+        mocked_get_osgeo_path.assert_has_calls([ call(self.source_image_path), call(self.source_mask_path) ])
+        mocked_identifydriver.assert_called_once_with(self.osgeo_mask_path)
+        mocked_gdal_open.assert_called_once_with(self.osgeo_image_path)
+
+
+class TestFromParameters(TestCase):
+    """Test class for the rok4.Raster.Raster.from_parameters(**kwargs) class constructor."""
+
+    def test_image(self):
+        i_path = "file:///path/to/image.tif"
+        i_bbox = (-5.4, 41.3, 9.8, 51.3)
+        i_bands = 4
+        i_format = ColorFormat.UINT8
+        i_dimensions = (1920, 1080)
+
+        result = Raster.from_parameters(path=i_path, bbox=i_bbox, bands=i_bands, format=i_format, dimensions=i_dimensions)
+
+        assert result.path == i_path
+        assert result.bbox == i_bbox
+        assert result.bands == i_bands
+        assert result.format == i_format
+        assert result.dimensions == i_dimensions
+        assert result.mask is None
+
+    def test_image_and_mask(self):
+        i_path = "file:///path/to/image.tif"
+        i_mask = "file:///path/to/image.msk"
+        i_bbox = (-5.4, 41.3, 9.8, 51.3)
+        i_bands = 4
+        i_format = ColorFormat.UINT8
+        i_dimensions = (1920, 1080)
+
+        result = Raster.from_parameters(path=i_path, bbox=i_bbox, bands=i_bands, format=i_format, dimensions=i_dimensions, mask=i_mask)
+
+        assert result.path == i_path
+        assert result.bbox == i_bbox
+        assert result.bands == i_bands
+        assert result.format == i_format
+        assert result.dimensions == i_dimensions
+        assert result.mask == i_mask
     

From e8adcfda816f0d353723369f898d6c8acfa6daca Mon Sep 17 00:00:00 2001
From: Xavier Dumetz <XDmz@protonmail.com>
Date: Mon, 3 Apr 2023 14:48:33 +0200
Subject: [PATCH 07/11] =?UTF-8?q?Lecture=20d'informations=20sur=20une=20do?=
 =?UTF-8?q?nn=C3=A9e=20raster=20unique=20depuis=20un=20fichier=20ou=20une?=
 =?UTF-8?q?=20liste=20de=20param=C3=A8tres.=20Les=20informations=20lues=20?=
 =?UTF-8?q?incluents=20:=20le=20chemin=20vers=20la=20donn=C3=A9e=20raster,?=
 =?UTF-8?q?=20le=20chemin=20=C3=A9ventuel=20vers=20sont=20masque=20associ?=
 =?UTF-8?q?=C3=A9,=20le=20nombre=20de=20de=20canaux=20de=20couleur,=20leur?=
 =?UTF-8?q?=20format=20de=20variable,=20les=20dimensions=20de=20l'image,?=
 =?UTF-8?q?=20et=20la=20boudingbox=20correspondante=20dans=20la=20projecti?=
 =?UTF-8?q?on=20de=20l'image.=20Les=20m=C3=A9thodes=20de=20lecture=20inclu?=
 =?UTF-8?q?ent=20:=20directement=20depuis=20le=20donn=C3=A9e=20raster,=20o?=
 =?UTF-8?q?u=20depuis=20une=20liste=20de=20param=C3=A8tres=20issus=20par?=
 =?UTF-8?q?=20exemple=20d'une=20ex=C3=A9cution=20pr=C3=A9c=C3=A9dente.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Réserve : la gestion des boundingbox ne tient actuellement par compte de l'ordre des coordonnées dans le système de référence de la donnée raster.
---
 CHANGELOG.md         | 21 +++++++++-------
 README.md            |  7 ++++--
 src/rok4/Raster.py   | 57 +++++++++++++++++++++++++++++++++++++-------
 tests/test_Raster.py | 36 +++++++++++++++++++---------
 4 files changed, 90 insertions(+), 31 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0a24c5b..a9d52f5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,20 +1,23 @@
 ## Summary
 
-Lecture facilitée de la liste d'une pyramide.
+Lecture d'informations sur une donnée raster unique depuis un fichier ou une liste de paramètres.
 
 ## Changelog
 
 ### [Added]
 
-* Pyramid
-    * Fonctions de gestion de la liste : chargement et lecture (via un generator)
-    * Taille du header d'une dalle stockée dans la variable `ROK4_IMAGE_HEADER_SIZE`
-    * La proriété `tile_extension` : retourne l'extension d'une tuile de la pyramide en fonction du format
-    * Des exemples d'utilisation des fonctions principales
-### [Fixed]
+* Raster
+    * Chargement des informations sur un fichier raster (chemin du fichier, chemin du fichier de masque si applicable, nombre de canaux, boundingbox de l'emprise géographique)
+        * depuis le fichier raster
+        * depuis une liste de paramètres provenant d'une utilisation précédente
+    * Tests unitaires
+    * Documentation interne des fonctions et classes
+
+### [Changed]
+
+* README.md
+    * Modification du bloc code de compilation pour utiliser explicitement python3, et installer certaines dépendances.
 
-* Storage
-    * Lecture de la taille d'un objet S3 : pas besoin d'enlever des quotes dans le header `Content-Length`
 <!--
 ### [Added]
 
diff --git a/README.md b/README.md
index 9cf6497..159c85e 100644
--- a/README.md
+++ b/README.md
@@ -37,7 +37,7 @@ Plus d'exemple dans la documentation développeur.
 ## Compiler la librairie
 
 ```sh
-apt install python3-venv python3-rados python3-gdal # user input required for gdal dependencies, unless DEBIAN_FRONTEND=noninteractive
+apt install python3-venv python3-rados python3-gdal
 python3 -m venv .venv
 source .venv/bin/activate
 python3 -m pip install --upgrade build bump2version
@@ -47,7 +47,7 @@ bump2version --allow-dirty --current-version 0.0.0 --new-version x.y.z patch pyp
 python3 -m pip install -e .[test]
 # To use system installed modules rados and osgeo
 echo "/usr/lib/python3/dist-packages/" >.venv/lib/python3.10/site-packages/system.pth
-python -c 'import sys; print (sys.path)'
+python3 -c 'import sys; print (sys.path)'
 # Run tests
 coverage run -m pytest
 # Get tests report and generate site
@@ -62,6 +62,9 @@ pdoc3 --html --output-dir dist/ rok4
 python3 -m build
 ```
 
+Remarque :
+Lors de l'installation du paquet apt `python3-gdal`, une dépendance, peut demander des interactions de configuration. Pour installer dans un environnement non-interactif, définir la variable shell `DEBIAN_FRONTEND=noninteractive` permet d'adopter une configuration par défaut.
+
 ## Publier la librairie sur Pypi
 
 Configurer le fichier `$HOME/.pypirc` avec les accès à votre compte PyPI.
diff --git a/src/rok4/Raster.py b/src/rok4/Raster.py
index 449db2c..3583b7d 100644
--- a/src/rok4/Raster.py
+++ b/src/rok4/Raster.py
@@ -7,17 +7,19 @@
 """
 
 import re
-import tempfile
 from enum import Enum
 
 from osgeo import ogr, gdal
 
-from rok4.Storage import exists, get_infos_from_path, copy, StorageType, get_osgeo_path
+from rok4.Storage import exists, get_osgeo_path
 
 # Enable GDAL/OGR exceptions
 ogr.UseExceptions()
 
 class ColorFormat(Enum):
+    """A color format enumeration.
+    Except from "BIT", the member's name matches a common variable format name. The member's value is the allocated bit size associated to this format.
+    """
     BIT = 1
     UINT8 = 8
     FLOAT32 = 32
@@ -35,6 +37,14 @@ class Raster():
         dimensions (Tuple[int, int]): image width and height expressed in pixels
     """
 
+    def __init__(self) -> None:
+        self.bands = None
+        self.bbox = (None, None, None, None)
+        self.dimensions = (None, None)
+        self.format = None
+        self.mask = None
+        self.path = None
+
     @classmethod
     def from_file(cls, path: str) -> 'Raster':
         """Creates a Raster object from an image
@@ -42,10 +52,21 @@ def from_file(cls, path: str) -> 'Raster':
         Args:
             path (str): path to the image file/object
 
+        Examples:
+
+            Loading informations from a file stored raster TIFF image
+
+                from rok4.Raster import Raster
+
+                try:
+                    raster = Raster.from_file("file:///data/images/SC1000_TIFF_LAMB93_FXX/SC1000_0040_6150_L93.tif")
+
+                except Exception as e:
+                    print(f"Cannot load information from image : {e}")
+
         Raises:
             RuntimeError: raised by OGR/GDAL if anything goes wrong
-            MissingEnvironmentError: Missing object storage informations
-            StorageError: Storage read issue
+            NotImplementedError: Storage type not handled
 
         Returns:
             Raster: a Raster instance
@@ -93,6 +114,18 @@ def from_parameters(cls, mask=None, **kwargs):
             **mask (str, optionnal): path to the associated mask file or object, if any, or None (same path as the image, but with a ".msk" extension and TIFF format. ex: file:///path/to/image.msk or s3://bucket/path/to/image.msk)
             **dimensions (Tuple[int, int]): image width and height expressed in pixels
 
+        Examples:
+
+            Loading informations from parameters, related to a TIFF main image coupled to a TIFF mask image
+
+                from rok4.Raster import Raster
+
+                try:
+                    raster = Raster.from_parameters(path="file:///data/images/SC1000_TIFF_LAMB93_FXX/SC1000_0040_6150_L93.tif", mask="file:///data/images/SC1000_TIFF_LAMB93_FXX/SC1000_0040_6150_L93.msk", bands=3, format=ColorFormat.UINT8, dimensions=(2000, 2000), bbox=(40000.000, 5950000.000, 240000.000, 6150000.000))
+
+                except Exception as e:
+                    print(f"Cannot load information from parameters : {e}")
+
         Raises:
             KeyError: a mandatory argument is missing
 
@@ -172,16 +205,22 @@ def _compute_format(dataset: gdal.Dataset, path=None) -> ColorFormat:
         raise Exception(f"Image {path} contains no color band.")
     
     band_1_datatype = dataset.GetRasterBand(1).DataType
-    band_1_color_interpretation = dataset.GetRasterBand(1).GetRasterColorInterpretation()
+    data_type_name = gdal.GetDataTypeName(band_1_datatype)
+    data_type_size = gdal.GetDataTypeSize(band_1_datatype)
+    color_interpretation = dataset.GetRasterBand(1).GetRasterColorInterpretation()
+    color_name = None
+    if color_interpretation is not None:
+        color_name = gdal.GetColorInterpretationName(color_interpretation)
     compression_regex_match = re.search(r'COMPRESSION\s*=\s*PACKBITS', gdal.Info(dataset))
 
-    if gdal.GetDataTypeName(band_1_datatype) == "Byte" and gdal.GetDataTypeSize(band_1_datatype) == 8 and compression_regex_match and band_1_color_interpretation is not None and gdal.GetColorInterpretationName(band_1_color_interpretation) == "Palette":
+
+    if data_type_name == "Byte" and data_type_size == 8 and color_name == "Palette" and compression_regex_match:
         format = ColorFormat.BIT
-    elif gdal.GetDataTypeName(band_1_datatype) == "Byte" and gdal.GetDataTypeSize(band_1_datatype) == 8:
+    elif data_type_name == "Byte" and data_type_size == 8:
         format = ColorFormat.UINT8
-    elif gdal.GetDataTypeName(band_1_datatype) == "Float32" and gdal.GetDataTypeSize(band_1_datatype) == 32:
+    elif data_type_name == "Float32" and data_type_size == 32:
         format = ColorFormat.FLOAT32
     else:
-        raise Exception(f"Unsupported color format for image {path} : '{gdal.GetDataTypeName(band_1_datatype)}' ({gdal.GetDataTypeSize(band_1_datatype)} bits)")
+        raise Exception(f"Unsupported color format for image {path} : '{data_type_name}' ({data_type_size} bits)")
 
     return format
diff --git a/tests/test_Raster.py b/tests/test_Raster.py
index 70afbc1..4c75833 100644
--- a/tests/test_Raster.py
+++ b/tests/test_Raster.py
@@ -1,14 +1,13 @@
 """Describes unit tests for the rok4.Raster module."""
 
 from rok4.Raster import ColorFormat, Raster, _compute_bbox, _compute_format
-from rok4.Storage import StorageType
 
 from osgeo import gdal
-import random
+import random, math
 
 import pytest
+from unittest import mock, TestCase
 from unittest.mock import *
-from unittest import mock, TestCase, skip
 
 class TestComputeBbox(TestCase):
     """Test class for the rok4.Raster._compute_bbox function."""
@@ -50,7 +49,10 @@ def test_nominal(self):
             max(y_range)
         )
         result = _compute_bbox(mocked_datasource)
-        assert expected == result
+        assert math.isclose(result[0], expected[0], rel_tol=1e-5)
+        assert math.isclose(result[1], expected[1], rel_tol=1e-5)
+        assert math.isclose(result[2], expected[2], rel_tol=1e-5)
+        assert math.isclose(result[3], expected[3], rel_tol=1e-5)
 
 
 class TestComputeFormat(TestCase):
@@ -112,7 +114,7 @@ def test_uint8(self, mocked_GetDataTypeName, mocked_GetDataTypeSize, mocked_GetC
         assert result == ColorFormat.UINT8
         mocked_GetDataTypeName.assert_called()
         mocked_GetDataTypeSize.assert_called()
-        mocked_GetColorInterpretationName.assert_not_called()
+        mocked_GetColorInterpretationName.assert_called()
         mocked_Info.assert_called()
 
     @mock.patch('rok4.Raster.gdal.Info')
@@ -137,7 +139,7 @@ def test_float32(self, mocked_GetDataTypeName, mocked_GetDataTypeSize, mocked_Ge
         assert result == ColorFormat.FLOAT32
         mocked_GetDataTypeName.assert_called()
         mocked_GetDataTypeSize.assert_called()
-        mocked_GetColorInterpretationName.assert_not_called()
+        mocked_GetColorInterpretationName.assert_called()
         mocked_Info.assert_called()
 
     @mock.patch('rok4.Raster.gdal.Info')
@@ -162,7 +164,7 @@ def test_unsupported(self, mocked_GetDataTypeName, mocked_GetDataTypeSize, mocke
         
         mocked_GetDataTypeName.assert_called()
         mocked_GetDataTypeSize.assert_called()
-        mocked_GetColorInterpretationName.assert_not_called()
+        mocked_GetColorInterpretationName.assert_called()
         mocked_Info.assert_called()
 
     @mock.patch('rok4.Raster.gdal.Info')
@@ -231,7 +233,10 @@ def test_image(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open, mocke
         assert raster_object.mask is None
 
         mocked_compute_bbox.assert_called_once()
-        assert raster_object.bbox == self.bbox
+        assert math.isclose(raster_object.bbox[0], self.bbox[0], rel_tol=1e-5)
+        assert math.isclose(raster_object.bbox[1], self.bbox[1], rel_tol=1e-5)
+        assert math.isclose(raster_object.bbox[2], self.bbox[2], rel_tol=1e-5)
+        assert math.isclose(raster_object.bbox[3], self.bbox[3], rel_tol=1e-5)
         assert raster_object.bands == 3
         mocked_compute_format.assert_called_once()
         assert raster_object.format == ColorFormat.UINT8
@@ -262,7 +267,10 @@ def test_image_and_mask(self, mocked_exists, mocked_compute_bbox, mocked_gdal_op
         assert raster_object.mask == self.source_mask_path
 
         mocked_compute_bbox.assert_called_once()
-        assert raster_object.bbox == self.bbox
+        assert math.isclose(raster_object.bbox[0], self.bbox[0], rel_tol=1e-5)
+        assert math.isclose(raster_object.bbox[1], self.bbox[1], rel_tol=1e-5)
+        assert math.isclose(raster_object.bbox[2], self.bbox[2], rel_tol=1e-5)
+        assert math.isclose(raster_object.bbox[3], self.bbox[3], rel_tol=1e-5)
         assert raster_object.bands == 3
         mocked_compute_format.assert_called_once()
         assert raster_object.format == ColorFormat.UINT8
@@ -316,7 +324,10 @@ def test_image(self):
         result = Raster.from_parameters(path=i_path, bbox=i_bbox, bands=i_bands, format=i_format, dimensions=i_dimensions)
 
         assert result.path == i_path
-        assert result.bbox == i_bbox
+        assert math.isclose(result.bbox[0], i_bbox[0], rel_tol=1e-5)
+        assert math.isclose(result.bbox[1], i_bbox[1], rel_tol=1e-5)
+        assert math.isclose(result.bbox[2], i_bbox[2], rel_tol=1e-5)
+        assert math.isclose(result.bbox[3], i_bbox[3], rel_tol=1e-5)
         assert result.bands == i_bands
         assert result.format == i_format
         assert result.dimensions == i_dimensions
@@ -333,7 +344,10 @@ def test_image_and_mask(self):
         result = Raster.from_parameters(path=i_path, bbox=i_bbox, bands=i_bands, format=i_format, dimensions=i_dimensions, mask=i_mask)
 
         assert result.path == i_path
-        assert result.bbox == i_bbox
+        assert math.isclose(result.bbox[0], i_bbox[0], rel_tol=1e-5)
+        assert math.isclose(result.bbox[1], i_bbox[1], rel_tol=1e-5)
+        assert math.isclose(result.bbox[2], i_bbox[2], rel_tol=1e-5)
+        assert math.isclose(result.bbox[3], i_bbox[3], rel_tol=1e-5)
         assert result.bands == i_bands
         assert result.format == i_format
         assert result.dimensions == i_dimensions

From a5ad9718bf3629d4d13ff8e69cef920135b46fbf Mon Sep 17 00:00:00 2001
From: Xavier Dumetz <XDmz@protonmail.com>
Date: Wed, 5 Apr 2023 18:40:56 +0200
Subject: [PATCH 08/11] =?UTF-8?q?Prise=20en=20compte=20de=20l'ordre=20des?=
 =?UTF-8?q?=20axes=20selon=20le=20CRS=20pour=20les=20BBOX=20raster.=20D?=
 =?UTF-8?q?=C3=A9placement=20des=20fonctions=20publiques=20statiques=20de?=
 =?UTF-8?q?=20Raster=20vers=20Utils.=20Diverses=20corrections=20de=20style?=
 =?UTF-8?q?.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 CHANGELOG.md         |   3 +
 src/rok4/Pyramid.py  |  12 +-
 src/rok4/Raster.py   | 100 +-------------
 src/rok4/Utils.py    | 113 +++++++++++++++-
 tests/test_Raster.py | 189 +-------------------------
 tests/test_Utils.py  | 310 +++++++++++++++++++++++++++++++++++++++++++
 6 files changed, 443 insertions(+), 284 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index a9d52f5..e93aeb8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -17,6 +17,9 @@ Lecture d'informations sur une donnée raster unique depuis un fichier ou une li
 
 * README.md
     * Modification du bloc code de compilation pour utiliser explicitement python3, et installer certaines dépendances.
+* Utils
+    * Fonction de calcul de la boundix box d'une donnée
+    * Fonction de détermination du format de variable des couleurs dans une donéne raster
 
 <!--
 ### [Added]
diff --git a/src/rok4/Pyramid.py b/src/rok4/Pyramid.py
index bc9e669..6263aaf 100644
--- a/src/rok4/Pyramid.py
+++ b/src/rok4/Pyramid.py
@@ -31,7 +31,7 @@ class PyramidType(Enum):
 class SlabType(Enum):
     """ Slab's type """
     DATA = "DATA" # Slab of data, raster or vector
-    MASK = "MASK" # Slab of mask, only for raster pyramide, image with one band : 0 is nodata, other values are data
+    MASK = "MASK" # Slab of mask, only for raster pyramid, image with one band : 0 is nodata, other values are data
 
 
 ROK4_IMAGE_HEADER_SIZE = 2048
@@ -794,11 +794,11 @@ def get_level(self, level_id: str) -> 'Level':
 
 
     def get_levels(self, bottom_id: str = None, top_id: str = None) -> List[Level]:
-        """Get sorted levels from bottom to top provided
+        """Get sorted levels in the provided range from bottom to top
 
         Args:
-            bottom_id (str): optionnal specific bottom level id. Defaults to None.
-            top_id (str): optionnal specific top level id. Defaults to None.
+            bottom_id (str, optionnal): specific bottom level id. Defaults to None.
+            top_id (str, optionnal): specific top level id. Defaults to None.
 
         Raises:
             Exception: Provided levels are not consistent (bottom > top or not in the pyramid)
@@ -969,7 +969,7 @@ def get_tile_data_binary(self, level: str, column: int, row: int) -> str:
         """Get a pyramid's tile as binary string
 
         To get a tile, 3 steps :
-            * calculate slab path from tile indice
+            * calculate slab path from tile index
             * read slab index to get offsets and sizes of slab's tiles
             * read the tile into the slab
 
@@ -1243,7 +1243,7 @@ def get_tile_data_vector(self, level: str, column: int, row: int) -> Dict:
     def get_tile_indices(self, x: float, y: float, level: str = None, **kwargs) -> Tuple[str, int, int, int, int]:
         """Get pyramid's tile and pixel indices from point's coordinates
 
-        Used coordinates system have to be the pyramide one. If EPSG:4326, x is latitude and y longitude.
+        Used coordinates system have to be the pyramid one. If EPSG:4326, x is latitude and y longitude.
 
         Args:
             x (float): point's x
diff --git a/src/rok4/Raster.py b/src/rok4/Raster.py
index 3583b7d..1d20fd6 100644
--- a/src/rok4/Raster.py
+++ b/src/rok4/Raster.py
@@ -12,20 +12,13 @@
 from osgeo import ogr, gdal
 
 from rok4.Storage import exists, get_osgeo_path
+from rok4.Utils import ColorFormat, compute_bbox,compute_format
 
 # Enable GDAL/OGR exceptions
 ogr.UseExceptions()
 
-class ColorFormat(Enum):
-    """A color format enumeration.
-    Except from "BIT", the member's name matches a common variable format name. The member's value is the allocated bit size associated to this format.
-    """
-    BIT = 1
-    UINT8 = 8
-    FLOAT32 = 32
-
 
-class Raster():
+class Raster:
     """A structure describing raster data
 
     Attributes :
@@ -95,23 +88,23 @@ def from_file(cls, path: str) -> 'Raster':
         else:
             self.mask = None
 
-        self.bbox = _compute_bbox(image_datasource)
+        self.bbox = compute_bbox(image_datasource)
         self.bands = image_datasource.RasterCount
-        self.format = _compute_format(image_datasource, path)
+        self.format = compute_format(image_datasource, path)
         self.dimensions = (image_datasource.RasterXSize, image_datasource.RasterYSize)
 
         return self
 
     @classmethod
-    def from_parameters(cls, mask=None, **kwargs):
+    def from_parameters(cls, mask: str = None, **kwargs) -> 'Raster':
         """Creates a Raster object from key/value parameters
 
         Args:
+            **mask (str, optionnal): path to the associated mask file or object, if any, or None (same path as the image, but with a ".msk" extension and TIFF format. ex: file:///path/to/image.msk or s3://bucket/path/to/image.msk)
             **path (str): path to the file/object (ex: file:///path/to/image.tif or s3://bucket/path/to/image.tif)
             **bbox (Tuple[float, float, float, float]): bounding rectange in the data projection
             **bands (int): number of color bands (or channels)
             **format (ColorFormat): numeric variable format for color values. Bit depth, as bits per channel, can be derived from it.
-            **mask (str, optionnal): path to the associated mask file or object, if any, or None (same path as the image, but with a ".msk" extension and TIFF format. ex: file:///path/to/image.msk or s3://bucket/path/to/image.msk)
             **dimensions (Tuple[int, int]): image width and height expressed in pixels
 
         Examples:
@@ -143,84 +136,3 @@ def from_parameters(cls, mask=None, **kwargs):
         self.dimensions = kwargs["dimensions"]
 
         return self
-
-
-def _compute_bbox(source_dataset: gdal.Dataset) -> tuple:
-    """Image boundingbox computing method
-
-    Args:
-        source_dataset (gdal.Dataset): Dataset object created from the raster image
-
-    Raises:
-        AttributeError: source_dataset is not a gdal.Dataset instance.
-        Exception: The dataset does not contain transform data.
-    """
-
-    transform_vector = source_dataset.GetGeoTransform()
-
-    if transform_vector is None:
-        raise Exception(f"No transform vector found in the dataset created from the following file : {source_dataset.GetFileList()[0]}")
-
-    width = source_dataset.RasterXSize
-    height = source_dataset.RasterYSize
-
-    x_range = (
-        transform_vector[0],
-        transform_vector[0] + width * transform_vector[1] + height * transform_vector[2]
-    )
-
-    y_range = (
-        transform_vector[3],
-        transform_vector[3] + width * transform_vector[4] + height * transform_vector[5]
-    )
-
-    bbox = (
-            min(x_range),
-            min(y_range),
-            max(x_range),
-            max(y_range)
-    )
-
-    return bbox
-
-
-def _compute_format(dataset: gdal.Dataset, path=None) -> ColorFormat:
-    """Image color format computing method
-
-    Args:
-        dataset (gdal.Dataset): Dataset object created from the raster image
-        path (str): path to the original file/object (optionnal)
-
-    Raises:
-        AttributeError: source_dataset is not a gdal.Dataset instance.
-        Exception: Image has no color band or its color format is unsupported.
-    """
-
-    format = None
-
-    if path is None:
-        path = dataset.GetFileList()[0]
-
-    if dataset.RasterCount < 1:
-        raise Exception(f"Image {path} contains no color band.")
-    
-    band_1_datatype = dataset.GetRasterBand(1).DataType
-    data_type_name = gdal.GetDataTypeName(band_1_datatype)
-    data_type_size = gdal.GetDataTypeSize(band_1_datatype)
-    color_interpretation = dataset.GetRasterBand(1).GetRasterColorInterpretation()
-    color_name = None
-    if color_interpretation is not None:
-        color_name = gdal.GetColorInterpretationName(color_interpretation)
-    compression_regex_match = re.search(r'COMPRESSION\s*=\s*PACKBITS', gdal.Info(dataset))
-
-
-    if data_type_name == "Byte" and data_type_size == 8 and color_name == "Palette" and compression_regex_match:
-        format = ColorFormat.BIT
-    elif data_type_name == "Byte" and data_type_size == 8:
-        format = ColorFormat.UINT8
-    elif data_type_name == "Float32" and data_type_size == 32:
-        format = ColorFormat.FLOAT32
-    else:
-        raise Exception(f"Unsupported color format for image {path} : '{data_type_name}' ({data_type_size} bits)")
-
-    return format
diff --git a/src/rok4/Utils.py b/src/rok4/Utils.py
index 7f8260b..548f5f7 100644
--- a/src/rok4/Utils.py
+++ b/src/rok4/Utils.py
@@ -2,12 +2,25 @@
 """
 
 import os
+import re
 
 from typing import Dict, List, Tuple, Union
-from osgeo import ogr, osr
+from osgeo import ogr, osr, gdal
+from enum import Enum
+
 ogr.UseExceptions()
 osr.UseExceptions()
 
+
+class ColorFormat(Enum):
+    """A color format enumeration.
+    Except from "BIT", the member's name matches a common variable format name. The member's value is the allocated bit size associated to this format.
+    """
+    BIT = 1
+    UINT8 = 8
+    FLOAT32 = 32
+
+
 __SR_BOOK = dict()
 def srs_to_spatialreference(srs: str) -> 'osgeo.osr.SpatialReference':
     """Convert coordinates system as string to OSR spatial reference
@@ -154,4 +167,100 @@ def reproject_point(point: Tuple[float, float], sr_src: 'osgeo.osr.SpatialRefere
     ct = osr.CreateCoordinateTransformation(sr_src, sr_dst)
     x_dst, y_dst, z_dst = ct.TransformPoint(point[0], point[1])
 
-    return (x_dst, y_dst)
\ No newline at end of file
+    return (x_dst, y_dst)
+
+
+def compute_bbox(source_dataset: gdal.Dataset) -> tuple:
+    """Image boundingbox computing method
+
+    Args:
+        source_dataset (gdal.Dataset): Dataset object created from the raster image
+    
+    Limitations:
+        Image's axis must be parallel to SRS' axis
+
+    Raises:
+        AttributeError: source_dataset is not a gdal.Dataset instance.
+        Exception: The dataset does not contain transform data.
+    """
+
+    bbox = None
+    transform_vector = source_dataset.GetGeoTransform()
+
+    if transform_vector is None:
+        raise Exception(f"No transform vector found in the dataset created from the following file : {source_dataset.GetFileList()[0]}")
+
+    width = source_dataset.RasterXSize
+    height = source_dataset.RasterYSize
+
+    x_range = (
+        transform_vector[0],
+        transform_vector[0] + width * transform_vector[1] + height * transform_vector[2]
+    )
+
+    y_range = (
+        transform_vector[3],
+        transform_vector[3] + width * transform_vector[4] + height * transform_vector[5]
+    )
+
+    spatial_ref = source_dataset.GetSpatialRef()
+    if spatial_ref is not None and spatial_ref.GetDataAxisToSRSAxisMapping() == [2, 1]:
+        # Coordonnées terrain de type (latitude, longitude) => on permute les coordonnées terrain par rapport à l'image
+        bbox = (
+            min(y_range),
+            min(x_range),
+            max(y_range),
+            max(x_range)
+        )
+    elif spatial_ref is None or spatial_ref.GetDataAxisToSRSAxisMapping() == [1, 2]:
+        # Coordonnées terrain de type (longitude, latitude) ou pas de SRS => les coordonnées terrain sont dans le même ordre que celle de l'image
+        bbox = (
+            min(x_range),
+            min(y_range),
+            max(x_range),
+            max(y_range)
+        )
+
+    return bbox
+
+
+def compute_format(dataset: gdal.Dataset, path: str = None) -> 'ColorFormat':
+    """Image color format computing method
+
+    Args:
+        dataset (gdal.Dataset): Dataset object created from the raster image
+        path (str, optionnal): path to the original file/object
+
+    Raises:
+        AttributeError: source_dataset is not a gdal.Dataset instance.
+        Exception: Image has no color band or its color format is unsupported.
+    """
+
+    format = None
+
+    if path is None:
+        path = dataset.GetFileList()[0]
+
+    if dataset.RasterCount < 1:
+        raise Exception(f"Image {path} contains no color band.")
+    
+    band_1_datatype = dataset.GetRasterBand(1).DataType
+    data_type_name = gdal.GetDataTypeName(band_1_datatype)
+    data_type_size = gdal.GetDataTypeSize(band_1_datatype)
+    color_interpretation = dataset.GetRasterBand(1).GetRasterColorInterpretation()
+    color_name = None
+    if color_interpretation is not None:
+        color_name = gdal.GetColorInterpretationName(color_interpretation)
+    compression_regex_match = re.search(r'COMPRESSION\s*=\s*PACKBITS', gdal.Info(dataset))
+
+
+    if data_type_name == "Byte" and data_type_size == 8 and color_name == "Palette" and compression_regex_match:
+        format = ColorFormat.BIT
+    elif data_type_name == "Byte" and data_type_size == 8:
+        format = ColorFormat.UINT8
+    elif data_type_name == "Float32" and data_type_size == 32:
+        format = ColorFormat.FLOAT32
+    else:
+        raise Exception(f"Unsupported color format for image {path} : '{data_type_name}' ({data_type_size} bits)")
+
+    return format
\ No newline at end of file
diff --git a/tests/test_Raster.py b/tests/test_Raster.py
index 4c75833..d7b2b24 100644
--- a/tests/test_Raster.py
+++ b/tests/test_Raster.py
@@ -1,189 +1,14 @@
 """Describes unit tests for the rok4.Raster module."""
 
-from rok4.Raster import ColorFormat, Raster, _compute_bbox, _compute_format
+from rok4.Raster import Raster
+from rok4.Utils import ColorFormat
 
-from osgeo import gdal
-import random, math
+import math
 
 import pytest
 from unittest import mock, TestCase
 from unittest.mock import *
 
-class TestComputeBbox(TestCase):
-    """Test class for the rok4.Raster._compute_bbox function."""
-
-    def test_nominal(self):
-        mocked_datasource = MagicMock(gdal.Dataset)
-        random.seed()
-
-        image_size = (
-            random.randint(1, 1000),
-            random.randint(1, 1000)
-        )
-        mocked_datasource.RasterXSize = image_size[0]
-        mocked_datasource.RasterYSize = image_size[1]
-
-        transform_tuple = (
-            random.uniform(-10000000.0, 10000000.0),
-            random.uniform(-10000, 10000),
-            random.uniform(-10000, 10000),
-            random.uniform(-10000000.0, 10000000.0),
-            random.uniform(-10000, 10000),
-            random.uniform(-10000, 10000)
-        )
-        mocked_datasource.GetGeoTransform = Mock(return_value = transform_tuple)
-
-        x_range = (
-            transform_tuple[0],
-            transform_tuple[0] + image_size[0] * transform_tuple[1] + image_size[1] * transform_tuple[2]
-        )
-        y_range = (
-            transform_tuple[3],
-            transform_tuple[3] + image_size[0] * transform_tuple[4] + image_size[1] * transform_tuple[5]
-        )
-
-        expected = (
-            min(x_range),
-            min(y_range),
-            max(x_range),
-            max(y_range)
-        )
-        result = _compute_bbox(mocked_datasource)
-        assert math.isclose(result[0], expected[0], rel_tol=1e-5)
-        assert math.isclose(result[1], expected[1], rel_tol=1e-5)
-        assert math.isclose(result[2], expected[2], rel_tol=1e-5)
-        assert math.isclose(result[3], expected[3], rel_tol=1e-5)
-
-
-class TestComputeFormat(TestCase):
-    """Test class for the rok4.Raster._compute_format function."""
-
-    def setUp(self) -> None:
-        self.bit_gdalinfo = """Driver: GTiff/GeoTIFF
-Size is 10000, 10000
-Image Structure Metadata:
-  COMPRESSION=PACKBITS
-  INTERLEAVE=BAND
-  MINISWHITE=YES
-"""
-        self.common_gdalinfo = """Driver: GTiff/GeoTIFF
-Size is 10000, 10000
-Metadata:
-  AREA_OR_POINT=Area
-Image Structure Metadata:
-  INTERLEAVE=BAND
-"""
-        return super().setUp()
-
-    @mock.patch('rok4.Raster.gdal.Info')
-    @mock.patch('rok4.Raster.gdal.GetColorInterpretationName', return_value="Palette")
-    @mock.patch('rok4.Raster.gdal.GetDataTypeSize', return_value=8)
-    @mock.patch('rok4.Raster.gdal.GetDataTypeName', return_value="Byte")
-    def test_bit(self, mocked_GetDataTypeName, mocked_GetDataTypeSize, mocked_GetColorInterpretationName, mocked_Info):
-        mocked_datasource = MagicMock(gdal.Dataset)
-
-        mocked_datasource.RasterCount = 1
-        mocked_Info.return_value = self.bit_gdalinfo
-
-        result = _compute_format(mocked_datasource)
-        assert result == ColorFormat.BIT
-        mocked_GetDataTypeName.assert_called()
-        mocked_GetDataTypeSize.assert_called()
-        mocked_GetColorInterpretationName.assert_called()
-        mocked_Info.assert_called()
-
-    @mock.patch('rok4.Raster.gdal.Info')
-    @mock.patch('rok4.Raster.gdal.GetColorInterpretationName')
-    @mock.patch('rok4.Raster.gdal.GetDataTypeSize', return_value=8)
-    @mock.patch('rok4.Raster.gdal.GetDataTypeName', return_value="Byte")
-    def test_uint8(self, mocked_GetDataTypeName, mocked_GetDataTypeSize, mocked_GetColorInterpretationName, mocked_Info):
-        mocked_datasource = MagicMock(gdal.Dataset)
-        
-        band_number = random.randint(1, 4)
-        mocked_datasource.RasterCount = band_number
-        band_name = None
-        if band_number == 1 or band_number == 2:
-            band_name = "Gray"
-        elif band_number == 3 or band_number == 4:
-            band_name = "Red"
-        mocked_GetColorInterpretationName.return_value = band_name
-        mocked_Info.return_value = self.common_gdalinfo
-
-        result = _compute_format(mocked_datasource)
-
-        assert result == ColorFormat.UINT8
-        mocked_GetDataTypeName.assert_called()
-        mocked_GetDataTypeSize.assert_called()
-        mocked_GetColorInterpretationName.assert_called()
-        mocked_Info.assert_called()
-
-    @mock.patch('rok4.Raster.gdal.Info')
-    @mock.patch('rok4.Raster.gdal.GetColorInterpretationName')
-    @mock.patch('rok4.Raster.gdal.GetDataTypeSize', return_value=32)
-    @mock.patch('rok4.Raster.gdal.GetDataTypeName', return_value="Float32")
-    def test_float32(self, mocked_GetDataTypeName, mocked_GetDataTypeSize, mocked_GetColorInterpretationName, mocked_Info):
-        mocked_datasource = MagicMock(gdal.Dataset)
-        
-        band_number = random.randint(1, 4)
-        mocked_datasource.RasterCount = band_number
-        band_name = None
-        if band_number == 1 or band_number == 2:
-            band_name = "Gray"
-        elif band_number == 3 or band_number == 4:
-            band_name = "Red"
-        mocked_GetColorInterpretationName.return_value = band_name
-        mocked_Info.return_value = self.common_gdalinfo
-
-        result = _compute_format(mocked_datasource)
-
-        assert result == ColorFormat.FLOAT32
-        mocked_GetDataTypeName.assert_called()
-        mocked_GetDataTypeSize.assert_called()
-        mocked_GetColorInterpretationName.assert_called()
-        mocked_Info.assert_called()
-
-    @mock.patch('rok4.Raster.gdal.Info')
-    @mock.patch('rok4.Raster.gdal.GetColorInterpretationName')
-    @mock.patch('rok4.Raster.gdal.GetDataTypeSize', return_value=16)
-    @mock.patch('rok4.Raster.gdal.GetDataTypeName', return_value="UInt16")
-    def test_unsupported(self, mocked_GetDataTypeName, mocked_GetDataTypeSize, mocked_GetColorInterpretationName, mocked_Info):
-        mocked_datasource = MagicMock(gdal.Dataset)
-
-        band_number = random.randint(1, 4)
-        mocked_datasource.RasterCount = band_number
-        band_name = None
-        if band_number == 1 or band_number == 2:
-            band_name = "Gray"
-        elif band_number == 3 or band_number == 4:
-            band_name = "Red"
-        mocked_GetColorInterpretationName.return_value = band_name
-        mocked_Info.return_value = self.common_gdalinfo
-
-        with pytest.raises(Exception):
-            _compute_format(mocked_datasource)
-        
-        mocked_GetDataTypeName.assert_called()
-        mocked_GetDataTypeSize.assert_called()
-        mocked_GetColorInterpretationName.assert_called()
-        mocked_Info.assert_called()
-
-    @mock.patch('rok4.Raster.gdal.Info')
-    @mock.patch('rok4.Raster.gdal.GetColorInterpretationName')
-    @mock.patch('rok4.Raster.gdal.GetDataTypeSize', return_value=16)
-    @mock.patch('rok4.Raster.gdal.GetDataTypeName', return_value="UInt16")
-    def test_no_band(self, mocked_GetDataTypeName, mocked_GetDataTypeSize, mocked_GetColorInterpretationName, mocked_Info):
-        mocked_datasource = MagicMock(gdal.Dataset)
-
-        mocked_datasource.RasterCount = 0
-
-        with pytest.raises(Exception):
-            _compute_format(mocked_datasource)
-
-        mocked_GetDataTypeName.assert_not_called()
-        mocked_GetDataTypeSize.assert_not_called()
-        mocked_GetColorInterpretationName.assert_not_called()
-        mocked_Info.assert_not_called()
-
 
 class TestFromFile(TestCase):
     """Test class for the rok4.Raster.Raster.from_file(path) class constructor."""
@@ -213,9 +38,9 @@ def test_image_not_found(self, mocked_exists):
         mocked_exists.assert_called_once_with(self.source_image_path)
 
     @mock.patch('rok4.Raster.get_osgeo_path')
-    @mock.patch('rok4.Raster._compute_format', return_value=ColorFormat.UINT8)
+    @mock.patch('rok4.Raster.compute_format', return_value=ColorFormat.UINT8)
     @mock.patch('rok4.Raster.gdal.Open')
-    @mock.patch('rok4.Raster._compute_bbox')
+    @mock.patch('rok4.Raster.compute_bbox')
     @mock.patch('rok4.Raster.exists', side_effect=[True, False])
     def test_image(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open, mocked_compute_format, mocked_get_osgeo_path):
         """Test case : Constructor called nominally on an image without mask."""
@@ -243,10 +68,10 @@ def test_image(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open, mocke
         assert raster_object.dimensions == self.image_size
 
     @mock.patch('rok4.Raster.get_osgeo_path')
-    @mock.patch('rok4.Raster._compute_format', return_value=ColorFormat.UINT8)
+    @mock.patch('rok4.Raster.compute_format', return_value=ColorFormat.UINT8)
     @mock.patch('rok4.Raster.gdal.IdentifyDriver')
     @mock.patch('rok4.Raster.gdal.Open')
-    @mock.patch('rok4.Raster._compute_bbox')
+    @mock.patch('rok4.Raster.compute_bbox')
     @mock.patch('rok4.Raster.exists', side_effect=[True, True])
     def test_image_and_mask(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open, mocked_identifydriver, mocked_compute_format, mocked_get_osgeo_path):
         """Test case : Constructor called nominally on an image with mask."""
diff --git a/tests/test_Utils.py b/tests/test_Utils.py
index 075e7d9..3ba87da 100644
--- a/tests/test_Utils.py
+++ b/tests/test_Utils.py
@@ -3,7 +3,9 @@
 
 import pytest
 import os
+from osgeo import gdal, osr
 import math
+import random
 
 from unittest.mock import *
 from unittest import mock
@@ -64,3 +66,311 @@ def test_reproject_point_ok():
         assert bbox[0] == 3
     except Exception as exc:
         assert False, f"Bbox reprojection raises an exception: {exc}"
+
+
+# Tests for the rok4.Utils.compute_bbox function.
+
+def test_compute_bbox_epsg_3857_ok():
+    try:
+        mocked_datasource = MagicMock(gdal.Dataset)
+        random.seed()
+
+        image_size = (
+            random.randint(1, 1000),
+            random.randint(1, 1000)
+        )
+        mocked_datasource.RasterXSize = image_size[0]
+        mocked_datasource.RasterYSize = image_size[1]
+
+        transform_tuple = (
+            random.uniform(-10000000.0, 10000000.0),
+            random.uniform(-10000, 10000),
+            random.uniform(-10000, 10000),
+            random.uniform(-10000000.0, 10000000.0),
+            random.uniform(-10000, 10000),
+            random.uniform(-10000, 10000)
+        )
+        mocked_datasource.GetGeoTransform = Mock(return_value = transform_tuple)
+        mocked_spatial_ref = MagicMock(osr.SpatialReference)
+        mocked_spatial_ref.GetDataAxisToSRSAxisMapping = Mock(return_value = [1,2])
+        mocked_datasource.GetSpatialRef = Mock(return_value = mocked_spatial_ref)
+
+        x_range = (
+            transform_tuple[0],
+            transform_tuple[0] + image_size[0] * transform_tuple[1] + image_size[1] * transform_tuple[2]
+        )
+        y_range = (
+            transform_tuple[3],
+            transform_tuple[3] + image_size[0] * transform_tuple[4] + image_size[1] * transform_tuple[5]
+        )
+
+        expected = (
+            min(x_range),
+            min(y_range),
+            max(x_range),
+            max(y_range)
+        )
+        result = compute_bbox(mocked_datasource)
+        assert math.isclose(result[0], expected[0], rel_tol=1e-5)
+        assert math.isclose(result[1], expected[1], rel_tol=1e-5)
+        assert math.isclose(result[2], expected[2], rel_tol=1e-5)
+        assert math.isclose(result[3], expected[3], rel_tol=1e-5)
+        mocked_datasource.GetSpatialRef.assert_called_once()
+        mocked_spatial_ref.GetDataAxisToSRSAxisMapping.assert_called()
+    except Exception as exc:
+        assert False, f"Bbox computation raises an exception: {exc}"
+
+
+def test_compute_bbox_epsg_4326_ok():
+    try:
+        mocked_datasource = MagicMock(gdal.Dataset)
+        random.seed()
+
+        image_size = (
+            random.randint(1, 1000),
+            random.randint(1, 1000)
+        )
+        mocked_datasource.RasterXSize = image_size[0]
+        mocked_datasource.RasterYSize = image_size[1]
+
+        transform_tuple = (
+            random.uniform(-10000000.0, 10000000.0),
+            random.uniform(-10000, 10000),
+            random.uniform(-10000, 10000),
+            random.uniform(-10000000.0, 10000000.0),
+            random.uniform(-10000, 10000),
+            random.uniform(-10000, 10000)
+        )
+        mocked_datasource.GetGeoTransform = Mock(return_value = transform_tuple)
+        mocked_spatial_ref = MagicMock(osr.SpatialReference)
+        mocked_spatial_ref.GetDataAxisToSRSAxisMapping = Mock(return_value = [2,1])
+        mocked_datasource.GetSpatialRef = Mock(return_value = mocked_spatial_ref)
+
+        x_range = (
+            transform_tuple[0],
+            transform_tuple[0] + image_size[0] * transform_tuple[1] + image_size[1] * transform_tuple[2]
+        )
+        y_range = (
+            transform_tuple[3],
+            transform_tuple[3] + image_size[0] * transform_tuple[4] + image_size[1] * transform_tuple[5]
+        )
+
+        expected = (
+            min(y_range),
+            min(x_range),
+            max(y_range),
+            max(x_range)
+        )
+        result = compute_bbox(mocked_datasource)
+        assert math.isclose(result[0], expected[0], rel_tol=1e-5)
+        assert math.isclose(result[1], expected[1], rel_tol=1e-5)
+        assert math.isclose(result[2], expected[2], rel_tol=1e-5)
+        assert math.isclose(result[3], expected[3], rel_tol=1e-5)
+        mocked_datasource.GetSpatialRef.assert_called_once()
+        mocked_spatial_ref.GetDataAxisToSRSAxisMapping.assert_called()
+    except Exception as exc:
+        assert False, f"Bbox computation raises an exception: {exc}"
+
+
+def test_compute_bbox_no_srs_ok():
+    try:
+        mocked_datasource = MagicMock(gdal.Dataset)
+        random.seed()
+
+        image_size = (
+            random.randint(1, 1000),
+            random.randint(1, 1000)
+        )
+        mocked_datasource.RasterXSize = image_size[0]
+        mocked_datasource.RasterYSize = image_size[1]
+
+        transform_tuple = (
+            random.uniform(-10000000.0, 10000000.0),
+            random.uniform(-10000, 10000),
+            random.uniform(-10000, 10000),
+            random.uniform(-10000000.0, 10000000.0),
+            random.uniform(-10000, 10000),
+            random.uniform(-10000, 10000)
+        )
+        mocked_datasource.GetGeoTransform = Mock(return_value = transform_tuple)
+        mocked_datasource.GetSpatialRef = Mock(return_value = None)
+
+        x_range = (
+            transform_tuple[0],
+            transform_tuple[0] + image_size[0] * transform_tuple[1] + image_size[1] * transform_tuple[2]
+        )
+        y_range = (
+            transform_tuple[3],
+            transform_tuple[3] + image_size[0] * transform_tuple[4] + image_size[1] * transform_tuple[5]
+        )
+
+        expected = (
+            min(x_range),
+            min(y_range),
+            max(x_range),
+            max(y_range)
+        )
+        result = compute_bbox(mocked_datasource)
+        assert math.isclose(result[0], expected[0], rel_tol=1e-5)
+        assert math.isclose(result[1], expected[1], rel_tol=1e-5)
+        assert math.isclose(result[2], expected[2], rel_tol=1e-5)
+        assert math.isclose(result[3], expected[3], rel_tol=1e-5)
+        mocked_datasource.GetSpatialRef.assert_called_once()
+    except Exception as exc:
+        assert False, f"Bbox computation raises an exception: {exc}"
+
+
+# Tests for the rok4.Utils.compute_format function.
+
+@mock.patch('rok4.Utils.gdal.Info')
+@mock.patch('rok4.Utils.gdal.GetColorInterpretationName', return_value="Palette")
+@mock.patch('rok4.Utils.gdal.GetDataTypeSize', return_value=8)
+@mock.patch('rok4.Utils.gdal.GetDataTypeName', return_value="Byte")
+def test_compute_format_bit_ok(mocked_GetDataTypeName, mocked_GetDataTypeSize, mocked_GetColorInterpretationName, mocked_Info):
+    try:
+        mocked_datasource = MagicMock(gdal.Dataset)
+
+        mocked_datasource.RasterCount = 1
+        mocked_Info.return_value = """Driver: GTiff/GeoTIFF
+Size is 10000, 10000
+Image Structure Metadata:
+  COMPRESSION=PACKBITS
+  INTERLEAVE=BAND
+  MINISWHITE=YES
+"""
+
+        result = compute_format(mocked_datasource)
+        assert result == ColorFormat.BIT
+        mocked_GetDataTypeName.assert_called()
+        mocked_GetDataTypeSize.assert_called()
+        mocked_GetColorInterpretationName.assert_called()
+        mocked_Info.assert_called()
+    except Exception as exc:
+        assert False, f"Color format computation raises an exception: {exc}"
+
+
+@mock.patch('rok4.Utils.gdal.Info')
+@mock.patch('rok4.Utils.gdal.GetColorInterpretationName')
+@mock.patch('rok4.Utils.gdal.GetDataTypeSize', return_value=8)
+@mock.patch('rok4.Utils.gdal.GetDataTypeName', return_value="Byte")
+def test_compute_format_uint8_ok(mocked_GetDataTypeName, mocked_GetDataTypeSize, mocked_GetColorInterpretationName, mocked_Info):
+    try:
+        mocked_datasource = MagicMock(gdal.Dataset)
+        
+        band_number = random.randint(1, 4)
+        mocked_datasource.RasterCount = band_number
+        band_name = None
+        if band_number == 1 or band_number == 2:
+            band_name = "Gray"
+        elif band_number == 3 or band_number == 4:
+            band_name = "Red"
+        mocked_GetColorInterpretationName.return_value = band_name
+        mocked_Info.return_value = """Driver: GTiff/GeoTIFF
+Size is 10000, 10000
+Metadata:
+  AREA_OR_POINT=Area
+Image Structure Metadata:
+  INTERLEAVE=BAND
+"""
+
+        result = compute_format(mocked_datasource)
+
+        assert result == ColorFormat.UINT8
+        mocked_GetDataTypeName.assert_called()
+        mocked_GetDataTypeSize.assert_called()
+        mocked_GetColorInterpretationName.assert_called()
+        mocked_Info.assert_called()
+    except Exception as exc:
+        assert False, f"Color format computation raises an exception: {exc}"
+
+
+@mock.patch('rok4.Utils.gdal.Info')
+@mock.patch('rok4.Utils.gdal.GetColorInterpretationName')
+@mock.patch('rok4.Utils.gdal.GetDataTypeSize', return_value=32)
+@mock.patch('rok4.Utils.gdal.GetDataTypeName', return_value="Float32")
+def test_compute_format_float32_ok(mocked_GetDataTypeName, mocked_GetDataTypeSize, mocked_GetColorInterpretationName, mocked_Info):
+    try:
+        mocked_datasource = MagicMock(gdal.Dataset)
+        
+        band_number = random.randint(1, 4)
+        mocked_datasource.RasterCount = band_number
+        band_name = None
+        if band_number == 1 or band_number == 2:
+            band_name = "Gray"
+        elif band_number == 3 or band_number == 4:
+            band_name = "Red"
+        mocked_GetColorInterpretationName.return_value = band_name
+        mocked_Info.return_value = """Driver: GTiff/GeoTIFF
+Size is 10000, 10000
+Metadata:
+  AREA_OR_POINT=Area
+Image Structure Metadata:
+  INTERLEAVE=BAND
+"""
+
+        result = compute_format(mocked_datasource)
+
+        assert result == ColorFormat.FLOAT32
+        mocked_GetDataTypeName.assert_called()
+        mocked_GetDataTypeSize.assert_called()
+        mocked_GetColorInterpretationName.assert_called()
+        mocked_Info.assert_called()
+    except Exception as exc:
+        assert False, f"Color format computation raises an exception: {exc}"
+
+
+@mock.patch('rok4.Utils.gdal.Info')
+@mock.patch('rok4.Utils.gdal.GetColorInterpretationName')
+@mock.patch('rok4.Utils.gdal.GetDataTypeSize', return_value=16)
+@mock.patch('rok4.Utils.gdal.GetDataTypeName', return_value="UInt16")
+def test_compute_format_unsupported_nok(mocked_GetDataTypeName, mocked_GetDataTypeSize, mocked_GetColorInterpretationName, mocked_Info):
+    try:
+        mocked_datasource = MagicMock(gdal.Dataset)
+
+        band_number = random.randint(1, 4)
+        mocked_datasource.RasterCount = band_number
+        band_name = None
+        if band_number == 1 or band_number == 2:
+            band_name = "Gray"
+        elif band_number == 3 or band_number == 4:
+            band_name = "Red"
+        mocked_GetColorInterpretationName.return_value = band_name
+        mocked_Info.return_value = """Driver: GTiff/GeoTIFF
+Size is 10000, 10000
+Metadata:
+  AREA_OR_POINT=Area
+Image Structure Metadata:
+  INTERLEAVE=BAND
+"""
+
+        with pytest.raises(Exception):
+            compute_format(mocked_datasource)
+        
+        mocked_GetDataTypeName.assert_called()
+        mocked_GetDataTypeSize.assert_called()
+        mocked_GetColorInterpretationName.assert_called()
+        mocked_Info.assert_called()
+    except Exception as exc:
+        assert False, f"Color format computation raises an exception: {exc}"
+
+
+@mock.patch('rok4.Utils.gdal.Info')
+@mock.patch('rok4.Utils.gdal.GetColorInterpretationName')
+@mock.patch('rok4.Utils.gdal.GetDataTypeSize', return_value=16)
+@mock.patch('rok4.Utils.gdal.GetDataTypeName', return_value="UInt16")
+def test_compute_format_no_band_nok(mocked_GetDataTypeName, mocked_GetDataTypeSize, mocked_GetColorInterpretationName, mocked_Info):
+    try:
+        mocked_datasource = MagicMock(gdal.Dataset)
+
+        mocked_datasource.RasterCount = 0
+
+        with pytest.raises(Exception):
+            compute_format(mocked_datasource)
+
+        mocked_GetDataTypeName.assert_not_called()
+        mocked_GetDataTypeSize.assert_not_called()
+        mocked_GetColorInterpretationName.assert_not_called()
+        mocked_Info.assert_not_called()
+    except Exception as exc:
+        assert False, f"Color format computation raises an exception: {exc}"
+

From 67efd52a1b4ef13ce5fdf9f443085875455b348b Mon Sep 17 00:00:00 2001
From: Xavier Dumetz <XDmz@protonmail.com>
Date: Wed, 12 Apr 2023 15:46:32 +0200
Subject: [PATCH 09/11] =?UTF-8?q?Retrait=20de=20l'utilisation=20de=20kwarg?=
 =?UTF-8?q?s=20pour=20des=20param=C3=A8tres=20obligatoires=20dans=20la=20f?=
 =?UTF-8?q?onction=20`Raster.from=5Fparameters()`.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/rok4/Raster.py | 27 ++++++++++++++-------------
 1 file changed, 14 insertions(+), 13 deletions(-)

diff --git a/src/rok4/Raster.py b/src/rok4/Raster.py
index 1d20fd6..7c5d955 100644
--- a/src/rok4/Raster.py
+++ b/src/rok4/Raster.py
@@ -10,6 +10,7 @@
 from enum import Enum
 
 from osgeo import ogr, gdal
+from typing import Tuple
 
 from rok4.Storage import exists, get_osgeo_path
 from rok4.Utils import ColorFormat, compute_bbox,compute_format
@@ -96,16 +97,16 @@ def from_file(cls, path: str) -> 'Raster':
         return self
 
     @classmethod
-    def from_parameters(cls, mask: str = None, **kwargs) -> 'Raster':
-        """Creates a Raster object from key/value parameters
+    def from_parameters(cls, path: str, bands: int, bbox: Tuple[float, float, float, float], dimensions: Tuple[int, int], format: ColorFormat, mask: str = None) -> 'Raster':
+        """Creates a Raster object from parameters
 
         Args:
-            **mask (str, optionnal): path to the associated mask file or object, if any, or None (same path as the image, but with a ".msk" extension and TIFF format. ex: file:///path/to/image.msk or s3://bucket/path/to/image.msk)
-            **path (str): path to the file/object (ex: file:///path/to/image.tif or s3://bucket/path/to/image.tif)
-            **bbox (Tuple[float, float, float, float]): bounding rectange in the data projection
-            **bands (int): number of color bands (or channels)
-            **format (ColorFormat): numeric variable format for color values. Bit depth, as bits per channel, can be derived from it.
-            **dimensions (Tuple[int, int]): image width and height expressed in pixels
+            path (str): path to the file/object (ex: file:///path/to/image.tif or s3://bucket/path/to/image.tif)
+            bands (int): number of color bands (or channels)
+            bbox (Tuple[float, float, float, float]): bounding rectange in the data projection
+            dimensions (Tuple[int, int]): image width and height expressed in pixels
+            format (ColorFormat): numeric variable format for color values. Bit depth, as bits per channel, can be derived from it.
+            mask (str, optionnal): path to the associated mask file or object, if any, or None (same path as the image, but with a ".msk" extension and TIFF format. ex: file:///path/to/image.msk or s3://bucket/path/to/image.msk)
 
         Examples:
 
@@ -128,11 +129,11 @@ def from_parameters(cls, mask: str = None, **kwargs) -> 'Raster':
 
         self = cls()
             
-        self.path = kwargs["path"]
+        self.path = path
+        self.bands = bands
+        self.bbox = bbox
+        self.dimensions = dimensions
+        self.format = format
         self.mask = mask
-        self.bbox = kwargs["bbox"]
-        self.bands = kwargs["bands"]
-        self.format = kwargs["format"]
-        self.dimensions = kwargs["dimensions"]
 
         return self

From 9a616e10225bd659a73f5ced8b1e9c2f43f4b678 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Th=C3=A9o=20Satabin?= <theo.satabin@ign.fr>
Date: Wed, 3 May 2023 17:10:49 +0200
Subject: [PATCH 10/11] Utilisation de GDAL avec exception

---
 src/rok4/Utils.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/rok4/Utils.py b/src/rok4/Utils.py
index 548f5f7..47e1bcd 100644
--- a/src/rok4/Utils.py
+++ b/src/rok4/Utils.py
@@ -10,6 +10,7 @@
 
 ogr.UseExceptions()
 osr.UseExceptions()
+gdal.UseExceptions()
 
 
 class ColorFormat(Enum):
@@ -263,4 +264,4 @@ def compute_format(dataset: gdal.Dataset, path: str = None) -> 'ColorFormat':
     else:
         raise Exception(f"Unsupported color format for image {path} : '{data_type_name}' ({data_type_size} bits)")
 
-    return format
\ No newline at end of file
+    return format

From 818e7e4c188d31ec5ffb558afa8bb3543d4e472a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Th=C3=A9o=20Satabin?= <theo.satabin@ign.fr>
Date: Wed, 3 May 2023 17:12:00 +0200
Subject: [PATCH 11/11] Utilisation de GDAL avec exception

---
 src/rok4/Raster.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/rok4/Raster.py b/src/rok4/Raster.py
index 7c5d955..2a06ee6 100644
--- a/src/rok4/Raster.py
+++ b/src/rok4/Raster.py
@@ -17,7 +17,7 @@
 
 # Enable GDAL/OGR exceptions
 ogr.UseExceptions()
-
+gdal.UseExceptions()
 
 class Raster:
     """A structure describing raster data