import numpy as np
from PyQt5.QtCore import QDateTime, Qt, QTimer
from PyQt5.QtGui import QImage, QPixmap, QPalette, QPainter
from PyQt5 import QtCore, QtGui, QtWidgets
from PyQt5.QtPrintSupport import QPrintDialog, QPrinter
from PyQt5.QtWidgets import QMessageBox, QProgressBar, QFileDialog
import cv2
import matplotlib.pyplot as plt


class Ui_Interface(object):
    def setupUi(self, Interface):

        Interface.setObjectName("Interface-CAM-python")
        Interface.setWindowModality(QtCore.Qt.NonModal)
        Interface.setMinimumSize(QtCore.QSize(800, 600))
        Interface.setWindowFlags(QtCore.Qt.WindowMaximizeButtonHint | QtCore.Qt.WindowMinimizeButtonHint)

        self.centralwidget = QtWidgets.QWidget(Interface)
        self.centralwidget.setObjectName("centralwidget")
        self.gridLayout_3 = QtWidgets.QGridLayout(self.centralwidget)
        self.gridLayout_3.setObjectName("gridLayout_3")
# layout pour les deux images principales
        self.horizontalLayout = QtWidgets.QHBoxLayout()
        self.horizontalLayout.setObjectName("horizontalLayout")
#latout pout les petites images
        self.horizontalLayout2 = QtWidgets.QHBoxLayout()
        self.horizontalLayout2.setObjectName("horizontalLayout2")
