---
title: INFO911 (2) Typologie, représentation
type: slide
slideOptions:
transition: slide
progress: true
slideNumber: true
---
# Typologie et représentation des images numériques
## (Traitement et Analyse d'Image 2)
> [name=Jacques-Olivier Lachaud][time=Novembre 2020][color=#907bf7]
> (Les images peuvent être soumises à des droits d'auteur. Elles sont utilisées ici exclusivement dans un but pédagogique)
###### tags: `info911`
Retour à [INFO911 (Main) Traitement et analyse d'image](https://codimd.math.cnrs.fr/s/UE_B59gMy)
---
# Qu'est-ce qu'une image ?
---
# Image : fonction d'un domaine vers des valeurs
**Domaine $\Omega$**: sous-ensemble de grille spatiale cartésienne $\mathbb{Z}^d$ et de grille temporelle $\mathbb{T}$
| Domaine | $\Omega\subset$ | Outils d'acquisition |
| -------- | ------------------------------ | -------------------------------------------------- |
| 1D+temps | $\mathbb{Z}\times\mathbb{T}$ | scanners linéaires optique/rayon X |
| 2D | $\mathbb{Z}^2$ | appareils photos, échographies, radiographies, etc |
| 2D+temps | $\mathbb{Z}^2\times\mathbb{T}$ | caméras et appareils photos numériques |
| 3D | $\mathbb{Z}^3$ | tomodensitométrie, IRM, imagerie radar volumique |
| 3D+temps | $\mathbb{Z}^3\times\mathbb{T}$ | IRM fonctionnelle|
> Les images sont stockées à l'aide de **tableaux multidimensionnels**
---
# Image : fonction d'un domaine vers des valeurs
**Valeurs $V$** : scalaires, nombres complexes, couleurs, vecteurs, codés avec un ou plusieurs entiers 8-bits $Byte$ ou 16-bits $Word$, parfois valeur flottante Float
| Valeurs | Codage | Types d'image |
| -------- | ------- | ------------------------------------------------------------------------------------- |
| scalaire | Byte | Images noir & blanc, sismique, échos, IRM, infrarouge |
| scalaire | Word | Radiographies, tomodensitométries |
| couleur | 3 Bytes | Images couleurs |
| complexe | 2 Bytes | échographie doppler (intensité + phase), radars doppler |
| vecteur 3D | 3 Float | IRM de diffusion |
| couleur+Z | 4 Bytes | Images RGB+depth (kinect) |
---
# Image : fonction d'un domaine vers des valeurs
**Image numérique** : tableau multidimensionnel (souvent 2) de valeurs, elles-mêmes parfois des tableaux.
Exemple: image couleur de taille $L \times H$ => tableau[H][L] de Byte[3]
=> ou tableau[H][L][3] de Byte
=> ou tableau[3][H][L] de Byte
*Tableau multidimensionnel*: brique de base du traitement d'image
Ex: numpy, pytorch/tensorflow (Deep Learning), OpenCV, VTK
*Programmation générique*: utile pour écrire des algorithmes qui s'appliquent à des domaines variés et à des valeurs variées
---
# OpenCV [https://opencv.org](https://opencv.org)
## bibliothèque versatile de vision par ordinateur
Classe de base `Mat`, matrice 2D, gestion mémoire intelligente
```C++=
Mat A, C; // creates just the header parts
A = imread(argv[1], IMREAD_COLOR); // (allocate matrix)
Mat B(A); // Use the copy constructor
C = A; // Assignment operator
Mat M(10,20, CV_8UC3,Scalar(0,0,255));// Image 10x20 RGB 8-bit
cout << "M = " << M << endl << end // affiche sur la console
Mat M(50,50, CV_8UC(4),Scalar(0,0,0,100));// Image 50x50 RGB+Z
```
---
# OpenCV [https://opencv.org](https://opencv.org)
On peut aussi faire des images nD
```C++=
int sz[3] = {10,15,20}; // taille 10 x 15 x 20
Mat L(3,sz, CV_8UC(1), Scalar::all(0)); // Image 3D Noir & Blanc
Mat F(3,sz, CV_32F, Scalar::all(0)); // Image 3D de float
```
See tutorial [OpenCV - Mat - The Basic Image Container](https://docs.opencv.org/master/d6/d6d/tutorial_mat_the_basic_image_container.html)
```C++=
Mat img = imread("lena.jpg"); // default to RGB 8bits (CV_8UC3)
Mat img = imread("lena.jpg", IMREAD_GRAYSCALE); // force N&B 8bits
imwrite("tutu.png", img); // save image as PNG
```
See tutorial [OpenCV - Operations with images](https://docs.opencv.org/master/d5/d98/tutorial_mat_operations.html)
---
# Représentation mathématique
* ==Image numérique $I$== : $R \subset \mathbb{Z}^d \rightarrow V$, où $I[i,j,\ldots]$ valeur dans un ensemble fini $V$,
* $R$ est un intervalle, rectangle, ... $(0,1, \ldots, L-1) \times (0,1, \ldots, H-1) \times \ldots$
* traitements numériques nécessitent des modèles mathématiques plus abstraits
* ==Image mathématique== $I$ : $\Omega \subset \mathbb{R}^d \rightarrow \mathbb{R}^c$, où $I(x,y,\ldots)$ valeur réelle/vectorielle
* $\Omega$ domaine, fonction scalaire N&B ($c=1$), fonction vectorielle couleur ($c=3$)
* Souvent pixels régulièrement espacés: $I[i,j]=I(i\Delta x, j\Delta y) =I(x,y)$
:::info
Si pixel=(3,4) et image I est échantillonnée avec $\Delta x=0.2$, $\Delta y = 0.3$, alors
$I[3,4]=I(3\Delta x, 4\Delta y)=I(3\times 0.2, 4 \times 0.3 ) = I(0.6, 1.2)$
:::
> Très souvent, on choisit $\Delta x=1.0, \Delta y=1.0$ pour simplifier [color=#907bf7]
---
# Discrétisation (échantillonnage du domaine)
```vega
{
"$schema": "https://vega.github.io/schema/vega-lite/v4.json",
"description": "Plots two functions using a generated sequence.",
"width": 150,
"height": 150,
"data": {
"sequence": {
"start": 0,
"stop": 12.7,
"step": 0.1,
"as": "x"
}
},
"transform": [
{
"calculate": "sin(datum.x)/(datum.x)",
"as": "I(x)"
},
{
"fold": ["I(x)"]
}
],
"mark": "line",
"encoding": {
"x": {
"type": "quantitative",
"field": "x"
},
"y": {
"field": "value",
"type": "quantitative"
},
"color": {
"field": "key",
"type": "nominal",
"title": ""
}
}
}
```
```vega
{
"$schema": "https://vega.github.io/schema/vega-lite/v4.json",
"description": "Plots two functions using a generated sequence.",
"width": 150,
"height": 150,
"data": {
"sequence": {
"start": 0,
"stop": 24,
"step": 1,
"as": "i"
}
},
"transform": [
{
"calculate": "sin(datum.i*0.5)/(datum.i*0.5)",
"as": "I(i)"
},
{
"fold": ["I(i)"]
}
],
"mark": "point",
"encoding": {
"x": {
"type": "quantitative",
"field": "i"
},
"y": {
"field": "value",
"type": "quantitative"
},
"color": {
"field": "key",
"type": "nominal",
"title": "I[i]"
}
}
}
```
Discrétisation avec pas $\Delta x = 0.5$
$I[i] = I(i \cdot \Delta x) = I(0.5 \cdot i)$, ou parfois $I[i] = Q( I( i \cdot \Delta x))$
---
# Quantification (échantillonnage des valeurs)
```vega
{
"$schema": "https://vega.github.io/schema/vega-lite/v4.json",
"description": "Plots two functions using a generated sequence.",
"width": 150,
"height": 150,
"data": {
"sequence": {
"start": 0,
"stop": 24,
"step": 1,
"as": "i"
}
},
"transform": [
{
"calculate": "sin(datum.i*0.5)/(datum.i*0.5)",
"as": "I(i)"
},
{
"fold": ["I(i)"]
}
],
"mark": "point",
"encoding": {
"x": {
"type": "quantitative",
"field": "i"
},
"y": {
"field": "value",
"type": "quantitative"
},
"color": {
"field": "key",
"type": "nominal",
"title": "I[i]"
}
}
}
```
```vega
{
"$schema": "https://vega.github.io/schema/vega-lite/v4.json",
"description": "Plots two functions using a generated sequence.",
"width": 150,
"height": 150,
"data": {
"sequence": {
"start": 0,
"stop": 24,
"step": 1,
"as": "i"
}
},
"transform": [
{
"calculate": "round( 7.5*sin(datum.i*0.5)/(datum.i*0.5))",
"as": "I(i)"
},
{
"fold": ["I(i)"]
}
],
"mark": {"type": "tick", "orient":"horizontal",
"width":5, "thickness":5},
"encoding": {
"x": {
"type": "quantitative",
"field": "i"
},
"y": {
"field": "value",
"type": "quantitative"
},
"color": {
"field": "key",
"type": "nominal",
"title": "I[i] quantifié"
}
}
}
```
Quantifié sur 4 bits $V=[-8,-7, \ldots, 6,7]$
$Q(v) := \mathrm{round}( 7.5 \cdot v )$ avec $v \in [-1,1]$
---
# Traitement d'image
```graphviz
digraph main {
rankdir="LR"
node [color=Red,fontname=Courier,shape=box]
edge [color=Blue]
imath [label="Image continue"]
ifloat [label="Image discrétisée"]
icoded [label="Image quantifiée"]
imath -> ifloat [label="discr"]
ifloat -> imath [label="erreurs"]
ifloat -> icoded [label="quant"]
icoded ->ifloat [label="erreurs"]
}
```
| Image "continue" | Image discrétisée | Image quantifiée |
| -------------------------------------- | -------------------------------------- | ---------------------------- |
| $I: \mathbb{R}^d \mapsto \mathbb{R}^c$ | $I: \mathbb{Z}^d \mapsto \mathbb{R}^c$ | $I: \mathbb{Z}^d \mapsto V$ |
| modélisation, raisonnement | traitements complexes | traitements simples, i/o |
| aucun | $\approx$ tableaux de `double` | tableaux codés (RGB=3octets) |