Redimension Bitmap

Version imprimable

26/12/2002, 05h24
Martin

Redimension Bitmap

Bonjour.

Je suis à la recherche d'un peut d'aide sur la redimension d'images.
Présentement je dois traiter l'image sous format 32bpp, donc je place le tout dans un struct RGBQUAD (Contenant 4 BYTE).

J'aimerais pouvoir diminuer ou simplement augmenter la taille d'une image. Si vous pourriez me donner un coup de pouce :hola:

Tu as plusieurs stratégies.
1) Pour diminuer, tu peux décider de couper l'image à la taille voulues, tu en pert donc une parties.
Pour augmenter, tu ajoute du vide autour

2) Tu peux homothétiser l'image:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
 
largeur : largeur de l'image d'origine
hauteur : hauteur de l'image d'origine
image : image d'origine
larg : largeur de l'image d'arrivée
haut : hauteur de l'image d'arrivée
img : image d'arrivée (inti avec une couleur (0,0,0,0) partout)
 
scale(image,largeur,hauteur,img,larg,haut)
   raportx <- largeur/larg (division réelle)
   raporty <- hauteur/haut (division réelle)
   POUR j DE 1 A haut FAIRE
      POUR i DE 1 A larg FAIRE
          setPixel(img,i,j,getPixel(image,i*rapportx,j*rapporty))
      FIN-POUR
   FIN-POUR
FIN-scale
 
 
x et y des réels
 
Couleur getPixel(image,x,y)
   xx=E(x)
   yy=E(y)
   poidsx1 <- 1-x+E(x)
   poidsx2 <- x-E(x)
   poidsy1 <- 1-y+E(y)
   poidsy2 <- y-E(y)
   couleur11 <- getCouleur(image,xx,yy) 
   couleur21 <- getCouleur(image,xx+1,yy) 
   couleur12 <- getCouleur(image,xx,yy+1) 
   couleur22 <- getCouleur(image,xx+1,yy+1)
   alpha <- E(getAlpha(couleur11)*(poidsx1+poidsy1)/2 + getAlpha(couleur21)*(poidsx2+poidsy1)/2 + getAlpha(couleur12)*(poidsx1+poidsy2)/2 + getAlpha(couleur11)*(poidsx2+poidsy2)/2)
   rouge <- E(getRouge(couleur11)*(poidsx1+poidsy1)/2 + getRouge(couleur21)*(poidsx2+poidsy1)/2 + getRouge(couleur12)*(poidsx1+poidsy2)/2 + getRouge(couleur11)*(poidsx2+poidsy2)/2)
   vert <- E(getVert(couleur11)*(poidsx1+poidsy1)/2 + getVert(couleur21)*(poidsx2+poidsy1)/2 + getVert(couleur12)*(poidsx1+poidsy2)/2 + getVert(couleur11)*(poidsx2+poidsy2)/2)
   bleu <- E(getBleu(couleur11)*(poidsx1+poidsy1)/2 + getBleu(couleur21)*(poidsx2+poidsy1)/2 + getBleu(couleur12)*(poidsx1+poidsy2)/2 + getBleu(couleur11)*(poidsx2+poidsy2)/2)
   returon Couleur(alpha,rouge,vert,bleu)
}
Fin-getPixel
 
 
getCouleur(image,x,y)
   SI x<1 ALORS x <- 1
   SI x>largeur ALORS x <- largeur
   SI y<1 ALORS y <- 1
   SI y>hauteur ALORS y <- hauteur
   retourne image.couleur(x,y)
FIN-getCouleur

JHelp

26/12/2002, 23h44
Ol'

Je doute fort que cela donne un resultat correct. D'ailleurs, si cela suffisait, aucun logiciel n'implémenterait dinterpolation bicubique et autres...

Je viens de regarder dans Matlab comment il realise ses interpolations, il complete le signal avec des 0 intercalés entre les valeurs de départ et réalise un filtrage passe bas. Dans les fait, il y a un effet de bord, et il faut donc que tu completes l'image avec des points calculés pour preserver la continuié et la dérivabilité de chaque ligne.