#trois composants
        #################################
        ##1
        self.Layout1 = QtWidgets.QVBoxLayout()
        self.Layout1.setContentsMargins(10, -1, 10, -1)
        self.Layout1.setSpacing(10)
        self.Layout1.setObjectName("Layout1")
        
        self.label_1 = QtWidgets.QLabel(self.centralwidget)
        self.label_1.setMinimumSize(QtCore.QSize(0, 0))
        self.label_1.setMaximumSize(QtCore.QSize(16777215, 50))
        self.label_1.setFrameShadow(QtWidgets.QFrame.Plain)
        self.label_1.setTextFormat(QtCore.Qt.AutoText)
        self.label_1.setAlignment(QtCore.Qt.AlignCenter)
        self.label_1.setObjectName("label_1")
        
        self.Layout1.addWidget(self.label_1)

        self.PictureLabel = QtWidgets.QLabel(self.centralwidget)
        self.PictureLabel.setMaximumSize(QtCore.QSize(200, 100))
        self.PictureLabel.setSizeIncrement(QtCore.QSize(0, 0))
        self.PictureLabel.setBaseSize(QtCore.QSize(200, 100))
        self.PictureLabel.setCursor(QtGui.QCursor(QtCore.Qt.PointingHandCursor))
        self.PictureLabel.setFrameShape(QtWidgets.QFrame.Box)
        self.PictureLabel.setMidLineWidth(0)
        self.PictureLabel.setIndent(-2)
        self.PictureLabel.setObjectName("PictureLabel")
        self.Layout1.addWidget(self.PictureLabel)

        ##2
        self.Layout12 = QtWidgets.QVBoxLayout()
        self.Layout12.setContentsMargins(10, -1, 10, -1)
        self.Layout12.setSpacing(10)
        self.Layout12.setObjectName("Layout12")
        
        self.label_12 = QtWidgets.QLabel(self.centralwidget)
        self.label_12.setMinimumSize(QtCore.QSize(0, 0))
        self.label_12.setMaximumSize(QtCore.QSize(16777215, 50))
        self.label_12.setFrameShadow(QtWidgets.QFrame.Plain)
        self.label_12.setTextFormat(QtCore.Qt.AutoText)
        self.label_12.setAlignment(QtCore.Qt.AlignCenter)
        self.label_12.setObjectName("label_12")
        
        self.Layout12.addWidget(self.label_12)

        self.PictureLabel2 = QtWidgets.QLabel(self.centralwidget)
        self.PictureLabel2.setMaximumSize(QtCore.QSize(200, 100))
        self.PictureLabel2.setSizeIncrement(QtCore.QSize(0, 0))
        self.PictureLabel2.setBaseSize(QtCore.QSize(200, 100))
        self.PictureLabel2.setCursor(QtGui.QCursor(QtCore.Qt.PointingHandCursor))
        self.PictureLabel2.setFrameShape(QtWidgets.QFrame.Box)
        self.PictureLabel2.setMidLineWidth(0)
        self.PictureLabel2.setIndent(-2)
        self.PictureLabel2.setObjectName("PictureLabel2")

        self.Layout12.addWidget(self.PictureLabel2)

        ##3
        self.Layout13 = QtWidgets.QVBoxLayout()
        self.Layout13.setContentsMargins(10, -1, 10, -1)
        self.Layout13.setSpacing(10)
        self.Layout13.setObjectName("Layout13")
        
        self.label_13 = QtWidgets.QLabel(self.centralwidget)
        self.label_13.setMinimumSize(QtCore.QSize(0, 0))
        self.label_13.setMaximumSize(QtCore.QSize(16777215, 50))
        self.label_13.setFrameShadow(QtWidgets.QFrame.Plain)
        self.label_13.setTextFormat(QtCore.Qt.AutoText)
        self.label_13.setAlignment(QtCore.Qt.AlignCenter)
        self.label_13.setObjectName("label_13")
        
        self.Layout13.addWidget(self.label_13)

        self.PictureLabel3 = QtWidgets.QLabel(self.centralwidget)
        self.PictureLabel3.setMaximumSize(QtCore.QSize(200, 100))
        self.PictureLabel3.setSizeIncrement(QtCore.QSize(0, 0))
        self.PictureLabel3.setBaseSize(QtCore.QSize(200, 100))
        self.PictureLabel3.setCursor(QtGui.QCursor(QtCore.Qt.PointingHandCursor))
        self.PictureLabel3.setFrameShape(QtWidgets.QFrame.Box)
        self.PictureLabel3.setMidLineWidth(0)
        self.PictureLabel3.setIndent(-2)
        self.PictureLabel3.setObjectName("PictureLabel3")

        self.Layout13.addWidget(self.PictureLabel3)

        ######################################

        self.verticalLayout_4 = QtWidgets.QVBoxLayout()
        self.verticalLayout_4.setContentsMargins(20, -1, 10, -1)
        self.verticalLayout_4.setSpacing(20)
        self.verticalLayout_4.setObjectName("verticalLayout_4")
        self.label_3 = QtWidgets.QLabel(self.centralwidget)
        self.label_3.setMinimumSize(QtCore.QSize(0, 0))
        self.label_3.setMaximumSize(QtCore.QSize(16777215, 50))
        font = QtGui.QFont()
        font.setBold(True)
        font.setItalic(True)
        font.setWeight(75)
        self.label_3.setFont(font)
        self.label_3.setFrameShadow(QtWidgets.QFrame.Plain)
        self.label_3.setTextFormat(QtCore.Qt.AutoText)
        self.label_3.setAlignment(QtCore.Qt.AlignCenter)
        self.label_3.setObjectName("label_3")
        self.verticalLayout_4.addWidget(self.label_3)
        self.originalpictureLabel = QtWidgets.QLabel(self.centralwidget)
        self.originalpictureLabel.setMaximumSize(QtCore.QSize(400, 320))
        self.originalpictureLabel.setBaseSize(QtCore.QSize(400, 320))
        self.originalpictureLabel.setCursor(QtGui.QCursor(QtCore.Qt.PointingHandCursor))
        self.originalpictureLabel.setMouseTracking(False)
        self.originalpictureLabel.setAutoFillBackground(False)
        self.originalpictureLabel.setFrameShape(QtWidgets.QFrame.Panel)
        self.originalpictureLabel.setMidLineWidth(1)
        self.originalpictureLabel.setText("")
        self.originalpictureLabel.setObjectName("originalpictureLabel")
        self.verticalLayout_4.addWidget(self.originalpictureLabel)
        self.horizontalLayout.addLayout(self.verticalLayout_4)
        
        self.verticalLayout_3 = QtWidgets.QVBoxLayout()
        self.verticalLayout_3.setContentsMargins(10, -1, 20, -1)
        self.verticalLayout_3.setSpacing(20)
        self.verticalLayout_3.setObjectName("verticalLayout_3")
        self.label_4 = QtWidgets.QLabel(self.centralwidget)
        self.label_4.setMinimumSize(QtCore.QSize(0, 0))
        self.label_4.setMaximumSize(QtCore.QSize(16777215, 50))
        self.label_4.setFont(font)
        self.label_4.setLayoutDirection(QtCore.Qt.LeftToRight)
        self.label_4.setAlignment(QtCore.Qt.AlignCenter)
        self.label_4.setObjectName("label_4")
        self.verticalLayout_3.addWidget(self.label_4)
        self.modifiedPictureLabel = QtWidgets.QLabel(self.centralwidget)
        self.modifiedPictureLabel.setMaximumSize(QtCore.QSize(400, 320))
        self.modifiedPictureLabel.setSizeIncrement(QtCore.QSize(0, 0))
        self.modifiedPictureLabel.setBaseSize(QtCore.QSize(400, 320))
        self.modifiedPictureLabel.setCursor(QtGui.QCursor(QtCore.Qt.PointingHandCursor))
        self.modifiedPictureLabel.setFrameShape(QtWidgets.QFrame.Box)
        self.modifiedPictureLabel.setMidLineWidth(0)
        self.modifiedPictureLabel.setIndent(-2)
        self.modifiedPictureLabel.setObjectName("modifiedPictureLabel")
        self.verticalLayout_3.addWidget(self.modifiedPictureLabel)
        self.horizontalLayout.addLayout(self.verticalLayout_3)

        self.horizontalLayout2.addLayout(self.Layout1)
        self.horizontalLayout2.addLayout(self.Layout12)
        self.horizontalLayout2.addLayout(self.Layout13)

        self.label_time = QtWidgets.QLabel(self.centralwidget)
        self.label_time.setMinimumSize(QtCore.QSize(0, 0))
        self.label_time.setMaximumSize(QtCore.QSize(16777215, 50))
        self.label_time.setFrameShadow(QtWidgets.QFrame.Plain)
        self.label_time.setTextFormat(QtCore.Qt.AutoText)
        self.label_time.setAlignment(QtCore.Qt.AlignCenter)
        self.label_time.setObjectName("label_time")
        self.label_time.setText("label_time")
        
        self.gridLayout_3.addLayout(self.horizontalLayout, 0, 0, 1, 2)
        
        self.gridLayout_3.addLayout(self.horizontalLayout2, 1, 0, 1, 2)

        self.gridLayout_3.addWidget(self.label_time,3, 0, 1, 2)


        # variables ##########################################################################
        #tailles max et min des contours
        self.MIN_CONTOUR_AREA = 80
        self.MAX_CONTOUR_AREA = 8000

        self.MIN_RATIO = 0.2
        self.MAX_RATIO = 2.0

        self.binar=0
        self.grayscale=0
        self.Rotat=0
        self.test=0
        
        
        #ce timer sera utiliser aprés dans l'aquisition du flux camera
        self.timercam = QTimer()
        self.timercam.timeout.connect(self.cam)
        self.timertime = QTimer()
        self.timertime.timeout.connect(self.Time)
        self.i_time=0
        self.i_timem=0
        self.timerShowTime = QTimer()
        self.timerShowTime.timeout.connect(self.showTimeCam)
        
        Interface.setCentralWidget(self.centralwidget)


        #crée le menubar
        self.menubar = QtWidgets.QMenuBar(Interface)
        self.menubar.setGeometry(QtCore.QRect(0, 0, 915, 22))

        #crée les menuitems
        self.menubar.setObjectName("menubar")
        self.menuFile = QtWidgets.QMenu(self.menubar)
        self.menuFile.setObjectName("menuFile")
        self.menuFunctions = QtWidgets.QMenu(self.menubar)
        self.menuFunctions.setObjectName("menuFunctions")
        self.menuTransformations = QtWidgets.QMenu(self.menubar)
        self.menuTransformations.setObjectName("menuTransformations")
        self.menuHelps = QtWidgets.QMenu(self.menubar)
        self.menuHelps.setObjectName("menuHelps")
        Interface.setMenuBar(self.menubar)
        
        #crée le statubar
        self.statusbar = QtWidgets.QStatusBar(Interface)
        self.statusbar.setObjectName("statusbar")
        Interface.setStatusBar(self.statusbar)

        #crée les sous menu
        self.actionOpen = QtWidgets.QAction(Interface)        
        self.actionOpen.setObjectName("actionOpen")         
        self.actionCapture = QtWidgets.QAction(Interface)
        self.actionCapture.setObjectName("actionCapture")
        self.actionCAM = QtWidgets.QAction(Interface)
        self.actionCAM.setObjectName("actionCAM")
        self.actionSave = QtWidgets.QAction(Interface)
        self.actionSave.setObjectName("actionSave")
        self.actionPrint = QtWidgets.QAction(Interface)
        self.actionPrint.setObjectName("actionPrint")
        self.actionClose = QtWidgets.QAction(Interface)
        self.actionClose.setObjectName("actionClose")

        self.actionRotation = QtWidgets.QAction(Interface)
        self.actionRotation.setObjectName("actionRotation")
        
        self.actionTraitement = QtWidgets.QAction(Interface)
        self.actionTraitement.setObjectName("actionTraitement")
        self.actionGrayscale = QtWidgets.QAction(Interface)
        self.actionGrayscale.setObjectName("actionGrayscale")
        self.actionBinary = QtWidgets.QAction(Interface)
        self.actionBinary.setObjectName("actionBinary")
        self.actionRGB_decomp = QtWidgets.QAction(Interface)
        self.actionRGB_decomp.setObjectName("actionRGB_decomp")
        self.actionYcbcr = QtWidgets.QAction(Interface)
        self.actionYcbcr.setObjectName("actionYcbcr")
        self.actionETIQ = QtWidgets.QAction(Interface)
        self.actionETIQ.setObjectName("actionETIQ")

        self.actionAbout_App = QtWidgets.QAction(Interface)
        self.actionAbout_App.setObjectName("actionAbout_App")

        #crée chaque menu sur l'interface..
        self.menuFile.addAction(self.actionOpen)
        self.menuFile.addAction(self.actionCapture)
        self.menuFile.addAction(self.actionCAM)
        self.menuFile.addAction(self.actionSave)
        self.menuFile.addSeparator()
        self.menuFile.addAction(self.actionPrint)
        self.menuFile.addSeparator()
        self.menuFile.addAction(self.actionClose)
        
        self.menuFunctions.addAction(self.actionGrayscale)
        self.menuFunctions.addAction(self.actionBinary)
        self.menuFunctions.addAction(self.actionGrayscale)
        self.menuFile.addSeparator()
        self.menuFunctions.addAction(self.actionRGB_decomp)
        self.menuFunctions.addAction(self.actionYcbcr)
        self.menuFile.addSeparator()
        self.menuFunctions.addAction(self.actionETIQ)

        self.menuTransformations.addAction(self.actionRotation)

        self.menuHelps.addAction(self.actionAbout_App)

        #crée les actions de chaque menu crée la relation avec la fonction correspondante..
        self.menubar.addAction(self.menuFile.menuAction())
        self.menubar.addAction(self.menuFunctions.menuAction())
        self.menubar.addAction(self.menuTransformations.menuAction())        
        self.menubar.addAction(self.menuHelps.menuAction())

        self.actionOpen.triggered.connect(self.open1)
        self.actionCapture.triggered.connect(self.capture)
        self.actionCAM.triggered.connect(self.cam)
  
        
        self.actionGrayscale.triggered.connect(self.Grayscale)
        self.actionBinary.triggered.connect(self.Binary)
        self.actionYcbcr.triggered.connect(self.ycbcr)
        self.actionETIQ.triggered.connect(self.etiquettage)
        self.actionRGB_decomp.triggered.connect(self.RGB_decomposition)

        self.actionRotation.triggered.connect(self.rotation)
        
        self.actionAbout_App.triggered.connect(self.About_App)
        self.actionPrint.triggered.connect(self.print)
        self.actionSave.triggered.connect(self.save)
        self.actionClose.triggered.connect(self.Close)        
        self.retranslateUi(Interface)
        QtCore.QMetaObject.connectSlotsByName(Interface)


        
    def RGB_decomposition(self):
        img =cv2.cvtColor(self.mat1, cv2.COLOR_BGR2RGB) 
        l=self.mat1.shape[0]
        h=self.mat1.shape[1]
        #crée un tableau de troix canals toute remplite de zeroes de la meme taille de l'image 
        img2 = np.zeros((l, h, 3), dtype=np.uint8)
        #ne garder que le canal rouge (le premier canal dans ce cas RGB)
        img2[:,:,0]=img[:,:,0]

        #ce commentaire faire presque la méme chose         
