#!/usr/bin/python
# -*- coding: Utf-8 -*-

import os, glob, string, shutil, Image, ImageChops, ImageDraw, ImageFilter, time
from numpy import *
from PyQt4.QtCore import *
from PyQt4.QtGui import *
from gui_modules_image.image_base import Base
from gui_modules_lecture.affichage_image.afficheurImage import VisionneurImagePourEKD


try: 
	# Importation de Psyco s'il est installé
	import psycho
	psycho.full()
except ImportError:
	pass


class Image_MasqueAlpha3D(QWidget):
	# -----------------------------------
	# Cadre accueillant les widgets de :
	# Image >> Masque alpha/3D
	# -----------------------------------
	def __init__(self, parent):
        	QWidget.__init__(self)
		
		# -------------------------------
		# Parametres généraux du widget
		# -------------------------------
		#=== tout sera mis dans une boîte verticale ===#
		vbox=QVBoxLayout(self)
		
		# Création des répertoires temporaires
		self.repTampon = '/tmp/ekd/tampon/temp_image_masque_alpha_3d/'
		if os.path.isdir(self.repTampon) is False:
        		os.makedirs(self.repTampon)
		
		# Au cas où le répertoire existait déjà et qu'il n'était pas vide 
		# -> purge (simple précausion)
		for toutRepCompo in glob.glob(self.repTampon+'*.*'):
			os.remove(toutRepCompo)
		
		# Délai avant conversion
		self.timer = QTimer()
		self.connect(self.timer, SIGNAL('timeout()'), self.sonderTempsActuel)
		
		# Fonctions communes à plusieurs cadres du module Image
		self.base = Base()
		# Paramètres de configuration
		self.config = parent.config
		self.listeChemin = []
		
		#-------------------------------------------------
		# Sélection images, type de méthode et de masque
		#-------------------------------------------------
		
		boutCharger=QPushButton(_(u'Ouvrir images'))
		self.connect(boutCharger, SIGNAL("clicked()"), self.ouvrirSource)
		vbox.addWidget(boutCharger)
		
		grid = QGridLayout()
		grid.addWidget(QLabel(_(u"Méthode :")), 0, 0)
		
		# boite de combo
		self.comboMethode=QComboBox()
		listeCombo=[	(_(u'Méthode 1') ,'methode1'),\
				(_(u'Méthode 2') ,'methode2')]
		
		# Insertion des codecs de compression dans la combo box
		for i in listeCombo:
                	self.comboMethode.addItem(i[0],QVariant(i[1]))
		self.connect(self.comboMethode, SIGNAL("activated(int)"), self.changerComboMethode)
		
		grid.addWidget(self.comboMethode, 0, 1)
		
		grid.addWidget(QLabel(_(u"Type de masque :")), 1, 0)
		
		# boite de combo pour le choix du masque
		self.comboMasque=QComboBox()
		listeCombo=[	(_(u'Masque alpha') ,'masque_alpha'),\
				(_(u'Masque 3D') ,'masque_3D')]
		
		# Insertion des codecs de compression dans la combo box
		for i in listeCombo:
                	self.comboMasque.addItem(i[0],QVariant(i[1]))
		self.connect(self.comboMasque, SIGNAL("activated(int)"), self.changerComboMasque)
		
		grid.addWidget(self.comboMasque, 1, 1)
		
		grid.setAlignment(Qt.AlignHCenter)
		vbox.addLayout(grid)
		
		#------------------------
		# Onglets et stacked
		#------------------------
		self.tabwidget=QTabWidget()
		
		#=== 1er onglet ===#
		self.framReglage=QFrame()
		vboxInfIm=QVBoxLayout(self.framReglage)
		
		# boite de combo
		self.comboReglage=QComboBox()
		listeCombo=[	(_(u'Personnalisé') ,'personnalise'),\
				(_(u'Fond Bleu') ,'fond_bleu'),\
				(_(u'Fond Vert') ,'fond_vert')]
		# Insertion des codecs de compression dans la combo box
		for i in listeCombo:
                	self.comboReglage.addItem(i[0],QVariant(i[1]))
		self.connect(self.comboReglage, SIGNAL("activated(int)"), self.changerComboReglage)
		
		# boite de combo pour Qualité 
		self.comboQualite=QComboBox() 
		listeComboQual=[	(_(u'Moyenne') ,'moyenne'),\
					(_(u'Bonne') ,'bonne'),\
					(_(u'Très bonne') ,'tres_bonne'),\
					(_(u'Excellente') ,'excellente')] 
		# Insertion des codecs de compression dans la combo box
		for i in listeComboQual:
                	self.comboQualite.addItem(i[0],QVariant(i[1]))
		self.connect(self.comboQualite, SIGNAL("activated(int)"), self.changerComboQualite)
		#self.connect(self.comboQualite, SIGNAL("activated(int)"), self.changerComboMethode)
		
		# boite de combo pour la netteté masque alpha méthode 2
		self.comboNettete=QComboBox() 
		listecomboNettete=[	(_(u"Par défaut") ,'par_defaut'),\
					(_(u'Formes plus nettes') ,'formes_nettes')]
		# Insertion des codecs de compression dans la combo box
		for i in listecomboNettete:
                	self.comboNettete.addItem(i[0],QVariant(i[1]))
		self.connect(self.comboNettete, SIGNAL("activated(int)"), self.changerNettete)
		
		# boite de combo pour pixels noirs ou blancs masque 3D méthode 2
		self.comboFondForme=QComboBox() 
		listeComboFondForme=[	(_(u'Fond noir forme(s) blanche(s)') ,'fon_noir_for_blanch'),\
					(_(u'Fond blanc forme(s) noire(s)') ,'fon_blanc_for_noir')]
		# Insertion des codecs de compression dans la combo box
		for i in listeComboFondForme:
                	self.comboFondForme.addItem(i[0],QVariant(i[1]))
		self.connect(self.comboFondForme, SIGNAL("activated(int)"), self.changerFondForme)
		
		hbox = QHBoxLayout()
		hbox.addWidget(QLabel(_(u'Type de fond uni :')))
		hbox.addWidget(self.comboReglage)
		hbox.setAlignment(Qt.AlignHCenter)
		
		grid = QGridLayout()
		grid.addWidget(QLabel(_(u"Teinte (début) :")), 0, 0)
		self.spinTeinteDebut = QSpinBox()
		# Degrés de 0 à 360
		self.spinTeinteDebut.setRange(0, 360)
		self.spinTeinteDebut.setValue(0)
		grid.addWidget(self.spinTeinteDebut, 0, 1)
		grid.addWidget(QLabel(_(u"Teinte (fin) :")), 0, 2)
		self.spinTeinteFin = QSpinBox()
		self.spinTeinteFin.setRange(0, 360)
		self.spinTeinteFin.setValue(360)
		grid.addWidget(self.spinTeinteFin, 0, 3)
		grid.addWidget(QLabel(_(u"Saturation (début) :")), 1, 0)
		self.spinSaturationDebut = QSpinBox()
		# Pourcentage de 0 à 100
		self.spinSaturationDebut.setRange(0, 100)
		self.spinSaturationDebut.setValue(0)
		grid.addWidget(self.spinSaturationDebut, 1, 1)
		grid.addWidget(QLabel(_(u"Saturation (fin) :")), 1, 2)
		self.spinSaturationFin = QSpinBox()
		# Pourcentage de 0 à 100
		self.spinSaturationFin.setRange(0, 100)
		self.spinSaturationFin.setValue(100)
		grid.addWidget(self.spinSaturationFin, 1, 3)
		grid.addWidget(QLabel(_(u"Luminosité :")), 2, 0)
		self.spinLuminosite = QSpinBox()
		self.spinLuminosite.setRange(0, 100)
		self.spinLuminosite.setValue(0)
		grid.addWidget(self.spinLuminosite, 2, 1)
		# ---------

		grid.setAlignment(Qt.AlignHCenter)
		
		# -----------------
		grid2 = QGridLayout()
		
		self.labelFondForme=QLabel(_(u"Choix du fond et de la forme :"))
		
		i = self.comboMasque.currentIndex()
		idCombo=str(self.comboMasque.itemData(i).toStringList()[0])
		if idCombo=='masque_alpha':
			self.labelFondForme.hide()
		grid2.addWidget(self.labelFondForme, 0, 0)
		
		i = self.comboMasque.currentIndex()
		idCombo=str(self.comboMasque.itemData(i).toStringList()[0])
		if idCombo=='masque_alpha':
			self.comboFondForme.hide()
		grid2.addWidget(self.comboFondForme, 0, 1)
		
		self.labelQualite=QLabel(_(u"Qualité :"))
		
		i = self.comboMethode.currentIndex()
		idCombo=str(self.comboMethode.itemData(i).toStringList()[0])
		if idCombo=='methode1':
			self.labelQualite.hide()
		grid2.addWidget(self.labelQualite, 1, 0)

		i = self.comboMethode.currentIndex()
		idCombo=str(self.comboMethode.itemData(i).toStringList()[0])
		if idCombo=='methode1':
			self.comboQualite.hide()
		grid2.addWidget(self.comboQualite, 1, 1)
		
		self.labelNettete=QLabel(_(u"Choix de la netteté :"))

		i = self.comboMethode.currentIndex()
		idCombo=str(self.comboMethode.itemData(i).toStringList()[0])
		if idCombo=='methode1':
			self.labelNettete.show()
		grid2.addWidget(self.labelNettete, 2, 0)

		i = self.comboMethode.currentIndex()
		idCombo=str(self.comboMethode.itemData(i).toStringList()[0])
		if idCombo=='methode1':
			self.comboNettete.show()
		grid2.addWidget(self.comboNettete, 2, 1)
		
		grid2.setAlignment(Qt.AlignHCenter)
		# -----------------
		
		self.boutReglage = QPushButton(_(u"Aperçu à partir de la première image"))
		self.boutReglage.setFocusPolicy(Qt.NoFocus)
		self.boutReglage.setEnabled(False)
		self.connect(self.boutReglage, SIGNAL("clicked()"), self.apercuReglages)
		
		vboxInfIm.addLayout(hbox)
		vboxInfIm.addSpacing(10)
		vboxInfIm.addLayout(grid)
		vboxInfIm.addLayout(grid2)
		vboxInfIm.addStretch()
		vboxInfIm.addWidget(self.boutReglage)
		
		#=== 2ème onglet ===#
		# infos - logs
		self.zoneAffichInfosImg = QTextEdit("")
		self.zoneAffichInfosImg.setReadOnly(True)
		self.framImg=QFrame()
		vboxInfIm=QVBoxLayout(self.framImg)
		vboxInfIm.addWidget(self.zoneAffichInfosImg)
		self.framImg.setEnabled(False)
		
		#=== 3ème onglet ===#
		self.afficheurImg_1=VisionneurImagePourEKD()
		self.afficheurImg_2=VisionneurImagePourEKD()
		
		self.indexTabReglage=self.tabwidget.addTab(self.framReglage, _(u'Réglages'))
		self.indexImagechargee=self.tabwidget.addTab(self.afficheurImg_1, _(u'Image chargée'))
		self.indexImageResultat=self.tabwidget.addTab(self.afficheurImg_2, _(u'Image Résultat'))
		self.indexTabInfo=self.tabwidget.addTab(self.framImg, _(u'Infos'))
		
		#self.connect(self.tabwidget, SIGNAL("currentChanged(int)"), self.)
		
		# [bidouillage] Comme on n'arrive pas à afficher les images centrées
		# de façon 'propre', en attendant on bidouille pour y
		# arriver (le prbl concerne surtout les images d'acceuil)
		self.connect(self.tabwidget, SIGNAL("currentChanged(int)"), self.protheseCentrageImg) 
		
		vbox.addWidget(self.tabwidget)
		
		#------------------
		# Widgets du bas
		#------------------
		
		# boutons
		boutAide=QPushButton(_(u" Aide"))
		boutAide.setIcon(QIcon("Icones/icone_aide_128.png"))
		boutAide.setFocusPolicy(Qt.NoFocus)
		self.connect(boutAide, SIGNAL("clicked()"), self.afficherAide)
		self.boutApp=QPushButton(_(u" Appliquer"))
		self.boutApp.setIcon(QIcon("Icones/icone_appliquer_128.png"))
		self.boutApp.setFocusPolicy(Qt.NoFocus)
		self.boutApp.setEnabled(False)
		self.connect(self.boutApp, SIGNAL("clicked()"), self.appliquer0)
		
		# ligne de séparation juste au dessus des boutons
		ligne = QFrame()
		ligne.setFrameShape(QFrame.HLine)
		ligne.setFrameShadow(QFrame.Sunken)
		vbox.addWidget(ligne)
		vbox.addSpacing(-5)	# la ligne doit être plus près des boutons
		
		hbox=QHBoxLayout()
		hbox.addWidget(boutAide)
		hbox.addStretch()	# espace entre les 2 boutons
		hbox.addWidget(self.boutApp)
		vbox.addLayout(hbox)
		
		self.setLayout(vbox)
		
		#------------------------------------------------
		# Barre de progression dans une fenêtre séparée
		#------------------------------------------------
		
		self.progress=QProgressDialog(_(u"Progression ..."), _(u"Arrêter le processus"), 0, 100)
		self.progress.setWindowTitle(_(u'EnKoDeur-Mixeur. Fenêtre de progression'))
		# Attribution des nouvelles dimensions
		self.progress.setMinimumWidth(500)
		self.progress.setMinimumHeight(100)
	
	
	def protheseCentrageImg(self, i):
		"""Rafraichissemnt pour affichage de l'image au
		# milieu de la fenêtre. La fonction setTailleFenetre()
		# vient de la classe VisionneurImagePourEKD du fichier
		# gui_modules_lecture/affichage_image/afficheurImage.py"""
		if i==1: # 2ème onglet
			self.afficheurImg_1.setTailleFenetre()
		elif i==2: # 3ème onglet
			self.afficheurImg_2.setTailleFenetre()
	

	def changerComboMethode(self, i):
		""" Conditions de disparition/réapparition des labels self.labelQualite, self.labelNettete et combos self.comboQualite, self.comboNettete """
		idCombo=str(self.comboMethode.itemData(i).toStringList()[0])
		
		if idCombo=='methode1':
			self.labelQualite.hide()
			self.comboQualite.hide()
			if self.comboMasque.currentIndex()==0:
				self.labelNettete.show()
				self.comboNettete.show()
			else:
				self.labelNettete.hide()
				self.comboNettete.hide()
		elif idCombo=='methode2':
			self.labelQualite.show()
			self.comboQualite.show()
			self.labelNettete.hide()
			self.comboNettete.hide()

		
	def changerComboMasque(self, i):
		""" Conditions de disparition/réapparition des labels self.labelFondForme, self.labelNettete et combos self.comboFondForme, self.comboNettete """
		idCombo=str(self.comboMasque.itemData(i).toStringList()[0])

		if idCombo=='masque_alpha':
			self.labelFondForme.hide()
			self.comboFondForme.hide()
			self.labelNettete.hide()
			self.comboNettete.hide()
			if self.comboMethode.currentIndex()==0:
				self.labelNettete.show()
				self.comboNettete.show()
			else:
				self.labelNettete.hide()
				self.comboNettete.hide()
		elif idCombo=='masque_3D':
			self.labelFondForme.show()
			self.comboFondForme.show()
			self.labelNettete.hide()
			self.comboNettete.hide()
		
	
	def changerComboQualite(self, i):
		"""Grisage/dégrisage du combo 'qualité' quand l'entrée de la boite de combo de méthode change (non grisé quand méthode 2 est sélectionné) ... humhum récup de l'index de self.comboQualite. Bon c'est pas terrible mon histoire là. Ya certainement moyen de faire mieux !"""
		print self.comboQualite.currentIndex()
		'''
		idCombo=str(self.comboMethode.itemData(i).toStringList()[0])
		if idCombo=='methode1':
			self.comboQualite.setEnabled(False)
		elif idCombo=='methode2':
			self.comboQualite.setEnabled(True)
		'''
		
		
	def changerFondForme(self, i):
		"""Grisage/dégrisage du combo 'qualité' quand l'entrée de la boite de combo de méthode change (non grisé quand méthode 2 est sélectionné) ... humhum récup de l'index de self.comboQualite. Bon c'est pas terrible mon histoire là. Ya certainement moyen de faire mieux !"""
		print self.comboFondForme.currentIndex()
		'''
		idCombo=str(self.comboMethode.itemData(i).toStringList()[0])
		if idCombo=='methode1':
			self.comboQualite.setEnabled(False)
		elif idCombo=='methode2':
			self.comboQualite.setEnabled(True)
		'''
		
		
	def changerNettete(self, i):
		"""Grisage/dégrisage du combo 'qualité' quand l'entrée de la boite de combo de méthode change (non grisé quand méthode 2 est sélectionné) ... humhum récup de l'index de self.comboQualite. Bon c'est pas terrible mon histoire là. Ya certainement moyen de faire mieux !"""
		print self.comboNettete.currentIndex()
		'''
		idCombo=str(self.comboMethode.itemData(i).toStringList()[0])
		if idCombo=='methode1':
			self.comboQualite.setEnabled(False)
		elif idCombo=='methode2':
			self.comboQualite.setEnabled(True)
		'''
	
	
	def changerComboReglage(self, i):
		"""Modification des valeurs des spins de la boite de réglage quand l'entrée de la boite de combo de réglage change"""
		idCombo=str(self.comboReglage.itemData(i).toStringList()[0])
		# Si c'est une image avec fond autre que bleu ou vert ...
		if idCombo=='personnalise':
			print 'Vous avez chargé une image avec fond autre que bleu ou vert'
			# Teinte (début)
			self.spinTeinteDebut.setValue(0)
			# Teinte (début)
			self.spinTeinteFin.setValue(360)
			# Saturation (début)
			self.spinSaturationDebut.setValue(0)
			# Saturation (fin)
			self.spinSaturationFin.setValue(100)
			# Luminosité
			self.spinLuminosite.setValue(0)
		# Si c'est une image avec fond bleu ...
		elif idCombo=='fond_bleu':
			print 'Vous avez chargé une image avec fond bleu'
			# Teinte (début)
			self.spinTeinteDebut.setValue(176)
			# Teinte (début)
			self.spinTeinteFin.setValue(298)
			# Saturation (début)
			self.spinSaturationDebut.setValue(16)
			# Saturation (fin)
			self.spinSaturationFin.setValue(100)
			# Luminosité
			self.spinLuminosite.setValue(39)
		# Si c'est une image avec fond vert ...
		elif idCombo=='fond_vert':
			print 'Vous avez chargé une image avec fond vert'
			# Teinte (début)
			self.spinTeinteDebut.setValue(76)
			# Teinte (début)
			self.spinTeinteFin.setValue(175)
			# Saturation (début)
			self.spinSaturationDebut.setValue(25)
			# Saturation (fin)
			self.spinSaturationFin.setValue(100)
			# Luminosité
			self.spinLuminosite.setValue(22)
	
	
	def ouvrirSource(self):
		txt = _("Fichier images")
		rep = self.base.getRepSource(self.listeChemin, self.config)
		listeChemin=QFileDialog.getOpenFileNames(None, _(u"Ouvrir"), rep, ("JPEG (*.jpg *.JPG *.jpeg *.JPEG);;PNG (*.png *.PNG);;GIF (*.gif *.GIF);;BMP (*.bmp *.BMP);;SGI (*.sgi *.SGI);;TIF (*.tif *.TIF);;TARGA (*.tga *.TGA);;PNM (*.pnm *.PNM);;PPM (*.ppm *.PPM);; *"))
		
		print "Chemin de chargement des images:", listeChemin, type(listeChemin)
		
		self.listeChemin = [str(listeChemin[i]) for i in range(len(listeChemin))]
		
		if self.listeChemin==[]: return
		
		self.listeChemin.sort()
		
		self.base.setRepSource(self.listeChemin, self.config)
		
		self.boutReglage.setEnabled(True)
		self.boutApp.setEnabled(True)
	
	
	def operationReussie(self):
		""" Boîte de d'avertissement réussite """
		
		message=QMessageBox(self)
		message.setText(_(u"Rendu terminé !"))
		message.setWindowTitle(_(u"EnKoDeur-Mixeur"))
		message.setIcon(QMessageBox.Information)
		message.exec_()
		
	
	def messageErreur(self):
		""" Boîte d'avertissement si erreur """
		
		erreur=QMessageBox(self)
		erreur.setText(_(u"Il s'est produit une erreur !"))
		erreur.setWindowTitle(_(u"Erreur"))
		erreur.setIcon(QMessageBox.Critical)
		erreur.exec_()	


	def meth_1_ReglagPrevis(self):
		""" Réglage des différents paramètres et prévisualisation pour la méthode 1 """

		try :

			# La page Image résultat devient visible à la fin du rendu
			self.tabwidget.setCurrentIndex(self.indexImageResultat)
			
			# Compteur départ pour le temps de rendu
			t0=time.time()
			
			# Liste pour affichage image découpée (ds le tabwidget)
			listeAff_1=[]
			
			# Ouverture de la 1ère image du lot pour résultat 
			# des réglages et prévisualisation
			imageDepart=Image.open(self.listeChemin[0])
			
			# On recupere la taille de l'image
			widthDepart, heightDepart=imageDepart.size

			# On recupere le nombre de pixels totaux
			nbPixelsTotal=widthDepart*heightDepart
			
			print 'Nbre total de pixels', nbPixelsTotal
		
			# On recupere le tableau de pixels
			imageData=imageDepart.getdata()

			#-------------------------------------------------------
			# Algorithme de detection du fond uni bleu/vert ou autre
			#-------------------------------------------------------	
	
			# On boucle sur l'image RVB -> on cree une nouvelle image RVBA, le fond 
			# bleu/vert est supprime . De plus on va stocker les pixels de bord .
			newImageRGBA=[]

			for parcRGB_1 in range(nbPixelsTotal) :
				
    				# On recupere les valeurs R,G et B
				val_R_rgb=imageData[parcRGB_1][0]
    				val_G_rgb=imageData[parcRGB_1][1]
    				val_B_rgb=imageData[parcRGB_1][2]
				
				"""
				# --------------------------------------------------------
				# Utilisation de la syntaxe PyQt4. Le code est plus concis
				# mais gros problème le traitement est beaucoup plus long
				# que l'algo en dessous (pour une image en 800 x 600 avec 
				# fond uni bleu, avec la syntaxe PyQt4 --> 1 mn 05 sec, avec
				# l'algo --> 45 secondes
				# --------------------------------------------------------
				# Conversion des couleurs en couleurs Qt
				couleurQt=QColor(val_R_rgb, val_G_rgb, val_B_rgb)

				# Calcul des valeurs HSV
				h_HSV=couleurQt.toHsv().hue()
				s_HSV=couleurQt.toHsv().saturation()
				v_HSV=couleurQt.toHsv().value()
				
				# On teste si le pixel appartient au fond ou non
    				if self.spinTeinteDebut.value()<=h_HSV<=self.spinTeinteFin.value() and self.spinSaturationDebut.value()<=s_HSV<=self.spinSaturationFin.value() and self.spinLuminosite.value()<=v_HSV<=256:
        				# Si oui, on affecte du noir (0, 0, 0, a) et de la 
					# transparence (a=0) au pixel
        				newImageRGBA.append((0, 0, 0, 0))
    				else :
        				# Si non, on conserve la valeur RVB avec une 
					# transparence a 100%, c'est à dire complètement opaque
					newImageRGBA.append((val_R_rgb, val_G_rgb, val_B_rgb, 255))
				"""
				
    				# ------------------------------- #
    				# On calcule les valeurs de H,S,V #
    				# ------------------------------- #
    				# On detecte le max et le min
    				maxRGB=float(max(imageData[parcRGB_1]))
    				minRGB=float(min(imageData[parcRGB_1]))
    				# Calcule de la difference entre min et max
    				deltaRGB=maxRGB-minRGB
    				# Calcul de la Saturation
    				if maxRGB>0: s_HSV=(deltaRGB/maxRGB)*100
    				else: s_HSV=0
    				# Calcul de Hue (Teinte)
    				if deltaRGB==0: h_HSV=-1
    				elif val_R_rgb==maxRGB: h_HSV=(val_G_rgb-val_B_rgb)/deltaRGB
    				elif val_G_rgb==maxRGB: h_HSV=2+(val_B_rgb-val_R_rgb)/deltaRGB
    				else: h_HSV=4+(val_R_rgb-val_G_rgb)/deltaRGB
				# Conversion en degres de Hue
    				h_HSV=h_HSV*60
    				if h_HSV<0: h_HSV=h_HSV+360
    				# Calcul de Value (Luminosite)
    				v_HSV=maxRGB
				# Pourcentage de 0 à 100 de Value (il est beaucoup plus
				# pratique de travailler avec une valeur entre 0 et 100)
				v_HSV=v_HSV*100/256 
    		
				# On teste si le pixel appartient au fond ou non
    				if self.spinTeinteDebut.value()<=h_HSV<=self.spinTeinteFin.value() and self.spinSaturationDebut.value()<=s_HSV<=self.spinSaturationFin.value() and self.spinLuminosite.value()<=v_HSV<=100:
        				# Si oui, on affecte du noir et de la transparence 
					# (A=0) au pixel
        				newImageRGBA.append((0, 0, 0, 0))
    				else :
        				# Si non, on conserve la valeur RVB avec une 
					# transparence a 100%, c'est à dire complètement opaque
        				newImageRGBA.append((val_R_rgb, val_G_rgb, val_B_rgb, 255))
			
			#-----------------------------------------------------
			# Fin algo de detection du fond uni bleu/vert ou autre
			#-----------------------------------------------------
			
			# On sauvegarde l'image avant anti-aliasing
			imgDecoup=Image.new('RGBA', imageDepart.size)
			imgDecoup.putdata(newImageRGBA)
			
			# Ouverture de l'image avec le fond en damier (avec EKD marque en bas a droite)
			imQuad=Image.open("gui_modules_lecture/affichage_image/ekd_quadrillage_canal_alpha.png")
			# Redimensionnement de l'image du damier (quadrillage) aux dimensions de la
			# premiere image chargee .
			RedimQuad=imQuad.resize(imageDepart.size, Image.ANTIALIAS)
			
			# Copie de l'image quadrillage dans le répertoire tampon 
			shutil.copy('gui_modules_lecture/affichage_image/ekd_quadrillage_canal_alpha.png', '/tmp/ekd/tampon/temp_image_masque_alpha_3d/')
		
			# On libère de la memoire
			del imageData
			
			#---------------------------------------------------------------------------
			# On supprimme la premiere ligne bleue (si fond bleu) 
			# restante autour du personnage. Début d'anti-aliasing
			antialiasing=[]

			for parcSupprimeLigne in range(nbPixelsTotal):
    			# Si le pixel detecte n'est pas transparent
				if newImageRGBA[parcSupprimeLigne][3]>0 :
					y_ligne=math.ceil((parcSupprimeLigne-1)/widthDepart)
        				x_ligne=parcSupprimeLigne-(y_ligne*widthDepart)
        				# Detection des bords
        				if (x_ligne==0 or x_ligne>=widthDepart-1 or y_ligne==0 or y_ligne>=heightDepart-1) :
						antialiasing.append((newImageRGBA[parcSupprimeLigne][0], newImageRGBA[parcSupprimeLigne][1], newImageRGBA[parcSupprimeLigne][2], newImageRGBA[parcSupprimeLigne][3]))
        				else :
            					# Si on a 1 voisin transparent bord
            					# Sinon -> pas bord
            					# On teste (x-1,y),(x+1,y),(x,y-1),(x,y+1)
						if (newImageRGBA[parcSupprimeLigne-1][3]==0 or newImageRGBA[parcSupprimeLigne+1][3]==0 or newImageRGBA[parcSupprimeLigne-widthDepart][3]==0 or newImageRGBA[parcSupprimeLigne+widthDepart][3]==0) :
                					# Si bord existe -> on efface . Le bord en 
							# question est transforme en R, G, B --> 
							# noir et A --> transparent .
							antialiasing.append((0, 0, 0, 0))
						else :
							antialiasing.append((newImageRGBA[parcSupprimeLigne][0], newImageRGBA[parcSupprimeLigne][1], newImageRGBA[parcSupprimeLigne][2], newImageRGBA[parcSupprimeLigne][3]))
    				else :
        				antialiasing.append((newImageRGBA[parcSupprimeLigne][0], newImageRGBA[parcSupprimeLigne][1], newImageRGBA[parcSupprimeLigne][2], 0))

			newImageRGBA=antialiasing
			#---------------------------------------------------------------------------

			# Creation d'une nouvelle image et integration des donnees recoltees .
			newImageAntialias=Image.new('RGBA', imgDecoup.size)
			newImageAntialias.putdata(antialiasing)
			a1, a2, a3, a4=newImageAntialias.split()
			imgMerge=Image.merge('RGBA', (a1, a2, a3, a4))
			# Sauvegarde de la nouvelle image (image tampon)
			imgMerge.save('/tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmp58g7e1gdf4g.png', 'PNG')
			
			# Condition (au choix de l'utilisateur) de réglage du combo de netteté 
			if self.comboNettete.currentIndex()==0:
				pass
			else:
				# Ouverture de l'image pour application du kernel (matrice)
				imk=Image.open('/tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmp58g7e1gdf4g.png')
				# Kernel 3x3 pour amélioration des bords. L'image devient plus nette.
				sizeKern3x3=(3, 3)
				# Matrice trouvee ici:
				# http://blogs.codes-sources.com/tkfe/archive/2005/04/15/6004.aspx
				kernAmBords=(-1, -2, -1, -2, 16, -2, -1, -2, -1)
				# Application de la matrice
				imKernelAmBords=imk.filter(ImageFilter.Kernel(sizeKern3x3, kernAmBords)).save('/tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmp58g7e1gdf4g.png', 'PNG')
			
			# Ouverture de l'image pour application du kernel (matrice)
			ouvIm=Image.open('/tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmp58g7e1gdf4g.png')
				
			# Kernel 3x3 anti-crénelage
			sizeKern3x3=(3, 3)
			# Type de kernel utilisé
			kernAntiAlias=(1, 2, 3, 4, 5, 6, 7, 8, 9)
			# Application d'un anti-aliasing sur l'image (et donc sur les contours) par cette matrice.
			# Cette excellente matrice a été trouvée ici: http://www.photo-lovers.org/mosaic.shtml.fr
			# (voir à partir de Méthode du vecteur médian)
			ouvIm.filter(ImageFilter.Kernel(sizeKern3x3, kernAntiAlias)).save('/tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmp58g7e1gdf4g.png', 'PNG')
			
			imgFinal=Image.open('/tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmp58g7e1gdf4g.png')
		
			# Compositing entre l'image avec le damier et l'image du fond vert/bleu decoupe
			ImageChops.composite(imgFinal, RedimQuad, imgFinal).save('/tmp/ekd/tampon/temp_image_masque_alpha_3d/aff_decoup_fond__tmp58g7y411eeya7.png', 'PNG')
			
			# Remplissage de listeAff_1 pour affichage (ds le tabwidget)
			listeAff_1.append('/tmp/ekd/tampon/temp_image_masque_alpha_3d/aff_decoup_fond__tmp58g7y411eeya7.png')
			
			# On libere la memoire
			del antialiasing, newImageRGBA, imQuad, RedimQuad, newImageAntialias, imgDecoup, val_R_rgb, val_G_rgb, val_B_rgb, h_HSV, s_HSV, v_HSV, parcRGB_1, parcSupprimeLigne, a1, a2, a3, a4, imageDepart
			# x_ligne et y_ligne ne sont pas libérés car cela peut produire une erreur ds 
			# certaines circonstances
			
			# --------------------------------------------------------------------
			# CALCUL ET AFFICHAGE DE LA DATE ET DU TEMPS DE RENDU
			# --------------------------------------------------------------------
			# Temps local (annee, mois, jour, heure, minute, seconde ...)
			tLocal=time.localtime()
			# Pour affichage de facon comprehensible de la date et l'heure
			datHeurEcr=_(u"Le ")+str(tLocal[2])+"/"+str(tLocal[1])+"/"+str(tLocal[0])+_(u" a ")+str(tLocal[3])+":"+str(tLocal[4])+":"+str(tLocal[5])
			# Positionnement au temps 2 pour le temps de rendu de l'image .
			t1=time.time()
			# Si le temps de rendu est inferieur a la minute ... .
			if int(t1-t0)<60 :
				# Pour affichage dans le terminal .
				affTerm=_("Temps de rendu : %s secondes") % (int(round(t1-t0)))
				print
				print datHeurEcr
				print "=================================================="
				print affTerm
				print "=================================================="
				print
				# Pour affichage dans l'interface (variable) .
				affTempsInterface=_("%s secondes") % (int(round(t1-t0)))
			# Si le temps de rendu est superieur a la minute ... calcul des 
			# minutes et des secondes .
			elif int(t1-t0)>=60 : 
				# Pour affichage dans le terminal .
				affTerm=_(u"Temps de rendu : ")+str(int(round(t1-t0))/60)+_(u" min ")+str(int(round(t1-t0))%60)+_(u" sec")
				print
				print datHeurEcr
				print "=================================================="
				print affTerm
				print "=================================================="
				print		
				# Pour affichage dans l'interface
				affTempsInterface=str(int(round(t1-t0))/60)+_(u" min ")+str(int(round(t1-t0))%60)+_(u" sec")
			# --------------------------------------------------------------------
			
			# Affichage de l'image chargée -----------------------
			self.afficheurImg_1.setImage(self.listeChemin[0])
			# Affichage de l'image découpée ----------------------
			self.afficheurImg_2.setImage(listeAff_1[0])
			# ----------------------------------------------------
			
			# Affichage des infos sur l'image --------------------	
			# On implémente les chemins des fichiers dans une variable
			# pour préparer l'affichage des infos
			texte=_(u" Image avant découpage du fond uni ")
			texte_2=_(u" Réglages(s)")
			texte_3=_(u" Résolution de l'image")
			texte_4=_(u" Temps de calcul de la découpe")
			a='#'*36
			
			self.infosImgProv=a+'\n# '+texte+'\n'+a+'\n'
			self.infosImgProv=self.infosImgProv+'\n'+self.listeChemin[0]+'\n\n'
			
			self.infosImgProv_2=a+'\n# '+texte_2+'\n'+a+'\n'
			self.infosImgProv_2=self.infosImgProv_2+'\n'+_(u'Valeur teinte (début) : ')+str(self.spinTeinteDebut.value())+'\n'+_(u'Valeur teinte (fin) : ')+str(self.spinTeinteFin.value())+'\n'+_(u'Valeur saturation (début) : ')+str(self.spinSaturationDebut.value())+'\n'+_(u'Valeur saturation (fin) : ')+str(self.spinSaturationFin.value())+'\n'+_(u'Valeur luminosité : ')+str(self.spinLuminosite.value())+'\n\n'
			
			self.infosImgProv_3=a+'\n# '+texte_3+'\n'+a+'\n'
			self.infosImgProv_3=self.infosImgProv_3+'\n'+str(widthDepart)+' x '+str(heightDepart)+_(u' pix')+'\n'+_(u"Nombre de pixels dans l'image : ")+str(nbPixelsTotal)+'\n\n'
			
			self.infosImgProv_4=a+'\n# '+texte_4+'\n'+a+'\n'
			self.infosImgProv_4=self.infosImgProv_4+'\n'+affTempsInterface+'\n\n'
			
			# affichage des infos dans l'onglet
			self.zoneAffichInfosImg.setText(self.infosImgProv+self.infosImgProv_2+self.infosImgProv_3+self.infosImgProv_4)
			self.framImg.setEnabled(True)
		
			# remise à 0 de la variable provisoire de log
			self.infosImgProv, self.infosImgProv_2, self.infosImgProv_3, self.infosImgProv_4='', '', '', ''
			# ----------------------------------------------------
			
			# Epuration/elimination des fichiers tampon
			for toutRepTemp in glob.glob('/tmp/ekd/tampon/temp_image_masque_alpha_3d/*.*'):
				os.remove(toutRepTemp)
				
			self.operationReussie()
			
		except :
			print "ERREUR !"
			self.messageErreur()
			
			
	def meth_1_ReglagMasqueAlpha(self):
		""" Masque alpha (découpe) pour la méthode 1 """
		
		# Cette fonction gere les chemins avec trous .
	
		try :	
			
			# Liste pour affichage image découpée (ds le tabwidget)
			listeAff_1=[]
			# Liste pour affichage dans la page Info
			listeAff_2=[]
	
			# Nbre d'images charges par l'utilisateur
			nbreElem=len(self.listeChemin)	

			# Compteur pour le calcul du temps de rendu cumule.
			som_t_renduCumul=0 
	
			# Compteur pour le 1er temps de rendu (exactement la meme variable
			# que pour ==> Positionnement au temps 1 pour le temps de rendu de 
			# l'image, juste en-dessous) .
			t0=0 

			# Positionnement au temps 1 pour le temps de rendu de l'image .
			temps1=time.localtime(time.time())	
	
			# Boucle principale de chargement des images .
			for parcPrincipal in range(nbreElem):
		
				# Ouverture de l'image dans le lot .
				imageDepart=Image.open(self.listeChemin[parcPrincipal])
		
				# Compteur pour le 1er temps de rendu .
				t0=time.time()

				# On recupere la taille de l'image
				widthDepart, heightDepart=imageDepart.size

				# On recupere le nombre de pixels totaux
				nbPixelsTotal=widthDepart*heightDepart
		
				# On recupere le tableau de pixels
				imageData=imageDepart.getdata()
 
				#-----------------------------------------------
				# Algorithme de detection du fond bleu/vert
				#-----------------------------------------------

				# On boucle sur l'image RVB -> on cree une nouvelle image RVBA, 
				# le fond bleu/vert est supprime . De plus on va stocker les 
				# pixels de bord .
				newImageRGBA=[]

				for parcRGB_1 in range(nbPixelsTotal) :
    					# On recupere les valeurs R,G et B
					val_R_rgb=imageData[parcRGB_1][0]
    					val_G_rgb=imageData[parcRGB_1][1]
    					val_B_rgb=imageData[parcRGB_1][2]
    
    					# ------------------------------- #
    					# On calcule les valeurs de H,S,V #
    					# ------------------------------- #
    					# On detecte le max et le min
    					maxRGB=float(max(imageData[parcRGB_1]))
    					minRGB=float(min(imageData[parcRGB_1]))
    					# Calcule de la difference entre min et max
    					deltaRGB=maxRGB-minRGB
    					# Calcul de la Saturation
    					if maxRGB>0: s_HSV=(deltaRGB/maxRGB)*100
    					else: s_HSV=0
    					# Calcul de Hue (Teinte)
    					if deltaRGB==0: h_HSV=-1
    					elif val_R_rgb==maxRGB: h_HSV=(val_G_rgb-val_B_rgb)/deltaRGB
    					elif val_G_rgb==maxRGB: h_HSV=2+(val_B_rgb-val_R_rgb)/deltaRGB
    					else: h_HSV=4+(val_R_rgb-val_G_rgb)/deltaRGB
					# Conversion en degres de Hue
    					h_HSV=h_HSV*60
    					if h_HSV<0: h_HSV=h_HSV+360
    					# Calcul de Value (Luminosite)
    					v_HSV=maxRGB
					# Pourcentage de 0 à 100 de Value (il est beaucoup plus
					# pratique de travailler avec une valeur entre 0 et 100)
					v_HSV=v_HSV*100/256
			
					# On teste si le pixel appartient au fond ou non
    					if self.spinTeinteDebut.value()<=h_HSV<=self.spinTeinteFin.value() and self.spinSaturationDebut.value()<=s_HSV<=self.spinSaturationFin.value() and self.spinLuminosite.value()<=v_HSV<=100:
        					# Si oui, on affecte du blanc et de la 
						# transparence (A=0) au pixel
        					newImageRGBA.append((0, 0, 0, 0))
    					else :
        					# Si non, on conserve la valeur RVB avec une 
						# transparence a 100% .
        					newImageRGBA.append((val_R_rgb, val_G_rgb, val_B_rgb, 255))	
			
					#-----------------------------------------------
					# Fin algo detection fond bleu/vert
					#-----------------------------------------------

				# On sauvegarde l'image avant anti-aliasing
				imgDecoup=Image.new('RGBA', imageDepart.size)
				imgDecoup.putdata(newImageRGBA)
				
				# Ouverture de l'image avec le fond en damier
				imQuad=Image.open("gui_modules_lecture/affichage_image/ekd_quadrillage_canal_alpha.png")
				# Redimensionnement de l'image du damier (quadrillage) aux 
				# dimensions de la premiere image chargee .
				RedimQuad=imQuad.resize(imageDepart.size, Image.ANTIALIAS)
			
				# Copie de l'image quadrillage dans le répertoire tampon 
				shutil.copy('gui_modules_lecture/affichage_image/ekd_quadrillage_canal_alpha.png', '/tmp/ekd/tampon/temp_image_masque_alpha_3d/')
		
				# On libere de la memoire
				del imageData

				#---------------------------------------------------------------------------
				# On supprimme la premiere ligne bleue (si fond bleu) 
				# restante autour du personnage. Début d'anti-aliasing
				antialiasing=[]

				for parcSupprimeLigne in range(nbPixelsTotal) :
    					# Si le pixel detecte n'est pas transparent
    					if newImageRGBA[parcSupprimeLigne][3]>0 :
        					y_ligne=math.ceil((parcSupprimeLigne-1)/widthDepart)
        					x_ligne=parcSupprimeLigne-(y_ligne*widthDepart)
        					# Detection des bords
        					if (x_ligne==0 or x_ligne>=widthDepart-1 or y_ligne==0 or y_ligne>=heightDepart-1) :
							antialiasing.append((newImageRGBA[parcSupprimeLigne][0], newImageRGBA[parcSupprimeLigne][1], newImageRGBA[parcSupprimeLigne][2], newImageRGBA[parcSupprimeLigne][3]))
        					else :
            						# Si on a 1 voisin transparent bord
            						# Sinon -> pas bord
            						# On teste (x-1,y),(x+1,y),(x,y-1),(x,y+1)
            						if (newImageRGBA[parcSupprimeLigne-1][3]==0 or newImageRGBA[parcSupprimeLigne+1][3]==0 or newImageRGBA[parcSupprimeLigne-widthDepart][3]==0 or newImageRGBA[parcSupprimeLigne+widthDepart][3]==0) :
                						# Si bord existe -> on efface . Le 
								# bord en question est transforme en R,
								# G, B --> blanc et A --> transparent
                						antialiasing.append((255, 255, 255, 0))
            						else :
                						antialiasing.append((newImageRGBA[parcSupprimeLigne][0], newImageRGBA[parcSupprimeLigne][1], newImageRGBA[parcSupprimeLigne][2], newImageRGBA[parcSupprimeLigne][3]))
    					else :
        					antialiasing.append((newImageRGBA[parcSupprimeLigne][0], newImageRGBA[parcSupprimeLigne][1], newImageRGBA[parcSupprimeLigne][2], 0))

				newImageRGBA=antialiasing
				#---------------------------------------------------------------------------
				
				# Creation d'une nouvelle image et integration des donnees recoltees .
				newImageAntialias=Image.new('RGBA', imgDecoup.size)
				newImageAntialias.putdata(antialiasing)
				a1, a2, a3, a4=newImageAntialias.split()
				imgMerge=Image.merge('RGBA', (a1, a2, a3, a4))
				# Sauvegarde de la nouvelle image (image tampon)
				imgMerge.save('/tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmpf1f84o824qz7.png', 'PNG')
			
				# Condition (au choix de l'utilisateur) de réglage du combo de netteté
				if self.comboNettete.currentIndex()==0:
					pass
				else:
					# Ouverture de l'image pour application du kernel (matrice)
					imk=Image.open('/tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmpf1f84o824qz7.png')
					# Kernel 3x3 pour amélioration des bords. L'image devient plus nette.
					sizeKern3x3=(3, 3)
					# Matrice trouvee ici:
					# http://blogs.codes-sources.com/tkfe/archive/2005/04/15/6004.aspx
					kernAmBords=(-1, -2, -1, -2, 16, -2, -1, -2, -1)
					# Application de la matrice
					imKernelAmBords=imk.filter(ImageFilter.Kernel(sizeKern3x3, kernAmBords)).save('/tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmpf1f84o824qz7.png', 'PNG')
			
				# Ouverture de l'image pour application du kernel (matrice)
				ouvIm=Image.open('/tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmpf1f84o824qz7.png')
				
				# Kernel 3x3 anti-crénelage
				sizeKern3x3=(3, 3)
				# Type de kernel utilisé
				kernAntiAlias=(1, 2, 3, 4, 5, 6, 7, 8, 9)
				# Application d'un anti-aliasing sur l'image (et donc sur les contours) par 
				# cette matrice. Cette excelllente matrice a été trouvée ici:
				# http://www.photo-lovers.org/mosaic.shtml.fr 
				# (voir à partir de Méthode du vecteur médian)
				#
				# Sauvegarde de l'image --> utilisateur
				ouvIm.filter(ImageFilter.Kernel(sizeKern3x3, kernAntiAlias)).save(self.chemDossierSauv+'_'+string.zfill((parcPrincipal+1), 6)+'.png', 'PNG')
				# Sauvegarde de l'image pour compositing
				ouvIm.filter(ImageFilter.Kernel(sizeKern3x3, kernAntiAlias)).save('/tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmpf1f84o824qz7.png')
			
				# Ouverture de l'image pour compositing
				imgFinal=Image.open('/tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmpf1f84o824qz7.png')
				# Compositing entre l'image avec le damier et l'image du fond vert/bleu decoupe et
				# enregistrement dans le rep temporaire (et ce pour l'affichage dans l'interface)
				ImageChops.composite(imgFinal, RedimQuad, imgFinal).save('/tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmpf1f84o824qz7.png', 'PNG')
			
				# Remplissage de listeAff_1 pour affichage (ds le tabwidget)
				listeAff_1.append('/tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmpf1f84o824qz7.png')
				
				# On libere la memoire
				del antialiasing, newImageRGBA, imQuad, RedimQuad, newImageAntialias, imgDecoup, val_R_rgb, val_G_rgb, val_B_rgb, h_HSV, s_HSV, v_HSV, parcRGB_1, parcSupprimeLigne, a1, a2, a3, a4, imageDepart
				# x_ligne et y_ligne ne sont pas libérés car cela peut produire une erreur ds 
				# certaines circonstances
				
				# ------------------------------------------------------------------ #
				# STATS DE RENDU (AFFICHAGE ET SAUVEGARDE) .
				# ------------------------------------------------------------------ #
				# Calcule le pourcentage effectue a chaque passage
				val_pourc=((parcPrincipal+1)*100)/nbreElem
				# Affichage du pourcentage du rendu dans le terminal
				# sous Linux ou la fenetre MS-DOS sous Windows
				print _("Progression du rendu :"), val_pourc # pas de unicode pour un print
				# Positionnement au temps 2 pour le temps de rendu de l'image
				t1=time.time()
				# Temps local (annee, mois, jour, heure, minute, seconde ...)
				tLocal=time.localtime()
				# Calcul avec le compteur pour le calcul du temps de rendu cumule
				som_t_renduCumul=som_t_renduCumul+(t1-t0)
				# Calcul pour la moyenne du temps de rendu .
				MoyRendu=som_t_renduCumul/(parcPrincipal+1) 
				# Calcul pour le temps de rendu restant .
				tempRestant=((MoyRendu*nbreElem)-(MoyRendu*parcPrincipal+1))-MoyRendu 
				# Mise en ordre du temps local pour ecriture dans fichier
				datHeurEcr=_(u"Le ")+str(tLocal[2])+"/"+str(tLocal[1])+"/"+str(tLocal[0])+_(u" a ")+str(tLocal[3])+":"+str(tLocal[4])+":"+str(tLocal[5])
			
				# Pour ecriture dans fichier
				progImg=_(u"Image ")+str(parcPrincipal+1)+"/"+str(nbreElem)
			
				# Si le temps de rendu est inferieur a la minute ... .
				if int(t1-t0)<60:
					affTemps=_(u"Temps de rendu : %s secondes") % (int(round(t1-t0)))
				# Si le temps de rendu est superieur a la minute ... calcul des 
				# minutes et des secondes
				elif int(t1-t0)>=60:
					affTemps=_(u"Temps de rendu : ")+str(int(round(t1-t0))/60)+_(u" min ")+str(int(round(t1-t0))%60)+_(u" sec")
				# Si la moyenne du temps de rendu est inferieur a la minute ... .	
				if MoyRendu<60:
					moyTemps=_(u"Moyenne du temps de rendu : %s secondes") % (int(round(MoyRendu))) 
				# Si la moyenne du temps de rendu est superieur a la minute ...  
				# calcul des minutes et des secondes .
				elif MoyRendu>=60:
					moyTemps=_(u"Moyenne du temps de rendu : ")+str(int(round(MoyRendu/60)))+_(u" min ")+str(int(round(MoyRendu%60)))+_(u" sec")
				# Si le temps de rendu est inferieur a la minute ... .
				if som_t_renduCumul<60:
					tRenduCumul=_(u"Temps de rendu cumule : %s secondes") % (int(round(som_t_renduCumul)))
				# Si le temps de rendu est superieur ou egal a la minute ... calcul des 
				# heures et des minutes .
				elif som_t_renduCumul>=60:
					tRenduInfMinut=int(round(som_t_renduCumul/60))
					tRenduCumul=_(u"Temps de rendu cumule : ")+str(tRenduInfMinut/60)+_(u" h ")+str(tRenduInfMinut%60)+_(u" min")
					
				# Pour le temps de rendu restant ...
				# Si le temps de rendu restant est superieur a 0 secondes .
				if tempRestant>0:
					# Si le temps de rendu restant est inferieur a la minute et le
					# calcul du pourcentage est inferieur a 100 % .
					if tempRestant<60 and val_pourc<100:
						tRestant=_(u"Temps de rendu restant (estimation) : %s secondes") % (int(round(tempRestant)))
					# Si le temps de rendu restant est superieur a la minute et le
					# calcul du pourcentage est inferieur a 100 % .
					elif tempRestant>=60 and val_pourc<100:
						tRestantInfMinut=int(round(tempRestant/60))
						tRestant=_(u"Temps de rendu restant (estimation) : ")+str(tRestantInfMinut/60)+_(u" h ")+str(tRestantInfMinut%60)+_(u" min")
				
				# Des que le rendu est arrive a 100%, affichage de dans le
				# terminal sous Linux ou la fenetre MS-DOS sous Windows
				if val_pourc==100 :
					print
					print _("Rendu terminé !")

				# Ecriture des statistiques (cumul de l'ecriture) dans un fichier texte	
				ecrStatRendu=open(self.chemDossierSauv+_("_image_masque_alpha_meth_1.txt"), 'a')
				ecrStatRendu.write("=================================================\n"+str(datHeurEcr)+"\n"+"-------------------------------------------------\n"+str(progImg)+"\n"+str(affTemps)+"\n"+str(moyTemps)+"\n"+str(tRenduCumul)+"\n\n")
				ecrStatRendu.close()
				
				# Affichage de l'image découpée ----------------------
				self.afficheurImg_2.setImage(listeAff_1[parcPrincipal])
				# ----------------------------------------------------
				
				# Remplissage de la liste pour les statistiques de rendu
				listeAff_2.append((_(u"Image chargée : ")+self.listeChemin[parcPrincipal], _(u"Image finale : ")+self.chemDossierSauv+'_'+string.zfill((parcPrincipal+1), 6)+'.png', progImg, affTemps, moyTemps, tRenduCumul, _(u"Nombre total de pixels : ")+str(nbPixelsTotal), _("Dimension : ")+str(widthDepart)+' x '+str(heightDepart)))

				# --------------------------------------------
				# Affichage de la progression (avec
				# QProgressDialog) ds une fenêtre séparée
				self.progress.setValue(val_pourc)
				#self.progress.setMinimumDuration(100) ##
				QApplication.processEvents()
				# Bouton Cancel pour arrêter la progression donc le process
				if (self.progress.wasCanceled()): break
				# Quand l'utilisateur charge au moins 2 images ...
				if len(self.listeChemin)>1:
					self.progress.setLabel(QLabel(QString(tRestant)))
				# --------------------------------------------
			
			# La page Image résultat devient visible à la fin des conversions
			self.tabwidget.setCurrentIndex(self.indexImageResultat)
			
			# Affichage de la dernière image du lot chargée par l'utilisateur---
			self.afficheurImg_1.setImage(self.listeChemin[len(self.listeChemin)-1])
			# ------------------------------------------------------------------
			
			# Affichage des infos sur l'image -------------------------	
			# On implémente les chemins des fichiers dans une variable
			# pour préparer l'affichage des infos
			texte=_(u" Statistiques de rendu")
			a='#'*36
			b="-"*36
			
			self.infosImgProv=a+'\n#'+texte+'\n'+a+'\n'
			for parcStatRendu in listeAff_2:
				self.infosImgProv=self.infosImgProv+'\n'+parcStatRendu[0]+'\n'+parcStatRendu[1]+'\n'+parcStatRendu[2]+'\n'+parcStatRendu[3]+'\n'+parcStatRendu[4]+'\n'+parcStatRendu[5]+'\n'+parcStatRendu[6]+'\n'+parcStatRendu[7]+'\n'+b+'\n'
				
			# affichage des infos dans l'onglet
			self.zoneAffichInfosImg.setText(self.infosImgProv)
			self.framImg.setEnabled(True)
			
			# remise à 0 de la variable provisoire de log
			self.infosImgProv=''
			# ---------------------------------------------------------
			
			# Epuration/elimination des fichiers tampon
			for toutRepTemp in glob.glob('/tmp/ekd/tampon/temp_image_masque_alpha_3d/*.*'):
				os.remove(toutRepTemp)
				
			self.operationReussie()
				
		except :
			print "ERREUR !"
			self.messageErreur()	
			
			
	def meth_1_ReglagMasque3D(self):
		""" Masque 3D pour la méthode 1 """
		
		# Cette fonction gere les chemins avec trous
	
		try :
			
			# Liste pour affichage image découpée (ds le tabwidget)
			listeAff_1=[]
			# Liste pour affichage dans la page Info
			listeAff_2=[]
		
			# Nbre d'images charges par l'utilisateur
			nbreElem=len(self.listeChemin) 

			# Compteur pour le calcul du temps de rendu cumule.
			som_t_renduCumul=0 
	
			# Compteur pour le 1er temps de rendu (exactement la meme variable
			# que pour ==> Positionnement au temps 1 pour le temps de rendu de 
			# l'image, juste en-dessous) .
			t0=0 

			# Positionnement au temps 1 pour le temps de rendu de l'image .
			temps1=time.localtime(time.time())	
	
			# Boucle principale de chargement des images .
			for parcPrincipal in range(nbreElem) :
		
				# Ouverture de l'image dans le lot .
				imageDepart=Image.open(self.listeChemin[parcPrincipal])
		
				# Compteur pour le 1er temps de rendu .
				t0=time.time()

				# On recupere la taille de l'image
				widthDepart, heightDepart=imageDepart.size

				# On recupere le nombre de pixels totaux
				nbPixelsTotal=widthDepart*heightDepart
		
				# On recupere le tableau de pixels
				imageData=imageDepart.getdata()
 
				#-----------------------------------------------
				# Algorithme de detection du fond bleu/vert
				#-----------------------------------------------

				# On boucle sur l'image RVB -> on cree une nouvelle image RVBA, 
				# le fond bleu/vert est supprime . De plus on va stocker les 
				# pixels de bord .
				newImageRGBA=[]

				for parcRGB_1 in range(nbPixelsTotal):
    					# On recupere les valeurs R,G et B
					val_R_rgb=imageData[parcRGB_1][0]
    					val_G_rgb=imageData[parcRGB_1][1]
    					val_B_rgb=imageData[parcRGB_1][2]
    
    					# ------------------------------- #
    					# On calcule les valeurs de H,S,V #
    					# ------------------------------- #
    					# On detecte le max et le min
    					maxRGB=float(max(imageData[parcRGB_1]))
    					minRGB=float(min(imageData[parcRGB_1]))
    					# Calcule de la difference entre min et max
    					deltaRGB=maxRGB-minRGB
    					# Calcul de la Saturation
    					if maxRGB>0: s_HSV=(deltaRGB/maxRGB)*100
    					else: s_HSV=0
    					# Calcul de Hue (Teinte)
    					if deltaRGB==0: h_HSV=-1
    					elif val_R_rgb==maxRGB: h_HSV=(val_G_rgb-val_B_rgb)/deltaRGB
    					elif val_G_rgb==maxRGB: h_HSV=2+(val_B_rgb-val_R_rgb)/deltaRGB
    					else: h_HSV=4+(val_R_rgb-val_G_rgb)/deltaRGB
					# Conversion en degres de Hue
    					h_HSV=h_HSV*60
    					if h_HSV<0: h_HSV=h_HSV+360
    					# Calcul de Value (Luminosite)
    					v_HSV=maxRGB
					# Pourcentage de 0 à 100 de Value (il est beaucoup plus
					# pratique de travailler avec une valeur entre 0 et 100)
					v_HSV=v_HSV*100/256

					# ----------------------------------------------------------- #
					# Attention conditions d'affichage du fond et de la forme !.
					# ----------------------------------------------------------- #
					# Ici si on a sélectionné un fond noir et une/des formes blanches
					if self.comboFondForme.currentIndex()==0:
						# On teste si le pixel appartient au fond ou non
    						if self.spinTeinteDebut.value()<=h_HSV<=self.spinTeinteFin.value() and self.spinSaturationDebut.value()<=s_HSV<=self.spinSaturationFin.value() and self.spinLuminosite.value()<=v_HSV<=100:
							
        						# Si oui, on affecte du noir et de la 
							# transparence (A=0) au pixel
        						newImageRGBA.append((0, 0, 0, 0))
    						else :
        						# Si non, on affecte du blanc avec une transparence a 100%
        						newImageRGBA.append((255, 255, 255, 255))
					# Là si on a sélectionné un fond blanc et une/des formes noires
					elif self.comboFondForme.currentIndex()==1:
						# On teste si le pixel appartient au fond ou non
    						if self.spinTeinteDebut.value()<=h_HSV<=self.spinTeinteFin.value() and self.spinSaturationDebut.value()<=s_HSV<=self.spinSaturationFin.value() and self.spinLuminosite.value()<=v_HSV<=100:
							
        						# Si oui, on affecte du blanc et de la 
							# transparence (A=0) au pixel
        						newImageRGBA.append((255, 255, 255, 0))
    						else :
        						# Si non, on affecte du noir avec une transparence a 100%
        						newImageRGBA.append((0, 0, 0, 255))
			
				#-----------------------------------------------
				# Fin algo detection fond bleu/vert
				#-----------------------------------------------

				# On sauvegarde l'image avant anti-aliasing
				imgDecoup=Image.new('RGBA', imageDepart.size)
				imgDecoup.putdata(newImageRGBA)
		
				# On libere de la memoire
				del imageData

				#---------------------------------------------------------------------------
				# On supprimme la premiere ligne bleue (si fond bleu) 
				# restante autour du personnage. Début d'anti-aliasing
				antialiasing=[]

				for parcSupprimeLigne in range(nbPixelsTotal):
    					# Si le pixel detecte n'est pas transparent
    					if newImageRGBA[parcSupprimeLigne][3]>0:
        					y_ligne=math.ceil((parcSupprimeLigne-1)/widthDepart)
        					x_ligne=parcSupprimeLigne-(y_ligne*widthDepart)
        					# Detection des bords
        					if (x_ligne==0 or x_ligne>=widthDepart-1 or y_ligne==0 or y_ligne>=heightDepart-1):
							antialiasing.append((newImageRGBA[parcSupprimeLigne][0], newImageRGBA[parcSupprimeLigne][1], newImageRGBA[parcSupprimeLigne][2], newImageRGBA[parcSupprimeLigne][3]))
        					else:
            						# Si on a 1 voisin transparent bord
            						# Sinon -> pas bord
            						# On teste (x-1,y),(x+1,y),(x,y-1),(x,y+1)
            						if (newImageRGBA[parcSupprimeLigne-1][3]==0 or newImageRGBA[parcSupprimeLigne+1][3]==0 or newImageRGBA[parcSupprimeLigne-widthDepart][3]==0 or newImageRGBA[parcSupprimeLigne+widthDepart][3]==0):
                						# Si bord existe -> on efface . Le bord en
								# question est transforme en R, G, B -->
								# noir et A --> transparent .
                						antialiasing.append((0, 0, 0, 0))
            						else :
                						antialiasing.append((newImageRGBA[parcSupprimeLigne][0], newImageRGBA[parcSupprimeLigne][1], newImageRGBA[parcSupprimeLigne][2], newImageRGBA[parcSupprimeLigne][3]))
    					else :
        					antialiasing.append((newImageRGBA[parcSupprimeLigne][0], newImageRGBA[parcSupprimeLigne][1], newImageRGBA[parcSupprimeLigne][2], 0))

				newImageRGBA=antialiasing
				#---------------------------------------------------------------------------
				
				# Creation d'une nouvelle image et integration des donnees recoltees .
				newImageAntialias=Image.new('RGBA', imgDecoup.size)
				newImageAntialias.putdata(antialiasing)
				a1, a2, a3, a4=newImageAntialias.split()
				imgMerge=Image.merge('RGBA', (a1, a2, a3, a4))
				# Sauvegarde de la nouvelle image (image tampon)
				imgMerge.save('/tmp/ekd/tampon/temp_image_masque_alpha_3d/masque3d_tmpg5dgf54dqk1oy8f.png', 'PNG')
				
				# Transformation du fond noir (ou fond blanc) transparent en fond noir (ou blanc) opaque 
				imgMerge.putalpha(255)
				
				# Sauvegarde de la nouvelle image (image tampon)
				imgMerge.save('/tmp/ekd/tampon/temp_image_masque_alpha_3d/masque3d_tmpg5dgf54dqk1oy8f.png', 'PNG')
				
				# Ouverture de l'image tampon
				ouvIm=Image.open('/tmp/ekd/tampon/temp_image_masque_alpha_3d/masque3d_tmpg5dgf54dqk1oy8f.png')
			
				# Kernel 5x5 Floutage
				sizeKern5x5=(5, 5)
				# Type de kernel utilisé
				kernFlou=(0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0)
				# Application d'un leger flou a l'image et enregistrement dans le
				# chemin (et avec le nom donné) et ce par/pour l'utilisateur
				ouvIm.filter(ImageFilter.Kernel(sizeKern5x5, kernFlou)).save(self.chemDossierSauv+'_'+string.zfill((parcPrincipal+1), 6)+'.png', 'PNG')
				# Application d'un leger flou a l'image et enregistrement dans le rep
				# temporaire (... et donc l'affichage dans l'interface)
				imKerFlou=ouvIm.filter(ImageFilter.Kernel(sizeKern5x5, kernFlou)).save('/tmp/ekd/tampon/temp_image_masque_alpha_3d/masque3d_tmpg5dgf54dqk1oy8f.png', 'PNG')
				
				# Remplissage de listeAff_1 pour affichage (ds le tabwidget)
				listeAff_1.append('/tmp/ekd/tampon/temp_image_masque_alpha_3d/masque3d_tmpg5dgf54dqk1oy8f.png')
				
				# On libere la memoire
				del antialiasing, newImageRGBA, newImageAntialias, imgDecoup, val_R_rgb, val_G_rgb, val_B_rgb, h_HSV, s_HSV, v_HSV, parcRGB_1, parcSupprimeLigne, a1, a2, a3, a4, imageDepart
				# x_ligne et y_ligne ne sont pas libérés car cela peut produire une erreur ds 
				# certaines circonstances
				
				# ------------------------------------------------------------------ #
				# STATS DE RENDU (AFFICHAGE ET SAUVEGARDE) .
				# ------------------------------------------------------------------ #
				# Calcule le pourcentage effectue a chaque passage
				val_pourc=((parcPrincipal+1)*100)/nbreElem
				# Affichage du pourcentage du rendu dans le terminal
				# sous Linux ou la fenetre MS-DOS sous Windows
				print _("Progression du rendu :"), val_pourc
				# Positionnement au temps 2 pour le temps de rendu de l'image
				t1=time.time()
				# Temps local (annee, mois, jour, heure, minute, seconde ...)
				tLocal=time.localtime()
				# Calcul avec le compteur pour le calcul du temps de rendu cumule
				som_t_renduCumul=som_t_renduCumul+(t1-t0)
				# Calcul pour la moyenne du temps de rendu .
				MoyRendu=som_t_renduCumul/(parcPrincipal+1) 
				# Calcul pour le temps de rendu restant .
				tempRestant=((MoyRendu*nbreElem)-(MoyRendu*parcPrincipal+1))-MoyRendu 
				# Mise en ordre du temps local pour ecriture dans fichier
				datHeurEcr=_(u"Le ")+str(tLocal[2])+"/"+str(tLocal[1])+"/"+str(tLocal[0])+_(u" a ")+str(tLocal[3])+":"+str(tLocal[4])+":"+str(tLocal[5])
			
				# Pour ecriture dans fichier
				progImg=_(u"Image ")+str(parcPrincipal+1)+"/"+str(nbreElem)
			
				# Si le temps de rendu est inferieur a la minute ... .
				if int(t1-t0)<60:
					affTemps=_(u"Temps de rendu : %s secondes") % (int(round(t1-t0)))
				# Si le temps de rendu est superieur a la minute ... calcul des 
				# minutes et des secondes
				elif int(t1-t0)>=60:
					affTemps=_(u"Temps de rendu : ")+str(int(round(t1-t0))/60)+_(u" min ")+str(int(round(t1-t0))%60)+_(u" sec")
				# Si la moyenne du temps de rendu est inferieur a la minute ... .	
				if MoyRendu<60:
					moyTemps=_(u"Moyenne du temps de rendu : %s secondes") % (int(round(MoyRendu))) 
				# Si la moyenne du temps de rendu est superieur a la minute ...  
				# calcul des minutes et des secondes .
				elif MoyRendu>=60:
					moyTemps=_(u"Moyenne du temps de rendu : ")+str(int(round(MoyRendu/60)))+_(u" min ")+str(int(round(MoyRendu%60)))+_(u" sec")
				# Si le temps de rendu est inferieur a la minute ... .
				if som_t_renduCumul<60:
					tRenduCumul=_(u"Temps de rendu cumule : %s secondes") % (int(round(som_t_renduCumul)))
				# Si le temps de rendu est superieur ou egal a la minute ... calcul des 
				# heures et des minutes .
				elif som_t_renduCumul>=60:
					tRenduInfMinut=int(round(som_t_renduCumul/60))
					tRenduCumul=_(u"Temps de rendu cumule : ")+str(tRenduInfMinut/60)+_(u" h ")+str(tRenduInfMinut%60)+_(u" min")
					
				# Pour le temps de rendu restant ...
				# Si le temps de rendu restant est superieur a 0 secondes .
				if tempRestant>0:
					# Si le temps de rendu restant est inferieur a la minute et le
					# calcul du pourcentage est inferieur a 100 % .
					if tempRestant<60 and val_pourc<100:
						tRestant=_(u"Temps de rendu restant (estimation) : %s secondes") % (int(round(tempRestant)))
					# Si le temps de rendu restant est superieur a la minute et le
					# calcul du pourcentage est inferieur a 100 % .
					elif tempRestant>=60 and val_pourc<100:
						tRestantInfMinut=int(round(tempRestant/60))
						tRestant=_(u"Temps de rendu restant (estimation) : ")+str(tRestantInfMinut/60)+_(u" h ")+str(tRestantInfMinut%60)+_(u" min")
						
				# Des que le rendu est arrive a 100%, affichage de dans le
				# terminal sous Linux ou la fenetre MS-DOS sous Windows .
				if val_pourc==100 :
					print
					print _("Rendu terminé !")
				
				# Ecriture des statistiques (cumul de l'ecriture) dans un fichier texte	
				ecrStatRendu=open(self.chemDossierSauv+_("_image_masque_3d_meth_1.txt"), 'a')
				ecrStatRendu.write("=================================================\n"+datHeurEcr+"\n"+"-------------------------------------------------\n"+progImg+"\n"+str(affTemps)+"\n"+str(moyTemps)+"\n"+str(tRenduCumul)+"\n\n")
				ecrStatRendu.close()
				
				# Affichage de l'image masque 3d ---------------------
				self.afficheurImg_2.setImage(listeAff_1[parcPrincipal])
				# ----------------------------------------------------
				
				# Remplissage de la liste pour les statistiques de rendu
				listeAff_2.append((_(u"Image chargée : ")+self.listeChemin[parcPrincipal], _(u"Image finale : ")+self.chemDossierSauv+'_'+string.zfill((parcPrincipal+1), 6)+'.png', progImg, affTemps, moyTemps, tRenduCumul, _(u"Nombre total de pixels : ")+str(nbPixelsTotal), _("Dimension : ")+str(widthDepart)+' x '+str(heightDepart)))
				
				# --------------------------------------------
				# Affichage de la progression (avec
				# QProgressDialog) ds une fenêtre séparée
				self.progress.setValue(val_pourc)
				# Quand l'utilisateur charge au moins 2 images ...
				QApplication.processEvents()
				# Bouton Cancel pour arrêter la progression donc le process
				if (self.progress.wasCanceled()): break
				if len(self.listeChemin)>1:
					self.progress.setLabel(QLabel(QString(tRestant)))
				# --------------------------------------------
			
			# La page Image résultat devient visible après les conversions
			self.tabwidget.setCurrentIndex(self.indexImageResultat)
			
			# Affichage de la dernière image du lot chargée par l'utilisateur --
			self.afficheurImg_1.setImage(self.listeChemin[len(self.listeChemin)-1])
			# ------------------------------------------------------------------
			
			# Affichage des infos sur l'image -------------------------
			# On implémente les chemins des fichiers dans une variable
			# pour préparer l'affichage des infos
			texte=_(u" Statistiques de rendu")
			a='#'*36
			b="-"*36
			
			self.infosImgProv=a+'\n#'+texte+'\n'+a+'\n'
			for parcStatRendu in listeAff_2:
				self.infosImgProv=self.infosImgProv+'\n'+parcStatRendu[0]+'\n'+parcStatRendu[1]+'\n'+parcStatRendu[2]+'\n'+parcStatRendu[3]+'\n'+parcStatRendu[4]+'\n'+parcStatRendu[5]+'\n'+parcStatRendu[6]+'\n'+parcStatRendu[7]+'\n'+b+'\n'
				
			# affichage des infos dans l'onglet
			self.zoneAffichInfosImg.setText(self.infosImgProv)
			self.framImg.setEnabled(True)
			
			# remise à 0 de la variable provisoire de log
			self.infosImgProv=''
			# ---------------------------------------------------------
			
			# Elimination de l'image tampon .
			os.remove("/tmp/ekd/tampon/temp_image_masque_alpha_3d/masque3d_tmpg5dgf54dqk1oy8f.png")
			
			self.operationReussie()
				
		except :
			print "ERREUR !"
			self.messageErreur()
				
			
	def meth_2_ReglagPrevis(self):
		""" Réglage des différents paramètres et prévisualisation pour la méthode 2 """

		try :
			
			# Compteur départ pour le temps de rendu
			t0=time.time()
			
			# Liste pour affichage image découpée (ds le tabwidget)
			listeAff_1=[]
	
			# Ouverture utile pour connaitre notamment la resolution de l'image .
			imageDepart=Image.open(self.listeChemin[0])
			
			# On recupere la taille de l'image
			widthDepart, heightDepart=imageDepart.size

			# On recupere le nombre de pixels totaux
			nbPixelsTotal=widthDepart*heightDepart
			
			print 'Nbre total de pixels', nbPixelsTotal
			
			# Si on a sélectionné Qualité Moyenne
			if self.comboQualite.currentIndex()==0:
				os.system('convert -resize '+str(round(imageDepart.size[0]*1.4))+'x '+"\""+"".join(self.listeChemin[0])+"\""+' /tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmp5ghy46s3y53k77w4.png')
			# Si on a sélectionné Qualité Bonne
			elif self.comboQualite.currentIndex()==1:
				os.system('convert -resize '+str(round(imageDepart.size[0]*1.6))+'x '+"\""+"".join(self.listeChemin[0])+"\""+' /tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmp5ghy46s3y53k77w4.png')
			# Si on a sélectionné Qualité Tres bonne
			elif self.comboQualite.currentIndex()==2:
				os.system('convert -resize '+str(round(imageDepart.size[0]*1.8))+'x '+"\""+"".join(self.listeChemin[0])+"\""+' /tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmp5ghy46s3y53k77w4.png')
			# Si on a sélectionné Qualité Excellente
			elif self.comboQualite.currentIndex()==3:
				os.system('convert -resize '+str(round(imageDepart.size[0]*2))+'x '+"\""+"".join(self.listeChemin[0])+"\""+' /tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmp5ghy46s3y53k77w4.png')
				
			imgOuv_1_tmp=Image.open("/tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmp5ghy46s3y53k77w4.png")
			
			# Creation de l'array avec les donnees de l'image chargee .
			imageData=array(imgOuv_1_tmp.getdata())
		
			# Collecte des coordonnees x (methode tout avec Numpy --> modulo)
			coord_X_1=remainder(arange(imageData.shape[0]), imgOuv_1_tmp.size[0]) 
			# Collecte des coordonnees y (methode tout avec Numpy --> division)
			coord_Y_1=divide(arange(imageData.shape[0]), imgOuv_1_tmp.size[0])
			# Autre facon de proceder :
			#coord_X_1=arange(len(imageData))%imgOuv_1_tmp.size[0] # collecte
			# coordonnees x
			#coord_Y_1=arange(len(imageData))/imgOuv_1_tmp.size[0] # collecte
			# coordonnees y
			
			# Remplissage d'un array (tableau) avec toutes les coordonnes de 
			# la grille, comme ceci :
			# array([[0, 0],
			#	 [1, 0],
			#	 [2, 0], ..., [0, 1], [1, 1], [2, 1], ..., [500, 50], ...]
			coord_XY=column_stack((coord_X_1, coord_Y_1))
			
			# Calcul de la valeur max . Exemple : [..., [12, 789, 1], [89, 567, 7],
			# ...] donne comme resultat : [[..., 789, 567, ...]] .
			maxRGB=imageData.max(axis=1)
		
			# Conversion en float
			maxRGB=maxRGB.astype(float)
		
			# ------------------------------------------------------------------
			# REMERCIEMENT SPECIAL A Gael Varoquaux (du forum python@aful.org), qui
			# m'a fait decouvrir Numpy et a trouve la formule pour le calcul de Hue
			# (h_HSV)
			# ------------------------------------------------------------------
			# CALCUL DE Hue (avec des valeurs arrondies a 2 chiffres apres la
			# virgule) .
			# TEINTE
			# ------------------------------------------------------------------
			h_HSV=(angle(inner(imageData, c_[1,exp(2j*pi/3.),exp(-2j*pi/3.)]))*180/pi)%360

			# ------------------------------------------------------------------
			# CALCUL DE Saturation	(imageData.ptp(axis=1) ==>
			# maxRGB-minRGB)
			# On obtient a la fin un pourcentage (*100). SATURATION
			# ------------------------------------------------------------------
			s_HSV=round_(imageData.ptp(axis=1)/maxRGB, decimals=2)*100
		
			# ------------------------------------------------------------------
			# CALCUL DE Value. Calcul du pourcentage. LUMINOSITE
			# ------------------------------------------------------------------
			#V_ADFBV=imageData.max(axis=1) # Sans pourcentage
			v_HSV=(imageData.max(axis=1))*100/256 # Avec pourcentage
		
			# Concatenation des colonnes . Exemple :
			# [[0, 1],
			#  [2, 3],
			#  [4, 5]] donne comme resultat : [[0, 2, 4], [1, 3, 5]]
			hsv=column_stack((h_HSV, s_HSV, v_HSV)).astype(int)
			
			# Concatenation des valeurs entre elles . Le tableau genere est
			# sous la forme [[x1 y1 h1 s1 v1] [x2 y2 h2 s2 v2] ... ]
			conc_XY_RGB=c_[coord_XY, hsv]
		
			# --------------------------------------------------------------
			# Collecte/selection des coordonnes x et y, valeurs de Hue, valeurs de
			# Saturation, valeurs de Value selon les reglages faits par 
			# l'utilisateur .
			# Collecte non dans une boucle, mais avec la syntaxe de Numpy .	
			condition_1=((conc_XY_RGB.take([0], axis=1).ravel()>=0) & (conc_XY_RGB.take([1], axis=1).ravel()>=0) & (conc_XY_RGB.take([2], axis=1).ravel()>self.spinTeinteDebut.value()) & (conc_XY_RGB.take([2], axis=1).ravel()<self.spinTeinteFin.value()) & (conc_XY_RGB.take([3], axis=1).ravel()>self.spinSaturationDebut.value()+4) & (conc_XY_RGB.take([3], axis=1).ravel()<self.spinSaturationFin.value()+4) & (conc_XY_RGB.take([4], axis=1).ravel()>self.spinLuminosite.value()-4) & (conc_XY_RGB.take([4], axis=1).ravel()<100))
		
			# Resultat de la condition juste au-dessus .
			selection_1=conc_XY_RGB[condition_1]
		
			# Collecte des coordonnes x et y exactes des pixels bleus/verts dans 
			# l'image. Les autres donnees ne sont pas prises en compte . Selection 
			# des coordonnees x et y avec la syntaxe de Numpy.
			a1=selection_1[:,0]
			a2=selection_1[:,1]
		
			# Mise en forme des cordonnes x et y dans le tableau
			listePrecisCoordonnees=column_stack((a1, a2))
			
			# Collecte de la couleur RGB a la position x=0, y=0 .
			data_1er_pixel=imgOuv_1_tmp.getpixel((0, 0))
		
			# Conversion en RGBA de l'image. RGB+Canal Alpha
			if imgOuv_1_tmp.mode!="RGBA": imagAlpha=imgOuv_1_tmp.convert("RGBA")
			else: imagAlpha=imgOuv_1_tmp
			
			# Ouverture de l'image avec le fond en damier
			imQuad=Image.open("gui_modules_lecture/affichage_image/ekd_quadrillage_canal_alpha.png")
			# Redimensionnement de l'image du damier (quadrillage) aux 
			# dimensions de la premiere image chargee .
			RedimQuad=imQuad.resize(imageDepart.size, Image.ANTIALIAS)
			
			# Copie de l'image quadrillage dans le répertoire tampon 
			shutil.copy('gui_modules_lecture/affichage_image/ekd_quadrillage_canal_alpha.png', '/tmp/ekd/tampon/temp_image_masque_alpha_3d/')
		
			# Transformation des pixels bleus ou verts du fond
			# en pixels transparents (RGBA --> A=0)
			ecrPix_1=ImageDraw.Draw(imagAlpha)	
			for parcoursXY in listePrecisCoordonnees:
				# Decoupe du fond (enfin le fond devient completement
				# transparent)
				leFondDevTransp=ecrPix_1.point(parcoursXY, (data_1er_pixel[0], data_1er_pixel[1], data_1er_pixel[2], 0))
						
			# -------------------------------------------------------------------
			# Sélection des pixels contigus autour du perso/forme (ceux les +
			# proches) --
			# -------------------------------------------------------------------
			# Selection des pixels contigus (c'est a dire ceux qui touchent le
			# personnage/la forme qui sera decoupe(e)) .
			# -------------------------------------------------------------------
			# Calcul des coordonnees cote gauche -->* (pixels de gauche)
			condit_2=where(listePrecisCoordonnees[1:].take([0], axis=1).ravel()>(listePrecisCoordonnees[:-1]+1).take([0], axis=1).ravel())
			# Resultat de la condition juste au-dessus .
			koko_1=listePrecisCoordonnees[condit_2]
			# -------------------------------------------------------------------
			# Inversion du tableau pour calcul des pix de droite ; Exemple : 
			# [[3, 127], [81, 127], [3, 3], [95, 3], [47, 3], [347, 3]] devient
			# [[347, 3], [47, 3], [95, 3], [3, 3], [81, 127], [3, 127]] .
			inversionPourCond_3=listePrecisCoordonnees[::-1]
			# Calcul des coordonnees cote droit *<-- (pixels de droite)
			conditInvers=where(inversionPourCond_3[1:].take([0], axis=1).ravel()<(inversionPourCond_3[:-1]-1).take([0], axis=1).ravel())
			# Resultat de la condition juste au-dessus. Et de nouveau inversion.
			koko_2=inversionPourCond_3[conditInvers][::-1]
			# Mise en forme des cordonnes x et y dans le tableau .
			l_coordXYcontigues=vstack((koko_1, koko_2))
			# -------------------------------------------------------------------
			# De nouveau merci a Gael Varoquaux pour cette methode de classement
			# juste en dessous (methode par une fonction) .
			def foncRemisEnOrdre(k_a, k_b) :
				if k_a[1] > k_b[1] : return 1
				elif k_a[1] < k_b[1] : return -1
				elif k_a[0] > k_b[0] : return 1
				elif k_a[0] < k_b[0] : return -1
				else : return 0
			# Creation d'une liste avec les données du tableu 
			# crée precedemment .
			listeXYcoordContig=l_coordXYcontigues.tolist()
			# Remise en ordre suivant le calcul dans la fonction 
			# foncRemisEnOrdreDFVA .
			listeXYcoordContig.sort(cmp=foncRemisEnOrdre)
			# Creation d'un tableau a partir de la liste .
			l_coordXYcontigues=array(listeXYcoordContig)
			# -------------------------------------------------------------------
		
			# -------------------------------------------------------------------
			# Sélection pour découpe des pixels (les pixels du contour du
			# perso/forme) --
			# -------------------------------------------------------------------
			# Compteur
			conptD_1=0
			# Decoupe des pixels contigus (niveau 1 ==> liste l_Decoup_1)
			l_Decoup_1=[]
			# Decoupe des pixels contigus (niveau 2 ==> liste l_Decoup_2)
			l_Decoup_2=[]
			# Decoupe des pixels contigus (niveau 3 ==> liste l_Decoup_3)
			l_Decoup_3=[]
		
			for parcDecoup_X, parcDecoup_Y in l_coordXYcontigues:
			
				# Si l'id du compteur est pair ca se decale sur la droite .
				if conptD_1%2==0:
					# Incrementation niv 1 de la valeur de x --> (x, y) 
					# a +1
					parcDecoup_X=parcDecoup_X+1
					l_Decoup_1.append((parcDecoup_X, parcDecoup_Y))	
					# Incrementation niv 2 de la valeur de x --> (x, y) 
					# a +1
					parcDecoup_X=parcDecoup_X+1 
					l_Decoup_2.append((parcDecoup_X, parcDecoup_Y)) 
					# Incrementation niv 3 de la valeur de x --> (x, y) 
					# a +1
					parcDecoup_X=parcDecoup_X+1 
					l_Decoup_3.append((parcDecoup_X, parcDecoup_Y)) 
				
				# Si l'id du compteur est impair ca se decale sur la gauche
				elif conptD_1%2==1:
					# Incrementation niv 1 de la valeur de x --> (x, y) 
					# a -1
					parcDecoup_X=parcDecoup_X-1
					l_Decoup_1.append((parcDecoup_X, parcDecoup_Y))	
					# Incrementation niv 2 de la valeur de x --> (x, y) 
					# a -1
					parcDecoup_X=parcDecoup_X-1 
					l_Decoup_2.append((parcDecoup_X, parcDecoup_Y)) 
					# Incrementation niv 3 de la valeur de x --> (x, y) 
					# a -1
					parcDecoup_X=parcDecoup_X-1 
					l_Decoup_3.append((parcDecoup_X, parcDecoup_Y)) 
												
				conptD_1=conptD_1+1
			# -------------------------------------------------------------------
	
			# -------------------------------------------------------------------
			# Selection et mise en relation ds une liste des couleurs aux
			# coordonnes x et y definies juste au dessus . A la fin les listes
			# sont sous cette forme : [..., ((x, y), (R, G, B, A)), ...]
			# -------------------------------------------------------------------
			lll_1=zip(l_Decoup_1, [imagAlpha.getpixel(bbb_1) for bbb_1 in l_Decoup_1])
			lll_2=zip(l_Decoup_2, [imagAlpha.getpixel(bbb_2) for bbb_2 in l_Decoup_2])
			lll_3=zip(l_Decoup_3, [imagAlpha.getpixel(bbb_3) for bbb_3 in l_Decoup_3])
			# -------------------------------------------------------------------
								
			# -------------------------------------------------------------------
			# Traitement de l'image ... decoupe/application du fond transparent
			# (du liseret 1) immediatement autour du perso ou forme .
			ecrPixBordur1=ImageDraw.Draw(imagAlpha)
			for parcBordurXY_1, parcBordurCoul_1 in lll_1 :
				# Découpe du liseret (enfin le liseret devient + ou -
				# transparent)
				ecrPixBordur1.point(parcBordurXY_1, (parcBordurCoul_1[0], parcBordurCoul_1[1], parcBordurCoul_1[2], 10))
			
			# Traitement de l'image ... decoupe/application du fond transparent
			# (du liseret 2) immediatement autour du perso ou forme .	
			ecrPixBordur2=ImageDraw.Draw(imagAlpha)
			for parcBordurXY_2, parcBordurCoul_2 in lll_2 : 
				# Découpe du liseret (enfin le liseret devient + ou -
				# transparent)
				ecrPixBordur2.point(parcBordurXY_2, (parcBordurCoul_2[0], parcBordurCoul_2[1], parcBordurCoul_2[2], 100)) 
			
			# Traitement de l'image ... decoupe/application du fond transparent
			# (du liseret 3) immediatement autour du perso ou forme .	
			ecrPixBordur3=ImageDraw.Draw(imagAlpha)
			for parcBordurXY_3, parcBordurCoul_3 in lll_3 : 
				# Découpe du liseret (enfin le liseret devient + ou -
				# transparent)
				ecrPixBordur3.point(parcBordurXY_3, (parcBordurCoul_3[0], parcBordurCoul_3[1], parcBordurCoul_3[2], 200)) 
			# -------------------------------------------------------------------
			
			# On libere la memoire
			del coord_X_1, coord_Y_1, coord_XY, maxRGB, h_HSV, s_HSV, v_HSV, hsv, conc_XY_RGB, condition_1, selection_1, a1, a2, listePrecisCoordonnees, data_1er_pixel, leFondDevTransp, condit_2, koko_1, inversionPourCond_3, conditInvers, koko_2, l_coordXYcontigues, l_Decoup_1, l_Decoup_2, l_Decoup_3, lll_1, lll_2, lll_3, ecrPixBordur1, ecrPixBordur2, ecrPixBordur3
			
			# -------------------------------------------------------------------
			# PARTIE FINALE DU RENDU
			# -------------------------------------------------------------------
			# Application d'un leger lissage de l'image
			imFILTsmooth=imagAlpha.filter(ImageFilter.SMOOTH)	
			# Compositing entre l'image avec lissage et l'image tampon
			ImageChops.composite(imFILTsmooth, imagAlpha, imagAlpha).save('/tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmp5ghy46s3y53k77w4.png', 'PNG')
				
			# Ouverture de l'image pour application du kernel (matrice)
			imk=Image.open("/tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmp5ghy46s3y53k77w4.png")
			# Kernel 3x3 pour amélioration des bords. L'image devient plus nette.
			sizeKern3x3=(3, 3) 
			# Matrice trouvee ici: http://blogs.codes-sources.com/tkfe/archive/2005/04/15/6004.aspx
			kernAmBords=(-1, -2, -1, -2, 16, -2, -1, -2, -1)
			imKernelAmBords=imk.filter(ImageFilter.Kernel(sizeKern3x3, kernAmBords)).save('/tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmp5ghy46s3y53k77w4.png', 'PNG')
				
			# Ouverture de l'image pour application du kernel (matrice)
			ouvIm=Image.open('/tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmp5ghy46s3y53k77w4.png')
				
			# Kernel 3x3 anti-crénelage
			sizeKern3x3=(3, 3)
			# Type de kernel utilisé
			kernAntiAlias=(1, 2, 3, 4, 5, 6, 7, 8, 9)
			# Application d'un anti-aliasing sur l'image (et donc sur les contours) par 
			# cette matrice. Cette excelllente matrice a été trouvée ici:
			# http://www.photo-lovers.org/mosaic.shtml.fr 
			# (voir à partir de Méthode du vecteur médian)
			#
			# Sauvegarde de l'image pour compositing
			ouvIm.filter(ImageFilter.Kernel(sizeKern3x3, kernAntiAlias)).save('/tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmp5ghy46s3y53k77w4.png')

			# Retour aux dimensions d'origine de l'image et enregistrement dans 
			# le rep temporaire (et ce pour le compositing ... et donc l'affichage
			# dans l'interface)
			os.system('convert -resize '+str(imageDepart.size[0])+'x /tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmp5ghy46s3y53k77w4.png /tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmp5ghy46s3y53k77w4.png')
			
			imgFinal=Image.open('/tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmp5ghy46s3y53k77w4.png')
		
			# Compositing entre l'image avec le damier et l'image du fond 
			# vert/bleu decoupe
			ImageChops.composite(imgFinal, RedimQuad, imgFinal).save('/tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmp5ghy46s3y53k77w4.png')
			
			# Remplissage de listeAff_1 pour affichage (ds le tabwidget)
			listeAff_1.append('/tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmp5ghy46s3y53k77w4.png')
			# -------------------------------------------------------------------
			
			# On re-libere la memoire
			del imFILTsmooth, imgFinal
				
			# Remplissage de listeAff_1 pour affichage (ds le tabwidget)
			listeAff_1.append('/tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmp5ghy46s3y53k77w4.png')
			
			# --------------------------------------------------------------------
			# CALCUL ET AFFICHAGE DE LA DATE ET DU TEMPS DE RENDU
			# --------------------------------------------------------------------
			# Temps local (annee, mois, jour, heure, minute, seconde ...)
			tLocal=time.localtime()
			# Pour affichage de facon comprehensible de la date et l'heure
			datHeurEcr=_(u"Le ")+str(tLocal[2])+"/"+str(tLocal[1])+"/"+str(tLocal[0])+_(u" a ")+str(tLocal[3])+":"+str(tLocal[4])+":"+str(tLocal[5])
			# Positionnement au temps 2 pour le temps de rendu de l'image .
			t1=time.time()
			# Si le temps de rendu est inferieur a la minute ... .
			if int(t1-t0)<60 :
				# Pour affichage dans le terminal .
				affTerm=_("Temps de rendu : %s secondes") % (int(round(t1-t0)))
				print
				print datHeurEcr
				print "=================================================="
				print affTerm
				print "=================================================="
				print
				# Pour affichage dans l'interface (variable)
				affTempsInterface=_("%s secondes") % (int(round(t1-t0)))
			# Si le temps de rendu est superieur a la minute ... calcul des 
			# minutes et des secondes .
			elif int(t1-t0)>=60 : 
				# Pour affichage dans le terminal
				affTerm=_(u"Temps de rendu : ")+str(int(round(t1-t0))/60)+_(u" min ")+str(int(round(t1-t0))%60)+_(u" sec")
				print
				print datHeurEcr
				print "=================================================="
				print affTerm
				print "=================================================="
				print		
				# Pour affichage dans l'interface
				affTempsInterface=str(int(round(t1-t0))/60)+_(u" min ")+str(int(round(t1-t0))%60)+_(u" sec")
			
			# La page Image résultat devient visible à la fin du rendu
			self.tabwidget.setCurrentIndex(self.indexImageResultat)
			
			# Affichage de l'image chargée -----------------------
			self.afficheurImg_1.setImage(self.listeChemin[0])
			# Affichage de l'image découpée ----------------------
			self.afficheurImg_2.setImage(listeAff_1[0])
			# ----------------------------------------------------
			
			# Affichage des infos sur l'image --------------------	
			# On implémente les chemins des fichiers dans une variable
			# pour préparer l'affichage des infos
			texte=_(u" Image avant découpage du fond uni ")
			texte_2=_(u" Réglages(s)")
			texte_3=_(u" Résolution de l'image")
			texte_4=_(u" Temps de calcul de la découpe")
			a='#'*36
			
			self.infosImgProv=a+'\n# '+texte+'\n'+a+'\n'
			self.infosImgProv=self.infosImgProv+'\n'+self.listeChemin[0]+'\n\n'
			
			self.infosImgProv_2=a+'\n# '+texte_2+'\n'+a+'\n'
			self.infosImgProv_2=self.infosImgProv_2+'\n'+_(u'Valeur teinte (début) : ')+str(self.spinTeinteDebut.value())+'\n'+_(u'Valeur teinte (fin) : ')+str(self.spinTeinteFin.value())+'\n'+_(u'Valeur saturation (début) : ')+str(self.spinSaturationDebut.value())+'\n'+_(u'Valeur saturation (fin) : ')+str(self.spinSaturationFin.value())+'\n'+_(u'Valeur luminosité : ')+str(self.spinLuminosite.value())+'\n\n'
			
			self.infosImgProv_3=a+'\n# '+texte_3+'\n'+a+'\n'
			self.infosImgProv_3=self.infosImgProv_3+'\n'+str(widthDepart)+' x '+str(heightDepart)+_(u' pix')+'\n'+_(u"Nombre de pixels dans l'image : ")+str(nbPixelsTotal)+'\n\n'
			
			self.infosImgProv_4=a+'\n# '+texte_4+'\n'+a+'\n'
			self.infosImgProv_4=self.infosImgProv_4+'\n'+affTempsInterface+'\n\n'
			
			# affichage des infos dans l'onglet
			self.zoneAffichInfosImg.setText(self.infosImgProv+self.infosImgProv_2+self.infosImgProv_3+self.infosImgProv_4)
			self.framImg.setEnabled(True)
		
			# remise à 0 de la variable provisoire de log
			self.infosImgProv, self.infosImgProv_2, self.infosImgProv_3, self.infosImgProv_4='', '', '', ''
			# ----------------------------------------------------
			
			# On re-re-libere la memoire
			del tLocal, datHeurEcr, t0, t1, affTerm, affTempsInterface, texte, texte_2, texte_3, texte_4, a, self.infosImgProv, self.infosImgProv_2, self.infosImgProv_3, self.infosImgProv_4, nbPixelsTotal, listeAff_1, imageDepart, widthDepart, heightDepart, imagAlpha
			
			# Epuration/elimination des fichiers tampon
			for toutRepTemp in glob.glob('/tmp/ekd/tampon/temp_image_masque_alpha_3d/*.*'):
				os.remove(toutRepTemp)
				
			self.operationReussie()
			
		except:
			print "ERREUR !"
			self.messageErreur()
			
			
	def meth_2_ReglagMasqueAlpha(self):
		""" Masque alpha (découpe) pour la méthode 2 """
		
		# Cette fonction gere les chemins avec trous .
	
		try :
			
			# Liste pour affichage image découpée (ds le tabwidget)
			listeAff_1=[]
			# Liste pour affichage dans la page Info
			listeAff_2=[]
	
			# Nbre d'images charges par l'utilisateur
			nbreElem=len(self.listeChemin)	

			# Compteur pour le calcul du temps de rendu cumule.
			som_t_renduCumul=0 
	
			# Compteur pour le 1er temps de rendu (exactement la meme variable
			# que pour ==> Positionnement au temps 1 pour le temps de rendu de 
			# l'image, juste en-dessous) .
			t0=0 

			# Positionnement au temps 1 pour le temps de rendu de l'image .
			temps1=time.localtime(time.time())	
	
			# Boucle principale de chargement des images .
			for parcPrincipal in range(nbreElem):
				
				# Ouverture de l'image dans le lot
				imageDepart=Image.open(self.listeChemin[parcPrincipal])
		
				# Compteur pour le 1er temps de rendu .
				t0=time.time()
				
				# On recupere la taille de l'image
				widthDepart, heightDepart=imageDepart.size
				# On recupere le nombre de pixels totaux
				nbPixelsTotal=widthDepart*heightDepart
				
				# Si on a sélectionné Qualité Moyenne
				if self.comboQualite.currentIndex()==0:
					os.system('convert -resize '+str(round(imageDepart.size[0]*1.4))+'x '+"\""+"".join(self.listeChemin[parcPrincipal])+"\""+' /tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmpt6x5q56fvw9qf6q6qx.png')
				# Si on a sélectionné Qualité Bonne
				elif self.comboQualite.currentIndex()==1:
					os.system('convert -resize '+str(round(imageDepart.size[0]*1.6))+'x '+"\""+"".join(self.listeChemin[parcPrincipal])+"\""+' /tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmpt6x5q56fvw9qf6q6qx.png')
				# Si on a sélectionné Qualité Tres bonne
				elif self.comboQualite.currentIndex()==2:
					os.system('convert -resize '+str(round(imageDepart.size[0]*1.8))+'x '+"\""+"".join(self.listeChemin[parcPrincipal])+"\""+' /tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmpt6x5q56fvw9qf6q6qx.png')
				# Si on a sélectionné Qualité Excellente
				elif self.comboQualite.currentIndex()==3:
					os.system('convert -resize '+str(round(imageDepart.size[0]*2))+'x '+"\""+"".join(self.listeChemin[parcPrincipal])+"\""+' /tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmpt6x5q56fvw9qf6q6qx.png')
				
				imgOuv_1_tmp=Image.open("/tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmpt6x5q56fvw9qf6q6qx.png")
			
				# Creation de l'array avec les donnees de l'image chargee
				imageData=array(imgOuv_1_tmp.getdata())

				# Collecte des coordonnees x (methode tout avec Numpy --> modulo)
				coord_X_1=remainder(arange(imageData.shape[0]), imgOuv_1_tmp.size[0]) 
				# Collecte des coordonnees y (methode tout avec Numpy --> division)
				coord_Y_1=divide(arange(imageData.shape[0]), imgOuv_1_tmp.size[0])
			
				# Remplissage d'un array (tableau) avec toutes les coordonnes de 
				# la grille, comme ceci :
				# array([[0, 0],
				#	 [1, 0],
				#	 [2, 0], ..., [0, 1], [1, 1], [2, 1], ..., [500, 50], ...]
				coord_XY=column_stack((coord_X_1, coord_Y_1))
			
				# Calcul de la valeur max . Exemple : [..., [12, 789, 1], [89, 567, 7],
				# ...] donne comme resultat : [[..., 789, 567, ...]] .
				maxRGB=imageData.max(axis=1)
		
				# Conversion en float
				maxRGB=maxRGB.astype(float)
		
				# ------------------------------------------------------------------
				# CALCUL DE Hue (avec des valeurs arrondies a 2 chiffres apres la
				# virgule) .
				# TEINTE
				# ------------------------------------------------------------------
				h_HSV=(angle(inner(imageData, c_[1,exp(2j*pi/3.),exp(-2j*pi/3.)]))*180/pi)%360

				# ------------------------------------------------------------------
				# CALCUL DE Saturation	(imageData.ptp(axis=1) ==>
				# maxRGB-minRGB)
				# On obtient a la fin un pourcentage (*100). SATURATION
				# ------------------------------------------------------------------
				s_HSV=round_(imageData.ptp(axis=1)/maxRGB, decimals=2)*100
		
				# ------------------------------------------------------------------
				# CALCUL DE Value. Calcul du pourcentage. LUMINOSITE
				# ------------------------------------------------------------------
				v_HSV=(imageData.max(axis=1))*100/256 # Avec pourcentage
		
				# Concatenation des colonnes . Exemple :
				# [[0, 1],
				#  [2, 3],
				#  [4, 5]] donne comme resultat : [[0, 2, 4], [1, 3, 5]]
				hsv=column_stack((h_HSV, s_HSV, v_HSV)).astype(int)
			
				# Concatenation des valeurs entre elles . Le tableau genere est
				# sous la forme [[x1 y1 h1 s1 v1] [x2 y2 h2 s2 v2] ... ]
				conc_XY_RGB=c_[coord_XY, hsv]
		
				# --------------------------------------------------------------
				# Collecte/selection des coordonnes x et y, valeurs de Hue, valeurs de
				# Saturation, valeurs de Value selon les reglages faits par 
				# l'utilisateur .
				# Collecte non dans une boucle, mais avec la syntaxe de Numpy .	
				condition_1=((conc_XY_RGB.take([0], axis=1).ravel()>=0) & (conc_XY_RGB.take([1], axis=1).ravel()>=0) & (conc_XY_RGB.take([2], axis=1).ravel()>self.spinTeinteDebut.value()) & (conc_XY_RGB.take([2], axis=1).ravel()<self.spinTeinteFin.value()) & (conc_XY_RGB.take([3], axis=1).ravel()>self.spinSaturationDebut.value()+4) & (conc_XY_RGB.take([3], axis=1).ravel()<self.spinSaturationFin.value()+4) & (conc_XY_RGB.take([4], axis=1).ravel()>self.spinLuminosite.value()-4) & (conc_XY_RGB.take([4], axis=1).ravel()<100))
		
				# Resultat de la condition juste au-dessus .
				selection_1=conc_XY_RGB[condition_1]
		
				# Collecte des coordonnes x et y exactes des pixels bleus/verts dans 
				# l'image. Les autres donnees ne sont pas prises en compte . Selection 
				# des coordonnees x et y avec la syntaxe de Numpy.
				a1=selection_1[:,0]
				a2=selection_1[:,1]
		
				# Mise en forme des cordonnes x et y dans le tableau
				listePrecisCoordonnees=column_stack((a1, a2))
			
				# Collecte de la couleur RGB a la position x=0, y=0 .
				data_1er_pixel=imgOuv_1_tmp.getpixel((0, 0))
		
				# Conversion en RGBA de l'image. RGB+Canal Alpha
				if imgOuv_1_tmp.mode!="RGBA": imagAlpha=imgOuv_1_tmp.convert("RGBA")
				else: imagAlpha=imgOuv_1_tmp
				
				# Ouverture de l'image avec le fond en damier
				imQuad=Image.open("gui_modules_lecture/affichage_image/ekd_quadrillage_canal_alpha.png")
				# Redimensionnement de l'image du damier (quadrillage) aux 
				# dimensions de la premiere image chargee .
				RedimQuad=imQuad.resize(imageDepart.size, Image.ANTIALIAS)
			
				# Copie de l'image quadrillage dans le répertoire tampon 
				shutil.copy('gui_modules_lecture/affichage_image/ekd_quadrillage_canal_alpha.png', '/tmp/ekd/tampon/temp_image_masque_alpha_3d/')
				
				# Transformation des pixels bleus ou verts du fond
				# en pixels transparents (RGBA --> A=0)
				ecrPix_1=ImageDraw.Draw(imagAlpha)	
				for parcoursXY in listePrecisCoordonnees:
					# Decoupe du fond (enfin le fond devient completement
					# transparent)
					leFondDevTransp=ecrPix_1.point(parcoursXY, (data_1er_pixel[0], data_1er_pixel[1], data_1er_pixel[2], 0))
	
				# -------------------------------------------------------------------
				# Sélection des pixels contigus autour du perso/forme (ceux les +
				# proches) --
				# -------------------------------------------------------------------
				# Selection des pixels contigus (c'est a dire ceux qui touchent le
				# personnage/la forme qui sera decoupe(e)) .
				# -------------------------------------------------------------------
				# Calcul des coordonnees cote gauche -->* (pixels de gauche)
				condit_2=where(listePrecisCoordonnees[1:].take([0], axis=1).ravel()>(listePrecisCoordonnees[:-1]+1).take([0], axis=1).ravel())
				# Resultat de la condition juste au-dessus .
				koko_1=listePrecisCoordonnees[condit_2]
				# -------------------------------------------------------------------
				# Inversion du tableau pour calcul des pix de droite ; Exemple : 
				# [[3, 127], [81, 127], [3, 3], [95, 3], [47, 3], [347, 3]] devient
				# [[347, 3], [47, 3], [95, 3], [3, 3], [81, 127], [3, 127]] .
				inversionPourCond_3=listePrecisCoordonnees[::-1]
				# Calcul des coordonnees cote droit *<-- (pixels de droite)
				conditInvers=where(inversionPourCond_3[1:].take([0], axis=1).ravel()<(inversionPourCond_3[:-1]-1).take([0], axis=1).ravel())
				# Resultat de la condition juste au-dessus. Et de nouveau inversion.
				koko_2=inversionPourCond_3[conditInvers][::-1]
				# Mise en forme des cordonnes x et y dans le tableau .
				l_coordXYcontigues=vstack((koko_1, koko_2))
				# -------------------------------------------------------------------
				# De nouveau merci a Gael Varoquaux pour cette methode de classement
				# juste en dessous (methode par une fonction) .
				def foncRemisEnOrdre(k_a, k_b) :
					if k_a[1] > k_b[1] : return 1
					elif k_a[1] < k_b[1] : return -1
					elif k_a[0] > k_b[0] : return 1
					elif k_a[0] < k_b[0] : return -1
					else : return 0
				# Creation d'une liste avec les donnes du tableu 
				# cree precedemment .
				listeXYcoordContig=l_coordXYcontigues.tolist()
				# Remise en ordre suivant le calcul dans la fonction 
				# foncRemisEnOrdreDFVA .
				listeXYcoordContig.sort(cmp=foncRemisEnOrdre)
				# Creation d'un tableau a partir de la liste .
				l_coordXYcontigues=array(listeXYcoordContig)
				# -------------------------------------------------------------------
		
				# -------------------------------------------------------------------
				# Sélection pour découpe des pixels (les pixels du contour du
				# perso/forme) --
				# -------------------------------------------------------------------
				# Compteur
				conptD_1=0
				# Decoupe des pixels contigus (niveau 1 ==> liste l_Decoup_1)
				l_Decoup_1=[]
				# Decoupe des pixels contigus (niveau 2 ==> liste l_Decoup_2)
				l_Decoup_2=[]
				# Decoupe des pixels contigus (niveau 3 ==> liste l_Decoup_3)
				l_Decoup_3=[]
		
				for parcDecoup_X, parcDecoup_Y in l_coordXYcontigues:
			
					# Si l'id du compteur est pair ca se decale sur la droite .
					if conptD_1%2==0 :
						# Incrementation niv 1 de la valeur de x --> (x, y) 
						# a +1
						parcDecoup_X=parcDecoup_X+1
						l_Decoup_1.append((parcDecoup_X, parcDecoup_Y))
						# Incrementation niv 2 de la valeur de x --> (x, y) 
						# a +1
						parcDecoup_X=parcDecoup_X+1 
						l_Decoup_2.append((parcDecoup_X, parcDecoup_Y)) 
						# Incrementation niv 3 de la valeur de x --> (x, y) 
						# a +1
						parcDecoup_X=parcDecoup_X+1 
						l_Decoup_3.append((parcDecoup_X, parcDecoup_Y)) 
				
					# Si l'id du compteur est impair ca se decale sur la gauche
					elif conptD_1%2==1 :
						# Incrementation niv 1 de la valeur de x --> (x, y) 
						# a -1
						parcDecoup_X=parcDecoup_X-1
						l_Decoup_1.append((parcDecoup_X, parcDecoup_Y))	
						# Incrementation niv 2 de la valeur de x --> (x, y) 
						# a -1
						parcDecoup_X=parcDecoup_X-1 
						l_Decoup_2.append((parcDecoup_X, parcDecoup_Y)) 
						# Incrementation niv 3 de la valeur de x --> (x, y) 
						# a -1
						parcDecoup_X=parcDecoup_X-1 
						l_Decoup_3.append((parcDecoup_X, parcDecoup_Y)) 
												
					conptD_1=conptD_1+1
				# -------------------------------------------------------------------
	
				# -------------------------------------------------------------------
				# Selection et mise en relation ds une liste des couleurs aux
				# coordonnes x et y definies juste au dessus . A la fin les listes
				# sont sous cette forme : [..., ((x, y), (R, G, B, A)), ...]
				# -------------------------------------------------------------------
				lll_1=zip(l_Decoup_1, [imagAlpha.getpixel(bbb_1) for bbb_1 in l_Decoup_1])
				lll_2=zip(l_Decoup_2, [imagAlpha.getpixel(bbb_2) for bbb_2 in l_Decoup_2])
				lll_3=zip(l_Decoup_3, [imagAlpha.getpixel(bbb_3) for bbb_3 in l_Decoup_3])
				# -------------------------------------------------------------------
								
				# -------------------------------------------------------------------
				# Traitement de l'image ... decoupe/application du fond transparent
				# (du liseret 1) immediatement autour du perso ou forme .
				ecrPixBordur1=ImageDraw.Draw(imagAlpha)
				for parcBordurXY_1, parcBordurCoul_1 in lll_1 :
					# Découpe du liseret (enfin le liseret devient + ou -
					# transparent)
					ecrPixBordur1.point(parcBordurXY_1, (parcBordurCoul_1[0], parcBordurCoul_1[1], parcBordurCoul_1[2], 10))
			
				# Traitement de l'image ... decoupe/application du fond transparent
				# (du liseret 2) immediatement autour du perso ou forme .	
				ecrPixBordur2=ImageDraw.Draw(imagAlpha)
				for parcBordurXY_2, parcBordurCoul_2 in lll_2 : 
					# Découpe du liseret (enfin le liseret devient + ou -
					# transparent)
					ecrPixBordur2.point(parcBordurXY_2, (parcBordurCoul_2[0], parcBordurCoul_2[1], parcBordurCoul_2[2], 100)) 
			
				# Traitement de l'image ... decoupe/application du fond transparent
				# (du liseret 3) immediatement autour du perso ou forme .	
				ecrPixBordur3=ImageDraw.Draw(imagAlpha)
				for parcBordurXY_3, parcBordurCoul_3 in lll_3 : 
					# Découpe du liseret (enfin le liseret devient + ou -
					# transparent)
					ecrPixBordur3.point(parcBordurXY_3, (parcBordurCoul_3[0], parcBordurCoul_3[1], parcBordurCoul_3[2], 200)) 
				# -------------------------------------------------------------------
			
				# On libere la memoire
				del coord_X_1, coord_Y_1, coord_XY, maxRGB, h_HSV, s_HSV, v_HSV, hsv, conc_XY_RGB, condition_1, selection_1, a1, a2, listePrecisCoordonnees, data_1er_pixel, leFondDevTransp, condit_2, koko_1, inversionPourCond_3, conditInvers, koko_2, l_coordXYcontigues, l_Decoup_1, l_Decoup_2, l_Decoup_3, lll_1, lll_2, lll_3, ecrPixBordur1, ecrPixBordur2, ecrPixBordur3
	
				# -------------------------------------------------------------------
				# PARTIE FINALE DU RENDU
				# -------------------------------------------------------------------
				# Application d'un leger lissage de l'image
				imFILTsmooth=imagAlpha.filter(ImageFilter.SMOOTH)	
				# Compositing entre l'image avec lissage et l'image tampon
				ImageChops.composite(imFILTsmooth, imagAlpha, imagAlpha).save('/tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmpt6x5q56fvw9qf6q6qx.png', 'PNG')
				
				# Ouverture de l'image pour application du kernel (matrice)
				imk=Image.open('/tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmpt6x5q56fvw9qf6q6qx.png')
				# Kernel 3x3 pour amélioration des bords. L'image devient plus nette.
				sizeKern3x3=(3, 3) 
				# Matrice trouvee ici: http://blogs.codes-sources.com/tkfe/archive/2005/04/15/6004.aspx
				kernAmBords=(-1, -2, -1, -2, 16, -2, -1, -2, -1)
				imKernelAmBords=imk.filter(ImageFilter.Kernel(sizeKern3x3, kernAmBords)).save('/tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmpt6x5q56fvw9qf6q6qx.png', 'PNG')
				
				# Ouverture de l'image pour application du kernel (matrice)
				ouvIm=Image.open('/tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmpt6x5q56fvw9qf6q6qx.png')
				
				# Kernel 3x3 anti-crénelage
				sizeKern3x3=(3, 3)
				# Type de kernel utilisé
				kernAntiAlias=(1, 2, 3, 4, 5, 6, 7, 8, 9)
				# Application d'un anti-aliasing sur l'image (et donc sur les contours) par 
				# cette matrice. Cette excelllente matrice a été trouvée ici:
				# http://www.photo-lovers.org/mosaic.shtml.fr 
				# (voir à partir de Méthode du vecteur médian)
				#
				# Sauvegarde de l'image pour compositing
				ouvIm.filter(ImageFilter.Kernel(sizeKern3x3, kernAntiAlias)).save('/tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmpt6x5q56fvw9qf6q6qx.png', 'PNG')
				
				# Retour aux dimensions d'origine de l'image et enregistrement dans le
				# rep temporaire (et ce pour la sauvegarde de l'image --> utilisateur)
				os.system('convert -resize '+str(imageDepart.size[0])+'x /tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmpt6x5q56fvw9qf6q6qx.png '+"\""+self.chemDossierSauv+'_'+string.zfill((parcPrincipal+1), 6)+'.png'+"\"")
				# Retour aux dimensions d'origine de l'image et enregistrement dans 
				# le rep temporaire (et ce pour le compositing ... et donc l'affichage
				# dans l'interface)
				os.system('convert -resize '+str(imageDepart.size[0])+'x /tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmpt6x5q56fvw9qf6q6qx.png /tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmpt6x5q56fvw9qf6q6qx.png')
		
				imgFinal=Image.open('/tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmpt6x5q56fvw9qf6q6qx.png')
		
				# Compositing entre l'image avec le damier et l'image du fond 
				# vert/bleu decoupe
				ImageChops.composite(imgFinal, RedimQuad, imgFinal).save('/tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmpt6x5q56fvw9qf6q6qx.png')
			
				# Remplissage de listeAff_1 pour affichage (ds le tabwidget)
				listeAff_1.append('/tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmpt6x5q56fvw9qf6q6qx.png')
				# -------------------------------------------------------------------
			
				# On re-libere la memoire
				del imFILTsmooth, imgFinal
				
				# ------------------------------------------------------------------ #
				# STATS DE RENDU (AFFICHAGE ET SAUVEGARDE) .
				# ------------------------------------------------------------------ #
				# Calcule le pourcentage effectue a chaque passage
				val_pourc=((parcPrincipal+1)*100)/nbreElem
				# Affichage du pourcentage du rendu dans le terminal
				# sous Linux ou la fenetre MS-DOS sous Windows
				print _("Progression du rendu :"), val_pourc
				# Positionnement au temps 2 pour le temps de rendu de l'image
				t1=time.time()
				# Temps local (annee, mois, jour, heure, minute, seconde ...)
				tLocal=time.localtime()
				# Calcul avec le compteur pour le calcul du temps de rendu cumule
				som_t_renduCumul=som_t_renduCumul+(t1-t0)
				# Calcul pour la moyenne du temps de rendu .
				MoyRendu=som_t_renduCumul/(parcPrincipal+1) 
				# Calcul pour le temps de rendu restant .
				tempRestant=((MoyRendu*nbreElem)-(MoyRendu*parcPrincipal+1))-MoyRendu 
				# Mise en ordre du temps local pour ecriture dans fichier
				datHeurEcr=_(u"Le ")+str(tLocal[2])+"/"+str(tLocal[1])+"/"+str(tLocal[0])+_(u" a ")+str(tLocal[3])+":"+str(tLocal[4])+":"+str(tLocal[5])
			
				# Pour ecriture dans fichier
				progImg=_(u"Image ")+str(parcPrincipal+1)+"/"+str(nbreElem)
			
				# Si le temps de rendu est inferieur a la minute ... .
				if int(t1-t0)<60:
					affTemps=_(u"Temps de rendu : %s secondes") % (int(round(t1-t0)))
				# Si le temps de rendu est superieur a la minute ... calcul des 
				# minutes et des secondes
				elif int(t1-t0)>=60:
					affTemps=_(u"Temps de rendu : ")+str(int(round(t1-t0))/60)+_(u" min ")+str(int(round(t1-t0))%60)+_(u" sec")
				# Si la moyenne du temps de rendu est inferieur a la minute ... .	
				if MoyRendu<60:
					moyTemps=_(u"Moyenne du temps de rendu : %s secondes") % (int(round(MoyRendu))) 
				# Si la moyenne du temps de rendu est superieur a la minute ...  
				# calcul des minutes et des secondes .
				elif MoyRendu>=60:
					moyTemps=_(u"Moyenne du temps de rendu : ")+str(int(round(MoyRendu/60)))+_(u" min ")+str(int(round(MoyRendu%60)))+_(u" sec")
				# Si le temps de rendu est inferieur a la minute ... .
				if som_t_renduCumul<60:
					tRenduCumul=_(u"Temps de rendu cumule : %s secondes") % (int(round(som_t_renduCumul)))
				# Si le temps de rendu est superieur ou egal a la minute ... calcul des 
				# heures et des minutes .
				elif som_t_renduCumul>=60:
					tRenduInfMinut=int(round(som_t_renduCumul/60)) 
					tRenduCumul=_(u"Temps de rendu cumule : ")+str(tRenduInfMinut/60)+_(u" h ")+str(tRenduInfMinut%60)+_(u" min")
					
				# Pour le temps de rendu restant ...
				# Si le temps de rendu restant est superieur a 0 secondes .
				if tempRestant>0:
					# Si le temps de rendu restant est inferieur a la minute et le
					# calcul du pourcentage est inferieur a 100 % .
					if tempRestant<60 and val_pourc<100:
						tRestant=_(u"Temps de rendu restant (estimation) : %s secondes") % (int(round(tempRestant)))
					# Si le temps de rendu restant est superieur a la minute et le
					# calcul du pourcentage est inferieur a 100 % .
					elif tempRestant>=60 and val_pourc<100:
						tRestantInfMinut=int(round(tempRestant/60))
						tRestant=_(u"Temps de rendu restant (estimation) : ")+str(tRestantInfMinut/60)+_(u" h ")+str(tRestantInfMinut%60)+_(u" min")
				
				# Des que le rendu est arrive a 100%, affichage de dans le
				# terminal sous Linux ou la fenetre MS-DOS sous Windows
				if val_pourc==100 :
					print
					print _("Rendu terminé !")

				# Ecriture des statistiques (cumul de l'ecriture) dans un fichier texte	
				ecrStatRendu=open(self.chemDossierSauv+_("_image_masque_alpha_meth_2.txt"), 'a')
				ecrStatRendu.write("=================================================\n"+str(datHeurEcr)+"\n"+"-------------------------------------------------\n"+str(progImg)+"\n"+str(affTemps)+"\n"+str(moyTemps)+"\n"+str(tRenduCumul)+"\n\n")
				ecrStatRendu.close()
				
				# Affichage de l'image découpée ----------------------
				self.afficheurImg_2.setImage(listeAff_1[parcPrincipal])
				# ----------------------------------------------------
				
				# Remplissage de la liste pour les statistiques de rendu
				listeAff_2.append((_(u"Image chargée : ")+self.listeChemin[parcPrincipal], _(u"Image finale : ")+self.chemDossierSauv+'_'+string.zfill((parcPrincipal+1), 6)+'.png', progImg, affTemps, moyTemps, tRenduCumul, _(u"Nombre total de pixels : ")+str(nbPixelsTotal), _("Dimension : ")+str(widthDepart)+' x '+str(heightDepart)))

				# --------------------------------------------
				# Affichage de la progression (avec
				# QProgressDialog) ds une fenêtre séparée
				# Bouton Cancel pour arrêter la progression donc le process
				self.progress.setValue(val_pourc)
				QApplication.processEvents()
				if (self.progress.wasCanceled()): break
				# Quand l'utilisateur charge au moins 2 images ...
				if len(self.listeChemin)>1:
					self.progress.setLabel(QLabel(QString(tRestant)))
				# --------------------------------------------
			
			# La page Image résultat devient visible après les conversions
			self.tabwidget.setCurrentIndex(self.indexImageResultat)
			
			# Affichage de la dernière image du lot chargée par l'utilisateur---
			self.afficheurImg_1.setImage(self.listeChemin[len(self.listeChemin)-1])
			# ------------------------------------------------------------------
			
			# Affichage des infos sur l'image -------------------------	
			# On implémente les chemins des fichiers dans une variable
			# pour préparer l'affichage des infos
			texte=_(u" Statistiques de rendu")
			a='#'*36
			b="-"*36
			
			self.infosImgProv=a+'\n#'+texte+'\n'+a+'\n'
			for parcStatRendu in listeAff_2:
				self.infosImgProv=self.infosImgProv+'\n'+parcStatRendu[0]+'\n'+parcStatRendu[1]+'\n'+parcStatRendu[2]+'\n'+parcStatRendu[3]+'\n'+parcStatRendu[4]+'\n'+parcStatRendu[5]+'\n'+parcStatRendu[6]+'\n'+parcStatRendu[7]+'\n'+b+'\n'
				
			# affichage des infos dans l'onglet
			self.zoneAffichInfosImg.setText(self.infosImgProv)
			self.framImg.setEnabled(True)
			
			# remise à 0 de la variable provisoire de log
			self.infosImgProv=''
			# ---------------------------------------------------------
			
			# Epuration/elimination des fichiers tampon
			for toutRepTemp in glob.glob('/tmp/ekd/tampon/temp_image_masque_alpha_3d/*.*'):
				os.remove(toutRepTemp)
				
			self.operationReussie()
			
		except :
			print "ERREUR !"
			self.messageErreur()
	
	
	def meth_2_ReglagMasque3D(self):
		
		""" Masque 3D pour la méthode 2. On utilise les méthodes de calcul de la méthode 1 et 
		avec quelques principes de la méthode 2 (sélection de la qualité --> self.comboQualite)"""

		# Cette fonction gere les chemins avec trous
	
		try :
			
			# Liste pour affichage image découpée (ds le tabwidget)
			listeAff_1=[]
			# Liste pour affichage dans la page Info
			listeAff_2=[]
		
			# Nbre d'images charges par l'utilisateur
			nbreElem=len(self.listeChemin)

			# Compteur pour le calcul du temps de rendu cumule.
			som_t_renduCumul=0 
	
			# Compteur pour le 1er temps de rendu (exactement la meme variable
			# que pour ==> Positionnement au temps 1 pour le temps de rendu de 
			# l'image, juste en-dessous) .
			t0=0 

			# Positionnement au temps 1 pour le temps de rendu de l'image .
			temps1=time.localtime(time.time())	
	
			# Boucle principale de chargement des images .
			for parcPrincipal in range(nbreElem):
				
				# Ouverture de l'image dans le lot
				imageDepart=Image.open(self.listeChemin[parcPrincipal])
		
				# Compteur pour le 1er temps de rendu .
				t0=time.time()

				# On recupere la taille de l'image originelle
				widthDepart, heightDepart=imageDepart.size
				# On recupere le nombre de pixels totaux
				nbPixelsTotal=widthDepart*heightDepart

				# Si on a sélectionné Qualité Moyenne
				if self.comboQualite.currentIndex()==0:
					os.system('convert -resize '+str(round(imageDepart.size[0]*1.4))+'x '+"\""+"".join(self.listeChemin[parcPrincipal])+"\""+' /tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmpds56682qd35az2d8u9hl.png')
				# Si on a sélectionné Qualité Bonne
				elif self.comboQualite.currentIndex()==1:
					os.system('convert -resize '+str(round(imageDepart.size[0]*1.6))+'x '+"\""+"".join(self.listeChemin[parcPrincipal])+"\""+' /tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmpds56682qd35az2d8u9hl.png')
				# Si on a sélectionné Qualité Tres bonne
				elif self.comboQualite.currentIndex()==2:
					os.system('convert -resize '+str(round(imageDepart.size[0]*1.8))+'x '+"\""+"".join(self.listeChemin[parcPrincipal])+"\""+' /tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmpds56682qd35az2d8u9hl.png')
				# Si on a sélectionné Qualité Excellente
				elif self.comboQualite.currentIndex()==3:
					os.system('convert -resize '+str(round(imageDepart.size[0]*2))+'x '+"\""+"".join(self.listeChemin[parcPrincipal])+"\""+' /tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmpds56682qd35az2d8u9hl.png')
				
				imgOuv_1_tmp=Image.open("/tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmpds56682qd35az2d8u9hl.png")
				
				# On recupere le tableau de pixels (image aggrandie)
				imageData=imgOuv_1_tmp.getdata()
				
				# On recupere la taille de l'image (image aggrandie)
				width_2, height_2=imgOuv_1_tmp.size
				# On recupere le nombre de pixels totaux (image aggrandie)
				nbPixelsTotal_2=width_2*height_2
 
				#-----------------------------------------------
				# Algorithme de detection du fond bleu/vert
				#-----------------------------------------------

				# On boucle sur l'image RVB -> on cree une nouvelle image RVBA, 
				# le fond bleu/vert est supprime . De plus on va stocker les 
				# pixels de bord .
				newImageRGBA=[]

				for parcRGB in range(nbPixelsTotal_2):
    					# On recupere les valeurs R,G et B
					val_R_rgb=imageData[parcRGB][0]
    					val_G_rgb=imageData[parcRGB][1]
    					val_B_rgb=imageData[parcRGB][2]
    
    					# ------------------------------- #
    					# On calcule les valeurs de H,S,V #
    					# ------------------------------- #
    					# On detecte le max et le min
    					maxRGB=float(max(imageData[parcRGB]))
    					minRGB=float(min(imageData[parcRGB]))
    					# Calcule de la difference entre min et max
    					deltaRGB=maxRGB-minRGB
    					# Calcul de la Saturation
    					if maxRGB>0: s_HSV=(deltaRGB/maxRGB)*100
    					else: s_HSV=0
    					# Calcul de Hue (Teinte)
    					if deltaRGB==0: h_HSV=-1
    					elif val_R_rgb==maxRGB: h_HSV=(val_G_rgb-val_B_rgb)/deltaRGB
    					elif val_G_rgb==maxRGB: h_HSV=2+(val_B_rgb-val_R_rgb)/deltaRGB
    					else: h_HSV=4+(val_R_rgb-val_G_rgb)/deltaRGB
					# Conversion en degres de Hue
    					h_HSV=h_HSV*60
    					if h_HSV<0: h_HSV=h_HSV+360
    					# Calcul de Value (Luminosite)
    					v_HSV=maxRGB
					# Pourcentage de 0 à 100 de Value (il est beaucoup plus
					# pratique de travailler avec une valeur entre 0 et 100)
					v_HSV=v_HSV*100/256
					
					# ----------------------------------------------------------- #
					# Attentions conditions d'affichage du fond et de la forme !.
					# ----------------------------------------------------------- #
					# Ici si on a sélectionné un fond noir et une/des formes blanches
					if self.comboFondForme.currentIndex()==0:
						# On teste si le pixel appartient au fond ou non
    						if self.spinTeinteDebut.value()<=h_HSV<=self.spinTeinteFin.value() and self.spinSaturationDebut.value()<=s_HSV<=self.spinSaturationFin.value() and self.spinLuminosite.value()<=v_HSV<=100:
							
        						# Si oui, on affecte du noir et de la 
							# transparence (A=0) au pixel
        						newImageRGBA.append((0, 0, 0, 0))
    						else :
        						# Si non, on affecte du blanc avec une transparence a 100%
        						newImageRGBA.append((255, 255, 255, 255))
					# Là si on a sélectionné un fond blanc et une/des formes noires
					elif self.comboFondForme.currentIndex()==1:
						# On teste si le pixel appartient au fond ou non
    						if self.spinTeinteDebut.value()<=h_HSV<=self.spinTeinteFin.value() and self.spinSaturationDebut.value()<=s_HSV<=self.spinSaturationFin.value() and self.spinLuminosite.value()<=v_HSV<=100:
							
        						# Si oui, on affecte du blanc et de la 
							# transparence (A=0) au pixel
        						newImageRGBA.append((255, 255, 255, 0))
    						else :
        						# Si non, on affecte du noir avec une transparence a 100%
        						newImageRGBA.append((0, 0, 0, 255))
					
				#-----------------------------------------------
				# Fin algo detection fond bleu/vert
				#-----------------------------------------------

				# On sauvegarde l'image avant anti-aliasing
				imgDecoup=Image.new('RGBA', imgOuv_1_tmp.size)
				imgDecoup.putdata(newImageRGBA)
		
				# On libere de la memoire
				del imageData

				#---------------------------------------------------------------------------
				# On supprimme la premiere ligne bleue (si fond bleu) 
				# restante autour du personnage. Début d'anti-aliasing
				antialiasing=[]

				for parcSupprimeLigne in range(nbPixelsTotal_2):
    					# Si le pixel detecte n'est pas transparent
    					if newImageRGBA[parcSupprimeLigne][3]>0:
        					y_ligne=math.ceil((parcSupprimeLigne-1)/width_2)
        					x_ligne=parcSupprimeLigne-(y_ligne*width_2)
        					# Detection des bords
        					if (x_ligne==0 or x_ligne>=width_2-1 or y_ligne==0 or y_ligne>=height_2-1):
							antialiasing.append((newImageRGBA[parcSupprimeLigne][0], newImageRGBA[parcSupprimeLigne][1], newImageRGBA[parcSupprimeLigne][2], newImageRGBA[parcSupprimeLigne][3]))
        					else:
            						# Si on a 1 voisin transparent bord
            						# Sinon -> pas bord
            						# On teste (x-1,y),(x+1,y),(x,y-1),(x,y+1)
            						if (newImageRGBA[parcSupprimeLigne-1][3]==0 or newImageRGBA[parcSupprimeLigne+1][3]==0 or newImageRGBA[parcSupprimeLigne-width_2][3]==0 or newImageRGBA[parcSupprimeLigne+width_2][3]==0):
                						# Si bord existe -> on efface . Le bord en
								# question est transforme en R, G, B -->
								# noir et A --> transparent .
                						antialiasing.append((0, 0, 0, 0))
            						else :
                						antialiasing.append((newImageRGBA[parcSupprimeLigne][0], newImageRGBA[parcSupprimeLigne][1], newImageRGBA[parcSupprimeLigne][2], newImageRGBA[parcSupprimeLigne][3]))
    					else :
        					antialiasing.append((newImageRGBA[parcSupprimeLigne][0], newImageRGBA[parcSupprimeLigne][1], newImageRGBA[parcSupprimeLigne][2], 0))

				newImageRGBA=antialiasing
				#---------------------------------------------------------------------------
				
				# Creation d'une nouvelle image et integration des donnees recoltees .
				newImageAntialias=Image.new('RGBA', imgDecoup.size)
				newImageAntialias.putdata(antialiasing)
				a1, a2, a3, a4=newImageAntialias.split()
				imgMerge=Image.merge('RGBA', (a1, a2, a3, a4))
		
				# Transformation du fond noir transparent en fond noir opaque 
				imgMerge.putalpha(255)
		
				# Sauvegarde de la nouvelle image (image tampon)
				imgMerge.save('/tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmpds56682qd35az2d8u9hl.png', 'PNG')
				
				# Ouverture de l'image tampon
				ouvIm=Image.open('/tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmpds56682qd35az2d8u9hl.png')
			
				# Kernel 5x5 Floutage
				sizeKern5x5=(5, 5)
				# Type de kernel utilisé
				kernFlou=(0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0)
				# Application d'un leger flou a l'image et enregistrement dans le
				# chemin (et avec le nom donné) et ce par/pour l'utilisateur
				ouvIm.filter(ImageFilter.Kernel(sizeKern5x5, kernFlou)).save(self.chemDossierSauv+'_'+string.zfill((parcPrincipal+1), 6)+'.png', 'PNG')
				# Application d'un leger flou a l'image et enregistrement dans le rep
				# temporaire (... et donc l'affichage dans l'interface)
				imKerFlou=ouvIm.filter(ImageFilter.Kernel(sizeKern5x5, kernFlou)).save('/tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmpds56682qd35az2d8u9hl.png', 'PNG')
				
				# Retour aux dimensions d'origine de l'image et enregistrement dans le
				# rep temporaire (et ce pour la sauvegarde de l'image --> utilisateur)
				os.system('convert -resize '+str(imageDepart.size[0])+'x /tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmpds56682qd35az2d8u9hl.png '+"\""+self.chemDossierSauv+'_'+string.zfill((parcPrincipal+1), 6)+'.png'+"\"")
				# Retour aux dimensions d'origine de l'image et enregistrement dans 
				# le rep temporaire (et ce pour le compositing ... et donc l'affichage
				# dans l'interface)
				os.system('convert -resize '+str(imageDepart.size[0])+'x /tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmpds56682qd35az2d8u9hl.png /tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmpds56682qd35az2d8u9hl.png')
				
				# Remplissage de listeAff_1 pour affichage (ds le tabwidget)
				listeAff_1.append('/tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmpds56682qd35az2d8u9hl.png')
				
				# On libere la memoire
				del antialiasing, newImageRGBA, newImageAntialias, imgDecoup, val_R_rgb, val_G_rgb, val_B_rgb, h_HSV, s_HSV, v_HSV, parcRGB, parcSupprimeLigne, a1, a2, a3, a4, imageDepart
				# x_ligne et y_ligne ne sont pas libérés car cela peut produire une erreur ds 
				# certaines circonstances
		
				# ------------------------------------------------------------------ #
				# STATS DE RENDU (AFFICHAGE ET SAUVEGARDE) .
				# ------------------------------------------------------------------ #
				# Calcule le pourcentage effectue a chaque passage
				val_pourc=((parcPrincipal+1)*100)/nbreElem
				# Affichage du pourcentage du rendu dans le terminal
				# sous Linux ou la fenetre MS-DOS sous Windows
				print _("Progression du rendu :"), val_pourc
				# Positionnement au temps 2 pour le temps de rendu de l'image
				t1=time.time()
				# Temps local (annee, mois, jour, heure, minute, seconde ...)
				tLocal=time.localtime()
				# Calcul avec le compteur pour le calcul du temps de rendu cumule
				som_t_renduCumul=som_t_renduCumul+(t1-t0)
				# Calcul pour la moyenne du temps de rendu .
				MoyRendu=som_t_renduCumul/(parcPrincipal+1) 
				# Calcul pour le temps de rendu restant .
				tempRestant=((MoyRendu*nbreElem)-(MoyRendu*parcPrincipal+1))-MoyRendu 
				# Mise en ordre du temps local pour ecriture dans fichier
				datHeurEcr=_(u"Le ")+str(tLocal[2])+"/"+str(tLocal[1])+"/"+str(tLocal[0])+_(u" a ")+str(tLocal[3])+":"+str(tLocal[4])+":"+str(tLocal[5])
			
				# Pour ecriture dans fichier
				progImg=_(u"Image ")+str(parcPrincipal+1)+"/"+str(nbreElem)
			
				# Si le temps de rendu est inferieur a la minute ... .
				if int(t1-t0)<60:
					affTemps=_(u"Temps de rendu : %s secondes") % (int(round(t1-t0)))
				# Si le temps de rendu est superieur a la minute ... calcul des 
				# minutes et des secondes
				elif int(t1-t0)>=60:
					affTemps=_(u"Temps de rendu : ")+str(int(round(t1-t0))/60)+_(u" min ")+str(int(round(t1-t0))%60)+_(u" sec")
				# Si la moyenne du temps de rendu est inferieur a la minute ... .	
				if MoyRendu<60:
					moyTemps=_(u"Moyenne du temps de rendu : %s secondes") % (int(round(MoyRendu))) 
				# Si la moyenne du temps de rendu est superieur a la minute ...  
				# calcul des minutes et des secondes .
				elif MoyRendu>=60:
					moyTemps=_(u"Moyenne du temps de rendu : ")+str(int(round(MoyRendu/60)))+_(u" min ")+str(int(round(MoyRendu%60)))+_(u" sec")
				# Si le temps de rendu est inferieur a la minute ... .
				if som_t_renduCumul<60:
					tRenduCumul=_(u"Temps de rendu cumule : %s secondes") % (int(round(som_t_renduCumul)))
				# Si le temps de rendu est superieur ou egal a la minute ... calcul des 
				# heures et des minutes .
				elif som_t_renduCumul>=60:
					tRenduInfMinut=int(round(som_t_renduCumul/60)) 
					tRenduCumul=_(u"Temps de rendu cumule : ")+str(tRenduInfMinut/60)+_(u" h ")+str(tRenduInfMinut%60)+_(u" min") 
					
				# Pour le temps de rendu restant ...
				# Si le temps de rendu restant est superieur a 0 secondes .
				if tempRestant>0:
					# Si le temps de rendu restant est inferieur a la minute et le
					# calcul du pourcentage est inferieur a 100 % .
					if tempRestant<60 and val_pourc<100:
						tRestant=_(u"Temps de rendu restant (estimation) : %s secondes") % (int(round(tempRestant)))
					# Si le temps de rendu restant est superieur a la minute et le
					# calcul du pourcentage est inferieur a 100 % .
					elif tempRestant>=60 and val_pourc<100:
						tRestantInfMinut=int(round(tempRestant/60))
						tRestant=_(u"Temps de rendu restant (estimation) : ")+str(tRestantInfMinut/60)+_(u" h ")+str(tRestantInfMinut%60)+_(u" min")
						
				# Des que le rendu est arrive a 100%, affichage de dans le
				# terminal sous Linux ou la fenetre MS-DOS sous Windows .
				if val_pourc==100 :
					print
					print _("Rendu terminé !")	
				
				# Ecriture des statistiques (cumul de l'ecriture) dans un fichier texte	
				ecrStatRendu=open(self.chemDossierSauv+_("_image_masque_3d_meth_2.txt"), 'a')
				ecrStatRendu.write("=================================================\n"+datHeurEcr+"\n"+"-------------------------------------------------\n"+progImg+"\n"+str(affTemps)+"\n"+str(moyTemps)+"\n"+str(tRenduCumul)+"\n\n")
				ecrStatRendu.close()
				
				# La page Image résultat devient visible après la conversion
				self.tabwidget.setCurrentIndex(self.indexImageResultat)
				
				# Affichage de l'image masque 3d ---------------------
				self.afficheurImg_2.setImage(listeAff_1[parcPrincipal])
				# ----------------------------------------------------
				
				# Remplissage de la liste pour les statistiques de rendu
				listeAff_2.append((_(u"Image chargée : ")+self.listeChemin[parcPrincipal], _(u"Image finale : ")+self.chemDossierSauv+'_'+string.zfill((parcPrincipal+1), 6)+'.png', progImg, affTemps, moyTemps, tRenduCumul, _(u"Nombre total de pixels : ")+str(nbPixelsTotal), _(u"Dimension : ")+str(widthDepart)+' x '+str(heightDepart)))
				
				# --------------------------------------------
				# Affichage de la progression (avec
				# QProgressDialog) ds une fenêtre séparée
				# Bouton Cancel pour arrêter la progression donc le process
				self.progress.setValue(val_pourc)
				QApplication.processEvents()
				if (self.progress.wasCanceled()): break
				# Quand l'utilisateur charge au moins 2 images ...
				if len(self.listeChemin)>1:
					self.progress.setLabel(QLabel(QString(tRestant)))
				# --------------------------------------------
				
			# Affichage de la dernière image du lot chargée par l'utilisateur --
			self.afficheurImg_1.setImage(self.listeChemin[len(self.listeChemin)-1])
			# ------------------------------------------------------------------
			
			# Affichage des infos sur l'image -------------------------
			# On implémente les chemins des fichiers dans une variable
			# pour préparer l'affichage des infos
			texte=_(u" Statistiques de rendu")
			a='#'*36
			b="-"*36
			
			self.infosImgProv=a+'\n#'+texte+'\n'+a+'\n'
			for parcStatRendu in listeAff_2:
				self.infosImgProv=self.infosImgProv+'\n'+parcStatRendu[0]+'\n'+parcStatRendu[1]+'\n'+parcStatRendu[2]+'\n'+parcStatRendu[3]+'\n'+parcStatRendu[4]+'\n'+parcStatRendu[5]+'\n'+parcStatRendu[6]+'\n'+parcStatRendu[7]+'\n'+b+'\n'
				
			# affichage des infos dans l'onglet
			self.zoneAffichInfosImg.setText(self.infosImgProv)
			self.framImg.setEnabled(True)
			
			# remise à 0 de la variable provisoire de log
			self.infosImgProv=''
			# ---------------------------------------------------------
			
			# Elimination de l'image tampon .
			os.remove("/tmp/ekd/tampon/temp_image_masque_alpha_3d/decoupe_fond_tmpds56682qd35az2d8u9hl.png")
			
			self.operationReussie()
				
		except :
			print "ERREUR !"
			self.messageErreur()
	
	
	def apercuReglages(self): 
		""" Aperçu du résultat sur la 1ère image du lot des réglages et ce juste avant d'appliquer soit masque alpha, soit masque 3D (pour méthode 1 ou 2) """
		
		print _('valeur de Teinte (debut)'), self.spinTeinteDebut.value()
		print _('valeur de Teinte (fin)'), self.spinTeinteFin.value()
		print _('valeur de Saturation (debut)'), self.spinSaturationDebut.value()
		print _('valeur de Saturation (fin)'), self.spinSaturationFin.value()
		print _('valeur de Luminosite'), self.spinLuminosite.value()
		
		# Si on a sélectionné la méthode 1
		if self.comboMethode.currentIndex()==0: self.meth_1_ReglagPrevis()
		# Si on a sélectionné la méthode 2
		elif self.comboMethode.currentIndex()==1: self.meth_2_ReglagPrevis()
	
	
	def sonderTempsActuel(self):
		"""x ms après l'apparition de la boite de dialogue, on lance la conversion. But: faire en sorte que la boite de dialogue ait le temps de s'afficher correctement"""
		self.timer.stop()
		self.appliquer()
	
	
	def appliquer(self):
		"""On lance le type de conversion correspondant aux items sélectionnés des 2 boites de combo """
		# Si on a sélectionné masque alpha et la méthode 1 
		if self.comboMasque.currentIndex()==0 and self.comboMethode.currentIndex()==0:
			self.meth_1_ReglagMasqueAlpha()
		# Si on a sélectionné masque 3D et la méthode 1 
		elif self.comboMasque.currentIndex()==1 and self.comboMethode.currentIndex()==0:
			self.meth_1_ReglagMasque3D()
		# Si on a sélectionné masque alpha et la méthode 2 
		elif self.comboMasque.currentIndex()==0 and self.comboMethode.currentIndex()==1:
			self.meth_2_ReglagMasqueAlpha()
		# Si on a sélectionné masque 3D et la méthode 2 
		elif self.comboMasque.currentIndex()==1 and self.comboMethode.currentIndex()==1:
			self.meth_2_ReglagMasque3D()
	
	
	def appliquer0(self):
		"""Préparation de la conversion"""
		
		print _(u'valeur de Teinte (debut)'), self.spinTeinteDebut.value()
		print _(u'valeur de Teinte (fin)'), self.spinTeinteFin.value()
		print _(u'valeur de Saturation (debut)'), self.spinSaturationDebut.value()
		print _(u'valeur de Saturation (fin)'), self.spinSaturationFin.value()
		print _(u'valeur de Luminosite'), self.spinLuminosite.value()
		
		# Boîte de dialogue pour sauvegarder (nom du nouveau fichier)
		rep = self.base.getRepSource(self.listeChemin, self.config)
		self.chemDossierSauv=str(QFileDialog.getSaveFileName(None, _(u"Sauver"), rep, _(u"Tous les fichiers *.*")))
		
		if self.chemDossierSauv=='': return
		
		self.progress.reset()
		self.progress.show()
		self.progress.setValue(0)
		QApplication.processEvents()
		
		# Lancement de la conversion dans 250 ms (seule solution trouvée pour éviter le grisage au début)
		self.timer.start(250)
		
		
	def afficherAide(self):
		"""Boîte de dialogue de l'aide"""
		messageAide=QMessageBox(self)
		messageAide.setText(_(u"Blablablabla ... blabla."))
		messageAide.setWindowTitle(_(u"Aide"))
		messageAide.setIcon(QMessageBox.Information)
		messageAide.exec_()