Version imprimable
Bonjour à tous.
Je suis entrain de réaliser une procédure qui effectue un zoom sur une image (en niveau de gris).Je traite le cas d’un Zoom (X 2) et voici comment je procède :
Chaque pixel de cette image devient 4 pixels adjacents de même valeur .Je m’explique avec cet exemple :
Si mon l’image est :
13 8
5 10
Elle devient :
13 13 8 8
13 13 8 8
5 5 10 10
5 5 10 10
Que pensez vous de cet algorithme ?est ce véritablement un zoom ?
Sinon quelqu’un pourrait me dire comment procéder ?
Merci d’avance.
ça s'appelle "zoom par duplication de pixel" et ça donne un résultat pas joli joli... :aie:
Sinon il faut faire des interpolations...
Bonjour,Citation:
Envoyé par b_reda31
c'est l'algorithm de base :D. Mais c'est la moin bonne :cry:
Première règle: tu parcoure toujours les pixels de l'image finale et tu recherche son ou ses correspondants dans l'image de départ.
Ensuite le calcul du pixel depend de l'interpolation. Il en existe beaucoup :
1- au plus proche : le tien
2- bilineaire : facile à implémenter et à comprendre
3- spline
...
Il doit y avoir plusieur poste sur ce sujet sur le forum. Tu devrait faire une recherche
C'est plutot un agrandissement. L'image obtenue est 2 fois plus grandes que l'image de départ.Citation:
Envoyé par b_reda31
Généralement on procède à l'envers. On commence par créer l'image finale (X fois plus grande) qui au départ est vide. On parcours ensuite chaque pixel (vide) de cette image finale, on calcule la valeur a partir de l'image de départ.Citation:
Sinon quelqu’un pourrait me dire comment procéder ?
Le calcul peut etre très simple, comme par exemple chercher les coordonnées du pixel dans l'image de départ par une division et un arrondi:
Pixel_Final(X,Y) = Pixel_Original( Arrondi(X/echelle), Arrondi(Y/echelle) )
Edit: 3 posts en 3 minutes ! cool... 8-)
waaw je m'attendais pas à toutes ces réponses et si rapidement!!
Merci à vous tous.
Je viens d'implémenter cette methode de la maniére suivante :Citation:
Envoyé par pseudocode
Pixel_Final(X,Y) = Pixel_Original( Arrondi(X/echelle), Arrondi(Y/echelle) )
h=(hauteur_image_initiale)*echelle
w=(largeur_image_initiale)*echelle
Pour i de 1 à w
faire
pour j de 1 à h
faire
Image_finale[i][j]=image_initiale[i/echelle][j/echelle] ;
finPr
finPr
Ca fonctionne trés bien mais le probléme c'est que ça demande un temps de reponse assez important (Environ 4 secondes pour une image 250X250)
Est ce parce que je calcule TOUTE l'image qui résulte en une seule fois?
Alors deuxième règle : pas de tableau 2D. Faire un tableau 1D et convertir les coordonné 2D en 1D par i*w+j;
troisième règle parcourir ligne par ligne :
tu code en quel langage?Citation:
h=(hauteur_image_initiale)*echelle
w=(largeur_image_initiale)*echelle
Pour i de 1 à h
faire
pour j de 1 à w
faire
Image_finale[i*w+j]=...;
finPr
finPr
Citation:
Envoyé par Mongaulois
tu code en quel langage?
Je travaille avec Borland C++ Builder
Aprés plusieurs tentatives j'ai compris que le problème n'etait pas ici.Citation:
Envoyé par Mongaulois
Alors deuxième règle : pas de tableau 2D. Faire un tableau 1D et convertir les coordonné 2D en 1D par i*w+j;
Voici comment je procéde:
1-) Afficher l'image originale dans un Timage "Timage1"
2-)Charger tous les pixels du Timage dans une matrice de byte "MAT1[i][j]"
3-)Effectuer le traitement : (METTRE LE RESULTAT DANS UNE MATRICE DE BYTE "MAT2[i][j]")
Pour i...
pour j...
MAT2[i][j]=MAT1[i/echelle][j/echelle]
FinPr
FinPr
Jusqu'ici toutes ces Etapes (1,2,3) s'effectuent quasi instantanément.
La lenteur survient lors de l affichage de MAT2[i][j] vers Timage2:
4-)
[I]
Pour i
Pour j
Image2->Canvas->Pixels[i][j]=MAT2[j];
FinPr
FinPr
Quelqu'un aurait une solution?
Tu auras plus de chance d'avoir une réponse sur le forum Delphi.Citation:
Envoyé par b_reda31
(je pense qu'il faut plutot utiliser TBitmap->Scanline)
Merci Pseudocode,en plein dans le mille,il faillait utiliser la fonction ScanLine.
Pour ceux qui sont intéressés voici le lien vers le topic dans le forum C++Builder.