##        i=0
##        while i<l :
##            j=0
##            while j<h :
##                (r,g,b)=img[i,j]
##                #r1=img[i,j,0]
##                img[i,j]=(r,0,0)
##                j+=1
##            i+=1
        cvt2qt = QtGui.QImage(img2.data, self.mat1.shape[1], self.mat1.shape[0],self.mat1.shape[1]*3,QtGui.QImage.Format_RGB888)
        self.PictureLabel.setPixmap(QPixmap.fromImage(cvt2qt))
        self.PictureLabel.setScaledContents(True)
        self.label_1.setText("canal Rouge")
        
        img2 = np.zeros((l, h, 3), dtype=np.uint8)
        img2[:,:,1]=img[:,:,1]
        cvt2qt = QtGui.QImage(img2.data, self.mat1.shape[1], self.mat1.shape[0],self.mat1.shape[1]*3,QtGui.QImage.Format_RGB888)
        self.PictureLabel2.setPixmap(QPixmap.fromImage(cvt2qt))
        self.PictureLabel2.setScaledContents(True)
        self.label_12.setText("canal Vert")

        img2 = np.zeros((l, h, 3), dtype=np.uint8)
        img2[:,:,2]=img[:,:,2]
        cvt2qt = QtGui.QImage(img2.data, self.mat1.shape[1], self.mat1.shape[0],self.mat1.shape[1]*3,QtGui.QImage.Format_RGB888)
        self.PictureLabel3.setPixmap(QPixmap.fromImage(cvt2qt))
        self.PictureLabel3.setScaledContents(True)
        self.label_13.setText("canal Bleu")        


    def ycbcr(self):
        Ycrcb = cv2.cvtColor(self.mat1, cv2.COLOR_BGR2YCrCb)
        cvt2qt = QtGui.QImage(Ycrcb.data, self.mat1.shape[1], self.mat1.shape[0],self.mat1.shape[1]*3, QtGui.QImage.Format_RGB888)
        self.affichage_traitment(cvt2qt)
        #Y
        Y = Ycrcb[:, :, 0]
        Y = cv2.cvtColor(Y, cv2.COLOR_GRAY2RGB)
        cvt2qt = QtGui.QImage(Y.data, self.mat1.shape[1], self.mat1.shape[0],self.mat1.shape[1]*3,QtGui.QImage.Format_RGB888)
        self.PictureLabel.setPixmap(QPixmap.fromImage(cvt2qt))
        self.PictureLabel.setScaledContents(True)
        self.label_1.setText("canal Y")
        

        #cr
        Y = Ycrcb[:, :, 1]
        Y = cv2.cvtColor(Y, cv2.COLOR_GRAY2RGB)
        cvt2qt = QtGui.QImage(Y.data, self.mat1.shape[1], self.mat1.shape[0],self.mat1.shape[1]*3,QtGui.QImage.Format_RGB888)
        self.PictureLabel2.setPixmap(QPixmap.fromImage(cvt2qt))
        self.PictureLabel2.setScaledContents(True)
        self.label_12.setText("canal CR")

        #cb
        Y = Ycrcb[:, :, 2]
        Y = cv2.cvtColor(Y, cv2.COLOR_GRAY2RGB)
        cvt2qt = QtGui.QImage(Y.data, self.mat1.shape[1], self.mat1.shape[0],self.mat1.shape[1]*3,QtGui.QImage.Format_RGB888)
        self.PictureLabel3.setPixmap(QPixmap.fromImage(cvt2qt))
        self.PictureLabel3.setScaledContents(True)
        self.label_13.setText("canal CB")


    def etiquettage(self):
