A~GenMat.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"color:white; background:#07D; padding:12px; font-size:20px; font-style:italic; text-align:center\">\n",
    "<span style=\"width:49%; display:inline-block; text-align:left\">Christophe Schlick</span>\n",
    "<span style=\"width:49%; display:inline-block; text-align:right\">schlick[at]u-bordeaux.fr</span>\n",
    "<span style=\"font-size:40px; font-style:normal\"><b>GENERATION D'IMAGES</b></span><br>\n",
    "<span style=\"width:49%; display:inline-block; text-align:left\">Version 2023-01</span>\n",
    "<span style=\"width:49%; display:inline-block; text-align:right\">Licence CC-BY-NC-ND</span></p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'objectif de cette feuille d'exercices est d'illustrer le principe de ***génération d'images par algorithmes***. L'ensemble des exercices vont mettre en oeuvre les fonctionnalités fournies par le package **`numpy`**, basées sur l'utilisation du conteneur **`array`** et des fonctions universelles pour manipuler les données stockées dans ce conteneur. Avant de commencer cette feuille d'exercices, il est donc fortement recommandé de relire le notebook **04-Numpy.ipynb** qui contient les éléments de cours correspondants.\n",
    "\n",
    "> **Remarque importante :** Pour bénéficier du gain de vitesse fourni par le mécanisme de **vectorisation** qu'offrent les fonctions universelles, il est primordial de raisonner uniquement en manipulations globales des vecteurs et des matrices, et ceci pour l'ensemble des traitements à effectuer. Par conséquent ***aucune boucle **`for`** ou **`while`** ne devra être utilisée dans aucun des exercices de cette feuille !***\n",
    "\n",
    "Le package **`numpy`** permet de créer des matrices de dimension quelconque, dont les éléments doivent tous être de même type. Mais dans le cadre de l'imagerie numérique, ***on va exclusivement utiliser 5 formes de matrices*** :\n",
    "\n",
    "- Matrice MxN de booléens = **image binaire** (chaque pixel est défini par un booléen)\n",
    "- Matrice MxN de réels = **image monochrome à valeurs continues** (chaque pixel est défini par un réel)\n",
    "- Matrice MxN d'entiers = **image monochrome à valeurs discrètes** (chaque pixel est défini par un entier)\n",
    "- Matrice MxNx3 de réels = **image polychrome à valeurs continues** (chaque pixel est défini par trois réels)\n",
    "- Matrice MxNx3 d'entiers = **image polychrome à valeurs discrètes** (chaque pixel est défini par trois entiers)\n",
    "\n",
    "---\n",
    "Pour simplifier la vérification du code à écrire dans les exercices, on fournit une fonction **`view`** qui permet d'afficher une matrice **`numpy`** sous la forme d'une image insérée dans le notebook, à condition qu'elle utilise l'une des 5 formes définies ci-dessus. Voici quelques exemple de mise en oeuvre :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np # import du package 'numpy' avec alias 'np'\n",
    "from SRC.tools import show, view # import de deux fonctions du module 'tools'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPAAAADwCAAAAAAbPrZOAAAAT0lEQVR4nO3BMQEAAADCoPVPbQZ/oAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPgPh8AABp0pKQgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<PIL.Image.Image image mode=L size=240x240>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "img.shape ━► (240, 240)\n",
      "img.size ━► 57600\n",
      "img.dtype ━► float64\n",
      "img.nbytes ━► 460800\n",
      "img ━►\n",
      "[[0. 0. 0. ... 0. 0. 0.]\n",
      " [0. 0. 0. ... 0. 0. 0.]\n",
      " [0. 0. 0. ... 0. 0. 0.]\n",
      " ...\n",
      " [0. 0. 0. ... 0. 0. 0.]\n",
      " [0. 0. 0. ... 0. 0. 0.]\n",
      " [0. 0. 0. ... 0. 0. 0.]]\n",
      "\n",
      "img[0,0] ━► 0.0\n",
      "img[0,:5] ━► [0. 0. 0. 0. 0.]\n",
      "img[-1,::20] ━► [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n"
     ]
    }
   ],
   "source": [
    "img = np.zeros((240, 240)) # image monochrome noire (valeurs réelles pour les pixels)\n",
    "#img = np.ones((240, 240)) # image monochrome blanche (valeurs réelles pour les pixels)\n",
    "#img = np.full((240, 240), False) # image binaire noire (valeurs booléennes pour les pixels)\n",
    "#img = np.full((240, 240), 0) # image monochrome noire (valeurs entières pour les pixels)\n",
    "#img = np.full((240, 240), 0.0) # image monochrome noire (valeurs réelles pour les pixels)\n",
    "#img = np.full((240, 240, 3), [0,0,0]) # image polychrome noire (valeurs entières pour les pixels)\n",
    "#img = np.full((240, 240, 3), [1,0,0]) # image polychrome rouge (valeurs entières pour les pixels)\n",
    "#img = np.full((240, 240, 3), [1,0.5,0]) # image polychrome orange (valeurs réelles pour les pixels)\n",
    "#img = np.full((240, 240, 3), [255,0,0]) # image polychrome rouge (valeurs entières pour les pixels)\n",
    "\n",
    "view(img) # affichage de la matrice sous forme d'image\n",
    "show(\"img.shape; img.size; img.dtype; img.nbytes; img#;\") # affichage des attributs de la matrice\n",
    "show(\"img[0,0]; img[0,:5]; img[-1,::20]\") # affichage de pixels ou tranches de pixels"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "<h2 style=\"padding:16px; color:white; background:#07D\">Exercice A1 - Génération d'aplats rectangulaires [grids]</h2>\n",
    "\n",
    "Ecrire les instructions Python permettant de générer les 12 images de la figure ci-dessous. Chaque image individuelle devra avoir une taille de 240 sur 240. Vous aurez besoin des fonctions suivantes fournies par le package **`numpy`** (à vous de trouver leur rôle et ceux de leurs paramètres) :\n",
    "\n",
    "- **`np.indices(size)`**\n",
    "- **`np.repeat(array, repeats, [axis=n])`**\n",
    "- **`np.min(array_or_tuple_of_arrays, [axis=n])`**\n",
    "- **`np.max(array_or_tuple_of_arrays, [axis=n])`**\n",
    "- **`np.random.randint(low, high, size)`**\n",
    "- **`np.random.random(size)`**\n",
    "\n",
    "![](IMG/grids.png 'grids.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO\n",
    "view(img); print(img.shape, '/ min =', img.min(), '/ max =', img.max())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "<h2 style=\"padding:16px; color:white; background:#07D\">Exercice A2 - Génération de dégradés axiaux [ramps]</h2>\n",
    "\n",
    "Ecrire les instructions Python permettant de générer les images de la figure ci-dessous. En plus de certaines des fonctions de l'exercice précédent, vous aurez également besoin des fonctions suivantes :\n",
    "\n",
    "- **`np.linspace(start, stop, samples)`**\n",
    "- **`np.tile(array, repeats)`**\n",
    "- **`np.divmod(number_or_array, number_or_array)`**\n",
    "- **`np.where(test, true_value, false_value)`**\n",
    "\n",
    "![](IMG/ramps.png 'ramps.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO\n",
    "view(img); print(img.shape, '/ min =', img.min(), '/ max =', img.max())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "<h2 style=\"padding:16px; color:white; background:#07D\">Exercice A3 - Génération de dégradés circulaires [spots]</h2>\n",
    "\n",
    "Ecrire les instructions Python permettant de générer les images de la figure ci-dessous. En plus de certaines des fonctions de l'exercice précédent, vous aurez également besoin des fonctions suivantes :\n",
    "\n",
    "- **`np.meshgrid(samples_for_x, samples_for_y)`**\n",
    "- **`np.clip(array, lower_bound, upper_bound)`**\n",
    "- **`np.hstack(tuple_of_arrays)`** ou **`np.vstack(tuple_of_arrays)`**\n",
    "- **`np.sin(array)`** ou **`np.cos(array)`** ou **`np.atan2(y, x)`**\n",
    "\n",
    "![](IMG/spots.png 'spots.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO\n",
    "view(img); print(img.shape, '/ min =', img.min(), '/ max =', img.max())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}