TP Synthese Python
TP Synthese Python
TP Synthese Python
Objectif : générer des nombres premiers dans un intervalle en utilisant les instructions for et
while.
Algorithme :
Un nombre premier est un nombre entier supérieur à 1 dont les seuls facteurs sont 1 et lui-même.
Les premiers nombres premiers sont 2, 3, 5, 7, 11, 13, 17, 19, 23 et 29.
Pour vérifier si un nombre donné (num) est un nombre premier, il faut d'abord le diviser par 2. Si
le résultat est un nombre entier (c'est-à-dire que num est divisible par 2 ou que le reste de num/2
est nul ou que num % 2 est 0), alors num n'est pas un nombre premier. Sinon, essayez de le
diviser par des nombres premiers 3, 5, 7, 11, ... , jusqu'à num-1 ou divisez-le par 3, 4, 5, ....
jusqu'à num-1. Si num n'est pas divisible jusqu'à num-1, alors num est un nombre premier.
# Pour afficher tous les nombres premiers dans un intervalle donné [inférieur, supérieur].
Resultat:
# Programme Python pour afficher tous les nombres premiers dans un intervalle donné [inférieur,
supérieur] en utilisant l'instruction while.
lower = int(input("Entrer la limite inférieure : "))
upper = int(input("Entrer la limite supérieure : "))
print("Les nombres premiers entre", lower, "et", upper, "sont :")
num=lower
while(num<=upper):
if num > 1:
for i in range(2, num):
if (num % i) == 0:
break
else:
print(num)
num=num+1
Résultat :
Entrer la limite inférieure : 50
Entrer la limite supérieure : 100
Les nombres premiers entre 50 et 100 sont : 53
59
61
67
71
73
79
83
89
97
>>>
Algorithme :
Exemples : x 2+ 5x + 6 = 0, 4x2+ 5x + 8 = 0.
Les valeurs de x qui satisfont l'équation sont appelées solutions ou racines de l'équation. Une
équation quadratique a toujours deux racines. On peut les trouver en calculant d = b 2- 4ac. La
valeur de d est zéro ou +ve ou -ve.
i) Si d = 0 alors les racines sont réelles et égales. Elles sont racine1 = -b/(2a) et racine2 = -b/(2a).
ii) Si d > 0 alors les racines sont réelles et différentes. Elles sont racine1=-b+√d/(2a) et racine2=-
b-√d/(2a).
iii) Si d < 0, alors les racines sont complexes ou imaginaires. Les racines sont de la forme p + iq
et p - iq, où p est la partie réelle de la racine et q est la partie imaginaire de la racine. La partie
réelle de la racine est p = -b/(2a) et la partie imaginaire est q = √-d/(2a).
Codage :
# Trouver les racines de l'équation quadratique a x 2 +bx
# Importer les modules maths et maths complexes
import math,cmath
a,b,c= (input("Entrez a, b et c : ")).split()
a,b,c =[int(a),int(b),int(c)]
d = (b**2) - (4*a*c)
if d==0:
sol1 = -b/(2*a)
sol2 = -b/(2*a)
print("Les racines sont réelles et égales")
elif d>0:
sol1 = (-b-math.sqrt(d))/(2*a)
sol2 = (-b+math.sqrt(d))/(2*a)
print("Les racines sont réelles et différentes")
elif d<0:
sol1 = (-b-cmath.sqrt(d))/(2*a)
sol2 = (-b+cmath.sqrt(d))/(2*a)
print("Les racines sont imaginaires")
print('{0} and {1}'.format(sol1,sol2))
Résultat :
Entrez a, b et c : 1 4 4
Les racines sont réelles et égales.
-2,0 et -2,0
>>>
Entrez a, b et c : 1 5 6
Les racines sont réelles et différentes.
-3.0 et -2.0
>>>
Entrez a, b et c : 1 2 3
Les racines sont imaginaires
(-1-1,4142135623730951j) et (-1+1,4142135623730951j)
>>>
Algorithme :
Une chaîne de caractères est un type de données utilisé en programmation, comme un nombre
entier et des nombres à virgule flottante, mais elle est utilisée pour représenter du texte plutôt que
des nombres. Elle est composée d'un ensemble de caractères. Un tableau de caractères est utilisé
pour stocker une chaîne de caractères.
Exemples : "Annamalai", "2345"
Les principales opérations sur les chaînes de caractères sont : la longueur d'une chaîne
(comptage du nombre de caractères dans la chaîne), l'inversion d'une chaîne, la concaténation de
deux chaînes et la comparaison de deux chaînes. En Python, l'opérateur arithmétique '+' est
utilisé pour concaténer des chaînes de caractères et les opérateurs relationnels '<', '<=', '>', '>='
'==' sont utilisés pour comparer des chaînes de caractères. En Python, une fonction est définie à
l'aide du mot-clé def.
Codage :
def strrev(str):
rstr=""
l=strlen(str)
while l>0:
rstr = rstr + str[l-1]
l=l-1
return rstr
def strcat(st1,st2):
return(st1+st2)
def strcmp(st1,st2):
if(st1==st2):
print(st1 + " et " + st2 + " sont identiques")
elif (st1>st2) :
print(st1 + " vient après " + st2 + " dans le Dictionnaire")
else :
print(st1 + " vient avant " + st2 + " dans le dictionnaire ")
print(" Fonctions des chaînes de caractères :\n1. Longueur de chaîne \n2. Inversion de chaîne
de caractères \n3. Concaténation de chaînes de caractères\n4. Comparaison de chaînes de
caractères")
Resultat:
Une liste est une structure de données en Python. Une liste contient une séquence ordonnée
d'éléments et elle peut être modifiée. Une liste Python est comparable à un tableau dans d'autres
langages. Les listes n'ont pas besoin d'avoir des éléments homogènes (même type de données), ce
qui en fait une structure de données très puissante en Python. Une seule liste peut contenir des
types de données tels que des entiers, des nombres flottants, des chaînes de caractères, etc,
Création de la liste : Initialement, une liste vide est créée. Les n éléments sont ajoutés à la liste
un par un en utilisant la fonction intégrée append().
Fonction : En Python, une fonction est définie à l'aide du mot-clé def. Pour trouver le plus grand
de n nombres donnés, le premier nombre est supposé être le plus grand. Le deuxième nombre est
comparé au plus grand. Si le deuxième nombre est plus grand que le plus grand, alors le
deuxième nombre est considéré comme le plus grand nombre actuel. Ce processus est répété
pour tous les autres nombres restants de la liste afin de trouver le plus grand nombre. En Python,
la fonction intégrée max() peut également être utilisée pour trouver le plus grand des n nombres
(par exemple, largest=max(lst)).
Codage :
# Le plus grand nombre de n nombres en utilisant Liste et Fonction
def lar(lst,n) :
l=lst[0]
for i in range(1,n):
if (lst[i]>l):
l=lst[i]
return l
lst=[]
n=int(input("Entrez le nombre total d'éléments : "))
print("Entrez les éléments un par un : ")
for i in range(n) :
num=float(input())
lst.append(num)
print("Les éléments donnés sont :")
print(lst)
print("Le plus grand nombre est",lar(lst,n))
Résultat :
Entrez le nombre total d'éléments : 5
Entrez les éléments un par un : 24
78
98
12
45
Les éléments donnés sont : [24.0, 78.0, 98.0, 12.0, 45.0]
Le plus grand nombre est 98.0
>>>
Algorithme :
Un tableau est une structure de données et il est utilisé pour stocker le même type (type de
données) d'éléments/valeurs. En python, une liste peut contenir des éléments de différents types de
données.
Création de la liste : Initialement, une liste vide est créée. Les éléments de la matrice A (m x n
éléments) sont ajoutés à la liste un par un en utilisant la fonction intégrée append().
Création d'une matrice : Les besoins de stockage d'un tableau doivent être spécifiés. Les
éléments de la matrice B (n x p éléments) sont lus un par un et stockés dans le tableau.
for i = 0 to m-1
for j = 0 to p-1
begin
c[i][j] = 0
for k = 0 to n-1
begin
c[i][j] = c[i][j] + a[i][k] * b [k][j]
end
end
Codage :
Resultat:
Entrez le nombre de lignes de la première matrice : 2
Entrez le nombre de colonnes de la première matrice : 2
Entrez le nombre de colonnes de la deuxième matrice : 2
Entrez les éléments de la première matrice (ordre des lignes) :
1
2
3
4
Entrez les éléments de la deuxième matrice (ordre des lignes) :
1
12
5
13
La matrice A est :
[[1, 2], [3, 4]]
La matrice B est :
[[1, 12], [5, 13]]
La matrice résultante est : [[11, 38], [23, 88]]
>>>
Classe et objets :
Un objet est une instance d'une classe. Lorsqu'une classe est définie, aucune mémoire n'est
allouée, mais lorsqu'elle est instanciée (c'est-à-dire lorsqu'un objet est créé), la mémoire est
allouée.
La fonction init () de la classe est exécutée automatiquement chaque fois que la classe est
utilisée pour créer un nouvel objet. Elle est appelée constructeur dans la terminologie orientée
objet. Cette fonction est utilisée pour initialiser les membres de données de la classe.
Dans la plupart des langages de programmation orientée objet (POO), les spécificateurs
d'accès sont utilisés pour limiter l'accès aux variables et aux fonctions d'une classe. La plupart
des langages POO utilisent trois types de spécificateurs d'accès : private, public et protected. En
Python, toutes les variables et les fonctions membres d'une classe sont publiques par défaut.
L'ajout d'un préfixe à la variable ou à la fonction membre les rend privées.
# Trouver la distance euclidienne entre deux pintes dans un espace à trois dimensions en utilisant des
classes et des objets.
import math
class point():
def __init__(self,a,b,c):
self.x=a
self.y=b
self.z=c
def distancefromorigin(self):
return ((self.x ** 2) + (self.y ** 2) +(self.z ** 2)) ** 0.5
Résultat :
Entrez les coordonnées d'un premier point P1(x1,y1,z1) : 1 2 3
Entrez les coordonnées d'un deuxième point P2(x2,y2,z2) : 2 3 4
Distance de l'origine à P1 : 3,7416573867739413
Distance de l'origine à P2 : 5,385164807134504
Distance de P1 à P2 : 1,7320508075688772
>>>
Exercice 7 : Classe Héritage simple et multiple
Objectif : définir une nouvelle classe à partir d'une ou plusieurs classes existantes.
Héritage :
L'héritage est un mécanisme par lequel une classe (classe dérivée) acquiert la propriété d'une autre
classe (classe de base). Avec l'héritage, nous pouvons réutiliser les variables et les méthodes de la
classe existante. La classe existante est appelée classe de base et la nouvelle classe est appelée
classe dérivée. L'héritage facilite donc la réutilisation et constitue un concept important de la
programmation orientée objet. Les types d'héritage sont : l'héritage simple, l'héritage multiple,
l'héritage multi-niveaux, l'héritage hiérarchique et l'héritage hybride.
L'héritage simple permet à une classe dérivée d'utiliser les variables et les fonctions définies dans
une classe existante. Dans l'héritage multiple, la classe dérivée hérite des caractéristiques et des
fonctions de plus d'une classe existante.
En python, la syntaxe pour définir l'héritage simple est class z(x), où x est le nom de la classe de
base et z est le nom de la classe dérivée. De même, l'héritage multiple est défini en utilisant la
syntaxe class z(x, y), où x et y sont les noms des classes de base et z est le nom de la classe
dérivée.
Codage :
class person :
def __init__ (self, n, a) :
self.name = n
self.age = a
# employee est la classe dérivée de person en utilisant l'héritage simple
class employee(person) :
def __init__ (self, n,a, d,s) :
person.__init__(self,n,a)
self.designation=d
self.salary=s
def show(self) :
print("Détails de l'employé : ")
print(" Nom : ",self.name, "\n Age :",self.age, "\n Designation :",self.designation, "\n Salary :",self.salary)
# étudiant est une classe de base
class student :
def __init__(self, id, rno):
self.studentId = id
self.roomno=rno
# resident est une classe dérivée de person et student en utilisant l'héritage multiple
class resident(person, student) :
def __init__(self, n, a, id,rno):
person.__init__(self, n, a)
student.__init__(self, id,rno)
def show(self) :
print("Détails du résident :")
print(" Nom :", self.name, "\n Age : ",self.age, "\n Id :" ,self.studentId, "\n Room no. :",self.roomno)
# Création d'objets des classes employé et résident
e1 =employee("Arun",35, "Data analyst",50000)
r1 = resident("Jean", 30, 201900025,203)
e1.show()
r1.show()
Résultat :
Détails de l'employé :
Nom : Arun
Age : 35
Designation : Data analyst
Salary : 50000
Détails du résident :
Nom : Jean
Age : 30
Id : 201900025
Room no. : 203
>>>
Exercice 8 : Surcharge de l'opérateur
Objectif : surcharger les opérateurs binaires pour effectuer des opérations sur des objets.
Surcharge de l’opérateur :
La surcharge d'opérateur nous permet de redéfinir la façon dont l'opérateur fonctionne pour les
types définis par l'utilisateur tels que les objets. Il ne peut pas être utilisé pour les types intégrés
tels que int, float, char etc. Par exemple, l'opérateur '+' peut être surchargé pour effectuer l'addition
de deux objets de la classe distance.
Python fournit une fonction spéciale ou une fonction magique qui est automatiquement invoquée
lorsqu'elle est associée à cet opérateur particulier. Par exemple, lorsque nous utilisons l'opérateur
+ sur des objets, la méthode magique add () est automatiquement invoquée. La
signification/opération de l'opérateur + est définie pour les objets définis par l'utilisateur.
Codage :
# la distance est une classe. La distance est mesurée en termes de pieds et de pouces :
class distance:
def __init__(self, f,i):
self.feet=f
self.inches=i
# surcharge de l'opérateur binaire > pour comparer deux
def __gt__(self,d):
if(self.feet>d.feet):
return(True)
elif((self.feet==d.feet) and (self.inches>d.inches)):
return(True)
else:
return(False)
# surcharge de l'opérateur binaire + pour ajouter deux
def __add__(self, d):
i=self.inches + d.inches
f=self.feet + d.feet
if(i>=12):
i=i-12
f=f+1
return distance(f,i)
# affichage de la distance
def show(self):
print("Pieds= ", self.feet, "Pouces= ",self.inches)
a,b= (input("Entrez les pieds et les pouces de la distance1: ")).split()
a,b =[int(a),int(b)]
c,d= (input("Entrez les pieds et les pouces de la distance2: ")).split()
c,d =[int(c),int(d)]
d1 = distance(a,b)
d2 = distance(c,d)
if(d1>d2):
print("La distance1 est supérieure à la distance2")
else:
print("La distance2 est supérieure à la distance1")
d3=d1+d2
print("La somme des deux distances est :")
d3.show()
Résultat :
Objectif : : effectuer des opérations sur des fichiers telles que l'ouverture, la lecture, l'écriture et la
fermeture de fichiers de données textuelles et numériques.
Un fichier est une collection de données stockées dans une unité, identifiée par un nom de fichier.
Il peut s'agir d'un document texte, d'une image, d'un fichier audio, audio-vidéo ou d'une autre
collection de données. Les formats/extensions courants pour les documents texte sont .doc, .docx
(documents Microsoft Word), .odt (document texte ouvert LibreOffice), .pdf (format de document
portable Adobe), rtf (format de texte riche Microsoft), .tex (texte LaTeX), .txt (texte Microsoft
Notepad). Les formats de fichiers d'image sont : .jpg, .tiff, .gif, .png, bmp. Les formats audio les
plus utilisés sont : .wav et .mp3. Les formats audio-vidéo sont les
suivants : .avi, .mp4, .mkv, .mov, .flv, .wmv, etc,
Python prend en charge la manipulation des fichiers et permet aux utilisateurs de manipuler des
fichiers, c'est-à-dire de lire et d'écrire des fichiers, ainsi que de nombreuses autres options de
manipulation de fichiers, pour opérer sur des fichiers. Les fonctions Python open() et close() sont
utilisées pour ouvrir et fermer un fichier. Les fonctions read() et write() sont utilisées pour lire et
écrire du texte (ou des données numériques ou binaires) depuis/vers le fichier, respectivement. Les
modes d'ouverture de fichiers en Python sont : r (lecture), w (écriture), a (ajout), rb (lecture de
données binaires), wb (écriture de données binaires).
# Copie de fichier - le contenu d'un fichier texte (input.txt) est copié dans un autre fichier texte
(output.txt)
infile=open("./input.txt","r")
outfile=open("./output.txt","w")
lines = chars = 0
for line in infile:
lines += 1
chars += len(line)
outfile.write(line)
# la somme de tous les nombres dans le fichier d'entrée (input.dat) est calculée
# et elle est écrite dans le fichier de sortie (output.dat)
infile=open("./input.dat","r")
outfile=open("./output.dat","w")
sum=0
s = infile.read()
numbers = [int(x) for x in s.split()]
print("The numbers are:")
print(numbers)
Résultat :
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Objectif : : comprendre et gérer les différents types d'exceptions qui surviennent au moment de
l'exécution du programme, ainsi que la méthode pour lever une exception.
Une instruction try en Python peut avoir plus d'une clause except pour gérer différentes
exceptions. L'instruction peut également comporter une instruction else et/ou finally facultative.
La syntaxe try-except est la suivante :
try:
<body>
except <ExceptionType1>:
<handler1>
...
...
except <ExceptionTypeN>:
<handlerN>
except:
<handlerExcept>
else:
<process_else>
finally:
<process_finally>
Les excepts multiples sont similaires aux elifs en python. Lorsqu'une exception se produit, on
vérifie si elle correspond à une exception dans une clause except après la clause try, une par une
(séquentiellement). Si une correspondance est trouvée, le gestionnaire pour le cas correspondant
est exécuté et le reste des clauses except est ignoré. Notez que le <ExceptionType> de la dernière
clause except peut être omis. Si l'exception ne correspond à aucun des types d'exception avant la
dernière clause except, la clause
<handlerExcept> pour la dernière clause except est exécutée.
Une instruction try peut comporter une clause else facultative, qui est exécutée si aucune
exception n'est levée dans le corps de l'instruction try.
Une instruction try peut comporter une clause finally facultative, destinée à définir les actions
de nettoyage qui doivent être exécutées en toutes circonstances.
Codage :
try:
number1, number2 = eval(input("Entrez deux nombres séparés par une virgule : "))
result = number1 / number2
print("Le résultat est", result)
if(number1==0):
raise RuntimeError()
except ZeroDivisionError:
print("Division par zéro")
except SyntaxError:
print("Une virgule peut manquer dans l'entrée")
except RuntimeError:
print("Peut être sans signification")
except:
print("Quelque chose d'erroné dans l'entrée")
else:
print("No Exceptions")
finally:
print("La clause finale est exécutée")
Résultat :
Tkinter :
Python offre de multiples options pour développer une interface utilisateur graphique
(GUI). Parmi toutes les méthodes d'interface graphique, Tkinter est la méthode la plus
couramment utilisée. Il s'agit d'une interface Python standard pour la boîte à outils Tk GUI livrée
avec Python. Python avec Tkinter est le moyen le plus rapide et le plus facile de créer des
applications GUI. Créer une interface graphique à l'aide de Tkinter est une tâche facile.
4. Entrez dans la boucle d'événement principale pour prendre des mesures contre
chaque événement déclenché par l'utilisateur.
Tkinter fournit divers contrôles, tels que des boutons, des étiquettes et des boîtes de texte
utilisés dans une application GUI. Ces contrôles sont communément appelés widgets. Il y a
actuellement 15 types de widgets dans Tkinter.
Dans ce codage, une application GUI est développée pour calculer les paiements de
prêts. Le code se compose des étapes suivantes :
1. Concevez une interface utilisateur composée d'étiquettes à l'aide de Label( ), de boîtes de
saisie de texte à l'aide de Entry( ) et d'un bouton à l'aide de Button( ).
2. Traitez l'événement. Lorsque le bouton est cliqué, le programme invoque une fonction de
rappel, en utilisant getMonthlyPayment( ) pour obtenir la saisie de l'utilisateur pour le taux
d'intérêt, le nombre d'années et le montant du prêt à partir des entrées de texte. Les paiements
mensuels et totaux sont calculés à l'aide de la fonction computePayment( ) et affichés dans les
étiquettes.
Codage :
from tkinter import * # Import all definitions from tkinter
class LoanCalculator:
def __init__(self):
window = Tk() # Create a window
window.title("Loan Calculator") # Set title
Label(window, text = "Annual Interest Rate").grid(row = 1,column = 1, sticky = W)
Label(window, text = "Number of Years").grid(row = 2,column = 1, sticky = W)
Label(window, text = "Loan Amount").grid(row = 3,column = 1, sticky = W)
Label(window, text = "Monthly Payment").grid(row = 4,column = 1, sticky = W)
Label(window, text = "Total Payment").grid(row = 5,column = 1, sticky = W)
self.annualInterestRateVar = StringVar()
Entry(window, textvariable = self.annualInterestRateVar,justify = RIGHT).grid(row = 1,
column = 2)
self.numberOfYearsVar = StringVar()
Entry(window, textvariable = self.numberOfYearsVar,justify = RIGHT).grid(row = 2,
column = 2)
self.loanAmountVar = StringVar()
Entry(window, textvariable = self.loanAmountVar,justify = RIGHT).grid(row = 3, column =
2)
self.monthlyPaymentVar = StringVar()
lblMonthlyPayment = Label(window, textvariable =self.monthlyPaymentVar).grid(row = 4,
column = 2,sticky= E)
self.totalPaymentVar = StringVar()
lblTotalPayment = Label(window, textvariable =self.totalPaymentVar).grid(row = 5,column
= 2, sticky = E)
btComputePayment = Button(window, text = "Compute Payment",command
=self.computePayment).grid(row = 6, column = 2, sticky = E)
window.mainloop() # Create an event loop
def computePayment(self):
monthlyPayment =
self.getMonthlyPayment(float(self.loanAmountVar.get()),float(self.annualInterestRateVar.get()) /
1200,int(self.numberOfYearsVar.get()))
self.monthlyPaymentVar.set(format(monthlyPayment, "10.2f"))
totalPayment = float(self.monthlyPaymentVar.get()) * 12 * int(self.numberOfYearsVar.get())
self.totalPaymentVar.set(format(totalPayment, "10.2f"))
def getMonthlyPayment(self,loanAmount, monthlyInterestRate, numberOfYears):
monthlyPayment = loanAmount * monthlyInterestRate / (1- 1 / (1 + monthlyInterestRate) **
(numberOfYears* 12))
return monthlyPayment;
LoanCalculator() # Create GUI
Résultat :
class PopupMenuDemo:
def __init__(self):
self.v1 = StringVar()
self.v2 = StringVar()
self.v3 = StringVar()
self.canvas.pack()
# Bind popup to canvas
self.canvas.bind("<Button-3>", self.popup)
def add(self):
self.v3.set(eval(self.v1.get()) + eval(self.v2.get()))
def subtract(self):
self.v3.set(eval(self.v1.get()) - eval(self.v2.get()))
def multiply(self):
self.v3.set(eval(self.v1.get()) * eval(self.v2.get()))
def divide(self):
self.v3.set(eval(self.v1.get()) / eval(self.v2.get()))
self.menu.post(event.x_root, event.y_root)
Objectif : lire et afficher une image couleur RVB et la convertir en niveaux de gris, en négatif
et en images de bord.
Image :
Une image est définie comme une fonction bidimensionnelle, f(x, y), où x et y sont des
coordonnées spatiales, et l'amplitude de F à toute paire de coordonnées (x, y) est appelée
l'intensité de cette image à ce point. Lorsque les valeurs de x, y et l'amplitude de F sont finies, on
parle d'image numérique. En d'autres termes, une image peut être définie par un tableau
bidimensionnel spécifiquement disposé en lignes et en colonnes. L'image numérique est
composée d'un nombre fini d'éléments, dont chacun a une valeur particulière à un endroit
particulier. Ces éléments sont appelés pixels ou éléments d'image.
Types d'images :
Dans ce codage, le bouton de sélection d'image est utilisé pour sélectionner une image.
La boîte de dialogue du fichier est utilisée pour sélectionner l'image d'entrée souhaitée sur le
disque dur. Après avoir sélectionné une image, quatre types d'opérations sont effectuées en
cliquant sur un bouton pour chaque opération. Le bouton RVB est utilisé pour afficher l'image
couleur RVB, le bouton gris est utilisé pour afficher l'image grise de l'image sélectionnée, le
bouton bord est utilisé pour afficher le bord de l'image sélectionnée, et le bouton négatif est
utilisé pour afficher le négatif de l'image sélectionnée.
Image RGB :
Une image RVB est une image dans laquelle chaque pixel est spécifié par trois valeurs,
une pour les composantes rouge, bleue et verte de la couleur du pixel. Les images RVB sont
stockées sous la forme d'un tableau de données m-par-n- par-3 qui définit les composantes rouge,
verte et bleue de la couleur de chaque pixel. La couleur de chaque pixel est déterminée par la
combinaison des intensités rouge, verte et bleue stockées dans chaque plan de couleur à
l'emplacement du pixel. Les formats de fichiers graphiques stockent les images RVB sous forme
d'images de 24 bits, où les composantes rouge, verte et bleue sont de 8 bits chacune. Cela donne
un potentiel de 16 millions (2 24) de couleurs. Un pixel dont les composantes de couleur sont (0,
0, 0) est affiché en noir, et un pixel dont les composantes de couleur sont (1, 1, 1), c'est-à-dire
(255, 255, 255), est affiché en blanc.
Une image RVB est convertie en images grises à l'aide de la méthode suivante
Image négative :
L'image négative est un type d'image qui peut être formé en soustrayant la valeur RVB de 255. La
fonction cv2.bitwise_not ( ) est utilisée pour convertir l'image couleur RGB en image négative en
couleur.
Une image couleur RVB (c'est-à-dire une image positive) est convertie en une image négative en
utilisant les méthodes suivantes
Rn = 255 – Rp
Gn = 255 - Gp
Bn = 255 – Bp
où p et n sont respectivement positifs et négatifs.
Image de bord :
La détection des contours comprend une variété de méthodes mathématiques qui visent à
identifier les points d'une image numérique où la luminosité de l'image change brusquement ou
présente des discontinuités. Les points où la luminosité de l'image change brusquement sont
généralement organisés en un ensemble de segments de lignes courbes appelés bords. Les bords
sont souvent associés aux limites des objets dans une image. Dans ce codage, la méthode de
détection des bords de Canny est utilisée pour convertir une image RVB en image de bord en
utilisant cv2.canny ( ).
Codage :
# importer les paquets nécessaires
from tkinter import *
from PIL import Image
from PIL import ImageTk
from tkinter import filedialog
import cv2
from tkinter import filedialog
from tkinter.filedialog import askopenfilename
def start():
global image1,path
global panel
path = filedialog.askopenfilename()
image1 = cv2.imread(path)
image1 = cv2.resize(image1,(200,100))
image1 = cv2.cvtColor(image1, cv2.COLOR_BGR2RGB)
image = Image.fromarray(image1)
image = ImageTk.PhotoImage(image)
if panel is None:
panel = Label(image=image)
panel.image = image
panel.pack(side="left", padx=30, pady=60)
else:
panel.configure(image=image)
panel.image = image
def gray_image():
global panelB
gray = cv2.cvtColor(image1, cv2.COLOR_BGR2GRAY)
gray = Image.fromarray(gray)
gray = ImageTk.PhotoImage(gray)
if panelB is None:
panelB = Label(image=gray)
panelB.image = gray
panelB.pack(side="left", padx=30, pady=60)
else:
panelB.configure(image=gray)
panelB.image = gray
def edge_image():
global panelB
gray = cv2.cvtColor(image1, cv2.COLOR_BGR2GRAY)
edge = cv2.Canny(gray, 50, 100)
edge = Image.fromarray(edge)
edge = ImageTk.PhotoImage(edge)
if panelB is None:
panelB = Label(image=edge)
panelB.image = edge
panelB.pack(side="left", padx=30, pady=60)
else:
panelB.configure(image=edge)
panelB.image = edge
def negative_image():
global panelB
image = cv2.cvtColor(image1, cv2.COLOR_BGR2RGB)
negative = cv2.bitwise_not(image)
negative = Image.fromarray(negative)
negative = ImageTk.PhotoImage(negative)
if panelB is None:
panelB = Label(image=negative)
panelB.image = negative
panelB.pack(side="left", padx=30, pady=60)
else:
panelB.configure(image=negative)
panelB.image = negative
root = Tk()
root.geometry('600x400')
fm = Frame(root, width=300, height=200)
fm.pack(side=BOTTOM, expand=NO, fill=NONE)
panelB = None
panel = None
btn = Button(root, text="Select an image", command=start,activebackground='red',fg="blue")
btn.pack(side="top")
btn2 = Button(fm, text="GRAY", command=gray_image,activebackground='red',height=2,
width=10,fg="gray")
btn2.pack(side=LEFT, padx="10", pady="20")
btn3 = Button(fm, text="EDGE", command=edge_image,activebackground='red',height=2,
width=10,fg="green")
btn3.pack(side=LEFT, padx="10", pady="20")
btn4 = Button(fm, text="NEGATIVE",
command=negative_image,activebackground='red',height=2, width=10,fg="purple")
btn4.pack(side=LEFT, padx="10", pady="20")
root.mainloop()
Résultat :
L'image couleur RVB donnée est convertie en niveaux de gris, en négatif et en images de bord en
utilisant Tkinter.
***
28