##        images = []
        imgTestingNumbers = cv2.resize(self.mat1, (420, 120))   # resize image
        imgGray = cv2.cvtColor(imgTestingNumbers, cv2.COLOR_BGR2GRAY)       # grayscale image
        imgBlurred = cv2.GaussianBlur(imgGray, (5,5), 0)                    # filtrage gaussian

        # image seuillage adaptatif (grayscale to black and white)
        imgThresh = cv2.adaptiveThreshold(imgBlurred,                           # image
                                          255,                                  # limiter le plafond a 255 pour les valeurs qui dépassent
                                          cv2.ADAPTIVE_THRESH_GAUSSIAN_C,       # utiliser le gaussian mieu que le moyenneur (mean),
                                          cv2.THRESH_BINARY_INV,                # inverser les black and white, le foreground = white, background = black
                                          11,                                   # taille du voisinage pour calculer le seuil
                                          2)                                    # constant la soustraction de la moyenne avec les les poids

        imgThreshCopy = imgThresh.copy()        # copie de l'image seuiller,
        cv2.imshow("imgThreshCopy", imgThreshCopy)

        npaContours, npaHierarchy = cv2.findContours(imgThreshCopy,             # entrer l'image, utiliser la copie, puisque cette function change cette image au cours de la recherche des contours
                                                     cv2.RETR_EXTERNAL,         # utilise seulement les contours externe
                                                     cv2.CHAIN_APPROX_SIMPLE)   # compress les segments horizontal, vertical, et diagonal  et laisse les points d'extremeter
        
        for npaContour in npaContours:
            [intX, intY, intWidth, intHeight] = cv2.boundingRect(npaContour)# parcouris chaque contour
            fltArea = cv2.contourArea(npaContour)
            ratio=(intWidth)/(intHeight)
            if (fltArea > self.MIN_CONTOUR_AREA) & (fltArea < self.MAX_CONTOUR_AREA):        # vérifier la surface
                if (ratio > self.MIN_RATIO) & (ratio < self.MAX_RATIO):
                    cv2.rectangle(imgTestingNumbers,                                        # dessiner un rectangle sur l'image originale
                                  (intX, intY),     # coint haut gauche
                                  (intX + intWidth, intY + intHeight),      # coin bas droite
                                  (0, 255, 0),              # couleur de ligne verte
                                  2)                        # episseur