http://www-ccs.ucsd.edu/matlab/toolb...al/interp.html

Le problème est tout aussi complexe pour la réduction en taille de l'image, en effet un filtrage peut faire apparaitre des artefacts visuels...

Il ne faut donc surtout pas filtrer avec un échelon comme proposé

Regarde à la même page la fonction decimate.m

J'espère t'avoir éclairé
Ol'
27/12/2002, 00h12
Martin

Merci beaucoup Ol'
Je vais voir ça tout de suite :)
27/12/2002, 03h28
LeGreg

la gradation est la suivante :
agrandissement d'image:
- nearest point. Pour une coordonnee transformee u2,v2, tu choisis la couleur du pixel correspondant le plus proche en coordonnees correspondantes u1,v1. Effet d'escalier garanti.
- bilineaire. A la place de ne considerer le point le plus proche, tu consideres les 4 pixels les plus proches et tu interpoles lineairement en fonction de la distance en chacun de ces points.
s*(t*c1+(1-t)*c2) + (1-s)*(t*c3+(1-t)*c4)
(les coefficients sont des polynomes de degre 1)
- bicubique. idem, sauf que cette fois tu consideres 16 points les plus proches. et cette fois les coefficients sont des polynomes de degre 3 (d'ou le cubique).
- passage par la transformee de fourier. les coefficients manquant dans les hautes resolutions sont mis a des valeurs arbitraires (zero) et l'image retransformee est un agrandissement (flou) de l'image d'origine. Mais c'est du flou garanti sans artefact.
- techniques exotiques: restauration d'image basee sur la dynamique des fluides
- reseaux de neurones.

Diminution d'image:
- ca fonctionne toujours mieux quand on divise les dimensions par un nombre entier.
- nearest point. Pour une coordonnee transformee u2,v2, tu choisis la couleur du pixel correspondant le plus proche en coordonnees correspondantes u1,v1. Artefacts, moire garanti. Ca fonctionne pour toute sortes de division mais ca marche mieux pour des divisions entieres.
- on prend 4 pixels de l'image d'origine et on en fait 1 seul en faisant la moyenne en RGB ou la mediane (division des dimensions par deux). On itere pour une division par 4 etc..
- on prend 16 pixels de l'image d'origine pour en faire 1 seul (toujours pour une division des dimensions par deux). On utilise des coefficients gaussiens pour calculer la contribution de chaque pixel. On itere pour une division par 4 etc..
- on effectue une transformee de fourier rapide. On elimine les coefficients dans les resolutions superieures a ce qu l'on veut obtenir. Ensuite on fait la transformee inverse pour obtenir une image retrecie quasiment sans artefacts lies a la reduction (attention aux pixels des bords cependant. il vaut parfois mieux travailler avec une image reflechie sur chacun des bords.). Ca fonctionne bien pour toutes sortes de retrecissements mais la transformee de fourier est parfois plus rapide si les dimensions des images sont des puissances de deux.

LeGreg
30/12/2002, 18h42
Ol'

Cela revient au même, la convolution par une matrice est équivalente à un filtrage. Le tout est de bien choisir la taille et le type du filtre de manière à ne pas ajouter d'artefactes sans pour autant rajouter trop de flou...

Ol
30/12/2002, 19h48
LeGreg

Citation:

Envoyé par Ol'

Cela revient au même, la convolution par une matrice est équivalente à un filtrage. Le tout est de bien choisir la taille et le type du filtre de manière à ne pas ajouter d'artefactes sans pour autant rajouter trop de flou...

Qu'est-ce qui revient au meme? j'ai explicite dix techniques differentes?

La convolution discrete est bien l'expression mathematique d'une forme
de filtrage mais ca ne recouvre pas l'ensemble des filtrages possibles.

LeGreg