diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0a24c5b..e93aeb8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,20 +1,26 @@
 ## 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.
+* 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
 
-* 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 a75c02f..159c85e 100644
--- a/README.md
+++ b/README.md
@@ -37,17 +37,17 @@ Plus d'exemple dans la documentation développeur.
 ## Compiler la librairie
 
 ```sh
-apt install python3-venv
+apt install python3-venv python3-rados python3-gdal
 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)'
+python3 -c 'import sys; print (sys.path)'
 # Run tests
 coverage run -m pytest
 # Get tests report and generate site
@@ -55,13 +55,16 @@ 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
 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/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
new file mode 100644
index 0000000..2a06ee6
--- /dev/null
+++ b/src/rok4/Raster.py
@@ -0,0 +1,139 @@
+"""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.
+
+"""
+
+import re
+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
+
+# Enable GDAL/OGR exceptions
+ogr.UseExceptions()
+gdal.UseExceptions()
+
+class Raster:
+    """A structure describing raster data
+
+    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
+        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) -> 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
+
+        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
+            NotImplementedError: Storage type not handled
+
+        Returns:
+            Raster: a Raster instance
+        """
+
+        if not exists(path):
+            raise Exception(f"No file or object found at path '{path}'.")
+
+        self = cls()
+
+        work_image_path = get_osgeo_path(path)
+
+        image_datasource = gdal.Open(work_image_path)
+        self.path = path
+
+        path_pattern = re.compile('(/[^/]+?)[.][a-zA-Z0-9_-]+$')
+        mask_path = path_pattern.sub('\\1.msk', 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}'")
+
+            self.mask = mask_path
+        else:
+            self.mask = 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, 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:
+            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:
+
+            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
+
+        Returns:
+            Raster: a Raster instance
+        """
+
+        self = cls()
+            
+        self.path = path
+        self.bands = bands
+        self.bbox = bbox
+        self.dimensions = dimensions
+        self.format = format
+        self.mask = mask
+
+        return self
diff --git a/src/rok4/Utils.py b/src/rok4/Utils.py
index 7f8260b..47e1bcd 100644
--- a/src/rok4/Utils.py
+++ b/src/rok4/Utils.py
@@ -2,11 +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()
+gdal.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':
@@ -154,4 +168,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
diff --git a/tests/test_Raster.py b/tests/test_Raster.py
new file mode 100644
index 0000000..d7b2b24
--- /dev/null
+++ b/tests/test_Raster.py
@@ -0,0 +1,180 @@
+"""Describes unit tests for the rok4.Raster module."""
+
+from rok4.Raster import Raster
+from rok4.Utils import ColorFormat
+
+import math
+
+import pytest
+from unittest import mock, TestCase
+from unittest.mock import *
+
+
+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 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
+        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 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
+        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 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
+        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 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
+        assert result.mask == i_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}"
+