##                    imgROI = imgTestingNumbers[intY : intY + intHeight,intX : intX + intWidth]     # couper chaque sous image des etiquette detecter avec leurs taille mais sur l'image seuillée                                               
##                    images.append(imgROI)                   #j'ai crée un tableau pour contenir tout les sous-images
        imgTestingNumbers = cv2.cvtColor(imgTestingNumbers, cv2.COLOR_BGR2RGB) 
        cvt2qt = QtGui.QImage(imgTestingNumbers.data, imgTestingNumbers.shape[1], imgTestingNumbers.shape[0],imgTestingNumbers.shape[1]*3, QtGui.QImage.Format_RGB888)
        self.affichage_traitment(cvt2qt)
        

    def Close(self):
        sys.exit(app.exec_())
        self.timercam.stop()
        self.cap.release()
    
    def Binary(self):
        if(self.test==1):
            self.binar=1
            self.grayscale=0
            self.Rotat=0
        if(self.binar==0):
            GrayImage=cv2.cvtColor(self.mat1,cv2.COLOR_BGR2GRAY)  
            #ret,thresh1=cv2.threshold(GrayImage,127,255,cv2.THRESH_BINARY)  
            ##        ret,thresh1=cv2.threshold(GrayImage,127,255,cv2.THRESH_BINARY_INV)  
            ##        ret,thresh1=cv2.threshold(GrayImage,127,255,cv2.THRESH_TRUNC)  
            ##        ret,thresh1=cv2.threshold(GrayImage,127,255,cv2.THRESH_TOZERO)  
            ##        ret,thresh1=cv2.threshold(GrayImage,127,255,cv2.THRESH_TOZERO_INV)

            #'Adaptive Mean Thresholding'
            thresh1 = cv2.adaptiveThreshold(GrayImage,255,cv2.ADAPTIVE_THRESH_MEAN_C,cv2.THRESH_BINARY,11,2)
            #'Adaptive Gaussian Thresholding'
            #thresh1 = cv2.adaptiveThreshold(GrayImage,255,cv2.ADAPTIVE_THRESH_GAUSSIAN_C,cv2.THRESH_BINARY,11,2)
            
            cvt2qt = QtGui.QImage(thresh1.data, thresh1.shape[1], thresh1.shape[0],thresh1.shape[1],QtGui.QImage.Format_Grayscale8)
            self.affichage_traitment(cvt2qt)

    def Grayscale(self):
        if(self.test==1):
            self.grayscale=1
            self.binar=0
            self.Rotat=0
