Discussion :

[ijk-ref]

Bonjour j'espère que le titre conviendra car je ne sais pas trop comment nommer ce que je cherche...

Ma question est un peu en rapport avec la compression par ondelette...

Je cherche à agrandir les dimensions d'une images par un 2, 4, 8, etc...

J'aimerai que l'image agrandie apparaisse "lisse" - reste à déterminer quel "lissage" adapter.

et surtout ma condition qui change toute la donne : je veux que cette "adaptation" me permet de retrouver l'image initiale exacte lors de sa réduction !!!

La réduction est celle-ci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
dst_pixel[i,j] = 
  (
    pixel[i*2+0, j*2+0] + pixel[i*2+1, j*2+0] + 
    pixel[i*2+0, j*2+1] + pixel[i*2+1, j*2+1]
  ) / 4;

Ainsi j'espère que vous comprenez bien qu'il ne s'agit pas d'un lissage "classique"

Si vous connaissez des approches dans le domaine... ou même des solutions... merci !

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
// Résumé 
 
Image B = A.Agrandissement2Lisse();
Image C = B.Reduction2();
 
// C doit être égale à A !!!

[pseudocode]

Avec cette formule de réduction, je ne suis pas bien sur que ca soit possible, ou du moins pas joli.

Exemple d'un agrandissement x2 en 1D

avant: 0 | 9 | 0
après: a b | c d | e f

on doit donc avoir: (a+b)/2=0, (c+d)/2=9, (e+f)/2=0

Déjà pour le premier et dernier pixel, soit on autorise les valeurs négatives, soit on aura a=b=0 => effet de pixelisation.

Pour le pixel central, soit on autorise une dissymetrie gauche/droite (alors que la sequence originale est symetrique), soit on aura aussi c=d=9 => effet de pixelisation.

Bref, déjà en 1D c'est pas gagné.

[ijk-ref]

Bref, déjà en 1D c'est pas gagné.

C'est vrai

Cependant il y a quand même moyen d'obtenir un lissage "intéressant" en 1D

Il faut trouver "d" tel que le "doublage" de pixels vérifie ceci :
pixel[i*2 + 0] = pixel[i] - d[i];
pixel[i*2 + 1] = pixel[i] + d[i];

(Ainsi la réduction retrouve bien avec les valeurs initiales)

En choisissant "d" vérifiant la "pente" des pixels voisins (pixel[i+1] - pixel[i-1]) j'obtiens quelque chose de satisfaisant... mais seulement en 1D

... l'appliquer en 2D (plus exactement bi-1D) ne fonctionne pas... problème d'intégration/dérivation dx/dy/dxy...

Il doit bien avoir des études faites la dessus non !? Le lissage dans la compression par ondelette me semble une notion très importante !

[pseudocode]

En choisissant "d" vérifiant la "pente" des pixels voisins (pixel[i+1] - pixel[i-1]) j'obtiens quelque chose de satisfaisant... mais seulement en 1D

Dans le cas où tu as une fonction croissante/décroissante, ton principe est applicable. Mais si tu prends mon exemple (un maximum/minimum local) ?

... l'appliquer en 2D (plus exactement bi-1D) ne fonctionne pas... problème d'intégration/dérivation dx/dy/dxy...

Pareil. Ca reste applicable pour un zone croissante/décroissante, mais pas pour un sommet ou une crête.

Il doit bien avoir des études faites la dessus non !? Le lissage dans la compression par ondelette me semble une notion très importante !

Je vois pas trop comment les ondelettes peuvent aider.

[ijk-ref]

Dans le cas où tu as une fonction croissante/décroissante, ton principe est applicable. Mais si tu prends mon exemple (un maximum/minimum local) ?

Pourtant je peux t'assurer que si tu appliques ce traitement à chaque doublement... tu te retrouves bien avec une courbe (pratiquement) lisse (par morceaux)... et les minima/maxima ne posent pas (trop) de problème :

