Bonjour à toutes et à tous,
Dans l'environnement Windows (je ne sais pas sous Linux et autres), des
logiciels permettent de charger des images et de les visualiser à
différents taux de zoom. La plupart de ces logiciels prennent un
quantité de mémoire égale au nombre de pixels de l'image multiplié par
le nombre d'octets par pixel. Il n'en prennent pas plus même si on
visualise ces images avec un taux de zoom supérieur à 100 %. La
visualisation se faisant aisément par scrolling.
En Java, je n'ai pas trouvé de classe ou de méthode permettant d'en
faire autant. Les méthodes que j'ai trouvées consomment de la mémoire à
hauteur du taux de zoom. Par exemple, pour une image de 8 Mpixels à 3
octets par pixel, la mémoire nécessaire à son chargement est 8 x 3 = 24
Mo. Si je fais un zoom x4 linéaire, la mémoire consommée est alors 24 x
4 x 4 = 384 Mo !!!
J'ai bien essayé la forme suivante :
drawImage(Image img, int dx1, int dy1, int dx2, int dy2, int sx1, int
sy1, int sx2, int sy2, ImageObserver observer)
en la plaçant dans un écouteur des mouvements des ascenseurs du
JScrollPane. J'ai obtenu des quantités de trucs bizarres, mais rien de
cohérent. Je ne m'en sort pas.
Je pense que j'ai dû rater quelque chose. En bref, existe-t-il en Java
des classes ou méthodes permettant d'y arriver.
Si vous avez des exemples.
Merci de votre aide.
Pierre.
Bonjour à toutes et à tous,
Dans l'environnement Windows (je ne sais pas sous Linux et autres), des
logiciels permettent de charger des images et de les visualiser à
différents taux de zoom. La plupart de ces logiciels prennent un
quantité de mémoire égale au nombre de pixels de l'image multiplié par
le nombre d'octets par pixel. Il n'en prennent pas plus même si on
visualise ces images avec un taux de zoom supérieur à 100 %. La
visualisation se faisant aisément par scrolling.
En Java, je n'ai pas trouvé de classe ou de méthode permettant d'en
faire autant. Les méthodes que j'ai trouvées consomment de la mémoire à
hauteur du taux de zoom. Par exemple, pour une image de 8 Mpixels à 3
octets par pixel, la mémoire nécessaire à son chargement est 8 x 3 = 24
Mo. Si je fais un zoom x4 linéaire, la mémoire consommée est alors 24 x
4 x 4 = 384 Mo !!!
J'ai bien essayé la forme suivante :
drawImage(Image img, int dx1, int dy1, int dx2, int dy2, int sx1, int
sy1, int sx2, int sy2, ImageObserver observer)
en la plaçant dans un écouteur des mouvements des ascenseurs du
JScrollPane. J'ai obtenu des quantités de trucs bizarres, mais rien de
cohérent. Je ne m'en sort pas.
Je pense que j'ai dû rater quelque chose. En bref, existe-t-il en Java
des classes ou méthodes permettant d'y arriver.
Si vous avez des exemples.
Merci de votre aide.
Pierre.
Bonjour à toutes et à tous,
Dans l'environnement Windows (je ne sais pas sous Linux et autres), des
logiciels permettent de charger des images et de les visualiser à
différents taux de zoom. La plupart de ces logiciels prennent un
quantité de mémoire égale au nombre de pixels de l'image multiplié par
le nombre d'octets par pixel. Il n'en prennent pas plus même si on
visualise ces images avec un taux de zoom supérieur à 100 %. La
visualisation se faisant aisément par scrolling.
En Java, je n'ai pas trouvé de classe ou de méthode permettant d'en
faire autant. Les méthodes que j'ai trouvées consomment de la mémoire à
hauteur du taux de zoom. Par exemple, pour une image de 8 Mpixels à 3
octets par pixel, la mémoire nécessaire à son chargement est 8 x 3 = 24
Mo. Si je fais un zoom x4 linéaire, la mémoire consommée est alors 24 x
4 x 4 = 384 Mo !!!
J'ai bien essayé la forme suivante :
drawImage(Image img, int dx1, int dy1, int dx2, int dy2, int sx1, int
sy1, int sx2, int sy2, ImageObserver observer)
en la plaçant dans un écouteur des mouvements des ascenseurs du
JScrollPane. J'ai obtenu des quantités de trucs bizarres, mais rien de
cohérent. Je ne m'en sort pas.
Je pense que j'ai dû rater quelque chose. En bref, existe-t-il en Java
des classes ou méthodes permettant d'y arriver.
Si vous avez des exemples.
Merci de votre aide.
Pierre.
Bonjour à toutes et à tous,
Dans l'environnement Windows (je ne sais pas sous Linux et autres),
des logiciels permettent de charger des images et de les visualiser à
différents taux de zoom. La plupart de ces logiciels prennent un
quantité de mémoire égale au nombre de pixels de l'image multiplié par
le nombre d'octets par pixel. Il n'en prennent pas plus même si on
visualise ces images avec un taux de zoom supérieur à 100 %. La
visualisation se faisant aisément par scrolling.
En Java, je n'ai pas trouvé de classe ou de méthode permettant d'en
faire autant. Les méthodes que j'ai trouvées consomment de la mémoire
à hauteur du taux de zoom. Par exemple, pour une image de 8 Mpixels à
3 octets par pixel, la mémoire nécessaire à son chargement est 8 x 3 =
24 Mo. Si je fais un zoom x4 linéaire, la mémoire consommée est alors
24 x 4 x 4 = 384 Mo !!!
J'ai bien essayé la forme suivante :
drawImage(Image img, int dx1, int dy1, int dx2, int dy2, int sx1, int
sy1, int sx2, int sy2, ImageObserver observer)
en la plaçant dans un écouteur des mouvements des ascenseurs du
JScrollPane. J'ai obtenu des quantités de trucs bizarres, mais rien de
cohérent. Je ne m'en sort pas.
Je pense que j'ai dû rater quelque chose. En bref, existe-t-il en Java
des classes ou méthodes permettant d'y arriver.
Si vous avez des exemples.
Merci de votre aide.
Pierre.
Bonjour,
Version longue :
...
Version courte :
http://weblogs.java.net/blog/gfx/archive/2005/09/zoom_pictures_w.html
Bonne lecture ... et si ce n'est pas suffisant, répond à la version
longue ;)
Bonjour à toutes et à tous,
Dans l'environnement Windows (je ne sais pas sous Linux et autres),
des logiciels permettent de charger des images et de les visualiser à
différents taux de zoom. La plupart de ces logiciels prennent un
quantité de mémoire égale au nombre de pixels de l'image multiplié par
le nombre d'octets par pixel. Il n'en prennent pas plus même si on
visualise ces images avec un taux de zoom supérieur à 100 %. La
visualisation se faisant aisément par scrolling.
En Java, je n'ai pas trouvé de classe ou de méthode permettant d'en
faire autant. Les méthodes que j'ai trouvées consomment de la mémoire
à hauteur du taux de zoom. Par exemple, pour une image de 8 Mpixels à
3 octets par pixel, la mémoire nécessaire à son chargement est 8 x 3 =
24 Mo. Si je fais un zoom x4 linéaire, la mémoire consommée est alors
24 x 4 x 4 = 384 Mo !!!
J'ai bien essayé la forme suivante :
drawImage(Image img, int dx1, int dy1, int dx2, int dy2, int sx1, int
sy1, int sx2, int sy2, ImageObserver observer)
en la plaçant dans un écouteur des mouvements des ascenseurs du
JScrollPane. J'ai obtenu des quantités de trucs bizarres, mais rien de
cohérent. Je ne m'en sort pas.
Je pense que j'ai dû rater quelque chose. En bref, existe-t-il en Java
des classes ou méthodes permettant d'y arriver.
Si vous avez des exemples.
Merci de votre aide.
Pierre.
Bonjour,
Version longue :
...
Version courte :
http://weblogs.java.net/blog/gfx/archive/2005/09/zoom_pictures_w.html
Bonne lecture ... et si ce n'est pas suffisant, répond à la version
longue ;)
Bonjour à toutes et à tous,
Dans l'environnement Windows (je ne sais pas sous Linux et autres),
des logiciels permettent de charger des images et de les visualiser à
différents taux de zoom. La plupart de ces logiciels prennent un
quantité de mémoire égale au nombre de pixels de l'image multiplié par
le nombre d'octets par pixel. Il n'en prennent pas plus même si on
visualise ces images avec un taux de zoom supérieur à 100 %. La
visualisation se faisant aisément par scrolling.
En Java, je n'ai pas trouvé de classe ou de méthode permettant d'en
faire autant. Les méthodes que j'ai trouvées consomment de la mémoire
à hauteur du taux de zoom. Par exemple, pour une image de 8 Mpixels à
3 octets par pixel, la mémoire nécessaire à son chargement est 8 x 3 =
24 Mo. Si je fais un zoom x4 linéaire, la mémoire consommée est alors
24 x 4 x 4 = 384 Mo !!!
J'ai bien essayé la forme suivante :
drawImage(Image img, int dx1, int dy1, int dx2, int dy2, int sx1, int
sy1, int sx2, int sy2, ImageObserver observer)
en la plaçant dans un écouteur des mouvements des ascenseurs du
JScrollPane. J'ai obtenu des quantités de trucs bizarres, mais rien de
cohérent. Je ne m'en sort pas.
Je pense que j'ai dû rater quelque chose. En bref, existe-t-il en Java
des classes ou méthodes permettant d'y arriver.
Si vous avez des exemples.
Merci de votre aide.
Pierre.
Bonjour,
Version longue :
...
Version courte :
http://weblogs.java.net/blog/gfx/archive/2005/09/zoom_pictures_w.html
Bonne lecture ... et si ce n'est pas suffisant, répond à la version
longue ;)
En Java, je n'ai pas trouvé de classe ou de méthode permettant d'en faire autant. Les méthodes que
j'ai trouvées consomment de la mémoire à hauteur du taux de zoom. Par exemple, pour une image de 8
Mpixels à 3 octets par pixel, la mémoire nécessaire à son chargement est 8 x 3 = 24 Mo. Si je fais
un zoom x4 linéaire, la mémoire consommée est alors 24 x 4 x 4 = 384 Mo !!!
J'ai bien essayé la forme suivante :
drawImage(Image img, int dx1, int dy1, int dx2, int dy2, int sx1, int sy1, int sx2, int sy2,
ImageObserver observer)
en la plaçant dans un écouteur des mouvements des ascenseurs du JScrollPane. J'ai obtenu des
quantités de trucs bizarres, mais rien de cohérent. Je ne m'en sort pas.
En Java, je n'ai pas trouvé de classe ou de méthode permettant d'en faire autant. Les méthodes que
j'ai trouvées consomment de la mémoire à hauteur du taux de zoom. Par exemple, pour une image de 8
Mpixels à 3 octets par pixel, la mémoire nécessaire à son chargement est 8 x 3 = 24 Mo. Si je fais
un zoom x4 linéaire, la mémoire consommée est alors 24 x 4 x 4 = 384 Mo !!!
J'ai bien essayé la forme suivante :
drawImage(Image img, int dx1, int dy1, int dx2, int dy2, int sx1, int sy1, int sx2, int sy2,
ImageObserver observer)
en la plaçant dans un écouteur des mouvements des ascenseurs du JScrollPane. J'ai obtenu des
quantités de trucs bizarres, mais rien de cohérent. Je ne m'en sort pas.
En Java, je n'ai pas trouvé de classe ou de méthode permettant d'en faire autant. Les méthodes que
j'ai trouvées consomment de la mémoire à hauteur du taux de zoom. Par exemple, pour une image de 8
Mpixels à 3 octets par pixel, la mémoire nécessaire à son chargement est 8 x 3 = 24 Mo. Si je fais
un zoom x4 linéaire, la mémoire consommée est alors 24 x 4 x 4 = 384 Mo !!!
J'ai bien essayé la forme suivante :
drawImage(Image img, int dx1, int dy1, int dx2, int dy2, int sx1, int sy1, int sx2, int sy2,
ImageObserver observer)
en la plaçant dans un écouteur des mouvements des ascenseurs du JScrollPane. J'ai obtenu des
quantités de trucs bizarres, mais rien de cohérent. Je ne m'en sort pas.
"ChP" :En Java, je n'ai pas trouvé de classe ou de méthode permettant d'en faire autant. Les méthodes que
j'ai trouvées consomment de la mémoire à hauteur du taux de zoom. Par exemple, pour une image de 8
Mpixels à 3 octets par pixel, la mémoire nécessaire à son chargement est 8 x 3 = 24 Mo. Si je fais
un zoom x4 linéaire, la mémoire consommée est alors 24 x 4 x 4 = 384 Mo !!!
J'utilise encore souvent la classe MemoryImageSource, qui permet de
manipuler directement les pixels dans un array de int (pratique pour les
applets : elle existe dans toutes les versions de java, même les plus
anciennes). Pour permettre des rafraichissements de l'image, mettre
setAnimated(true). Puis tu mets ce que tu veux dans ce tableau, et
quand ton image à afficher est prête, tu l'envoie à l'écran via la méthode
newPixels(). Le rendu lui-même est rapide (le reste dépend des
algorithmes que tu utilises pour générer ton tableau de pixels).
Pour ton problème, tu peux par exemple extraire le tableau de
pixels de ton image originale, créer un autre tableau de pixels de
la taille de l'image à afficher, et, selon ce que fait ton programme,
transférer les pixels d'un tableau à l'autre ou peindre sur ton
tableau-cible. Tu ne boufferas alors pas plus de mémoire que
celle occupée par ces deux tableaux, quelle que soit la taille de
ton image-source et de ton image-cible.
Pour un zoom, tu peux alors choisir l'algorithme qui te convient
le mieux : simple (copie du pixel courant sur plusieurs lignes et
colonnes), interpolation linéaire (tu génères des gradients de couleurs
sur les pixels-cible, en fonction de la valeur des pixels-source),
ou tu peux même t'offrir un zoom fractal qui bluffera tout le monde,
en générant les pixels manquants via une fonction gaussienne
(si l'image visible n'est pas trop grande : ça bouffe du CPU !).J'ai bien essayé la forme suivante :
drawImage(Image img, int dx1, int dy1, int dx2, int dy2, int sx1, int sy1, int sx2, int sy2,
ImageObserver observer)
en la plaçant dans un écouteur des mouvements des ascenseurs du JScrollPane. J'ai obtenu des
quantités de trucs bizarres, mais rien de cohérent. Je ne m'en sort pas.
Tu peux fabriquer un "faux" scrollpane : tu mets ton composant
qui affiche l'image-cible au centre, et tu l'entoures de 2 (ou 4)
scrollbar. Dans le composant central, tu crées une variable
proportion. En fonction de la puissance de zoom du moment et
des dimensions de ton image-source, tu fais varier cette
variable. Et un listener sur tes scrollbars envoie un % de
déplacement vers la droite et vers le bas. Tu as alors tout
pour savoir par quel pixel commencer le transfert du
tableau-souce au tableau-cible.
Michel
Le but de mon programme étant de faire du traiteùent d'image, les
"ChP" :
En Java, je n'ai pas trouvé de classe ou de méthode permettant d'en faire autant. Les méthodes que
j'ai trouvées consomment de la mémoire à hauteur du taux de zoom. Par exemple, pour une image de 8
Mpixels à 3 octets par pixel, la mémoire nécessaire à son chargement est 8 x 3 = 24 Mo. Si je fais
un zoom x4 linéaire, la mémoire consommée est alors 24 x 4 x 4 = 384 Mo !!!
J'utilise encore souvent la classe MemoryImageSource, qui permet de
manipuler directement les pixels dans un array de int (pratique pour les
applets : elle existe dans toutes les versions de java, même les plus
anciennes). Pour permettre des rafraichissements de l'image, mettre
setAnimated(true). Puis tu mets ce que tu veux dans ce tableau, et
quand ton image à afficher est prête, tu l'envoie à l'écran via la méthode
newPixels(). Le rendu lui-même est rapide (le reste dépend des
algorithmes que tu utilises pour générer ton tableau de pixels).
Pour ton problème, tu peux par exemple extraire le tableau de
pixels de ton image originale, créer un autre tableau de pixels de
la taille de l'image à afficher, et, selon ce que fait ton programme,
transférer les pixels d'un tableau à l'autre ou peindre sur ton
tableau-cible. Tu ne boufferas alors pas plus de mémoire que
celle occupée par ces deux tableaux, quelle que soit la taille de
ton image-source et de ton image-cible.
Pour un zoom, tu peux alors choisir l'algorithme qui te convient
le mieux : simple (copie du pixel courant sur plusieurs lignes et
colonnes), interpolation linéaire (tu génères des gradients de couleurs
sur les pixels-cible, en fonction de la valeur des pixels-source),
ou tu peux même t'offrir un zoom fractal qui bluffera tout le monde,
en générant les pixels manquants via une fonction gaussienne
(si l'image visible n'est pas trop grande : ça bouffe du CPU !).
J'ai bien essayé la forme suivante :
drawImage(Image img, int dx1, int dy1, int dx2, int dy2, int sx1, int sy1, int sx2, int sy2,
ImageObserver observer)
en la plaçant dans un écouteur des mouvements des ascenseurs du JScrollPane. J'ai obtenu des
quantités de trucs bizarres, mais rien de cohérent. Je ne m'en sort pas.
Tu peux fabriquer un "faux" scrollpane : tu mets ton composant
qui affiche l'image-cible au centre, et tu l'entoures de 2 (ou 4)
scrollbar. Dans le composant central, tu crées une variable
proportion. En fonction de la puissance de zoom du moment et
des dimensions de ton image-source, tu fais varier cette
variable. Et un listener sur tes scrollbars envoie un % de
déplacement vers la droite et vers le bas. Tu as alors tout
pour savoir par quel pixel commencer le transfert du
tableau-souce au tableau-cible.
Michel
Le but de mon programme étant de faire du traiteùent d'image, les
"ChP" :En Java, je n'ai pas trouvé de classe ou de méthode permettant d'en faire autant. Les méthodes que
j'ai trouvées consomment de la mémoire à hauteur du taux de zoom. Par exemple, pour une image de 8
Mpixels à 3 octets par pixel, la mémoire nécessaire à son chargement est 8 x 3 = 24 Mo. Si je fais
un zoom x4 linéaire, la mémoire consommée est alors 24 x 4 x 4 = 384 Mo !!!
J'utilise encore souvent la classe MemoryImageSource, qui permet de
manipuler directement les pixels dans un array de int (pratique pour les
applets : elle existe dans toutes les versions de java, même les plus
anciennes). Pour permettre des rafraichissements de l'image, mettre
setAnimated(true). Puis tu mets ce que tu veux dans ce tableau, et
quand ton image à afficher est prête, tu l'envoie à l'écran via la méthode
newPixels(). Le rendu lui-même est rapide (le reste dépend des
algorithmes que tu utilises pour générer ton tableau de pixels).
Pour ton problème, tu peux par exemple extraire le tableau de
pixels de ton image originale, créer un autre tableau de pixels de
la taille de l'image à afficher, et, selon ce que fait ton programme,
transférer les pixels d'un tableau à l'autre ou peindre sur ton
tableau-cible. Tu ne boufferas alors pas plus de mémoire que
celle occupée par ces deux tableaux, quelle que soit la taille de
ton image-source et de ton image-cible.
Pour un zoom, tu peux alors choisir l'algorithme qui te convient
le mieux : simple (copie du pixel courant sur plusieurs lignes et
colonnes), interpolation linéaire (tu génères des gradients de couleurs
sur les pixels-cible, en fonction de la valeur des pixels-source),
ou tu peux même t'offrir un zoom fractal qui bluffera tout le monde,
en générant les pixels manquants via une fonction gaussienne
(si l'image visible n'est pas trop grande : ça bouffe du CPU !).J'ai bien essayé la forme suivante :
drawImage(Image img, int dx1, int dy1, int dx2, int dy2, int sx1, int sy1, int sx2, int sy2,
ImageObserver observer)
en la plaçant dans un écouteur des mouvements des ascenseurs du JScrollPane. J'ai obtenu des
quantités de trucs bizarres, mais rien de cohérent. Je ne m'en sort pas.
Tu peux fabriquer un "faux" scrollpane : tu mets ton composant
qui affiche l'image-cible au centre, et tu l'entoures de 2 (ou 4)
scrollbar. Dans le composant central, tu crées une variable
proportion. En fonction de la puissance de zoom du moment et
des dimensions de ton image-source, tu fais varier cette
variable. Et un listener sur tes scrollbars envoie un % de
déplacement vers la droite et vers le bas. Tu as alors tout
pour savoir par quel pixel commencer le transfert du
tableau-souce au tableau-cible.
Michel
Le but de mon programme étant de faire du traiteùent d'image, les
"ChP" :En Java, je n'ai pas trouvé de classe ou de méthode permettant d'en
faire autant. Les méthodes que j'ai trouvées consomment de la mémoire à
hauteur du taux de zoom. Par exemple, pour une image de 8 Mpixels à 3
octets par pixel, la mémoire nécessaire à son chargement est 8 x 3 = 24
Mo. Si je fais un zoom x4 linéaire, la mémoire consommée est alors 24 x
4 x 4 = 384 Mo !!!
J'utilise encore souvent la classe MemoryImageSource, qui permet de
manipuler directement les pixels dans un array de int (pratique pour les
applets : elle existe dans toutes les versions de java, même les plus
anciennes). Pour permettre des rafraichissements de l'image, mettre
setAnimated(true). Puis tu mets ce que tu veux dans ce tableau, et
quand ton image à afficher est prête, tu l'envoie à l'écran via la
méthode
newPixels(). Le rendu lui-même est rapide (le reste dépend des
algorithmes que tu utilises pour générer ton tableau de pixels).
Pour ton problème, tu peux par exemple extraire le tableau de
pixels de ton image originale, créer un autre tableau de pixels de
la taille de l'image à afficher, et, selon ce que fait ton programme,
transférer les pixels d'un tableau à l'autre ou peindre sur ton
tableau-cible. Tu ne boufferas alors pas plus de mémoire que
celle occupée par ces deux tableaux, quelle que soit la taille de
ton image-source et de ton image-cible.
Pour un zoom, tu peux alors choisir l'algorithme qui te convient
le mieux : simple (copie du pixel courant sur plusieurs lignes et
colonnes), interpolation linéaire (tu génères des gradients de couleurs
sur les pixels-cible, en fonction de la valeur des pixels-source),
ou tu peux même t'offrir un zoom fractal qui bluffera tout le monde,
en générant les pixels manquants via une fonction gaussienne
(si l'image visible n'est pas trop grande : ça bouffe du CPU !).J'ai bien essayé la forme suivante :
drawImage(Image img, int dx1, int dy1, int dx2, int dy2, int sx1, int
sy1, int sx2, int sy2, ImageObserver observer)
en la plaçant dans un écouteur des mouvements des ascenseurs du
JScrollPane. J'ai obtenu des quantités de trucs bizarres, mais rien de
cohérent. Je ne m'en sort pas.
Tu peux fabriquer un "faux" scrollpane : tu mets ton composant
qui affiche l'image-cible au centre, et tu l'entoures de 2 (ou 4)
scrollbar. Dans le composant central, tu crées une variable
proportion. En fonction de la puissance de zoom du moment et
des dimensions de ton image-source, tu fais varier cette
variable. Et un listener sur tes scrollbars envoie un % de
déplacement vers la droite et vers le bas. Tu as alors tout
pour savoir par quel pixel commencer le transfert du
tableau-souce au tableau-cible.
Michel
Le but de mon programme étant de faire du traiteùent d'image, les
solutions que tu me proposes vont dans le bon sens.
Je t'en remercie et je vais étudier ça de plus près.
Cordialement.
Pierre.
"ChP" :
En Java, je n'ai pas trouvé de classe ou de méthode permettant d'en
faire autant. Les méthodes que j'ai trouvées consomment de la mémoire à
hauteur du taux de zoom. Par exemple, pour une image de 8 Mpixels à 3
octets par pixel, la mémoire nécessaire à son chargement est 8 x 3 = 24
Mo. Si je fais un zoom x4 linéaire, la mémoire consommée est alors 24 x
4 x 4 = 384 Mo !!!
J'utilise encore souvent la classe MemoryImageSource, qui permet de
manipuler directement les pixels dans un array de int (pratique pour les
applets : elle existe dans toutes les versions de java, même les plus
anciennes). Pour permettre des rafraichissements de l'image, mettre
setAnimated(true). Puis tu mets ce que tu veux dans ce tableau, et
quand ton image à afficher est prête, tu l'envoie à l'écran via la
méthode
newPixels(). Le rendu lui-même est rapide (le reste dépend des
algorithmes que tu utilises pour générer ton tableau de pixels).
Pour ton problème, tu peux par exemple extraire le tableau de
pixels de ton image originale, créer un autre tableau de pixels de
la taille de l'image à afficher, et, selon ce que fait ton programme,
transférer les pixels d'un tableau à l'autre ou peindre sur ton
tableau-cible. Tu ne boufferas alors pas plus de mémoire que
celle occupée par ces deux tableaux, quelle que soit la taille de
ton image-source et de ton image-cible.
Pour un zoom, tu peux alors choisir l'algorithme qui te convient
le mieux : simple (copie du pixel courant sur plusieurs lignes et
colonnes), interpolation linéaire (tu génères des gradients de couleurs
sur les pixels-cible, en fonction de la valeur des pixels-source),
ou tu peux même t'offrir un zoom fractal qui bluffera tout le monde,
en générant les pixels manquants via une fonction gaussienne
(si l'image visible n'est pas trop grande : ça bouffe du CPU !).
J'ai bien essayé la forme suivante :
drawImage(Image img, int dx1, int dy1, int dx2, int dy2, int sx1, int
sy1, int sx2, int sy2, ImageObserver observer)
en la plaçant dans un écouteur des mouvements des ascenseurs du
JScrollPane. J'ai obtenu des quantités de trucs bizarres, mais rien de
cohérent. Je ne m'en sort pas.
Tu peux fabriquer un "faux" scrollpane : tu mets ton composant
qui affiche l'image-cible au centre, et tu l'entoures de 2 (ou 4)
scrollbar. Dans le composant central, tu crées une variable
proportion. En fonction de la puissance de zoom du moment et
des dimensions de ton image-source, tu fais varier cette
variable. Et un listener sur tes scrollbars envoie un % de
déplacement vers la droite et vers le bas. Tu as alors tout
pour savoir par quel pixel commencer le transfert du
tableau-souce au tableau-cible.
Michel
Le but de mon programme étant de faire du traiteùent d'image, les
solutions que tu me proposes vont dans le bon sens.
Je t'en remercie et je vais étudier ça de plus près.
Cordialement.
Pierre.
"ChP" :En Java, je n'ai pas trouvé de classe ou de méthode permettant d'en
faire autant. Les méthodes que j'ai trouvées consomment de la mémoire à
hauteur du taux de zoom. Par exemple, pour une image de 8 Mpixels à 3
octets par pixel, la mémoire nécessaire à son chargement est 8 x 3 = 24
Mo. Si je fais un zoom x4 linéaire, la mémoire consommée est alors 24 x
4 x 4 = 384 Mo !!!
J'utilise encore souvent la classe MemoryImageSource, qui permet de
manipuler directement les pixels dans un array de int (pratique pour les
applets : elle existe dans toutes les versions de java, même les plus
anciennes). Pour permettre des rafraichissements de l'image, mettre
setAnimated(true). Puis tu mets ce que tu veux dans ce tableau, et
quand ton image à afficher est prête, tu l'envoie à l'écran via la
méthode
newPixels(). Le rendu lui-même est rapide (le reste dépend des
algorithmes que tu utilises pour générer ton tableau de pixels).
Pour ton problème, tu peux par exemple extraire le tableau de
pixels de ton image originale, créer un autre tableau de pixels de
la taille de l'image à afficher, et, selon ce que fait ton programme,
transférer les pixels d'un tableau à l'autre ou peindre sur ton
tableau-cible. Tu ne boufferas alors pas plus de mémoire que
celle occupée par ces deux tableaux, quelle que soit la taille de
ton image-source et de ton image-cible.
Pour un zoom, tu peux alors choisir l'algorithme qui te convient
le mieux : simple (copie du pixel courant sur plusieurs lignes et
colonnes), interpolation linéaire (tu génères des gradients de couleurs
sur les pixels-cible, en fonction de la valeur des pixels-source),
ou tu peux même t'offrir un zoom fractal qui bluffera tout le monde,
en générant les pixels manquants via une fonction gaussienne
(si l'image visible n'est pas trop grande : ça bouffe du CPU !).J'ai bien essayé la forme suivante :
drawImage(Image img, int dx1, int dy1, int dx2, int dy2, int sx1, int
sy1, int sx2, int sy2, ImageObserver observer)
en la plaçant dans un écouteur des mouvements des ascenseurs du
JScrollPane. J'ai obtenu des quantités de trucs bizarres, mais rien de
cohérent. Je ne m'en sort pas.
Tu peux fabriquer un "faux" scrollpane : tu mets ton composant
qui affiche l'image-cible au centre, et tu l'entoures de 2 (ou 4)
scrollbar. Dans le composant central, tu crées une variable
proportion. En fonction de la puissance de zoom du moment et
des dimensions de ton image-source, tu fais varier cette
variable. Et un listener sur tes scrollbars envoie un % de
déplacement vers la droite et vers le bas. Tu as alors tout
pour savoir par quel pixel commencer le transfert du
tableau-souce au tableau-cible.
Michel
Le but de mon programme étant de faire du traiteùent d'image, les
solutions que tu me proposes vont dans le bon sens.
Je t'en remercie et je vais étudier ça de plus près.
Cordialement.
Pierre.
Je ne comprends pas bien le problème. Il est clair que pour bénéficier de la
gestion automatique des scrollbars, il faut une image de la taille réelle x
facteur de zoom. En revanche, avec la gestion manuelle des scrollbars, il
suffit d'afficher l'image réelle dans la zone visible en controllant le zoom
avec les paramètres de la méthode drawImage (par exemple AffineTransform).
L'interpolation est controlée par les rendering hints (cf classe
RenderingHints) du Graphic2D.
En clair, on stocke l'image avec sa résolution d'origine, et en paint
dynamiquement la zone sélectionnée par l'état zoom/scrollbars dans la
fenêtre désirée. En plus, si swing est assez intelligent, le zoom est
accéléré matériellement et la performance devrait être bonne (mais bon, je
ne parierais pas là-dessus^^).
Apparemment, il est possible de bénéficier de la gestion automatique des
Je ne comprends pas bien le problème. Il est clair que pour bénéficier de la
gestion automatique des scrollbars, il faut une image de la taille réelle x
facteur de zoom. En revanche, avec la gestion manuelle des scrollbars, il
suffit d'afficher l'image réelle dans la zone visible en controllant le zoom
avec les paramètres de la méthode drawImage (par exemple AffineTransform).
L'interpolation est controlée par les rendering hints (cf classe
RenderingHints) du Graphic2D.
En clair, on stocke l'image avec sa résolution d'origine, et en paint
dynamiquement la zone sélectionnée par l'état zoom/scrollbars dans la
fenêtre désirée. En plus, si swing est assez intelligent, le zoom est
accéléré matériellement et la performance devrait être bonne (mais bon, je
ne parierais pas là-dessus^^).
Apparemment, il est possible de bénéficier de la gestion automatique des
Je ne comprends pas bien le problème. Il est clair que pour bénéficier de la
gestion automatique des scrollbars, il faut une image de la taille réelle x
facteur de zoom. En revanche, avec la gestion manuelle des scrollbars, il
suffit d'afficher l'image réelle dans la zone visible en controllant le zoom
avec les paramètres de la méthode drawImage (par exemple AffineTransform).
L'interpolation est controlée par les rendering hints (cf classe
RenderingHints) du Graphic2D.
En clair, on stocke l'image avec sa résolution d'origine, et en paint
dynamiquement la zone sélectionnée par l'état zoom/scrollbars dans la
fenêtre désirée. En plus, si swing est assez intelligent, le zoom est
accéléré matériellement et la performance devrait être bonne (mais bon, je
ne parierais pas là-dessus^^).
Apparemment, il est possible de bénéficier de la gestion automatique des