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:
1 parent
16589716fd
commit
3ed0fa0987
13 files changed
+1090
-37
No files matched your search
+73
-4
@@ -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):
|
||||
|
||||
Reference in new issue
Block a user