- la courbe bleue représente les intensités lumineuses à la dimension initiale
- la courbe violette représente après une itération.
- la courbe rouge représente la valeur limite (itérations à l'infini)

L'aire est donc identique sous chaque partie.

En fait, il existe de bien meilleurs résultats. Par exemple un lissage par morceaux de cubiques... mais elles demandes un calcul sur tous leurs voisins.

Autrement en utilisant une "intégration => doublement => dérivation" on peut aussi respecter la propriété des aires.

Cependant le passage 2D (bi-1D) ne fonctionnement pas.

Je vois pas trop comment les ondelettes peuvent aider.

Je crois surtout que l'on ne parle pas exactement de la même chose Je n'ai pas utiliser ce mot au sens mathématique. C'est juste le coté traitement d'image qui m'intéresse

Donc je veux seulement utiliser : p'[i] = (p[2*i+0] + p[2*i+1))/2

Cette formule reste la partie sur la réduction d'image la plus courant en compression par ondelette et c'est la seule que veux utiliser.

Possédant seulement cette partie, je souhaite pouvoir en augmenter la résolution... et je souhaite naturellement que cette augmentation ne fasse pas apparaître de gros carrés de pixels !

Evidemment cette augmentation doit permettre de toujours vérifier les propriétés de l'orignal - avec p'[i] = (p[2*i+0] + p[2*i+1))/2

Donc oui... je pense que ce problème a dû être abordé lors des définitions de JPG2000, MPG4 et autres formats à bases de compression par ondelettes

[pseudocode]

Pourtant je peux t'assurer que si tu appliques ce traitement à chaque doublement... tu te retrouves bien avec une courbe (pratiquement) lisse (par morceaux)... et les minima/maxima ne posent pas (trop) de problème :

- la courbe bleue représente les intensités lumineuses à la dimension initiale
- la courbe violette représente après une itération.
- la courbe rouge représente la valeur limite (itérations à l'infini)

L'aire est donc identique sous chaque partie.

En ce cas, c'est possible puisque tu autorises les dépassements de valeurs limites (0-255) et les dissymetries (gauche/droite).

Le plus simple c'est de prendre une méthode d'interpolation (quelconque) et d'ajouter un offset identique aux 4 nouvelles valeurs afin que leur moyenne soit égale au pixel original.

Après, on peut jouer plus finement en ajoutant un offset différent aux 4 pixels, en essayant de coller aux derivées partielles.

[Invité]

et surtout ma condition qui change toute la donne : je veux que cette "adaptation" me permet de retrouver l'image initiale exacte lors de sa réduction !!!

Exact à quelle précision près ? 1/256 ou le même nombre flottant ?

Sinon je t'aurais conseillé un resampling lanzcos4 pour l'agrandissement et lanzcos3 pour le réduction.


Un sujet intéressant pour avoir la même image après agrandissement/réduction.
http://www.virtualdub.org/blog/pivot/entry.php?id=86

Il s'agit de sampler au bon endroit.

EDIT : une solution simple pour réduire si tu as fais un agrandissement par 2^N = prendre un pixel tous les 2^N et oublier les autres. Si tu as fait un traitement (comme je l'imagine) alors il faudra filtrer.

[kmaniche]

Je ne pense pas que se soit possible avec les ondelettes. Pourquoi, parce que déjà tu commence par calculer les coefficients d'ondelettes qui sont en réels (imaginaires), ensuite tu vas modifier ton image pour l'agrandir, et ensuite tu applique un filtrage d'adaptation.

Je ne connais pas une méthode au monde qui permet de faire ceci et de revenir en arrière. Il y a une perte de donnée et c'est normale.

Sinon, si tu insiste, lorsque tu fais le traitement, et lorsque tu reviens à ton image originale, pour comparer les deux image tu peux intégrer une incertitude de calcul, ce que l'on appelle epsilon.

Pour le filtrage, pourquoi ne pas utiliser un filtrage à base d'ondelette. je me rappelle d'un exemple sur le site de << enst >>

[ijk-ref]

Désolé de ne pas avoir répondu avant... mais c'est parce que je sais pas trop quoi répondre pour allez vers une bonne solution.

En ce cas, c'est possible puisque tu autorises (...) les dissymetries (gauche/droite).

... Je ne comprends pas le coup des dissymétries !? Que je prennes le problème de gauche ou de droite... le résultat est le même.

Exact à quelle précision près ? 1/256 ou le même nombre flottant ?

Je ne travaille ni en entier ni en flottant mais je travaille en réel au sens mathématique

Sinon je t'aurais conseillé un resampling lanzcos4 pour l'agrandissement et lanzcos3 pour le réduction.

Oui merci Lanzcos semble en théorie s'approcher de ce que je cherche

Un sujet intéressant pour avoir la même image après agrandissement/réduction.
http://www.virtualdub.org/blog/pivot/entry.php?id=86

Dommage il n'y a pas d'images ou de formules... juste beaucoup beaucoup de blabla en anglais - un peu trop pour mon niveau

Je ne pense pas que se soit possible avec les ondelettes. Pourquoi, parce que déjà tu commence par calculer les coefficients d'ondelettes qui sont en réels (imaginaires), ensuite tu vas modifier ton image pour l'agrandir, et ensuite tu applique un filtrage d'adaptation.

Je ne connais pas une méthode au monde qui permet de faire ceci et de revenir en arrière. Il y a une perte de donnée et c'est normale.

T'es sûr que l'on parle du même sens !?

Par exemple mon image initale : {a, b}

Je peux l'agrandir en {a, a, b, b}

et puis je peux revenir à {a, b} avec la simple formule :
dst[n] = (src[2.n + 0] + src[2.n + 1]) / 2

Donc il y a bien une méthode qui le permet

Je cherche un agrandissement un peu plus lisse vérifiant toujours le "retour-arrière" Et c'est possible comme tu peux le voir sur ma courbe d'exemple.

[kmaniche]

OK en théorie ça marche. Mais tu voulais le faire en utilisant les ondelettes.

[pseudocode]

... Je ne comprends pas le coup des dissymétries !? Que je prennes le problème de gauche ou de droite... le résultat est le même.

image initiale : {a, b, a} <--- symétrique par rapport au milieu

image agrandie : {_, _, b1, b2, _, _}

- pour conserver la symetrie, il faut que b1=b2, ce qui ne permet pas le lissage
- Si on veut lisser, alors il faut k tel que b1=b-k et b2=b+k -> pas symetrique

[ijk-ref]

OK en théorie ça marche. Mais tu voulais le faire en utilisant les ondelettes.

Je n'ai jamais dit ça. Je veux juste que ça marche avec les conditions exposées.

image initiale : {a, b, a} <--- symétrique par rapport au milieu
image agrandie : {_, _, b1, b2, _, _}
- pour conserver la symetrie, il faut que b1=b2, ce qui ne permet pas le lissage
- Si on veut lisser, alors il faut k tel que b1=b-k et b2=b+k -> pas symetrique

Et alors dans ce cas précis il y a quand même lissage... mais à l'itération suivante.

[Invité]

je travaille en réel au sens mathématique

C'est purement théorique ? OK.

Alors si tu veux upsampler par deux parfaitement une image, il s'agit de se rappeler qu'un "échantillon" représente réellement non pas un dirac mais un sinus cardinal convolué (je sais pas si c'est clair dans ma tête non plus ).

Dans ce cas ca l'algo ressemblerait donc en pseudo-code à :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
pixel(x, y) = somme de tous les [pixel(x + i, y + j) * sin(pi*i) * sin(pi * j) / (pi * i * pi * j) ]

avec i et j qui vont de -infini a + infini.

Ce que font exactement les algorithme genre Lanzcos mais avec un fenetrage pour ne pas calculer une trop grosse intégrale.

Si tu fais ca tu peux faire théoriquement l'aller-retour sans perte de données. En effet l'image 2x plus grande contient 4x plus d'information.

[Invité]

Donc je veux seulement utiliser : p'[i] = (p[2*i+0] + p[2*i+1))/2

Cette formule reste la partie sur la réduction d'image la plus courant en compression par ondelette et c'est la seule que veux utiliser.

Il n'y a pas qu'une sorte d'ondelette utilisée en image...
Le problème que tu a posé peut-être résolu par les ondelettes mais n'y est pas fondamentalement relié.

[ijk-ref]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

pixel(x, y) = somme de tous les [pixel(x + i, y + j) * sin(pi*i) * sin(pi * j) / (pi * i * pi * j) ]

Marrant j'étais arrivé au à un résultat similaire !

En valeur discret j'entends. Puisque ce résultat peut découler de l'inverse d'une matrice cyclique... pouvant être résolue par une transformé de Fourier.

Va falloir que j'en étudie toutes les propriétés.

Il n'y a pas qu'une sorte d'ondelette utilisée en image...
Le problème que tu a posé peut-être résolu par les ondelettes mais n'y est pas fondamentalement relié.

Ah là là ceci je l'ai précisé plusieurs fois :

Cette formule reste la partie sur la réduction d'image la plus courant en compression par ondelette et c'est la seule que veux utiliser.

Possédant seulement cette partie, je souhaite pouvoir en augmenter la résolution...

M'enfiche d'où ça vient et de la technique utilisée je veux juste que ça marche

[Invité]

Une autre manière (sans doute plus rapide qu'une somme exhaustive) est de faire la FFT2D de ton image, de l'agrandir avec des zeros autour afin qu'elle fasse 2x la taille, puis de faire la transformée inverse.

[ijk-ref]

Une autre manière (sans doute plus rapide qu'une somme exhaustive) est de faire la FFT2D de ton image, de l'agrandir avec des zeros autour afin qu'elle fasse 2x la taille, puis de faire la transformée inverse.

Ce serait au final la solution idéale à laquelle j'ai évidement pensé... MAIS... tu négliges LA condition principale de tout mon smilblick : p'[i] = (p[2*i+0] + p[2*i+1))/2

[Invité]

Avec cette réduction, comme tu dis je ne vois rien d'autre possible que
[A B] => [A A B B] (en 1D) ...

[ijk-ref]

Avec cette réduction, comme tu dis je ne vois rien d'autre possible que
[A B] => [A A B B] (en 1D) ...

Il y a en a portant... comme mon exemple proposé au début. Après itération l'échantillonnage en bleu donne la courbe rouge. Et celle-ci vérifie bien ma contrainte initiale.

[pseudocode]

Il y a en a portant... comme mon exemple proposé au début. Après itération l'échantillonnage en bleu donne la courbe rouge. Et celle-ci vérifie bien ma contrainte initiale.

J'en reviens à mon idée du post #6 : fait un agrandissement avec interpolation et force ta contrainte après coup.