digiSimul/Resolution.py at master · lydianish/digiSimul · GitHub

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
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
from PIL import Image


#Fonctions qui vont permettrent de calculer la taille en pixels, ou en pouce ou la resolution d'une image donnee
#L'utilite de ces fonctions est qu'elles vont permettrent de calculer la nouvelle taille à donner en paramètres à rezize pour le changement de resolution

#------------------------------------------------------------------------
#Methode qui calcule la taille(largeur * hauteur) en pixels d'une image
#Donées :
#   - ro : la resolution de l'image
#   - d = (ld, hd) :dimensions physiques en pouces de l'image avec :
#           - ld = largeur en pouces
#           - hd = hauteur en pouces
#Remmarque : d est un tuple
#Containtes : ld et hd doivent etre exprimés en pouces

#Code :
def taille_en_pixels(ro, d):
    ld, hd = d
    lt = (int)(ld * ro)
    ht = (int)(hd * ro)
    return (lt,ht)

#Test de la methode :
#print(taille_en_pixels(500, (30,40)))

#------------------------------------------------------------------------
#Methode qui calcule la taille(largeur * hauteur) en pouce d'une image
#Donées :
#   - ro : la resolution de l'image
#   - t = (lt, ht) :dimensions en pixels (definition) de l'image avec :
#           - lt = largeur en pixels
#           - ht = hauteur en pixels
#Remmarque : t est un tuple
#Containtes : lt et ht doivent etre exprimés en pixels

#Code :
def taille_en_pouces(ro, t):
    lt, ht = t
    ld = lt / ro
    hd = ht / ro
    return (ld,hd)

#Test de la methode :
#1
#print(taille_en_pouces(500, (15000,20000)))

#2
#ro = 500
#rc = 400
#cheminf = "/Users/docteur/Desktop/L3/S2/Stage_Applicatif/Test_Photos/105_2.tif"
#i = Image.open(cheminf)
#d = taille_en_pouces(ro, i.size)
#print(d)
#t = taille_en_pixels(rc, d)
#print(t)
#i2 = (i.copy()).resize(t, Image.ANTIALIAS)
#i.show()
#i2.show()

#------------------------------------------------------------------------
#Methode qui calcule la resolution d'une image
#Donées :
#   - t = (lt, ht) :dimensions en pixels (definition) de l'image avec :
#           - lt = largeur en pixels
#           - ht = hauteur en pixels
#   - d = (ld, hd) :dimensions physiques en pouces de l'image avec :
#           - ld = largeur en pouces
#           - hd = hauteur en pouces
#Remmarque : t et d sont des tuples
#Containtes :   - lt et ht doivent etre exprimés en pixels
#               - ld et hd doivent etre exprimés en pouces

#Code :
def resolution(t, d):
    lt, ht = t
    ld, hd = d
    ro = lt//ld
    return ro

#Test de la methode :
#print(resolution((15000,20000), (30,40)))


# ----------------------------------------------------------------------------
# Methode qui sous-echantillonne l'image dont le chemin est donne en parametre
# Renvoie une copie de l'image sous-echantillonnee (avec une resolution rc)
# Données :
#       - ro : resolutionOriginale (c'est la resolution de l'image originale dont le chemin est donne en parametre)
#       - rc : resolutionCapteur (c'est la resolution finale)
#       - chemin : chemin vers l'image a re-echantillonner
#Contrainte : ro > rc

#Code :
def sous_echantillonnage(ro, rc, chemin):
    if(ro <= rc):
        print("Erreur de sous_echantillonnage, ro doit etre strictement plus grand que rc")
        return
    else:
        # print("Vous etes dans Sous-echantillonnage")
        imageOriginale = Image.open(chemin)
        imOCopie = imageOriginale.copy()
        # print("taille initiale", imOCopie.size)
        #Calcul des dimensions de l'image
        d = taille_en_pouces(ro, imOCopie.size)
        # print("dimension", d)
        #Calcul de la nouvelle de l'image pour la resolution rc
        t = taille_en_pixels(rc, d)
        # print("nouvelle taille", t)
        #sous-echantillonnage
        im = (imOCopie.copy()).resize(t, Image.ANTIALIAS)
        return im

# Test de la methode :
#ro = 500
#rc = 200
#cheminf = "/Users/docteur/Desktop/L3/S2/Stage_Applicatif/Test_Photos/105_2.tif"
#i = Image.open(cheminf)
#im1 = sous_echantillonnage(ro, rc, cheminf)
#i.show()
#im1.show()


# ----------------------------------------------------------------------------
# Methode qui sur-echantillonne l'image dont le chemin est donne en parametre
# Renvoie une copie de l'image sur-echantillonnee (avec une resolution rc)
# Données :
#       - ro : resolutionOriginale (c'est la resolution de l'image originale dont le chemin est donne en parametre)
#       - rc : resolutionCapteur (c'est la resolution finale)
#       - chemin : chemin vers l'image a re-echantillonner
# Contrainte : ro < rc

#Code :
def sur_echantillonnage(ro, rc, chemin):
    if (ro >= rc):
        print("Erreur de sur_echantillonnage, ro doit etre strictement plus petit que rc")
        return
    else:
        # print("Vous etes dans Sur-echantillonnage")
        imageOriginale = Image.open(chemin)
        imOCopie = imageOriginale.copy()
        # print("taille initiale", imOCopie.size)
        #Calcul des dimensions de l'image
        d = taille_en_pouces(ro, imOCopie.size)
        # print("dimension", d)
        #Calcul de la nouvelle de l'image pour la resolution rc
        t = taille_en_pixels(rc, d)
        # print("nouvelle taille", t)
        #sous-echantillonnage
        im = (imOCopie.copy()).resize(t, Image.ANTIALIAS)
        return im

# Test de la methode :
#ro = 500
#rc = 600
#cheminf = "/Users/docteur/Desktop/L3/S2/Stage_Applicatif/Test_Photos/105_2.tif"
#i = Image.open(cheminf)
#im2 = sur_echantillonnage(ro, rc, cheminf)
#i.show()
#im2.show()

# ----------------------------------------------------------------------------
# Methode qui re-echantillonne l'image dont le chemin est donne en parametre
# Renvoie une copie de l'image re-echantillonnee (avec une resolution rc)
# Données :
#       - ro : resolutionOriginale (c'est la resolution de l'image originale dont le chemin est donne en parametre)
#       - rc : resolutionCapteur (c'est la resolution finale)
#       - chemin : chemin vers l'image a re-echantillonner
#Contrainte : nulle

#Code :
def re_echantillonnage(ro, rc, chemin):
    if(ro > rc):                             #l 'image originale  une resolution plus grande que celle du capteur
        im = sous_echantillonnage(ro, rc, chemin)
        return im
    elif(ro < rc):                           #l 'image originale  une resolution plus petite que celle du capteur
        im = sur_echantillonnage(ro, rc, chemin)
        return im
    else:                                    #l 'image originale  une resolution egale a celle du capteur
        # print("Vous etes dans Re-echantillonnage:\nro = rc --> rien à faire")
        imageOriginale = Image.open(chemin)
        imOCopie = imageOriginale.copy()
        # print("taille initiale = finale ", imOCopie.size)
        return imOCopie