Carte de profondeur pour des planches qui suivent les volumes

La profondeur de la scène est estimée à partir de la photo (MiDaS small
ou Depth Anything V2 Small) et mélangée aux gris : les planches suivent
les volumes du sujet plutôt que ses lumières et ses ombres.

- Onglet « Profondeur » : part de la carte de profondeur, modèle, et
  détails fins de la photo gravés dans la profondeur (yeux, bouche).
- Répartition des niveaux : rapproche les planches d'aires égales quand
  les valeurs sont tassées sur quelques gris.
- Images 16 bits lues sur toute leur plage (elles étaient écrêtées à 255).
- Le Python d'Inkscape (MinGW, sans pip) ne peut pas charger onnxruntime :
  le calcul tourne dans un environnement à part, installé par
  deploy.ps1 -Depth, lancé en sous-processus, résultat gardé en cache.
- Depth Anything sur la carte graphique (DirectML) avec repli sur le
  processeur ; MiDaS small toujours sur le processeur, DirectML lui
  faisant rendre une carte fausse.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AumyrbcuQobB3GbPrFjG9i
This commit is contained in:
AlexandClaude Opus 5.5 committed 2026-10-04 14:19:26 +02:00
1 parent 16589716fd
commit 3ed0fa0987
13 files changed
+1090 -37

No files matched your search

