class Main(tk.Tk):
    def __init__(self):
        tk.Tk.__init__(self)
        self.filename = None
        self.origin_image = None
        self.processed_image = None
        
        self.title("Segmentation and Edge Detection")

        self.toolbar = ToolBar(master=self)
        separator = ttk.Separator(master=self)
        self.image_viewer = Viewer(master=self)

        self.toolbar.pack(pady=10)
        separator.pack(fill=tk.X, padx=20, pady=5)
        self.image_viewer.pack(fill=tk.BOTH, padx=20, pady=10, expand=1)
Exemplo n.º 2
0
class CalendarZone(Frame):
    """
    Classe contenant la barre d'outil et la zone d'affichage.
    """
    def __init__(self, master=None, periodeManager=None, **kwargs):
        """
        Constructeur de CalendarZone.
        @param master: master du tkinter.Frame() que cet objet est.
        @param periodeManager: le PeriodeManager pour la barre d'outil des périodes, connue dans cet objet.
        @param **kwargs: Les options d'affichages pour le tkinter.Frame() que cet objet est.
        """
        Frame.__init__(self, master, **kwargs)
        # Note : self.master est référence vers l'Application.

        self.__isBarrePeriode = False
        # Barre du haut
        self.outilBar = ToolBar(self)  # frame avec tous les boutons outils
        self.outilBar.pack(side=TOP, fill=X, expand=NO)

        # Barre du haut pour les périodes
        self.outilBarPeriode = PeriodToolBar(
            self, periodeManager)  # frame avec tous les boutons outils

        # Zone calendrier
        self.zoneDynamicCalendarFrame = ZoneAffichage(
            self
        )  # frame avec la zone d'affichage des paramètre et la zone avec les données
        self.zoneDynamicCalendarFrame.pack(side=BOTTOM, fill=BOTH, expand=YES)

    ""  # Pour le repli de code je rappelle
    #############
    # Getters : #
    #############
    ""

    def getApplication(self):
        """
        Getter pour l'application.
        @return l'application.
        """
        return self.master

    def getBarreOutilActive(self):
        """
        Getter pour la barre d'outil des périodes active.
        @return la barre d'outil des périodes active.
        """
        if self.__isBarrePeriode:
            return self.outilBarPeriode
        else:
            return self.outilBar

    def getDonneeCalendrier(self):
        """
        Getter pour le DonneeCalendrier.
        @return le DonneeCalendrier.
        """
        return self.getZoneAffichage().getDonneeCalendrier()

    def getFirstAndLast(self):
        """
        Getter parmi les tâches sélectionnés
        Permet de déterminer la tache qui fini le plus tôt et la tache qui commence le plus tard
        @return first : (Task) tache qui fini le plus tôt
        @return last  : (Task) tache qui commence le plus tard
        """

        # Manière la plus simple avec min() et max() comme ceci, le critère se faisant suivant la lambda :
        first = min(self.getDonneeCalendrier().getSelectedSchedulable(),
                    key=lambda t: t.getFin())
        last = max(self.getDonneeCalendrier().getSelectedSchedulable(),
                   key=lambda t: t.getDebut())

        return first, last

    def getPanneauActif(self):
        """
        Getter pour le panneau actif dans DonneeCalendrier.
        @return le panneau actif dans DonneeCalendrier.
        """
        return self.getZoneAffichage().getPanneauActif()

    def getParametreAffichage(self):
        """
        Getter pour les ParametreAffichage.
        @return le ParametreAffichage.
        """
        return self.getZoneAffichage().getParametreAffichage()

    def getPeriodeActive(self):
        """
        Getter de la periode active.
        @return la période active.
        """
        return self.getDonneeCalendrier().getPeriodeActive()

    def getZoneAffichage(self):
        """
        Getter pour la ZoneAffichage.
        @return la ZoneAffichage.
        """
        return self.zoneDynamicCalendarFrame

    ""
    #############
    # Setters : #
    #############
    ""

    def setBarreOutilPeriode(self, value):
        """
        Permet de switcher entre la barre d'outil normale
        et la barre d'outil des périodes.
        @param value: True si c'est la barre d'outil des périodes, False sinon.
        """
        self.__isBarrePeriode = value
        if value:
            self.outilBarPeriode.pack(side=TOP, fill=X, expand=NO)
            self.outilBar.pack_forget()
        else:
            self.outilBarPeriode.pack_forget()
            self.outilBar.pack(side=TOP, fill=X, expand=NO)

    ""
    #####################################################
    # Pour la barre d'outil des calendriers standards : #
    #####################################################
    ""

    def afficherMasquerJour(self):
        """
        Permet d'afficher ou masquer un jour...
        """
        self.getBarreOutilActive().changeAfficherMasquerMode(
            askAfficherMasquer(self.getApplication().getPeriodManager()))
        # On se met à jour
        self.getDonneeCalendrier().updateAffichage()

    def ajouterHeure(self):
        """
        Méthode exécutée par la barre d'outil des périodes
        quand l'utilisateur appuie sur le bouton pour rajouter des heures.
        """
        min = self.getDonneeCalendrier().getHeureDebut()
        max = datetime.timedelta(hours=23) - datetime.timedelta(
            hours=self.getDonneeCalendrier().getHeureFin().hour)
        max2 = self.getDonneeCalendrier().getHeureFin()
        nbHeure = max2.hour - min.hour
        nb, pos = askAjouterHeure(min, max, nbHeure)
        self.gestionHeure(nb, pos)
        self.getDonneeCalendrier().updateAffichage(force=True)

    def ajouterJour(self):
        """
        Méthode exécutée par la barre d'outil des périodes
        quand l'utilisateur appuie sur le bouton pour rajouter des jours.
        """
        totalJour = self.getDonneeCalendrier().getLongueurPeriode().days - 1
        nb, pos = askAjouterJour(totalJour)
        self.gestionJour(nb, pos)

    def avancementMannuel(self):
        """
        Permet de valider les tâches sélectionnées.
        """
        schedulables = []
        for schedulable in self.getPeriodeActive().getInstanciatedSchedulables(
        ):  # On peut prendre Instanciated car on ne valide pas les taches conteneurs
            if schedulable.isSelected():
                schedulables.extend(schedulable.setDone(True))

        self.getApplication().getTaskEditor().redessiner()
        if schedulables != []:
            UndoRedoTasksValidations(schedulables)

    def avancementNormal(self):
        """
        Valide TOUTES les tâches qui sont avant maintenant.
        """
        schedulables = []
        now = datetime.datetime.now()
        for schedulable in self.getDonneeCalendrier().getPeriodeActive(
        ).getInstanciatedSchedulables():
            if schedulable.getFin() <= now:
                schedulables.extend(schedulable.setDone(True))

            #schedulable.updateStatut() fait dans la methode setDone()
        self.getApplication().getTaskEditor().redessiner()
        if schedulables != []:
            UndoRedoTasksValidations(schedulables)

    def avancementJourFini(self):
        """
        Valide toutes les tâches qui sont terminées aujourd'hui.
        """
        schedulables = []
        now = datetime.date.today()
        for tache in self.getDonneeCalendrier().getPeriodeActive(
        ).getInstanciatedSchedulables():
            if tache.getFin().date() == now:
                schedulables.extend(tache.setDone(True))

        self.getApplication().getTaskEditor().redessiner()
        if schedulables != []:
            UndoRedoTasksValidations(schedulables)

    def decalerHeure(self):
        """
        Permet de décaler les tâches sélectionnées par l'utilisateur,
        d'un certain nombre d'heures, suivant ce que l'utilisateur souhaite.
        Un message lui sera demandé si jamais cela dépasse de la journée.
        """
        # Si la liste est vide on évite la question
        if len(list(self.getDonneeCalendrier().getSelectedSchedulable())) == 0:
            return

        # On détermine le nombre d'heure min et max
        first, last = self.getFirstAndLast()

        periode = self.getPeriodeActive()

        heureDebut = self.getDonneeCalendrier().getHeureDebut()
        heureFin = self.getDonneeCalendrier().getHeureFin()

        lastDiffJour = (
            last.getDebut().date() -
            periode.getDebut()).days  # .days pour int-ifier le tout
        firstDiffJour = (periode.getFin() - first.getFin().date()).days
        heureRetirerMax = last.getDebut().hour + lastDiffJour * 24
        heureAjoutMax = heureFin.hour - first.getFin(
        ).hour + 1 + firstDiffJour * 24
        nb, pos, param = askDecalHeure(heureRetirerMax, heureAjoutMax,
                                       heureDebut, heureFin,
                                       last.getDebut().hour - heureDebut.hour,
                                       heureFin.hour - first.getFin().hour + 1)

        if nb is None or pos is None or param is None or nb == 0:
            return

        # Ajustement des heures
        horsChamp = False

        # map des undo-redo-s :
        mapIDBeginTaskBefore = {}
        mapIDBeginTaskAfter = {}

        for tache in self.getDonneeCalendrier().getSelectedSchedulable():
            if isinstance(tache, Task):
                # map d'avant le déplacement :
                mapIDBeginTaskBefore[tache.getUniqueID()] = tache.getDebut()

                # Si tout va bien
                if  (tache.getDebut()+datetime.timedelta(hours=nb)).date() == (tache.getFin()+datetime.timedelta(hours=nb)).date()\
                and heureDebut <= (tache.getDebut()+datetime.timedelta(hours=nb)).time()\
                and heureFin   >= (tache.getFin()+datetime.timedelta(hours=nb)).time():
                    tache.setDebut(tache.getDebut() +
                                   datetime.timedelta(hours=nb))

                # Si on dépasse, on cadre selon les limites et mode bloquer
                elif param == "bloquer":
                    # Si on retire des heures au début
                    if nb < 0:
                        # On peut pas mettre un
                        tache.setDebut(
                            datetime.datetime.combine(tache.getDebut().date(),
                                                      heureDebut))
                    # Si on ajoute pour mettre à la fin
                    else:
                        heureFin = heureFin  # Time
                        time = datetime.datetime.combine(
                            tache.getFin().date(), heureFin) - tache.getDuree(
                            )  # datetime - timedelta
                        tache.setDebut(time)

                # Si on dépasse et que l'on ne bloque pas
                elif param == "duree":
                    tache.setDebut(tache.getDebut() +
                                   datetime.timedelta(hours=nb))
                    horsChamp = True

                # Si au final il y a des tâches hors champs on demande si on affiche les heures pour voir le.s tache.s
                if horsChamp and askChangerHeure():
                    timeAvant = heureDebut
                    timeApres = heureFin
                    tacheAvant = None
                    tacheApres = None
                    for tache in self.getDonneeCalendrier().getSelectedTask():
                        # Si le début est avant la fin (hors date) ET qu'il est avant le referent
                        if tache.getDebut().time() < tache.getFin().time(
                        ) and tache.getDebut().time() < timeAvant:
                            tacheAvant = tache
                            timeAvant = tache.getDebut().time()

                        # Si la fin est avant le début (hors date) ET qu'il est avant le referent
                        elif tache.getDebut().time() > tache.getFin().time(
                        ) and tache.getFin().time() < timeAvant:
                            tacheAvant = tache
                            timeAvant = tache.getFin().time()

                        # Si la fin est après le début (hors date) ET qu'il est après le referent
                        if tache.getDebut().time() < tache.getFin().time(
                        ) and tache.getFin().time() > timeApres:
                            tacheApres = tache
                            timeApres = tache.getFin().time()

                        # Si le début est après la fin (hors date) ET qu'il est après le referent
                        elif tache.getDebut().time() > tache.getFin().time(
                        ) and tache.getDebut().time() > timeApres:
                            tacheApres = tache
                            timeApres = tache.getDebut().time()

                    # Maintenant on applique les changements
                    if tacheAvant is not None:
                        addAvant = heureDebut.hour - timeAvant.hour
                        self.gestionHeure(addAvant, "Avant")
                    if tacheApres is not None:
                        addApres = timeApres.hour - heureFin.hour
                        self.gestionHeure(addApres, "Apres")

                # map d'après le déplacement :
                mapIDBeginTaskAfter[tache.getUniqueID()] = tache.getDebut()

        # Undo-redo :
        UndoRedoDecaler(self.getPeriodeActive(), mapIDBeginTaskBefore,
                        mapIDBeginTaskAfter)

        # Update affichage :
        self.getDonneeCalendrier().updateAffichage(True)

    def decalerJour(self):
        """
        Permet de décaler les tâches sélectionnées par l'utilisateur,
        d'un certain nombre de jours, suivant ce que l'utilisateur souhaite.
        Un message lui sera demandé si jamais cela dépasse de la période.
        """
        # Si la liste est vide on évite la question
        if len(list(self.getDonneeCalendrier().getSelectedSchedulable())) == 0:
            return

        # On détermine le nombre de jour min et max
        first, last = self.getFirstAndLast()

        debut = self.getPeriodeActive().getDebut()  # Date de début
        fin = self.getPeriodeActive().getFin()  # Date de fin

        # Les variables ci-dessous calculent le nombre max de jours pour le décalage
        # si il y a un bloquage dans un sens ou dans l'autre. Cependant, quand on
        # bloque, on peut bouger jusqu'à ce que la fin de la tâche la plus tôt
        # atteigne la fin de la période ; ou que le début de la tâche la plus tard
        # atteigne le début de la période.
        jourRetireBloque = (last.getDebut().date() - debut).days
        jourAjoutBloque = (fin - first.getFin().date()).days

        # Appel du dialogue à l'utilisateur :
        nb, pos, param = askDecalJour(debut, fin, jourRetireBloque,
                                      jourAjoutBloque)

        if nb is None or pos is None or param is None or nb == 0:
            return

        # Ajustement des jours
        horsChamp = False
        duree = datetime.timedelta(days=nb)

        # map des undo-redo-s :
        mapIDBeginTaskBefore = {}
        mapIDBeginTaskAfter = {}

        for tache in self.getDonneeCalendrier().getSelectedSchedulable():
            if isinstance(tache, Task):  # TODO avec groupe.
                # map d'avant le déplacement :
                mapIDBeginTaskBefore[tache.getUniqueID()] = tache.getDebut()
                # Si tout va bien
                if  debut <= (tache.getDebut()+duree).date()\
                and fin   >= (tache.getFin()+duree).date():
                    tache.setDebut(tache.getDebut() + duree)

                # Si on dépasse, on cadre selon les limites et mode bloquer
                elif param == "bloquer":
                    # Si on retire des heures au début
                    if nb < 0:
                        # On peut pas mettre un
                        tache.setDebut(
                            datetime.datetime.combine(debut,
                                                      tache.getDebut().time()))
                    # Si on ajoute pour mettre à la fin
                    else:
                        time = datetime.datetime.combine(
                            fin,
                            tache.getFin().time()) - tache.getDuree(
                            )  # datetime - timedelta
                        tache.setDebut(time)

                # Si on dépasse et que l'on ne bloque pas
                elif param == "duree":
                    tache.setDebut(tache.getDebut() +
                                   datetime.timedelta(days=nb))
                    horsChamp = True

                # Si au final il y a des tâches hors champs on demande si on affiche les heures pour voir le.s tache.s
                if horsChamp:
                    horsChamp = False
                    choix, periode = askComplicationjour(
                        tache,
                        self.getApplication().getPeriodManager())
                    # On annule les changements
                    if choix is None:
                        tache.setDebut(tache.getDebut() -
                                       datetime.timedelta(days=nb))
                        continue
                    # On agrandit la période
                    elif choix == "agrandir":
                        if tache.getDebut().date() < debut:
                            addAvant = (debut - tache.getDebut().date()).days
                            self.gestionJour(addAvant, "Avant")

                        else:
                            addApres = (last.getFin().date() - fin).days
                            self.gestionJour(addApres, "Apres")
                    elif choix == "supprimer":  # TODO supprimer la tache
                        pass
                    elif choix == "independante":  # TODO rendre la tache indépendante
                        pass
                    elif choix == "changer":
                        tache.setPeriode(periode)

                # map d'après le déplacement :
                mapIDBeginTaskAfter[tache.getUniqueID()] = tache.getDebut()

        # Undo-redo :
        UndoRedoDecaler(self.getPeriodeActive(), mapIDBeginTaskBefore,
                        mapIDBeginTaskAfter)

        self.getDonneeCalendrier().updateAffichage(True)

    def degrouper(self):
        """
        Permet de dégrouper un groupe.
        """
        # Obtention de la période et des schedulables instanciés sélectionnés :
        periode = self.getDonneeCalendrier().getPeriodeActive()
        schedulables = set(self.getDonneeCalendrier().getSelectedSchedulable())
        schedPerGroup = {}  # dictionnaire des tâches à dégrouper, par groupe.
        # Calcul des tâches à enlever par groupes :
        for schedulable in set(schedulables):
            if isinstance(schedulable, Groupe):
                if schedulable not in schedPerGroup:
                    schedPerGroup[schedulable] = set()
            else:  # Task
                groupe = schedulable.getGroupe()
                if groupe is None:
                    showerror(
                        "Erreur de sélection",
                        "Vous ne pouvez pas dégrouper des tâches qui ne sont pas dans un groupe."
                    )
                    return
                if groupe not in schedPerGroup:
                    schedPerGroup[groupe] = set()
                schedPerGroup[groupe].add(schedulable)

        # Pour chaque groupes sélectionnés :
        for groupe in schedPerGroup:
            # Ré-ajout au calendrier des tâches qui étaient dans le groupe :
            for t in schedPerGroup[groupe] if schedPerGroup[
                    groupe] else groupe.getListTasks():
                groupe.removeTask(t, testDelete=True)

            # Demande de suppression du groupe, s'il n'y a plus qu'une tâche :
            if len(groupe.getListTasks()) == 1:
                if askyesnowarning(
                        title="Édition du groupe",
                        message=
                        'Le groupe "%s" ne possède plus qu\'une tache :\n\t- %s\nVoulez-vous supprimer le groupe ?'
                        % (groupe.getNom(), list(
                            groupe.getListTasks())[0].getNom())):
                    groupe.removeTask(list(groupe.getListTasks())[0],
                                      testDelete=True)
                    # Le groupe va s'auto-delete avec le testDelete.

        # Mise à jour de l'affichage qu'à la fin :
        self.getApplication().getTaskEditor().redessiner()
        self.getDonneeCalendrier().updateAffichage(
            True)  # True = on force la total, car suppression d'objet.

    def deplacerIntervertir(self):
        """
        Permet d'intervertir 2 jours exactement.
        Ce sont ceux sélectionnés par l'utilisateur.
        """
        self.getDonneeCalendrier().intervertir()

    def gestionHeure(self, nombreHeure, position):
        """
        Fonction qui s'occupe de rajouter des heures visibles.
        En dehors de la fonction ajouterHeure lié au bouton car on pourrait avoir à ajouter des heures autrement que par le bouton
        @param nombreHeure : int relatif, permet d'ajouter ou retirer des heures
        @param position    : string "Avant" / "Apres" pour savoir ou appliquer les changements
        """
        if nombreHeure is not None and position is not None:
            if position == "Avant":
                timeHeure = datetime.time(
                    self.getDonneeCalendrier().getHeureDebut().hour -
                    nombreHeure)
                self.getDonneeCalendrier().setHeureDebut(timeHeure)
            elif position == "Apres":
                timeHeure = datetime.time(
                    self.getDonneeCalendrier().getHeureFin().hour +
                    nombreHeure,
                    self.getDonneeCalendrier().getHeureFin().minute)
                self.getDonneeCalendrier().setHeureFin(timeHeure)

    def gestionJour(self, nombreDeJour, position):
        """
        Fonction qui s'occupe d'ajouter ou de supprimer des jours
        En dehors de la fonction ajouterJour lié au bouton car on pourrait avoir à ajouter des jours autrement que par le bouton
        @param nombreDeJour : int relatif, permet d'ajouter ou retirer des jours
        @param position     : string "Avant" / "Apres" pour savoir ou appliquer les changements
        """
        if nombreDeJour is not None and position is not None:
            periode = self.getPeriodeActive()
            if position == "Avant":
                self.getDonneeCalendrier().setPeriodeActiveDebut(
                    periode.getDebut() - datetime.timedelta(days=nombreDeJour))
            elif position == "Apres":
                self.getDonneeCalendrier().setPeriodeActiveFin(
                    periode.getFin() + datetime.timedelta(days=nombreDeJour))

            # Mise à jour du Combobox
            self.getParametreAffichage().updateComboboxNbJour()

    def grouper(self):
        """
        Permet de grouper les tâches.
        """
        periode = self.getPeriodeActive()
        schedulables = list(
            self.getDonneeCalendrier().getSelectedSchedulable())
        # Petite vérification :
        if len(schedulables) < 2:
            return showerror(
                "Sélection invalide",
                "Vous devez avoir au moins 2 éléments sélectionner pour pouvoir les grouper."
            )
        groupe = None
        taches = []
        for obj in schedulables:
            if isinstance(obj, Groupe):
                if groupe is None:
                    groupe = obj
                elif groupe != obj:
                    return showerror(
                        "Sélection invalide",
                        "Vous ne pouvez pas grouper des tâches dans plusieurs groupes."
                    )
            elif not isinstance(obj, Task):
                return showerror("Sélection invalide",
                                 "Vous ne pouvez grouper que des tâches.")
            else:
                taches.append(obj)

        # Création du groupe :
        ajout = True
        if groupe:
            ajout = False
        groupe = groupe or askGroup(periode)
        if groupe is None:
            return

        for t in taches:
            groupe.addTask(t)

        if ajout:
            periode.addPrimitiveSchedulable(groupe)
            self.getApplication().getTaskEditor().redessiner()
            groupe.instantiate()
            self.getDonneeCalendrier().updateAffichage()

    def selectionnerJour(self):
        """
        Méthode pour demander un jour à sélectionner à l'utilisateur, pour le sélectionner ensuite où qu'il soit.
        """
        jour = askdate()
        if jour is not None:
            donneeCalendrier = self.getDonneeCalendrier()
            if jour >= donneeCalendrier.getDebutPeriode(
            ) and jour <= donneeCalendrier.getFinPeriode():
                donneeCalendrier.deselectJours()
                donneeCalendrier.selectJour(jour)
                dureeJours = donneeCalendrier.getDureeJour()
                if donneeCalendrier.getJourDebut() > jour:
                    donneeCalendrier.setJourDebut(jour)
                    donneeCalendrier.setDureeJour(dureeJours)
                    donneeCalendrier.updateAffichage()
                elif donneeCalendrier.getJourFin() < jour:
                    donneeCalendrier.setJourFin(jour)
                    donneeCalendrier.setJourDebut(jour - dureeJours +
                                                  datetime.timedelta(days=1))
                    donneeCalendrier.updateAffichage()
            else:
                # TODO : mettre dans le dialogue lui-même
                showerror(
                    "Date invalide",
                    "La date que vous avez choisie est en dehors des limites de la période."
                )

    ""
    ########################################
    # Pour la barre d'outil des périodes : #
    ########################################
    ""

    def voirTacheDansVue(self):
        """
        Permet de voir une tâche dans une autre vue, via demande
        à l'utilisateur dans une boîte de dialogue usuelle.
        TODO
        """
        pass

    def supprimerTache(self):
        """
        Permet de supprimer une tâche indépendante.
        Fera-t-on des groupes indépendants ? Si oui -> renommer en supprimerSchedulable()...
        TODO
        """
        pass