##            GrayImage = cv2.cvtColor(self.mat1, cv2.COLOR_BGR2GRAY)
        if(self.grayscale==0):
            GrayImage = cv2.cvtColor(self.mat1, cv2.COLOR_BGR2GRAY)
            cvt2qt = QtGui.QImage(GrayImage.data, self.mat1.shape[1], GrayImage.shape[0],GrayImage.shape[1],QtGui.QImage.Format_Grayscale8)
            self.affichage_traitment(cvt2qt)


    def rotation(self):        
        # Rotating the image after Warp
        if(self.test==1):
            self.Rotat=1
            self.binar=0
            self.grayscale=0
##            GrayImage = cv2.cvtColor(self.mat1, cv2.COLOR_BGR2GRAY)
        if(self.Rotat==0):
            image = cv2.cvtColor(self.mat1,cv2.COLOR_BGR2RGB)
            center = (image.shape[1]//2, image.shape[0]//2)
            angle = -50
            scale = 1
            rot_mat = cv2.getRotationMatrix2D( center, angle, scale )
            warp_rotate_dst = cv2.warpAffine(image, rot_mat, (image.shape[1], image.shape[0]))
            cvt2qt = QtGui.QImage(warp_rotate_dst.data, warp_rotate_dst.shape[1], warp_rotate_dst.shape[0],warp_rotate_dst.shape[1]*3,QtGui.QImage.Format_RGB888)
            self.affichage_traitment(cvt2qt)
        
##        self.modifiedPictureLabel.setPixmap(QPixmap.fromImage(cvt2qt))
##        self.modifiedPictureLabel.setScaledContents(True)
            
    def capture(self):     
        if (self.test==1):
            self.timercam.stop()
        if (self.test==0):
            self.cap = cv2.VideoCapture(0)
            self.test=1

        ret, self.mat1 = self.cap.read()
        GrayImage = cv2.cvtColor(self.mat1, cv2.COLOR_BGR2RGB)
        cvt2qt = QtGui.QImage(GrayImage.data, GrayImage.shape[1], GrayImage.shape[0],GrayImage.shape[1]*3, QtGui.QImage.Format_RGB888)
##        self.affichage_traitment(cvt2qt)
        self.affichage_CAM(cvt2qt)

#POUR TESTER AVEC TIMER
    def cam(self):
        if (self.test==0):
            self.cap = cv2.VideoCapture(0)
            self.test=1
        if (self.binar==1):
            ret, frame = self.cap.read()
            img = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
            ret,thresh1=cv2.threshold(img,127,255,cv2.THRESH_BINARY)  
    
            cvt2qt = QtGui.QImage(thresh1.data, thresh1.shape[1], thresh1.shape[0],thresh1.shape[1],QtGui.QImage.Format_Grayscale8)
            self.modifiedPictureLabel.setPixmap(QPixmap.fromImage(cvt2qt))
            self.modifiedPictureLabel.setScaledContents(True)
            
            #c'est juste un message que je vais utiliser pour dire que la cam est lancer

        if(self.Rotat==1):
            ret, frame = self.cap.read()
            image = cv2.cvtColor(frame,cv2.COLOR_BGR2RGB)
            center = (image.shape[1]//2, image.shape[0]//2)
            angle = -50
            scale = 1
            rot_mat = cv2.getRotationMatrix2D( center, angle, scale )
            warp_rotate_dst = cv2.warpAffine(image, rot_mat, (image.shape[1], image.shape[0]))
            cvt2qt = QtGui.QImage(warp_rotate_dst.data, warp_rotate_dst.shape[1], warp_rotate_dst.shape[0],warp_rotate_dst.shape[1]*3,QtGui.QImage.Format_RGB888)
            self.affichage_traitment(cvt2qt)
            
        if (self.grayscale==1):
            ret, frame = self.cap.read()
            img = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
            cvt2qt = QtGui.QImage(img.data, img.shape[1], img.shape[0],img.shape[1],QtGui.QImage.Format_Grayscale8)
            self.modifiedPictureLabel.setPixmap(QPixmap.fromImage(cvt2qt))
            self.modifiedPictureLabel.setScaledContents(True)
            
            #c'est juste un message que je vais utiliser pour dire que la cam est lancer
        
        ret, frame = self.cap.read()
        img = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
        cvt2qt = QtGui.QImage(img.data, img.shape[1], img.shape[0],img.shape[1]*3,QtGui.QImage.Format_RGB888)
        self.originalpictureLabel.setPixmap(QPixmap.fromImage(cvt2qt))
        self.originalpictureLabel.setScaledContents(True)
        #pour lancer la répétition chaque 100ms
        self.timercam.start(100)

    def showTimeCam(self):
        self.label_time.setText("Time= " + str(self.i_timem)+"m"+ str(self.i_time)+"s")
        self.i_time=self.i_time+1
        if (self.i_time ==60):
            self.i_time=0
            self.i_timem=self.i_timem+1            
        #pour lancer la répétition chaque 100ms
        self.timerShowTime.start(1000)

    def Time(self):
        self.label_time.setText("Time= " + str(self.i_time)+"ms")
        self.i_time=self.i_time+1
        #pour lancer la répétition chaque 100ms
        self.timertime.start(100)
        
    def open1(self):
        self.Time()
        if (self.test==1):
            self.binar=0
            self.grayscale=0
            self.Rotat0
            self.test=0
            self.cap.release()
            self.timercam.stop()
        options = QFileDialog.Options()
        # fileName = QFileDialog.getOpenFileName(self, "Open File", QDir.currentPath())
        fileName, _ = QFileDialog.getOpenFileName(None, 'QFileDialog.getOpenFileName()', "",
                                                  'Images (*.png *.jpeg *.jpg *.bmp *.gif)', options=options)
        self.imgPath = fileName
        if fileName:
            self.image = QImage(fileName)
            print(fileName)
            if self.image.isNull():
                QMessageBox.information(self, "Image Viewer", "Cannot load %s." % fileName)
                return

            #CONVERTIR SUR ARRAY (NUMPY) POUR TRAITEMANT OPENCV VS setpixelmap
            incomingImage = self.image
            incomingImage = incomingImage.convertToFormat(4)
            width = incomingImage.width()
            height = incomingImage.height()
            ptr = incomingImage.bits()
            ptr.setsize(incomingImage.byteCount())
            arr = np.array(ptr).reshape(height, width, 4)

            dim = (width,height)
            self.mat1 = cv2.resize(arr, dim, interpolation=cv2.INTER_AREA)
##            print(self.mat1)
            #AFFICHAGE ORIGINALE
            self.affichage()
            self.timertime.stop()

            
    def affichage_CAM(self,img):
        self.originalpictureLabel.setPixmap(QPixmap.fromImage(img))
        self.originalpictureLabel.setScaledContents(True)

    def affichage(self):
        self.originalpictureLabel.setPixmap(QPixmap.fromImage(self.image))
        self.originalpictureLabel.setScaledContents(True)

    def affichage_traitment(self,img):
        self.modifiedPictureLabel.setPixmap(QPixmap.fromImage(img))
        self.modifiedPictureLabel.setScaledContents(True)

    def save(self):
        import datetime
        options = QFileDialog.Options()
        fileName, _ = QFileDialog.getSaveFileName(None, 'QFileDialog.getOpenFileName()', str(datetime.datetime.now()),
                                                  'Images (*.png *.jpeg *.jpg *.bmp *.gif)', options=options)

        if fileName:              
          #  fichier = QFileDialog.getSaveFileName(None, "Enregistrer l'image", "./", "Images (*.png )")
            print(datetime.datetime.now())
            cv2.imwrite(fileName,self.img)
            print("save...")
        else: return


    def print(self):
        self.printer = QPrinter()
        dialog = QPrintDialog(self.printer)
        if dialog.exec_():
            painter = QPainter(self.printer)
            rect = painter.viewport()
            size = self.modifiedPictureLabel.pixmap().size()
            size.scale(rect.size(), Qt.KeepAspectRatio)
            painter.setViewport(rect.x(), rect.y(), size.width(), size.height())
            painter.setWindow(self.modifiedPictureLabel.pixmap().rect())
            painter.drawPixmap(0, 0, self.modifiedPictureLabel.pixmap())

    def About_App(self):
        msgBox = QMessageBox()
        msgBox.setIcon(QMessageBox.Information)
        msgBox.setText(" © copyright")
        msgBox.setWindowTitle("About App")
        msgBox.setStandardButtons(QMessageBox.Ok)
        msgBox.exec_()

    def retranslateUi(self, Interface):
        _translate = QtCore.QCoreApplication.translate
        Interface.setWindowTitle(_translate("Interface", "Interface traitement d'image"))
        self.label_3.setText(_translate("Interface", "The original picture"))
        self.label_4.setText(_translate("Interface", "Modified picture"))
        self.menuFile.setTitle(_translate("Interface", "File"))
        self.menuFunctions.setTitle(_translate("Interface", "Function"))
        self.menuTransformations.setTitle(_translate("Interface", "Transformations"))
        self.menuHelps.setTitle(_translate("Interface", "Help"))
        self.actionOpen.setText(_translate("Interface", "Open"))
        self.actionRotation.setText(_translate("Interface", "Rotation"))
        self.actionClose.setText(_translate("Interface", "Close"))
        self.actionCapture.setText(_translate("Interface", "Capture_Cam"))
        self.actionCAM.setText(_translate("Interface", "Lancer_Cam"))
        self.actionSave.setText(_translate("Interface", "Save"))
        self.actionPrint.setText(_translate("Interface", "Print"))
        self.actionAbout_App.setText(_translate("Interface", "About App"))
        self.actionGrayscale.setText(_translate("Interface", "Grayscale"))
        self.actionBinary.setText(_translate("Interface", "Binary"))
        self.actionRGB_decomp.setText(_translate("Interface", "RGB decomposition"))
        self.actionYcbcr.setText(_translate("Interface", "espace Ycbcr"))
        self.actionETIQ.setText(_translate("Interface", "etiquettage"))


if __name__ == "__main__":
    import sys
    app = QtWidgets.QApplication(sys.argv)
    Interface = QtWidgets.QMainWindow()
    ui = Ui_Interface()
    ui.setupUi(Interface)
    Interface.show()
    sys.exit(app.exec_())