projet4a_Euvrard_Donnat.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "1a5e02c3",
   "metadata": {},
   "outputs": [],
   "source": [
    "#classe image\n",
    "import os\n",
    "from PIL import Image\n",
    "from PIL import ImageEnhance, ImageFilter,  ImageOps\n",
    "from PIL.ImageFilter import MedianFilter\n",
    "\n",
    "\n",
    "#Création d'une classe image\n",
    "class CustomImage :\n",
    "    def __init__(self,path=0,folder=\"transformed_image\"):\n",
    "            self.image = Image.open(path) #retient l'image\n",
    "            self.image.thumbnail((600,300)) #change la taille de l'image pour être adaptée à la fenêtre de l'application\n",
    "            self.width,self.height = self.image.size #largeur et hauteur de l'image\n",
    "            self.path = path #chemin de l'image\n",
    "            self.format = self.image.format # format de l'image\n",
    "            self.nom, self.extension = os.path.splitext(path) #permet de separer le nom de l'image et son extension\n",
    "\n",
    "    #fonction copie qui prend en argument une CustomImage et en revoie une copie\n",
    "    def copie(self):\n",
    "        image_mod = CustomImage(self.path) # nouvelle CustomImage\n",
    "        image_mod.image = self.image\n",
    "        image_mod.width = self.width \n",
    "        image_mod.height = self.height\n",
    "        image_mod.path = self.path\n",
    "        image_mod.format = self.format\n",
    "        image_mod.nom = self.nom\n",
    "        image_mod.extension = self.extension\n",
    "        \n",
    "        return image_mod #renvoi de la nouvelle CustomImage ayant les mêmes propriétés que celle en argument \n",
    "    \n",
    "    #fonction zoom qui permet de reduire ou augmenter la taille d'une image\n",
    "    #prend en argument une CustomImage et renvoie une CustomImage dont la taille a été modifiée\n",
    "    def Zoom(self,size=0.5,width_max = 1500, height_max = 1000, quality=75):\n",
    "        new_width = round(self.width*size) #pour arrondir\n",
    "        new_height = round(self.height * size)\n",
    "\n",
    "        #Cas où la taille de l'image dépasse la taille max\n",
    "        if (new_width > width_max) or (new_height > height_max) :\n",
    "            \n",
    "            \n",
    "            if new_width > new_height :\n",
    "                facteur = width_max/new_width\n",
    "                new_width = width_max \n",
    "                new_height = round(new_height*facteur) \n",
    "                \n",
    "            else :\n",
    "                facteur = height_max/new_height\n",
    "                new_height = height_max \n",
    "                new_width = round(new_width*facteur)\n",
    "                \n",
    "        self.image = self.image.resize((new_width,new_height),Image.ANTIALIAS) #antialias pour avoir une meilleure qualité\n",
    "        return self\n",
    "        \n",
    "    #fonction rotation vers la droite qui permet de faire pivoter une image vers la droite\n",
    "    #prend en argument une CustomImage et renvoie la CustomImage transformée\n",
    "    def RightRotation(self,angle = 270,quality=75):\n",
    "        \n",
    "        if angle == 90 :\n",
    "            self.image = self.image.transpose(Image.ROTATE_90)\n",
    "        if angle == 180 :\n",
    "            self.image = self.image.transpose(Image.ROTATE_180)\n",
    "        if angle == 270 :\n",
    "            self.image = self.image.transpose(Image.ROTATE_270) \n",
    "        \n",
    "        #on inverse la largeur et la hauteur de l'image pour garder les bonnes mesures\n",
    "        w = self.height\n",
    "        h = self.width\n",
    "        self.height = h\n",
    "        self.width = w\n",
    "        \n",
    "        return self\n",
    "        \n",
    "    \n",
    "    # fonction contraste : permet d'augmenter ou de diminuer le contraste de la CustomImage\n",
    "    #prend en argument une CustomImage et renvoie la CustomImage modifiée \n",
    "    def Contrast(self,scale = 1,quality=75):\n",
    "        scale_value=scale \n",
    "        self.image = ImageEnhance.Contrast(self.image).enhance(scale) #fonction de PIL permettant le changement de contaste\n",
    "        return self\n",
    "\n",
    "    # fonction flou : permet de flouter la CustomImage (aussi appelé filtre gaussien)\n",
    "    #prend en argument une CustomImage et renvoie la CustomImage modifiée\n",
    "    def Fuzzy(self,scale = 2, quality=75):\n",
    "        self.image = self.image.filter(ImageFilter.GaussianBlur(radius= scale))\n",
    "        return self\n",
    "        \n",
    "    # fonction négatif : permet de passer en négatif la CustomImage \n",
    "    #prend en argument une CustomImage et renvoie la CustomImage modifiée\n",
    "    def Negative(self,quality=75):\n",
    "        self.image = ImageOps.invert(self.image)\n",
    "        return self\n",
    "\n",
    "    # fonction sobel ou détection des contours  : permet d'appliquer la detection des contours à la CustomImage \n",
    "    #prend en argument une CustomImage et renvoie la CustomImage modifiée\n",
    "    def Sobel(self,quality=75):\n",
    "        self.image = self.image.filter(ImageFilter.FIND_EDGES)\n",
    "        return self\n",
    "    \n",
    "    # fonction médiane : permet d'appliquer le filtre médian à la CustomImage \n",
    "    #prend en argument une CustomImage et renvoie la CustomImage modifiée\n",
    "    def Median(self,quality = 75):\n",
    "        self.image = self.image.filter(MedianFilter())\n",
    "        return self\n",
    "\n",
    "    # fonction lissage ou moyenne : permet de lisser la CustomImage \n",
    "    #prend en argument une CustomImage et renvoie la CustomImage modifiée\n",
    "    def Moyen(self,quality=75):\n",
    "        self.image = self.image.filter(ImageFilter.SMOOTH)\n",
    "        return self\n",
    "        \n",
    "    # fonction niveaux de gris : permet de passer la CustomImage en niveaux de grix\n",
    "    #prend en argument une CustomImage et renvoie la CustomImage modifiée\n",
    "    def GrayScale(self,quality=75):\n",
    "        self.image = self.image.convert('L')\n",
    "        return self\n",
    "    \n",
    "    # fonction netteté : permet d'augmenter la netteté de la CustomImage \n",
    "    #prend en argument une CustomImage et renvoie la CustomImage modifiée\n",
    "    def Sharpen(self,value=1,quality=75):\n",
    "        self.image = self.image.filter(ImageFilter.UnsharpMask(radius=value))\n",
    "        return self\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "5dc698f4",
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "from PyQt5.QtWidgets import QApplication, QWidget, QGridLayout, QPushButton, QLineEdit, QSlider, QLabel, QHBoxLayout, QVBoxLayout, QGraphicsAnchorLayout, QComboBox \n",
    "from PyQt5.Qt import *\n",
    "from PIL.ImageQt import ImageQt\n",
    "from PyQt5 import QtGui\n",
    "\n",
    "#class permettant de transformer une image en bouton\n",
    "class PicButton(QAbstractButton):\n",
    "    def __init__(self, pixmap, parent=None):\n",
    "        super(PicButton, self).__init__(parent)\n",
    "        self.pixmap = pixmap.scaled(150, 150, Qt.KeepAspectRatio)\n",
    "    \n",
    "    #procédure permettant l'affichage du bouton-image\n",
    "    def paintEvent(self, event):\n",
    "        painter = QPainter(self)\n",
    "        painter.drawPixmap(event.rect(), self.pixmap)\n",
    "    \n",
    "    #procédure permettant de changer l'image du bouton-image déjà existant\n",
    "    def changePic(self, pic):\n",
    "        self.pixmap = pic.scaled(500, 300, Qt.KeepAspectRatio)\n",
    "    \n",
    "    #fonction retournant la taille de l'image\n",
    "    def sizeHint(self):\n",
    "        return self.pixmap.size()\n",
    "\n",
    "\n",
    "#class permettant de transformer une image PIL en QPixmap (utilisable avec Qt)\n",
    "def pil2pixmap(im):\n",
    "    if im.mode == \"RGB\":\n",
    "        r, g, b = im.split()\n",
    "        im = Image.merge(\"RGB\", (b, g, r))\n",
    "    elif  im.mode == \"RGBA\":\n",
    "        r, g, b, a = im.split()\n",
    "        im = Image.merge(\"RGBA\", (b, g, r, a))\n",
    "    elif im.mode == \"L\":\n",
    "        im = im.convert(\"RGBA\")\n",
    "    im2 = im.convert(\"RGBA\")\n",
    "    data = im2.tobytes(\"raw\", \"RGBA\")\n",
    "    qim = QtGui.QImage(data, im.size[0], im.size[1], QtGui.QImage.Format_ARGB32)\n",
    "    pixmap = QtGui.QPixmap.fromImage(qim)\n",
    "    return pixmap"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "2fbcb1e9",
   "metadata": {},
   "outputs": [],
   "source": [
    "from PyQt5.QtGui import *\n",
    "\n",
    "#fenetre de dialogue pour l'enregistrement de l'image une fois les modifications finies\n",
    "class FenetreEnregistre(QDialog):\n",
    "    def __init__(self, image, parent=None):\n",
    "        super().__init__(parent=parent)\n",
    "        \n",
    "        self.setWindowTitle(\"Enregistrer\") #le titre de la fenetre est mis a 'Enregistrer'\n",
    "        self.setWindowIcon(QIcon(\"disquette.jpg\")) # l'icone de la fenetre devient une disquette\n",
    "        self.resize(750,400) #on ajuste la taille de la fenêtre\n",
    "        self.image = image #la valeur self.image est initialisé avec la valeur image qui correspond à l'image à enregister\n",
    "        \n",
    "        #on crée la première ligne du formulaire à remplir : le nom donnée à la nouvelle image\n",
    "        l1 = QLabel(\"Nom\") #titre de la ligne\n",
    "        self.nom = QLineEdit() #lineEdit permettant à l'utilisateur d'entrer le nom voulu\n",
    "    \n",
    "        # on crée la deuxième ligne du formulaire ) remplir : le chemin dans lequel doit être enregistrer l'image\n",
    "        l2 = QLabel(\"Chemin\") #titre de la ligne\n",
    "        self.chemin = QLineEdit() #lineEdit permettant à l'utilisateur d'entrer le nom voulu\n",
    "        \n",
    "        #on crée la troisième ligne du formulaire : un menu déroulant pour selectionner le format dans lequel doit être enregister l'image\n",
    "        formatlabel = QLabel(\"Format\") #titre de la ligne\n",
    "        self.formatimgList = QComboBox() #menu déroulant\n",
    "        self.formatimgList.addItem(\"JPG\") #première option du menu deroulant : jpeg\n",
    "        self.formatimgList.addItem(\"PNG\") #deuxième option du menu deroulant : png\n",
    "        self.formatimgList.addItem(\"PDF\") #troisième option du menu deroulant : pdf\n",
    "        \n",
    "        #bouton enregistrer\n",
    "        self.enregistre = QPushButton(\"Enregistrer\")\n",
    "        self.enregistre.clicked.connect(self.Enregistre) #connexion du bouton à la fonction qu'il appelle quand il est cliqué\n",
    "        \n",
    "        # layout de la fenetre : \n",
    "        form = QFormLayout()\n",
    "        form.addRow(l1,self.nom) # on ajoute la première ligne \n",
    "        form.addRow(l2,self.chemin) # on ajoute la deuxième ligne\n",
    "        form.addRow(formatlabel, self.formatimgList) # on ajoute la troisème ligne\n",
    "        form.addRow(self.enregistre) # on ajoute le bouton enregistrer\n",
    "        form.setSpacing(70) # on ajuste l'espace entre les lignes du layout\n",
    "        self.setLayout(form) #on applique le layout à la fenetre\n",
    "        \n",
    "    #fonction liée au bouton enregistrer : permet l'enregistrement de l'image \n",
    "    def Enregistre(self):\n",
    "        nom = self.nom.text() #on recupère le nom de l'image dans le lineEdit correspondant\n",
    "        chemin = self.chemin.text() # on recupère le chemin de l'image dans le lineEdit correspondant\n",
    "        formatimgtxt = self.formatimgList.currentText().lower() #on recupère le format de l'image et on la passe en minuscule\n",
    "        formatimgSave = self.formatimgList.currentText() # on recupère le format de l'image\n",
    "        #si le format selectionné est le format jpg on change la valeur de formatimagesave pour correspondre aux exigences de PIL\n",
    "        if formatimgSave == 'JPG':\n",
    "            formatimgSave='JPEG'\n",
    "        #si le chemin exite ou il est rester vide on peut enregistrer l'image\n",
    "        if os.path.exists(chemin) or chemin == '' : \n",
    "            cheminImage =  os.path.join(chemin, nom + '.' + formatimgtxt) #on créer le chemin entier de l'image\n",
    "            self.image.image.save(cheminImage,formatimgSave,quality=70) #on sauvegarde l'image\n",
    "            self.close() #on ferme la fenetre d'enregistrement\n",
    "        #si le chemin n'existe pas, on affiche une message d'erreur à l'aide d'un pop-up\n",
    "        else :\n",
    "            CheminInvalide = QMessageBox() #création du pop-up\n",
    "            CheminInvalide.setIcon(QMessageBox.Information) #il est de type information\n",
    "\n",
    "            CheminInvalide.setText(\"Chemin Invalide\") #message délivré par le pop-up\n",
    "            CheminInvalide.exec_() #on execute le pop-up pour qu'il s'affiche"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "21ec34fb",
   "metadata": {},
   "outputs": [],
   "source": [
    "#fenetre principale\n",
    "class Fenetre(QWidget):\n",
    "    \n",
    "    #constructeur\n",
    "    def __init__(self):\n",
    "        \n",
    "        QWidget.__init__(self)\n",
    "        #titre de la fenetre\n",
    "        self.setWindowTitle(\"Application Traitement d'images\")\n",
    "        #Logo de la fenetre\n",
    "        self.setWindowIcon(QIcon(\"pinceau.png\"))\n",
    "        #ajustement de la taille de la fenêtre\n",
    "        self.setFixedSize(1700,1050)\n",
    "        #attribut permettant de savoir si une image a été importée ou non dans la fenetre\n",
    "        self.imageImportee = 0\n",
    "\n",
    "        \n",
    "        #layout de la fenetre principale\n",
    "        layout1 = QVBoxLayout()\n",
    "        \n",
    "        #label 2 : image, chemin, bouton OK\n",
    "        layout2 = QHBoxLayout()\n",
    "        #creation d'un label Image et ajout au layout 2\n",
    "        image = QLabel('Image : ')\n",
    "        layout2.addWidget(image)\n",
    "        #creation d'un lineEdit pour recuperer le chemin de l'image a transformer et ajout au layout 2\n",
    "        self.cheminImage = QLineEdit(\"Chemin\")\n",
    "        layout2.addWidget(self.cheminImage)\n",
    "        #creation du bouton OK qui permet d'ouvrir l'image dans la fenetre et ajout au layout 2\n",
    "        self.btnOk = QPushButton('OK')\n",
    "        layout2.addWidget(self.btnOk)\n",
    "        self.btnOk.clicked.connect(self.btn_ok) #connection a la fontcion qui se déclenche quand le bouton est cliqué\n",
    "        \n",
    "        \n",
    "        \n",
    "        # layout img : caractéristiques de l'image, image, bouton retour, bouton reinitialiser\n",
    "        layoutimg = QHBoxLayout()\n",
    "        \n",
    "        #layoutcaracimg : creation de 3 label -> taille, format, nom de l'image et ajout au layout caracimg\n",
    "        layoutcaracimg = QVBoxLayout() #création d'un layout vertical\n",
    "        #label comportant le nom de l'image lorsque importée\n",
    "        self.nom = QLabel(\"Nom :\")\n",
    "        self.nom.setFixedSize(200,100) #on fixe la taille du label\n",
    "        #label comportant le taille de l'image lorsque importée\n",
    "        self.taille = QLabel(\"Taille :\")\n",
    "        self.taille.setFixedSize(200,100) #on fixe la taille du label\n",
    "        #label comportant le nom de l'image lorsque importée\n",
    "        self.format = QLabel(\"Format : \")\n",
    "        self.format.setFixedSize(200,100) #on fixe la taille du label\n",
    "        #on ajoute tous les labels créés au layout caracimg\n",
    "        layoutcaracimg.addWidget(self.nom)\n",
    "        layoutcaracimg.addWidget(self.taille)\n",
    "        layoutcaracimg.addWidget(self.format)\n",
    "        layoutcaracimg.setAlignment(Qt.AlignTop) #les widgets sont alignés vers le haut dans le layout \n",
    "        \n",
    "        #creation d'un label cadre qui permettra par la suite l'affichage de l'image a transformer\n",
    "        self.cadre = QLabel()\n",
    "        self.cadre.setFixedSize(600,300) #on fixe la taille du label\n",
    "        self.cadre.setStyleSheet(\"background-color:gray\") #on affiche un rectangle gris lorqu'on ouvre la fenetre pour repérer l'endroit où s'affichera l'image importée\n",
    "        \n",
    "        #layout btn : creation de 2 PushButton -> retour et reenitialiser qui permettrons de défaire la dernière action effectuée\n",
    "        #sur l'image et revenir à l'image de base importée\n",
    "        layoutimgbtn = QVBoxLayout() #creation d'un layout vertical\n",
    "        #création du bouton retour\n",
    "        self.btnRetour = QPushButton(\"Retour\")\n",
    "        self.btnRetour.setFixedSize(200,70) #on fixe la taille du bouton\n",
    "        self.btnRetour.clicked.connect(self.btn_Retour) #on connecte le bouton à la fonction qui est appelée lorsqu'il est cliqué\n",
    "        layoutimgbtn.addWidget(self.btnRetour) #on ajoute le bouton au layout imgbtn\n",
    "        #création du bouton reinitialiser\n",
    "        self.btnReinit = QPushButton(\"Réinitialiser\")\n",
    "        self.btnReinit.setFixedSize(200,70) #on fixe la taille du bouton\n",
    "        self.btnReinit.clicked.connect(self.btn_Reinit)  #on connecte le bouton à la fonction qui est appelée lorsqu'il est cliqué\n",
    "        layoutimgbtn.addWidget(self.btnReinit) #on ajoute le bouton au layout imgbtn\n",
    "        layoutimgbtn.setAlignment(Qt.AlignRight) # les widgets sont alignés à droite dans le layout\n",
    "        layoutimgbtn.setAlignment(Qt.AlignTop) # les widgets sont alignés vers le haut dans le layout\n",
    "        \n",
    "        #ajout des 2 sous layout et du label cadre au layout img\n",
    "        layoutimg.addLayout(layoutcaracimg)\n",
    "        layoutimg.addWidget(self.cadre)\n",
    "        layoutimg.addLayout(layoutimgbtn)\n",
    "        \n",
    "        #layout 3 : bouton rotation, curseur zoom, curseur contraste, curseur flou/netteté\n",
    "        layout3 = QHBoxLayout() #création d'un layout horizontal\n",
    "        #bouton rotation\n",
    "        self.btnRotation = QPushButton()\n",
    "        #on change l'icone du bouton rotation par une image de fleche effectuant une rotation vers la droite\n",
    "        icon = QIcon(\"fleche_rotation.jpg\") #creation d'une icone \n",
    "        self.btnRotation.setIcon(icon) #application au bouton\n",
    "        self.btnRotation.setFixedSize(150,70) # on fixe la taille du bouton\n",
    "        self.btnRotation.clicked.connect(self.btn_Rotation)  #on connecte le bouton à la fonction qui est appelée lorsqu'il est cliqué\n",
    "        layout3.addWidget(self.btnRotation) # on ajoute le bouton au layout3\n",
    "        \n",
    "        #curseur zoom\n",
    "        layoutCZ = QVBoxLayout() #creation du layout vertical pour le curseur de zoom\n",
    "        self.zoomlabel = QLabel(\"Zoom\") #on crée un label faisant office de titre pour le curseur\n",
    "        layoutCZ.addWidget(self.zoomlabel) #on ajoute le titre au layout\n",
    "        layoutCZ2 = QHBoxLayout() #creation d'un nouveau layout horizontal pour le curseur et l'affichage de sa valeur\n",
    "        self.curseurZoom = QSlider(Qt.Horizontal) #creation du curseur zoom\n",
    "        self.curseurZoom.setMinimum(0) #on fixe sa valeur minimale a 0\n",
    "        self.curseurZoom.setMaximum(100) #on fixe sa valeur maximale a 100\n",
    "        self.curseurZoom.setValue(50) # on fixe sa valuer de départ à 50\n",
    "        self.curseurZoom.setFixedSize(200,20) #on fixe la taille du curseur\n",
    "        layoutCZ2.addWidget(self.curseurZoom) #on ajoute le curseur au layout\n",
    "        #label état du curseur zoom\n",
    "        self.pourcentZoom = QLabel('50%') #on initialise la valeur du label a 50%\n",
    "        self.pourcentZoom.setFixedSize(70,40) #on fixe la taille de label\n",
    "        self.pourcentZoom.setFrameStyle(QFrame.Panel | QFrame.Plain) #on modifie le style d'affiche en lui donnant un contour\n",
    "        layoutCZ2.addWidget(self.pourcentZoom) #on ajoute le label au layout horizontal\n",
    "        layoutCZ.addLayout(layoutCZ2) #on ajoute le layout horizontal au layout vertical\n",
    "        layout3.addLayout(layoutCZ)#on ajoute le layout vertical de zoom au layout 3\n",
    "        self.curseurZoom.valueChanged.connect(self.valuechangeZoom) #on connecte le curseur à la fonction qui s'applique lorsque le curseur est déplacé\n",
    "        \n",
    "        #curseur constraste\n",
    "        layoutCC = QVBoxLayout()#creation du layout vertical pour le curseur de contraste\n",
    "        self.contrastelabel = QLabel(\"Contraste\") #on crée un label faisant office de titre pour le curseur\n",
    "        layoutCC.addWidget(self.contrastelabel)  #on ajoute le titre au layout\n",
    "        layoutCC2 = QHBoxLayout() #creation d'un nouveau layout horizontal pour le curseur et l'affichage de sa valeur\n",
    "        self.curseurContraste = QSlider(Qt.Horizontal) #creation du curseur contraste\n",
    "        self.curseurContraste.setMinimum(0) #on fixe sa valeur minimale a 0\n",
    "        self.curseurContraste.setMaximum(100) #on fixe sa valeur maximale a 100\n",
    "        self.curseurContraste.setValue(50) # on fixe sa valuer de départ à 50\n",
    "        self.curseurContraste.setFixedSize(200,20)  #on fixe la taille du curseur\n",
    "        layoutCC2.addWidget(self.curseurContraste)  #on ajoute le curseur au layout\n",
    "        #label etat du curseur contraste \n",
    "        self.pourcentContraste = QLabel('50%') #on initialise la valeur du label a 50%\n",
    "        self.pourcentContraste.setFixedSize(70,40)  #on fixe la taille de label\n",
    "        self.pourcentContraste.setFrameStyle(QFrame.Panel | QFrame.Plain) #on modifie le style d'affiche en lui donnant un contour\n",
    "        layoutCC2.addWidget(self.pourcentContraste) #on ajoute le label au layout horizontal\n",
    "        layoutCC.addLayout(layoutCC2)  #on ajoute le layout horizontal au layout vertical\n",
    "        layout3.addLayout(layoutCC) #on ajoute le layout vertical de zoom au layout 3\n",
    "        self.curseurContraste.valueChanged.connect(self.valuechangeContraste) #on connecte le curseur à la fonction qui s'applique lorsque le curseur est déplacé\n",
    "        \n",
    "        #curseur flou/netteté\n",
    "        layoutCF = QVBoxLayout() #creation du layout vertical pour le curseur de flou/netteté\n",
    "        self.floulabel = QLabel(\"Flou\") #on crée un label faisant office de titre pour le curseur\n",
    "        layoutCF.addWidget(self.floulabel) #on ajoute le titre au layout\n",
    "        layoutCF2 = QHBoxLayout()#creation d'un nouveau layout horizontal pour le curseur et l'affichage de sa valeur\n",
    "        self.curseurFlou = QSlider(Qt.Horizontal) #creation du curseur flou/netteté\n",
    "        self.curseurFlou.setMinimum(0)  #on fixe sa valeur minimale a 0\n",
    "        self.curseurFlou.setMaximum(100) #on fixe sa valeur maximale a 100\n",
    "        self.curseurFlou.setValue(50) # on fixe sa valuer de départ à 50\n",
    "        self.curseurFlou.setFixedSize(200,20) #on fixe la taille du curseur\n",
    "        layoutCF2.addWidget(self.curseurFlou)  #on ajoute le curseur au layout\n",
    "        #label etat du curseur flou/netteté\n",
    "        self.pourcentFlou = QLabel('50%') #on initialise la valeur du label a 50%\n",
    "        self.pourcentFlou.setFixedSize(70,40) #on fixe la taille de label\n",
    "        self.pourcentFlou.setFrameStyle(QFrame.Panel | QFrame.Plain)  #on modifie le style d'affiche en lui donnant un contour\n",
    "        layoutCF2.addWidget(self.pourcentFlou, Qt.AlignCenter)  #on ajoute le label au layout horizontal\n",
    "        layoutCF.addLayout(layoutCF2)  #on ajoute le layout horizontal au layout vertical\n",
    "        self.curseurFlou.valueChanged.connect(self.valuechangeFlou) #on connecte le curseur à la fonction qui s'applique lorsque le curseur est déplacé\n",
    "        layout3.addLayout(layoutCF)  #on ajoute le layout vertical de zoom au layout 3\n",
    "        \n",
    "        \n",
    "        #layout 4 : filtres négatif, detection des contours, lissage, médian, niveau de gris\n",
    "        layout4 = QHBoxLayout() #on crée un layout horizontal qui prendra les 5 layouts : négatif, detection des contours, lissage, médian, niveau de gris\n",
    "        layoutNeg = QVBoxLayout() #creation du layout vertical négatif\n",
    "        \n",
    "        #image exemple utlisé pour démontrer les filtres en attendant qu'une image soit importée\n",
    "        image = Image.open('lapin_mignon.jpg') \n",
    "        #bouton filtre negatif\n",
    "        self.buttonNeg = PicButton(pil2pixmap(ImageOps.invert(image)))#on crée une image cliquable qui montre l'utilisation du filtre négatif\n",
    "        self.buttonNeg.clicked.connect(self.btn_Neg) #on connecte le bouton à la fonction qu'il appelle lorsqu'il est cliqué\n",
    "        NegLabel = QLabel('Négatif') # on ajoute un label faisant office de titre \n",
    "        NegLabel.setAlignment(Qt.AlignCenter)#le label est aligné au centre du layout \n",
    "        layoutNeg.addWidget(self.buttonNeg) #on ajoute le bouton au layout\n",
    "        layoutNeg.addWidget(NegLabel) #on ajoute le label au layout\n",
    "        \n",
    "        #bouton filtre detection des contours (sobel)\n",
    "        layoutSob = QVBoxLayout() #creation du layout vertical detection des contours\n",
    "        self.buttonSobel = PicButton(pil2pixmap(image.filter(ImageFilter.FIND_EDGES))) #on crée une image cliquable qui montre l'utilisation du filtre de détection des contours\n",
    "        self.buttonSobel.clicked.connect(self.btn_Sob) #on connecte le bouton à la fonction qu'il appelle lorsqu'il est cliqué\n",
    "        SobLabel = QLabel('Détéction des contours')  # on ajoute un label faisant office de titre \n",
    "        SobLabel.setAlignment(Qt.AlignCenter) #le label est aligné au centre du layout\n",
    "        layoutSob.addWidget(self.buttonSobel)#on ajoute le bouton au layout\n",
    "        layoutSob.addWidget(SobLabel)#on ajoute le label au layout\n",
    "        \n",
    "        #bouton filtre lissage\n",
    "        layoutMoy = QVBoxLayout() #creation du layout vertical lissage\n",
    "        self.buttonMoy = PicButton(pil2pixmap(image.filter(ImageFilter.SMOOTH))) #on crée une image cliquable qui montre l'utilisation du filtre lissant\n",
    "        self.buttonMoy.clicked.connect(self.btn_Moy) #on connecte le bouton à la fonction qu'il appelle lorsqu'il est cliqué\n",
    "        MoyLabel = QLabel('Lissage') # on ajoute un label faisant office de titre \n",
    "        MoyLabel.setAlignment(Qt.AlignCenter)#le label est aligné au centre du layout\n",
    "        layoutMoy.addWidget(self.buttonMoy) #on ajoute le bouton au layout\n",
    "        layoutMoy.addWidget(MoyLabel) #on ajoute le label au layout\n",
    "        \n",
    "        #bouton filtre median \n",
    "        layoutMed = QVBoxLayout()\n",
    "        self.buttonMed = PicButton(pil2pixmap(image.filter(MedianFilter()))) #on crée une image cliquable qui montre l'utilisation du filtre médian\n",
    "        self.buttonMed.clicked.connect(self.btn_Med) #on connecte le bouton à la fonction qu'il appelle lorsqu'il est cliqué\n",
    "        MedLabel = QLabel('Médian') # on ajoute un label faisant office de titre \n",
    "        MedLabel.setAlignment(Qt.AlignCenter)#le label est aligné au centre du layout\n",
    "        layoutMed.addWidget(self.buttonMed) #on ajoute le bouton au layout\n",
    "        layoutMed.addWidget(MedLabel) #on ajoute le label au layout\n",
    "        \n",
    "        #bouton filtre niveau de gris\n",
    "        layoutNG = QVBoxLayout()\n",
    "        self.buttonNivGris = PicButton(pil2pixmap(image.convert('L'))) #on crée une image cliquable qui montre l'utilisation du filtre niveaux de gris\n",
    "        self.buttonNivGris.clicked.connect(self.btn_NG) #on connecte le bouton à la fonction qu'il appelle lorsqu'il est cliqué\n",
    "        NGLabel = QLabel('Niveau de gris') # on ajoute un label faisant office de titre \n",
    "        NGLabel.setAlignment(Qt.AlignCenter)#le label est aligné au centre du layout\n",
    "        layoutNG.addWidget(self.buttonNivGris) #on ajoute le bouton au layout\n",
    "        layoutNG.addWidget(NGLabel) #on ajoute le label au layout\n",
    "        \n",
    "        layout4.addLayout(layoutNeg) #on ajoute le layout négatif au layout4\n",
    "        layout4.addLayout(layoutSob) #on ajoute le layout detection des contours au layout4\n",
    "        layout4.addLayout(layoutMoy) #on ajoute le layout lissant au layout4\n",
    "        layout4.addLayout(layoutMed) #on ajoute le layout médian au layout4\n",
    "        layout4.addLayout(layoutNG) #on ajoute le layout niveaux de gris au layout4\n",
    "        \n",
    "        #layout 5 : bouton enregister l'image\n",
    "        layout5 = QHBoxLayout() #on crée un layout horizontal\n",
    "        self.btnEnregistre = QPushButton(\"Enregistrer l'image\") #creation du boutn d'enregistrement\n",
    "        self.btnEnregistre.setFixedSize(400,70) # on fixe la taille du bouton\n",
    "        self.btnEnregistre.clicked.connect(self.btn_Enregistre) # on connecte le bouton à la fonction qu'il appelle lorqu'il est cliqué\n",
    "   \n",
    "        \n",
    "        layout5.addWidget(self.btnEnregistre) #on ajoute le bouton au layout 5\n",
    "        layout5.setAlignment(Qt.AlignRight) #les widgets du layout5 sont alignés sur la droite\n",
    "        \n",
    "        \n",
    "        \n",
    "        #ajout de tous les sous layout au layout 1\n",
    "        layout1.addLayout(layout2)\n",
    "        layout1.addLayout(layoutimg)\n",
    "        layout1.addLayout(layout3)\n",
    "        layout1.addLayout(layout4)\n",
    "        layout1.addLayout(layout5)\n",
    "        \n",
    "        #espace entre les layout\n",
    "        layout1.setSpacing(75)\n",
    "        #application du layout1 a la fenetre\n",
    "        self.setLayout(layout1)\n",
    "\n",
    "    #fonction liée au curseur de zoom\n",
    "    def valuechangeZoom(self):\n",
    "        self.imgRetour = self.imgCurrent.copie() #image retour prend une copie de l'image courante\n",
    "        imgAffiche = self.imgCurrent.copie() #image afiche prend une copie de l'image courante\n",
    "        #si le curseur contraste est différent de 50 on applique la valeur du contraste a image affiche\n",
    "        if (self.sizeContraste != 50):\n",
    "            imgAffiche = imgAffiche.Contrast((self.sizeContraste-49)/10)\n",
    "        #si le curseur flou est différent de 50 on applique la valeur du flou/netteté a image affiche\n",
    "        if (self.sizeflou != 50):\n",
    "            if (self.sizeflou > 50):\n",
    "                imgAffiche = imgAffiche.Sharpen((self.sizeflou-49)/10)\n",
    "            else :\n",
    "                imgAffiche = imgAffiche.Fuzzy((51-self.sizeflou)/10)\n",
    "        #on recupère la valeur du curseur zoom\n",
    "        self.sizezoom = self.curseurZoom.value()\n",
    "        #on change la valeur du label indiquant la valeur du curseur zoom\n",
    "        self.pourcentZoom.setText(str(self.sizezoom)+'%')\n",
    "        #on affiche l'image zoomée\n",
    "        self.cadre.setPixmap(pil2pixmap(imgAffiche.Zoom(self.sizezoom/50).image)) \n",
    "        self.valzoom = 1 #la dernière action est le zoom donc on l'incrémente à un\n",
    "        #on remet à 0 celle du contraste et du flou\n",
    "        self.valconstraste = 0\n",
    "        self.valflou = 0\n",
    "        \n",
    "        \n",
    "    # fonction liée au curseur de contraste\n",
    "    def valuechangeContraste(self):\n",
    "        self.imgRetour = self.imgCurrent.copie() #image retour prend une copie de l'image courante\n",
    "        self.sizeContraste = self.curseurContraste.value() #on recupère la valeur du curseur contraste\n",
    "        imgAffiche = self.imgCurrent.copie() #image afiche prend une copie de l'image courante\n",
    "        #si le curseur zoom est différent de 50 on applique la valeur du zoom a image affiche\n",
    "        if (self.sizezoom != 50):\n",
    "            imgAffiche = imgAffiche.Zoom(self.sizezoom/50)\n",
    "        #si le curseur flou est différent de 50 on applique la valeur du flou/netteté a image affiche\n",
    "        if (self.sizeflou != 50):\n",
    "            if (self.sizeflou > 50):\n",
    "                imgAffiche = imgAffiche.Sharpen((self.sizeflou-49)/10)\n",
    "            else :\n",
    "                imgAffiche = imgAffiche.Fuzzy((51-self.sizeflou)/10)\n",
    "        #on change la valeur du label indiquant la valeur du curseur contraste\n",
    "        self.pourcentContraste.setText(str(self.sizeContraste)+'%')\n",
    "        #on affiche l'image avec le changement de contraste\n",
    "        self.cadre.setPixmap(pil2pixmap(imgAffiche.Contrast((self.sizeContraste-49)/10).image))\n",
    "        self.valconstraste = 1 #la dernière action est le contraste donc on l'incrémente à un\n",
    "        #on remet à 0 celle du zoom et du flou\n",
    "        self.valzoom = 0 \n",
    "        self.valflou = 0\n",
    "    \n",
    "    #fonction liée au curseur flou\n",
    "    def valuechangeFlou(self):\n",
    "        self.imgRetour = self.imgCurrent.copie() #image retour prend une copie de l'image courante\n",
    "        self.sizeflou = self.curseurFlou.value() #on recupère la valeur du curseur flou\n",
    "        imgAffiche = self.imgCurrent.copie() #image afiche prend une copie de l'image courante\n",
    "        #si le curseur zoom est différent de 50 on applique la valeur du zoom a image affiche\n",
    "        if (self.sizezoom != 50):\n",
    "            imgAffiche = imgAffiche.Zoom(self.sizezoom/50)\n",
    "        #si le curseur contraste est différent de 50 on applique la valeur du contraste a image affiche\n",
    "        if (self.sizeContraste != 50):\n",
    "            imgAffiche = imgAffiche.Contrast((self.sizeContraste-49)/10)\n",
    "        #on change la valeur du label indiquant la valeur du curseur flou\n",
    "        self.pourcentFlou.setText(str(self.sizeflou)+'%')\n",
    "        #si la valeur de size flou est inférieur à 50, on affiche l'image en appliquant le filtre flouteur\n",
    "        if (self.sizeflou > 50):\n",
    "            self.cadre.setPixmap(pil2pixmap(imgAffiche.Sharpen((self.sizeflou-49)/10).image))\n",
    "        #sinon, on affiche l'image en appliquant le filtre de netteté\n",
    "        else :\n",
    "            self.cadre.setPixmap(pil2pixmap(imgAffiche.Fuzzy((51-self.sizeflou)/10).image))\n",
    "        self.valflou = 1 #la dernière action est le flou donc on l'incrémente à un\n",
    "        #on remet à 0 celle du zoom et du contraste\n",
    "        self.valzoom = 0\n",
    "        self.valconstraste = 0\n",
    "        \n",
    "    #fonction liée au bouton ok\n",
    "    def btn_ok(self):\n",
    "        #si le chemin existe on importe l'image\n",
    "        if os.path.exists(self.cheminImage.text())  : \n",
    "            self.imageImportee = 1 #on incrément imageImportée\n",
    "            self.imgbase = CustomImage(self.cheminImage.text()) #on importe l'image dans imgbase qui nous servira pour le bouton réinitialiser\n",
    "            self.imgRetour = CustomImage(self.cheminImage.text()) #on importe l'image dans imgRetour qui nous servira dans le bouton Retour\n",
    "            self.imgCurrent = CustomImage(self.cheminImage.text()) #on importe l'image\n",
    "            self.cadre.setPixmap(pil2pixmap(self.imgCurrent.image)) # on affiche l'image dans la fenetre\n",
    "            self.cadre.setStyleSheet(\"background-color:none\") #on enlève la couleur de fond du Qlabel cadre\n",
    "            \n",
    "            #transformation des images cliquables démontrant les filtres \n",
    "            imgNeg = self.imgbase.copie().Negative() #création d'une image avec le filtre négatif\n",
    "            self.buttonNeg.changePic(pil2pixmap(imgNeg.image).scaled(150,150,Qt.KeepAspectRatio)) #changement de l'image pour le bouton négatif\n",
    "            self.buttonNeg.update() #prise en compte des modifications\n",
    "            imgSob = self.imgbase.copie().Sobel() #création d'une image avec le filtre de detection des contours\n",
    "            self.buttonSobel.changePic(pil2pixmap(imgSob.image).scaled(150,150,Qt.KeepAspectRatio)) #changement de l'image pour le bouton detection des contours \n",
    "            self.buttonSobel.update() #prise en compte des modifications\n",
    "            imgMed = self.imgbase.copie().Median() #création d'une image avec le filtre médian\n",
    "            self.buttonMed.changePic(pil2pixmap(imgMed.image).scaled(150,150,Qt.KeepAspectRatio)) #changement de l'image pour le bouton médian\n",
    "            self.buttonMed.update() #prise en compte des modifications\n",
    "            imgMoy = self.imgbase.copie().Moyen() #création d'une image avec le filtre lissant\n",
    "            self.buttonMoy.changePic(pil2pixmap(imgMoy.image).scaled(150,150,Qt.KeepAspectRatio)) #changement de l'image pour le bouton lissant\n",
    "            self.buttonMoy.update() #prise en compte des modifications\n",
    "            imgNG = self.imgbase.copie().GrayScale() #création d'une image avec le filtre niveaux de gris\n",
    "            self.buttonNivGris.changePic(pil2pixmap(imgNG.image).scaled(1500,150,Qt.KeepAspectRatio)) #changement de l'image pour le bouton niveaux de gris\n",
    "            self.buttonNivGris.update() #prise en compte des modifications\n",
    "            \n",
    "            #on modifie les Qlabel pour affiche les caractéristiques de l'image importée\n",
    "            self.nom.setText('Nom : ' +str(os.path.basename(self.imgbase.path))) #affichage du nom de l'image\n",
    "            self.nom.setToolTip(str(os.path.basename(self.imgbase.path))) #on ajoute une infobulle avec le nom complet de l'image s'il n'est pas visible en entier dans la fenêtre\n",
    "            self.taille.setText('Taille : '+str(self.imgbase.width)+\"x\"+str(self.imgbase.height)) #affichage de la taille de l'image\n",
    "            self.format.setText('Format : ' +str(self.imgbase.format)) #affichage du format de l'image\n",
    "            \n",
    "            self.curseurZoom.setValue(50) #on assure la valeur de curseur zoom à 50\n",
    "            self.curseurContraste.setValue(50) #on assure la valeur de curseur contraste à 50\n",
    "            self.curseurFlou.setValue(50) #on assure la valeur de flou zoom à 50\n",
    "            \n",
    "            #on intialise les actions sur les curseurs à 0, ces valeurs nous sont utiles pour repérer si la dernière action \n",
    "            #effectuée est sur un curseur pour le bouton Retour\n",
    "            self.valzoom = 0\n",
    "            self.valconstraste = 0\n",
    "            self.valflou = 0\n",
    "            \n",
    "            #on initialise bien toute les valeurs des curseurs à 50\n",
    "            self.sizeflou = 50\n",
    "            self.sizezoom = 50\n",
    "            self.sizeContraste = 50\n",
    "            \n",
    "        #sinon on affiche une fentre popup de type information qui affiche le message \"Chemin Invalide\"\n",
    "        else : \n",
    "            CheminInvalide = QMessageBox() #creation de la fenetre pop-up\n",
    "            CheminInvalide.setIcon(QMessageBox.Information) #on la crée de type information \n",
    "\n",
    "            CheminInvalide.setText(\"Chemin Invalide\") #on initialise le message à \"Chemin invalide\"\n",
    "            CheminInvalide.exec_() #on lance l'affichage de la fenetre\n",
    "    \n",
    "    #fonction lié au bouton Retour : ne permet que de revenir sur la dernière action effectuée \n",
    "    def btn_Retour(self):\n",
    "        #si une image est importée on procède a effacer la dernière modification que l'on a effectué sur celle-ci\n",
    "        #sinon il ne se passe rien\n",
    "        if (self.imageImportee == 1):\n",
    "            #si la denrière action est sur le curseur zoom alors on réinitialise celui-ci à 50\n",
    "            if (self.valzoom == 1):\n",
    "                self.curseurZoom.setValue(50)\n",
    "            #si la denrière action est sur le curseur contraste alors on réinitialise celui-ci à 50\n",
    "            if (self.valconstraste == 1):\n",
    "                self.curseurContraste.setValue(50)\n",
    "            #si la denrière action est sur le curseur flou alors on réinitialise celui-ci à 50\n",
    "            if (self.valflou == 1):\n",
    "                self.curseurFlou.setValue(50)\n",
    "            imgAffiche = self.imgCurrent.copie() #image affiche prend une copie d'image courante\n",
    "            \n",
    "            #les if qui suivent permettent d'afficher les modifications apportées par les curseurs sans endommagé l'image courante\n",
    "             #si le curseur zoom est différent de 50 on applique la valeur du zoom a image affiche\n",
    "            if (self.sizezoom != 50):\n",
    "                imgAffiche = imgAffiche.Zoom(self.sizezoom/50)\n",
    "             #si le curseur contraste est différent de 50 on applique la valeur du contraste a image affiche\n",
    "            if (self.sizeContraste != 50):\n",
    "                imgAffiche = imgAffiche.Contrast((self.sizeContraste-49)/10)\n",
    "             #si le curseur flou est différent de 50 on applique la valeur du flou a image affiche\n",
    "            if (self.sizeflou != 50):\n",
    "                if (self.sizeflou > 50):\n",
    "                    imgAffiche = imgAffiche.Sharpen((self.sizeflou-49)/10)\n",
    "                else :\n",
    "                    imgAffiche = imgAffiche.Fuzzy((51-self.sizeflou)/10)\n",
    "            #affichage de l'image modifié dans la fenetre    \n",
    "            self.cadre.setPixmap(pil2pixmap(imgAffiche.image)) #.scaled(600,300,Qt.KeepAspectRatio))\n",
    "            self.imgCurrent = self.imgRetour.copie() #image courante prend une copie de l'image Retour\n",
    "            \n",
    "            #on remet à 0 la valeur de l'action du zoom, du contraste et du flou\n",
    "            self.valzoom = 0\n",
    "            self.valconstraste = 0\n",
    "            self.valflou = 0\n",
    "\n",
    "    #fonciton liée au bouton réinitialiser\n",
    "    def btn_Reinit(self):\n",
    "        #si une image est importée on procède a reinitialiser les curseurs et l'image courante reprend la valeur de le de l'image de base \n",
    "        #sinon il ne se passe rien\n",
    "        if (self.imageImportee == 1):\n",
    "            self.curseurZoom.setValue(50)# on remet le curseur zoom a 50\n",
    "            self.curseurContraste.setValue(50) #on remet le curseur contraste a 50\n",
    "            self.curseurFlou.setValue(50) #on remet le curseur flou à 50\n",
    "            #on remet à 0 la valeur de l'action du zoom, du contraste et du flou\n",
    "            self.valzoom = 0\n",
    "            self.valconstraste = 0\n",
    "            self.valflou = 0\n",
    "            #on affiche l'image de base\n",
    "            self.cadre.setPixmap(pil2pixmap(self.imgbase.image))\n",
    "            self.imgCurrent = self.imgbase.copie()# l'image courante prend une copie de l'image de base\n",
    "        \n",
    "    def btn_Rotation(self):\n",
    "        #si une image est importée on applique une rotation vers la droite à l'image courante\n",
    "        #sinon il ne se passe rien\n",
    "        if (self.imageImportee == 1):\n",
    "            self.imgRetour = self.imgCurrent.copie() #image retour prend une copie de l'image courante\n",
    "            imgAffiche = self.imgCurrent.copie() #image affiche prend une copie d'image courante\n",
    "            #si le curseur zoom est différent de 50 on applique la valeur du zoom a image affiche\n",
    "            if (self.sizezoom != 50):\n",
    "                imgAffiche = imgAffiche.Zoom(self.sizezoom/50)\n",
    "            #si le curseur contraste est différent de 50 on applique la valeur du contraste a image affiche\n",
    "            if (self.sizeContraste != 50):\n",
    "                imgAffiche = imgAffiche.Contrast((self.sizeContraste-49)/10)\n",
    "            #si le curseur flou est différent de 50 on applique la valeur du flou a image affiche\n",
    "            if (self.sizeflou != 50):\n",
    "                if (self.sizeflou > 50):\n",
    "                    imgAffiche = imgAffiche.Sharpen((self.sizeflou-49)/10)\n",
    "                else :\n",
    "                    imgAffiche = imgAffiche.Fuzzy((51-self.sizeflou)/10)\n",
    "            imgAffiche = imgAffiche.RightRotation() #on applique la rotation a image affiche\n",
    "            imgAffiche.image.thumbnail((600,300)) #on ajuste image affiche pour qu'elle puisse etre vu en entier dans la fenetre\n",
    "            self.cadre.setPixmap(pil2pixmap(imgAffiche.image)) #on affiche l'image avec une rotation à droite\n",
    "            self.imgCurrent.RightRotation() #on applique la rotation à l'image courante\n",
    "            #on remet à 0 la valeur de l'action du zoom, du contraste et du flou\n",
    "            self.valzoom = 0\n",
    "            self.valconstraste = 0\n",
    "            self.valflou = 0\n",
    "        \n",
    "    def btn_Neg(self):\n",
    "        #si une image est importée on applique le filtre négatif à l'image courante\n",
    "        #sinon il ne se passe rien\n",
    "        if (self.imageImportee == 1):\n",
    "            self.imgRetour = self.imgCurrent.copie() #image retour prend une copie de l'image courante\n",
    "            imgAffiche = self.imgCurrent.copie() #image affiche prend une copie d'image courante\n",
    "            #si le curseur zoom est différent de 50 on applique la valeur du zoom a image affiche\n",
    "            if (self.sizezoom != 50):\n",
    "                imgAffiche = imgAffiche.Zoom(self.sizezoom/50)\n",
    "            #si le curseur contraste est différent de 50 on applique la valeur du contraste a image affiche\n",
    "            if (self.sizeContraste != 50):\n",
    "                imgAffiche = imgAffiche.Contrast((self.sizeContraste-49)/10)\n",
    "            #si le curseur flou est différent de 50 on applique la valeur duflou a image affiche\n",
    "            if (self.sizeflou != 50):\n",
    "                if (self.sizeflou > 50):\n",
    "                    imgAffiche = imgAffiche.Sharpen((self.sizeflou-49)/10)\n",
    "                else :\n",
    "                    imgAffiche = imgAffiche.Fuzzy((51-self.sizeflou)/10)\n",
    "            self.cadre.setPixmap(pil2pixmap(imgAffiche.Negative().image)) #on affiche l'image avec le filtre négatif\n",
    "            self.imgCurrent.Negative()  #on applique le filtre négatif à l'image courante\n",
    "            #on remet à 0 la valeur de l'action du zoom, du contraste et du flou\n",
    "            self.valzoom = 0\n",
    "            self.valconstraste = 0\n",
    "            self.valflou = 0\n",
    "        \n",
    "    def btn_Sob(self):\n",
    "        #si une image est importée on applique le filtre de detection des contours à l'image courante\n",
    "        #sinon il ne se passe rien\n",
    "        if (self.imageImportee == 1):\n",
    "            self.imgRetour = self.imgCurrent.copie() #image retour prend une copie de l'image courante\n",
    "            self.imgCurrent = self.imgCurrent.Sobel()  #on applique le filtre de detection de contours à l'image courante\n",
    "            imgAffiche = self.imgCurrent.copie() #image affiche prend une copie d'image courante\n",
    "            #si le curseur zoom est différent de 50 on applique la valeur du zoom a image affiche\n",
    "            if (self.sizezoom != 50):\n",
    "                imgAffiche = imgAffiche.Zoom(self.sizezoom/50)\n",
    "            #si le curseur contraste est différent de 50 on applique la valeur du contraste a image affiche\n",
    "            if (self.sizeContraste != 50):\n",
    "                imgAffiche = imgAffiche.Contrast((self.sizeContraste-49)/10)\n",
    "            #si le curseur flou est différent de 50 on applique la valeur du flou a image affiche\n",
    "            if (self.sizeflou != 50):\n",
    "                if (self.sizeflou > 50):\n",
    "                    imgAffiche = imgAffiche.Sharpen((self.sizeflou-49)/10)\n",
    "                else :\n",
    "                    imgAffiche = imgAffiche.Fuzzy((51-self.sizeflou)/10)\n",
    "            self.cadre.setPixmap(pil2pixmap(imgAffiche.image)) #on affiche l'image avec le filtre de detection des contours\n",
    "            #on remet à 0 la valeur de l'action du zoom, du contraste et du flou\n",
    "            self.valzoom = 0\n",
    "            self.valconstraste = 0\n",
    "            self.valflou = 0\n",
    "    \n",
    "    def btn_Moy(self):\n",
    "        #si une image est importée on applique le filtre lissant à l'image courante\n",
    "        #sinon il ne se passe rien\n",
    "        if (self.imageImportee == 1):\n",
    "            self.imgRetour = self.imgCurrent.copie() #image retour prend une copie de l'image courante\n",
    "            self.imgCurrent = self.imgCurrent.Moyen()  #on applique le filtre lissant à l'image courante\n",
    "            imgAffiche = self.imgCurrent.copie() #image affiche prend une copie d'image courante\n",
    "            #si le curseur zoom est différent de 50 on applique la valeur du zoom a image affiche\n",
    "            if (self.sizezoom != 50):\n",
    "                imgAffiche = imgAffiche.Zoom(self.sizezoom/50)\n",
    "            #si le curseur contraste est différent de 50 on applique la valeur du contraste a image affiche\n",
    "            if (self.sizeContraste != 50):\n",
    "                imgAffiche = imgAffiche.Contrast((self.sizeContraste-49)/10)\n",
    "            #si le curseur flou est différent de 50 on applique la valeur du flou a image affiche\n",
    "            if (self.sizeflou != 50):\n",
    "                if (self.sizeflou > 50):\n",
    "                    imgAffiche = imgAffiche.Sharpen((self.sizeflou-49)/10)\n",
    "                else :\n",
    "                    imgAffiche = imgAffiche.Fuzzy((51-self.sizeflou)/10)\n",
    "            self.cadre.setPixmap(pil2pixmap(imgAffiche.image)) #on affiche l'image avec le filtre lissant\n",
    "            #on remet à 0 la valeur de l'action du zoom, du contraste et du flou\n",
    "            self.valzoom = 0\n",
    "            self.valconstraste = 0\n",
    "            self.valflou = 0\n",
    "    \n",
    "    def btn_Med(self):\n",
    "        #si une image est importée on applique le filtre médian à l'image courante\n",
    "        #sinon il ne se passe rien\n",
    "        if (self.imageImportee == 1):\n",
    "            self.imgRetour = self.imgCurrent.copie() #image retour prend une copie de l'image courante\n",
    "            self.imgCurrent = self.imgCurrent.Median()  #on applique le filtre médian à l'image courante\n",
    "            imgAffiche = self.imgCurrent.copie() #image affiche prend une copie d'image courante\n",
    "            #si le curseur zoom est différent de 50 on applique la valeur du zoom a image affiche\n",
    "            if (self.sizezoom != 50):\n",
    "                imgAffiche = imgAffiche.Zoom(self.sizezoom/50)\n",
    "            #si le curseur contraste est différent de 50 on applique la valeur du contraste a image affiche\n",
    "            if (self.sizeContraste != 50):\n",
    "                imgAffiche = imgAffiche.Contrast((self.sizeContraste-49)/10)\n",
    "            #si le curseur flou est différent de 50 on applique la valeur du flou a image affiche\n",
    "            if (self.sizeflou != 50):\n",
    "                if (self.sizeflou > 50):\n",
    "                    imgAffiche = imgAffiche.Sharpen((self.sizeflou-49)/10)\n",
    "                else :\n",
    "                    imgAffiche = imgAffiche.Fuzzy((51-self.sizeflou)/10)\n",
    "            self.cadre.setPixmap(pil2pixmap(imgAffiche.image)) #on affiche l'image avec le filtre médian\n",
    "            #on remet à 0 la valeur de l'action du zoom, du contraste et du flou\n",
    "            self.valzoom = 0\n",
    "            self.valconstraste = 0\n",
    "            self.valflou = 0\n",
    "    \n",
    "    def btn_NG(self):\n",
    "        #si une image est importée on applique le filtre de niveaux de gris à l'image courante\n",
    "        #sinon il ne se passe rien\n",
    "        if (self.imageImportee == 1):\n",
    "            self.imgRetour = self.imgCurrent.copie() #image retour prend une copie de l'image courante\n",
    "            self.imgCurrent = self.imgCurrent.GrayScale()  #on applique le filtrede niveaux de gris à l'image courante\n",
    "            imgAffiche = self.imgCurrent.copie() #image affiche prend une copie d'image courante\n",
    "            #si le curseur zoom est différent de 50 on applique la valeur du zoom a image affiche\n",
    "            if (self.sizezoom != 50):\n",
    "                imgAffiche = imgAffiche.Zoom(self.sizezoom/50)\n",
    "            #si le curseur contraste est différent de 50 on applique la valeur du contraste a image affiche\n",
    "            if (self.sizeContraste != 50):\n",
    "                imgAffiche = imgAffiche.Contrast((self.sizeContraste-49)/10)\n",
    "            #si le curseur flou est différent de 50 on applique la valeur du flou a image affiche\n",
    "            if (self.sizeflou != 50):\n",
    "                if (self.sizeflou > 50):\n",
    "                    imgAffiche = imgAffiche.Sharpen((self.sizeflou-49)/10)\n",
    "                else :\n",
    "                    imgAffiche = imgAffiche.Fuzzy((51-self.sizeflou)/10)\n",
    "            self.cadre.setPixmap(pil2pixmap(imgAffiche.image)) #on affiche l'image avec le filtre de niveaux de gris\n",
    "            #on remet à 0 la valeur de l'action du zoom, du contraste et du flou\n",
    "            self.valzoom = 0\n",
    "            self.valconstraste = 0\n",
    "            self.valflou = 0\n",
    "        \n",
    "    def btn_Enregistre(self):\n",
    "        #si une image est importée on peut enregistrer l'image\n",
    "        #sinon il ne se passe rien\n",
    "        if (self.imageImportee == 1):\n",
    "            #si le curseur zoom est différent de 50 on applique la valeur du zoom a image courante\n",
    "            if (self.sizezoom != 50):\n",
    "                self.imgCurrent.Zoom(self.sizezoom/50)\n",
    "            #si le curseur contraste est différent de 50 on applique la valeur du contraste a image courante\n",
    "            if (self.sizeContraste != 50):\n",
    "                self.imgCurrent.Contrast((self.sizeContraste-49)/10)\n",
    "            #si le curseur flou est différent de 50 on applique la valeur du flou a image courante\n",
    "            if (self.sizeflou != 50):\n",
    "                if (self.sizeflou > 50):\n",
    "                    self.imgCurrent.Sharpen((self.sizeflou-49)/10)\n",
    "                else :\n",
    "                    self.imgCurrent.Fuzzy((51-self.sizeflou)/10)\n",
    "            #on appelle le constructeur de la fenetre de dialogue en mettant en argument l'image modifiée\n",
    "            fenEnr = FenetreEnregistre(self.imgCurrent)\n",
    "            #on execute la fenetre de dialogue pour enregistrer l'image\n",
    "            if fenEnr.exec_() : \n",
    "                print(\"yeah\") #pour tester si la fenêtre s'execute bien\n",
    "            fenEnr.show()\n",
    "\n",
    "#on vérifie s'il existe déjà une instance de QApplication    \n",
    "app = QApplication.instance() \n",
    "# sinon on crée une instance de QApplication\n",
    "if not app:\n",
    "    app = QApplication(sys.argv)\n",
    "\n",
    "#on crée une fenetre principale\n",
    "fen = Fenetre()\n",
    "#on l'affiche\n",
    "fen.show()\n",
    "\n",
    "#execution de l'application\n",
    "app.exec_()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5daadc96",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}