+89 -9
View File
@@ -44,7 +44,18 @@ aplanis mais les yeux, la bouche et le bord du visage restent nets, et les
reconnaissable. Un flou gaussien simple reste disponible pour les reliefs
abstraits.
- Quantification à seuils réguliers, de 2 à 64 niveaux, après étirement de la
plage de gris de l'image.
plage de gris de l'image. Une répartition réglable rapproche les niveaux
d'aires égales, pour les images dont presque toutes les valeurs tiennent
dans quelques gris (cartes de profondeur).
- Carte de profondeur (facultative) : la profondeur de la scène est estimée
à partir de la photo par un réseau de neurones (MiDaS small ou Depth
Anything V2 Small), enrichie des contrastes fins de la photo (yeux, bouche)
et mélangée aux gris dans la proportion voulue. Les
planches suivent alors les volumes du sujet plutôt que ses lumières et ses
ombres. Calcul sur la carte graphique quand c'est possible, résultat gardé
en cache.
- Images 16 bits (cartes de profondeur produites ailleurs) lues sur toute
leur plage.
- Contours tracés au sous-pixel sur l'image lissée (« marching squares »), puis
simplifiés et convertis en courbes de Bézier : pas d'escalier de pixels.
- Toutes les formes sont fermées : là où un niveau touche le bord de l'image,
@@ -73,8 +84,9 @@ aplanis mais les yeux, la bouche et le bord du visage restent nets, et les
## Installation
Aucune dépendance à installer : l'extension utilise `inkex`, `numpy` et
`Pillow`, tous fournis avec Inkscape.
Aucune dépendance à installer pour l'usage de base : l'extension utilise
`inkex`, `numpy` et `Pillow`, tous fournis avec Inkscape. Seule la carte de
profondeur demande une installation à part (`-Depth`, ci-dessous).
### Windows
@@ -82,10 +94,41 @@ Aucune dépendance à installer : l'extension utilise `inkex`, `numpy` et
.\deploy.ps1 # copie dans %APPDATA%\inkscape\extensions\GrayIsoLayers
.\deploy.ps1 -Uninstall # retire l'extension
.\deploy.ps1 -Force # déploie même si Inkscape est ouvert
.\deploy.ps1 -Depth # déploie, et installe de quoi calculer la profondeur
```
Inkscape doit être fermé pendant la copie, puis relancé.
### Carte de profondeur
Le Python fourni avec Inkscape ne peut pas charger `onnxruntime` (c'est une
construction MinGW, sans `pip`). `.\deploy.ps1 -Depth` installe donc, dans
`%LOCALAPPDATA%\GrayIsoLayers` :
- `venv\` : un environnement Python avec `onnxruntime-directml`, `numpy` et
`pillow`, créé à partir du Python 3 de la machine (`python` du `PATH`, sinon
le lanceur `py` ; `-Python <chemin>` pour en imposer un autre) ;
- `models\` : les deux modèles, téléchargés une fois (64 Mo et 94 Mo) ;
- `cache\` : les 30 dernières cartes calculées.
L'extension lance le calcul dans cet environnement. Sans lui, elle le signale
et travaille sur les gris seuls. `.\deploy.ps1 -Uninstall` supprime aussi ce
dossier. La variable d'environnement `GRAY_ISO_LAYERS_PYTHON` désigne un autre
Python que celui de `venv\`.
Temps mesurés sur le portrait d'essai, lancement du Python compris (Core i7-3770
et RTX 4080 SUPER ; à titre indicatif) :
| Modèle | Calcul | Premier passage | Passages suivants |
| --- | --- | --- | --- |
| MiDaS small (256 points) | processeur | 1 s environ | cache, sans délai |
| Depth Anything V2 Small (518 points) | carte graphique (DirectML) | 2 s environ | cache, sans délai |
| Depth Anything V2 Small | processeur | 3 s environ | cache, sans délai |
MiDaS small est toujours calculé sur le processeur : sous DirectML il rend une
carte fausse, et son calcul est plus court que l'initialisation de la carte
graphique.
### Manuelle
Copier dans un sous-dossier du répertoire des extensions utilisateur
@@ -93,7 +136,8 @@ Copier dans un sous-dossier du répertoire des extensions utilisateur
sous Linux, `~/Library/Application Support/org.inkscape.Inkscape/config/inkscape/extensions`
sous macOS) :
- `gray_iso_layers.inx`, `gray_iso_layers.py`, `gray_iso_layers_core.py` ;
- `gray_iso_layers.inx`, `gray_iso_layers.py`, `gray_iso_layers_core.py`,
`gray_iso_layers_depth.py`, `depth_estimate.py` ;
- `images/parameters_en.png` ;
- le dossier `locale/`.
@@ -127,6 +171,19 @@ vide.
- **Contours anguleux** : augmenter le lissage ou la simplification.
- **Détails perdus, visage méconnaissable** : réduire le lissage (0,5 à 1 %),
laisser « Préserver les contours » coché, augmenter la résolution de calcul.
- **Relief fidèle aux volumes** : onglet « Profondeur », part de la carte de
profondeur à 100 % et modèle « Fin », qui détoure nettement mieux les cheveux
et le visage que le modèle « Rapide ». Les planches suivent les volumes (le
nez devant, le fond derrière) et le réglage « Détails fins » y grave les
yeux, la bouche et les sourcils, que la profondeur seule ne contient pas.
Visage trop lisse : monter les détails fins (jusqu'à 150 %). Trop de petites
formes dans les cheveux ou la barbe : les baisser, ou augmenter le lissage.
- **Planches vides, sujet tassé sur quelques planches** (fréquent avec une
carte de profondeur) : augmenter la répartition des niveaux. À 100 %, toutes
les planches ont la même surface, fond compris ; une valeur intermédiaire
garde plus de planches pour le sujet.
- **Carte de profondeur produite ailleurs** : l'importer et la sélectionner
comme n'importe quelle image (8 ou 16 bits), part de profondeur à 0.
- **Portrait** : un fond uni donne le meilleur résultat ; un fond en dégradé
produit des anneaux, puisque chaque nuance du dégradé devient un aplat.
- **Image liée introuvable** : l'incorporer (clic droit > Incorporer l'image).
@@ -142,6 +199,7 @@ Onglet **Niveaux**
| Paramètre | Défaut | Rôle |
| --- | --- | --- |
| Nombre de niveaux de gris | 16 | Nombre d'aplats, donc de calques produits (2 à 64). |
| Répartition des niveaux (% d'aires égales) | 0 | 0 : seuils régulièrement espacés. 100 : chaque planche couvre la même surface. |
| Contenu de chaque planche | Empilées, la plus claire devant | « Empilées, la plus claire devant » : planche n° 1 = la plus sombre, toute l'image. « Empilées, la plus sombre devant » : planche n° 1 = la plus claire, toute l'image. « Son gris seul » : planches côte à côte, sans recouvrement, planche n° 1 = le gris le plus sombre. |
| Reporter sur chaque planche le contour de la suivante | oui | Repère d'assemblage tracé dans la couleur de marquage (planches empilées uniquement). |
| Lissage (% du grand côté de l'image) | 1 | Lissage appliqué avant la découpe : plus il est fort, plus les contours sont ronds et simples. |
@@ -151,6 +209,14 @@ Onglet **Niveaux**
| Simplification (points de calcul) | 0,4 | Écart maximal toléré lors de la suppression de nœuds ; 0 les conserve tous. |
| Lisser les contours avec des courbes de Bézier | oui | Sinon, les contours sont des polygones. |
Onglet **Profondeur**
| Paramètre | Défaut | Rôle |
| --- | --- | --- |
| Part de la carte de profondeur (%) | 0 | 0 : gris de l'image seuls. 100 : profondeur estimée seule. Entre les deux, mélange. Demande `deploy.ps1 -Depth`. |
| Modèle de profondeur | Rapide (MiDaS small) | « Rapide » : MiDaS small, carte lisse. « Fin » : Depth Anything V2 Small, contours plus précis. |
| Détails fins de la photo (%) | 100 | Grave dans la profondeur les contrastes fins de la photo (yeux, bouche, sourcils). Un fond uni n'apporte rien et reste au fond. 0 : profondeur lisse seule. |
Onglet **Style**
| Paramètre | Défaut | Rôle |
@@ -169,6 +235,8 @@ Onglet **Style**
gray_iso_layers.inx Boîte de dialogue (textes source en anglais)
gray_iso_layers.py Couche inkex : lecture de l'image, écriture du SVG
gray_iso_layers_core.py Noyau de calcul, sans inkex (numpy seul)
gray_iso_layers_depth.py Carte de profondeur : lancement du calcul, cache
depth_estimate.py Calcul de la profondeur (onnxruntime), hors Inkscape
i18n.py Extraction / mise à jour / compilation des traductions
po/ Catalogues grayisolayers.pot, en.po, fr.po
locale/ Catalogues compilés (.mo), déployés
@@ -194,13 +262,17 @@ gris (0 noir, 1 blanc) ; un anneau est un tableau `(n, 2)` de points, en
| `edge_preserving_blur(field, radius, contrast)` | Lissage qui respecte les contours (filtre guidé). |
| `smooth(field, blur, preserve_edges)` | Lissage avant découpe, puis étirement sur 0..1. |
| `normalize(field)` | Étire le champ sur 0..1. |
| `spread_levels(field, amount)` | Répartit les valeurs pour que les niveaux tendent vers des aires égales. |
| `guided_filter(guide, source, radius, eps)` | Lisse `source` en lui donnant les contours de `guide` (carte de profondeur recalée sur la photo). |
| `add_detail(depth, gray, amount, sigma)` | Grave dans la profondeur les contrastes fins des gris (yeux, bouche). |
| `blend_fields(gray, depth, mix)` | Mélange des gris et de la profondeur. |
| `thresholds(levels)` | Seuils réguliers séparant les niveaux. |
| `contour_rings(field, threshold, above=True)` | Contours fermés de la région au-dessus (ou au-dessous) du seuil. |
| `ring_area(ring)` | Aire d'un anneau. |
| `simplify_ring(ring, tolerance)` / `simplify_chain(chain, tolerance)` | Simplification de Douglas-Peucker d'un anneau fermé, d'une ligne ouverte. |
| `contour_lines(field, threshold, tolerance, min_area)` | Ligne de niveau d'un seuil : boucles fermées et lignes ouvertes aboutissant au bord. |
| `region_rings(field, lines, inside)` | Contour fermé d'une région bornée par des lignes de niveau, refermé le long du bord de l'image. |
| `iso_boards(field, levels, blur, min_area, tolerance, shapes, preserve_edges)` | Une planche par niveau : liste de `(niveau, gris, anneaux, repère)`, le repère étant la ligne de niveau qui borde la planche suivante. |
| `iso_boards(field, levels, blur, min_area, tolerance, shapes, preserve_edges, equalize)` | Une planche par niveau : liste de `(niveau, gris, anneaux, repère)`, le repère étant la ligne de niveau qui borde la planche suivante. |
| `iso_layers(…)` | Comme `iso_boards`, sans les repères. |
| `image_ring(width, height)` | Rectangle de l'image. |
| `scale_rings(rings, scale_x, scale_y, offset_x, offset_y)` | Passage au repère de destination. |
@@ -215,18 +287,26 @@ pip install pytest numpy pillow
python -m pytest -q
```
Sans `inkex` : 41 tests passent, 13 sont ignorés. Avec `inkex` :
Sans `inkex` : 51 tests passent, 17 sont ignorés. Avec `inkex` :
```powershell
pip install lxml tinycss2 cssselect2 cssselect
$env:PYTHONPATH = 'C:\Program Files\Inkscape\share\inkscape\extensions'
python -m pytest -q # 54 tests passent
python -m pytest -q # 67 tests passent, 1 est ignoré
```
Les tests couvrent le noyau (lissage qui respecte les contours, contours d'un cône et d'une rampe, fermeture le
Le test ignoré est le calcul réel d'une carte de profondeur, qui demande
`onnxruntime` et le modèle. Il se lance dans l'environnement de `-Depth` :
```powershell
& "$env:LOCALAPPDATA\GrayIsoLayers\venv\Scripts\python.exe" -m pip install pytest
& "$env:LOCALAPPDATA\GrayIsoLayers\venv\Scripts\python.exe" -m pytest -q -k depth
```
Les tests couvrent le noyau (lissage qui respecte les contours, répartition des niveaux, filtre guidé, détails fins gravés dans la profondeur, contours d'un cône et d'une rampe, fermeture le
long des bords, cas selle, simplification, aplats conformes à l'image
quantifiée, frontières communes aux aplats voisins, feuilles à empiler, îlots
écartés, écriture des chemins), l'extension de bout en bout (un calque par niveau, repères d'assemblage, image incorporée, liée ou
écartés, écriture des chemins), la carte de profondeur avec un calcul simulé (cache, environnement transmis, causes d'échec), l'extension de bout en bout (image 16 bits, mélange de la profondeur et repli sur les gris, un calque par niveau, repères d'assemblage, image incorporée, liée ou
tournée, groupe sélectionné, styles, messages d'erreur) et la cohérence des traductions et du
`.inx`.