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

+73 -4
View File
@@ -163,6 +163,70 @@ def normalize(field):
return (field - low) / (high - low)
def spread_levels(field, amount=1.0, bins=1024):
"""Repartit les valeurs du champ pour que les niveaux aient la meme aire.
Le champ est remappe par sa fonction de repartition (egalisation
d'histogramme) : des seuils reguliers decoupent alors des surfaces egales,
meme si presque toutes les valeurs sont tassees sur une plage etroite
(carte de profondeur : fond lointain etendu, sujet resserre). `amount`
dose l'effet, de 0 (champ etire sur 0..1, sans plus) a 1 (aires egales).
"""
field = normalize(field)
amount = min(1.0, max(0.0, float(amount)))
if amount <= 0:
return field
counts, edges = np.histogram(field, bins=bins, range=(0.0, 1.0))
share = np.concatenate([[0.0], np.cumsum(counts)]) / float(field.size)
return (1.0 - amount) * field + amount * np.interp(field, edges, share)
def guided_filter(guide, source, radius, eps=1e-3):
"""Lisse `source` en lui donnant les contours de `guide` (filtre guide).
Dans chaque fenetre de `radius` echantillons, `source` est approche par
une fonction affine de `guide` : un bord flou de `source` (carte de
profondeur calculee en basse resolution) se recale sur le bord net
correspondant de `guide` (la photo). `eps` est la variance de `guide` en
dessous de laquelle une zone est tenue pour calme, donc simplement lissee.
"""
guide = np.asarray(guide, dtype=float)
source = np.asarray(source, dtype=float)
radius = int(radius)
if radius < 1:
return source.copy()
mean_guide, mean_source = box_blur(guide, radius), box_blur(source, radius)
covariance = box_blur(guide * source, radius) - mean_guide * mean_source
variance = np.maximum(box_blur(guide * guide, radius) - mean_guide ** 2, 0.0)
slope = covariance / (variance + eps)
offset = mean_source - slope * mean_guide
return box_blur(slope, radius) * guide + box_blur(offset, radius)
def add_detail(depth, gray, amount, sigma):
"""Grave dans la profondeur les contrastes fins des gris.
Une carte de profondeur donne les volumes mais gomme les yeux, la bouche,
les sourcils. On lui ajoute les gris prives de leurs grandes variations
(ecart a leur moyenne locale, sur `sigma` echantillons) : un trait sombre
se creuse, un reflet ressort, alors qu'un fond uni, clair ou sombre,
n'apporte rien et reste a sa profondeur. `amount` dose l'effet (0 : la
profondeur seule). Le resultat reste sur 0..1.
"""
depth = normalize(depth)
if amount <= 0:
return depth
gray = normalize(gray)
return np.clip(depth + amount * (gray - gaussian_blur(gray, sigma)), 0.0, 1.0)
def blend_fields(gray, depth, mix):
"""Melange les gris et la profondeur, chacun etire sur 0..1 : `mix` = 0
garde les gris seuls, 1 la profondeur seule."""
mix = min(1.0, max(0.0, float(mix)))
return (1.0 - mix) * normalize(gray) + mix * normalize(depth)
def thresholds(levels):
"""Seuils reguliers separant `levels` niveaux de gris sur 0..1."""
return [k / float(levels) for k in range(1, levels)]
@@ -536,13 +600,15 @@ def region_rings(field, lines, inside):
# --------------------------------------------------------------------------
def iso_boards(field, levels=16, blur=0.0, min_area=0.0, tolerance=0.0,
shapes="light", preserve_edges=False):
shapes="light", preserve_edges=False, equalize=0.0):
"""Decoupe un champ de gris en une planche par niveau.
Le champ est lisse (`blur` en echantillons, `preserve_edges` : voir
`smooth`), etire sur 0..1 puis quantifie en `levels` niveaux a seuils
reguliers : le niveau k couvre les valeurs de k / levels a
(k + 1) / levels. Renvoie les planches du fond vers l'avant de la pile :
(k + 1) / levels. Avec `equalize` (0 a 1, voir `spread_levels`), les
valeurs sont d'abord reparties pour que les niveaux tendent vers des
aires egales. Renvoie les planches du fond vers l'avant de la pile :
`(niveau, gris, rings, mark)` avec `niveau` de 0 (le plus sombre) a
levels - 1 et `gris` entre 0 et 1.
@@ -570,6 +636,8 @@ def iso_boards(field, levels=16, blur=0.0, min_area=0.0, tolerance=0.0,
height, width = field.shape
levels = max(2, int(levels))
field = smooth(field, blur, preserve_edges)
if equalize > 0:
field = spread_levels(field, equalize)
smallest = min_area * (width - 1) * (height - 1)
cuts = thresholds(levels)
@@ -601,11 +669,12 @@ def iso_boards(field, levels=16, blur=0.0, min_area=0.0, tolerance=0.0,
def iso_layers(field, levels=16, blur=0.0, min_area=0.0, tolerance=0.0,
shapes="band", preserve_edges=False):
shapes="band", preserve_edges=False, equalize=0.0):
"""Comme `iso_boards`, sans les reperes d'assemblage : liste de
`(niveau, gris, rings)`."""
return [board[:3] for board in iso_boards(field, levels, blur, min_area,
tolerance, shapes, preserve_edges)]
tolerance, shapes, preserve_edges,
equalize)]
def image_ring(width, height):