Pynovisao.py

#!/usr/bin/python
# -*- coding: utf-8 -*-
#
"""
  Nome: Pynovisao.py
  Autor: Alessandro dos Santos Ferreira ( santosferreira.alessandro@gmail.com )

  Descricão: Classe que contem a implementacao de todas as acoes disponiveis no programa.
"""

from collections import OrderedDict

from interface import *
from interface.Interface import InterfaceException as IException
from segmentation import *
from util import *
from util.Config import Config
from util.File import File as f

class Act(object):

    tk = None
    
    segmenter = None
    
    classes = None
    dataset = None
    
    __image = None
    __const_image = None
    __image_name = None
    
    __current_class = None


    def __init__(self, tk, args):
        self.tk = tk
        self.segmenter = Slic.Slic()

        self.dataset = args["dataset"]
        self.__init_classes(args["classes"], args["colors"])

    
    def __init_classes(self, classes = None, colors = None):
        self.classes = []
        
        classes = sorted(f.list_dirs(self.dataset)) if classes is None else classes.split()
        colors = [] if colors is None else colors.split()

        if(len(classes) > 0):
            for i in range(0, len(classes)):
                self.add_class(dialog = False, name=classes[i], color=colors[i] if i < len(colors) else None)
        else:
            self.add_class(dialog = False, color='Green')
            self.add_class(dialog = False, color='Yellow')
            
        self.__current_class = 0
        
        
    def open_image(self, imagename = None):
        
        def onclick(event):
            if event.xdata != None and event.ydata != None and int(event.ydata) != 0:
                x = int(event.xdata)
                y = int(event.ydata)
                self.tk.write_log("Coordinates: x = %d y = %d", x, y)
                
                segment, size_segment, idx_segment, run_time = self.segmenter.get_segment(x, y)
                
                if size_segment > 0:
                    self.tk.append_log("\nSegment = %d: %0.3f seconds", idx_segment, run_time)
                    
                    self.__image, run_time = self.segmenter.paint_segment(self.__image, self.classes[self.__current_class]["color"].value, x, y)
                    self.tk.append_log("Painting segment: %0.3f seconds", run_time)
                    self.tk.refresh_image(self.__image)
                    
                    filepath = f.save_image(segment, self.dataset, self.classes[self.__current_class]["name"].value, self.__image_name, idx_segment)
                    if filepath:
                        self.tk.append_log("\nSegment saved in %s", filepath)
        
        if imagename is None:
            imagename = self.tk.utils.ask_image_name()

        if imagename:
            self.__image = f.open_image(imagename)
            self.__image_name = f.get_filename(imagename)

            self.tk.write_log("Opening %s...", self.__image_name)
            self.tk.add_image(self.__image, self.__image_name, onclick)
            self.__const_image = self.__image
        
    def close_image(self):
        
        if self.__const_image is None:
            raise IException("Image not found")
        
        if self.tk.close_image():
            self.tk.write_log("Closing image...")
            self.__const_image = None


    def add_class(self, dialog = True, name = None, color = None):
        n_classes = len(self.classes)
        if n_classes >= self.tk.MAX_CLASSES:
            raise IException("You have reached the limite of %d classes" % self.tk.MAX_CLASSES)
                
        def edit_class(index):
            self.edit_class(index)
            
        def update_current_class(index):
            self.update_current_class(index)
        
        def process_config():
            new_class = self.tk.get_config_and_destroy()
            new_class["name"].value = '_'.join(new_class["name"].value.split())

            self.classes.append( new_class )
            self.tk.write_log("New class: %s", new_class["name"].value)
            self.tk.refresh_panel_classes(self.classes, self.__current_class)
            
        if name is None:
            name = "Class_%02d" % (n_classes+1)
        if color is None:
            color = X11Colors.Colors.random_color()
            
        class_config = OrderedDict()
        class_config["name"] = Config(label="Name", value=name, c_type=str)
        class_config["color"] = Config(label="Color (X11 Colors)", value=color, c_type='color')
        class_config["callback"] = Config(label=None, value=update_current_class, c_type=None, hidden=True)
        class_config["callback_color"] = Config(label=None, value=edit_class, c_type=None, hidden=True)
        class_config["args"] = Config(label=None, value=n_classes, c_type=int, hidden=True)
        
        if dialog == False:
            self.classes.append( class_config )
            return 

        title = "Add a new classe"
        self.tk.dialogue_config(title, class_config, process_config)        
      

    def edit_class(self, index):
        def process_update(index):
            updated_class = self.tk.get_config_and_destroy()
            updated_class["name"].value = '_'.join(updated_class["name"].value.split())
            
            self.classes[index] = updated_class
            self.tk.write_log("Class updated: %s", updated_class["name"].value)
            self.tk.refresh_panel_classes(self.classes, self.__current_class)
        
        current_config = self.classes[index]
            
        title = "Edit class %s" % current_config["name"].value
        self.tk.dialogue_config(title, current_config, lambda *_ : process_update(index))
            
    def update_current_class(self, index):
        self.__current_class = index

        
    def set_dataset_path(self):
        directory = self.tk.utils.ask_directory(default_dir = self.dataset)
        if directory:
            self.dataset = directory
            self.tk.write_log("Image dataset defined: %s", self.dataset)
            
            self.__init_classes()
            self.tk.refresh_panel_classes(self.classes)


    def run_segmentation(self):
        
        if self.__const_image is None:
            raise IException("Image not found")
        
        self.tk.write_log("Running %s,,,", self.segmenter.get_name())

        self.tk.append_log("\nConfig: %s", str(self.segmenter.get_summary_config()))
        self.__image, run_time = self.segmenter.run(self.__const_image)
        self.tk.append_log("Time elapsed: %0.3f seconds", run_time)
        
        self.tk.refresh_image(self.__image)

    def config_segmentation(self):
        
        title = "Configuring %s" % self.segmenter.get_name()
        self.tk.write_log(title)

        current_config = self.segmenter.get_config()
        
        def process_config():
            new_config = self.tk.get_config_and_destroy()

            self.segmenter.set_config(new_config)
            self.tk.append_log("\nConfig updated:\n%s", str(self.segmenter.get_summary_config()))

        self.tk.dialogue_config(title, current_config, process_config)


    def func_not_available(self):
        self.tk.write_log("This functionality is not available right now.")