image_settings_frame.py

Go to the documentation of this file.

# -*- coding: utf-8 -*-
# never read this code - it's ugly
import Tkinter
import roslib
roslib.load_manifest('face_contour_detector')
import rospy
import cv
import cv_bridge
import Image
import ImageTk
import tkMessageBox
from face_contour_detector.srv import *
from face_contour_detector.msg import *
import face_contour_detector.image_information.sql_database as sql_database

## @package face_contour_detector.gui.image_settings_frame
#
#  This module defines two classes: JumpScale which is a subclass of Tkinter.Scale but jumps to the position where it is clicked instead of moving a fixed amount.
#  The second class is the ImageSettingsFrame itself. A frame which contains several sliders for all available filters and allows the user to modify them.
#  @author Fabian Wenzelmann

# todo egtl nen log wenn init stattfindet das er nicht immer neu malt

## @brief constant defining the minimum value for blur width
BLUR_WIDTH_MIN = 1
## @brief constant defining the maximum value for blur width
BLUR_WIDTH_MAX = 50

## @brief constant defining the minimum value for blur height
BLUR_HEIGHT_MIN = 1
## @brief constant defining the maximum value for blur height
BLUR_HEIGHT_MAX = 50

## @brief constant defining the minimum value for canny threshold1
CANNY_THRESHOLD1_MIN = 1
## @brief constant defining the maximum value for canny threshold1
CANNY_THRESHOLD1_MAX = 30000

## @brief constant defining the minimum value for canny threshold2
CANNY_THRESHOLD2_MIN = 1
## @brief constant defining the maximum value for canny threshold2
CANNY_THRESHOLD2_MAX = 30000

## @brief constant defining the minimal search radius for edge connection
SEARCH_RADIUS_MIN = 1
## @brief constant defining the maximum search radius for edge connection
SEARCH_RADIUS_MAX = 20

## @brief constant defining the minimal amount of pixels that can be passed as argument to the short line deletion filter
PIXEL_NUM_MIN = 1
## @brief constant defining the maximal amount of pixels that can be passed as argument to the short line deletion filter
PIXEL_NUM_MAX = 20

## @brief The length of all sliders used on this frame
SLIDER_LENGTH = 200

## @brief This field saves the original with all filters applied according to the current settings as sensor_msgs/Image. Initially it is set to None.
current_image = None

## @brief A class that behaves like the Tkinter Scale widget but if you click on it the slider jumps to the clicked position.
#  @author Fabian Wenzelmann
#
#  This class is made for a narrow purpose! It only works with horizontal sliders and binding an event to this widget with the bind()
#  method does not work anymore.
class JumpScale(Tkinter.Scale):
    ## @brief Constroctur method
    #  @param self the object pointer
    #  @param master Tkinter master widget
    #  @param options additional parameters for this sliders as in the Tkinter.Scale widget
    def __init__(self, master=None, **options):
        Tkinter.Scale.__init__(self, master, options)
        dif = self["to"] - self["from"]
        self.factor = dif / self["length"]
        self.bind("<1>", self._jump)
    
    # member variable documentation
    
    ## @var factor
    #  the factor that is used to calculate the position when the user clicks on the widget - the factor is defined as \f$ \frac{Scale_{to} - Scale_{from}}{Scale_{length}} \f$ where \f$ Scale_{to}\f$ is the maximum value of the slider, \f$Scale_{from}\f$ the minimum value of the slider and \f$ Scale_{length}\f$ is the length of the slider
    
    ## @brief Methhod that makes the slider jump to the correct position
    #
    #  @param self the object pointer
    #  @param evt the mouse event that caused the execution of this function
    def _jump(self, evt):
        x, y = evt.x, evt.y
        _id = self.identify(x, y)
        if _id == "trough1" or _id == "trough2":
            self.set(self.factor * x + self["from"])


## @brief Frame to modify filter parameters.
#  @author Fabian Wenzelmann
#
#  This frame is used to modify the arguments for the filter. Each filter is grouped together with sliders and text fields for all its parameters.
#  The text fields and sliders are linked together so you can modify both. The filters and its parameters are:
#  <ul>
#       <li>
#               Gaussian Blur
#               <ul> <li>Blur width</li><li>Blur height</li> </ul>
#       </li>
#       <li>
#               Canny
#               <ul><li>m_threshold1</li><li>m_threshold2</li></ul>
#               as defined in the opencv documentation
#       </li>
#       <li>
#               Edge Connector
#               <ul><li>Search Radius</li></ul>
#       </li>
#       <li>
#               Delete Short Lines
#               <ul><li>Min length</li></ul>
#       </li>
#  </ul>
#  The resulting image using the current filter settings (as a "preview") is displayed on the right side of the frame.
#  Since each image is seperated in areas (for mouth, eyes and so on) the values of the filters can be set for each of those areas.
#  All areas are accessible through a OptionMenu. The areas can be adjusted by hand to correct the position.
#  The selected area is surrounded by a red rectangle (in the preview). If the mouse moves over the image also a blue rectangle is drawn
#  which marks the new position of this area when the users presses the left mouse key.
#  There is a button "apply" which updates the preview image by applying the filter-settings on the original image. There's also the option "Immediately apply changes".
#  If this value is set to yes (by activating a check button) the preview image is updated each time the user changes one of the filter settings. Hower this can become very slow depending on the image and the current settings...
#  The user presses the "Commit" button to commit the current settings and edge image to the main gui.
#  Below the preview image there is a group of six RadioButtons. The user can rate the image with the current settings. The raitings are saved in a database and are used for our "learning" algorithm (well lets say it tries to do something useful according to the collected data).
#  1 is the worste and 6 is the best raiting.
#  Below there's an example image:
#  @image html image_settings_frame.png
class ImageSettingsFrame(Tkinter.Frame):
    ## @brief Constructor method
    #  @param self the object pointer
    #  @param master the Tkinter master widget (usually a Tkinter.Toplevel)
    #  @param filter_settings is of type autoselect_result (message type)
    def __init__(self, master, filter_settings):
        # call the superclass constructor
        Tkinter.Frame.__init__(self, master)
        # a cv_bridge used for this frame
        self.master.title("Filter Settings")
        self.bridge = bridge = cv_bridge.CvBridge()
        # keep a reference to the original image
        self.original_image = filter_settings.image
        # we also need the image as cvMat
        self.orignal_image_as_cvM = bridge.imgmsg_to_cv(self.original_image)
        # save all areas in a hashmap
        self.areas = areas = {}
        for area in filter_settings.areas:
            areas[area.area.name] = area
        # also save the list for the service call
        self.list_areas = filter_settings.areas
        
        # create "subframes"
        area_frame = Tkinter.LabelFrame(self, text="Image Area")
        self.area_selection = area_selection = Tkinter.StringVar(master=self)
        area_selection.set(filter_settings.areas[0].area.name)
        area_box = apply(Tkinter.OptionMenu, (area_frame, area_selection) + tuple( [area.area.name for area in filter_settings.areas]))
        box_label = Tkinter.Label(area_frame, text="Selected Area: ")
        
        area_box.grid(row=0, column=1, sticky="W")
        box_label.grid(row=0, column=0, sticky="W")
        
        # filter and settings frame
        blur_frame = Tkinter.LabelFrame(self, text="Gaussian Blur")
        canny_frame = Tkinter.LabelFrame(self, text="Canny")
        connect_frame = Tkinter.LabelFrame(self, text="Connect Edges")
        delete_frame = Tkinter.LabelFrame(self, text="Delete Short Lines")
        settings_frame = Tkinter.LabelFrame(self, text="Settings / Options")
        
        # Blur
        self.blur_width = blur_width = Tkinter.IntVar(master=self)
        self.blur_height = blur_height = Tkinter.IntVar(master=self)
        
        blur_width_slider = JumpScale(blur_frame, from_=BLUR_WIDTH_MIN, to=BLUR_WIDTH_MAX, orient=Tkinter.HORIZONTAL, label="blur width", variable=blur_width, tickinterval=_slider_tickinterval(BLUR_WIDTH_MIN, BLUR_WIDTH_MAX), length=SLIDER_LENGTH, showvalue=False)
        # TODO: validate?
        blur_width_txt_field = Tkinter.Entry(blur_frame, textvariable=blur_width, width=len(str(BLUR_WIDTH_MAX)) + 1)
        
        blur_height_slider = JumpScale(blur_frame, from_=BLUR_HEIGHT_MIN, to=BLUR_HEIGHT_MAX, orient=Tkinter.HORIZONTAL, label="blur height", variable=blur_height, tickinterval=_slider_tickinterval(BLUR_HEIGHT_MIN, BLUR_HEIGHT_MAX), length=SLIDER_LENGTH, showvalue=False)
        blur_height_txt_field = Tkinter.Entry(blur_frame, textvariable=blur_height, width=len(str(BLUR_HEIGHT_MAX)) + 1)
        
        blur_width_slider.grid(row=0, column=0)
        blur_width_txt_field.grid(row=1, column=0, sticky="W")
        blur_height_slider.grid(row=2, column=0, sticky="WE")
        blur_height_txt_field.grid(row=3, column=0, sticky="W")
        
        self.c_threshold1 = c_threshold1 = Tkinter.IntVar(master=self)
        self.c_threshold2 = c_threshold2 = Tkinter.IntVar(master=self)
        
        # Canny
        c_threshold1_slider = JumpScale(canny_frame, from_=CANNY_THRESHOLD1_MIN, to=CANNY_THRESHOLD1_MAX, orient=Tkinter.HORIZONTAL, label="threshold 1", variable=c_threshold1, tickinterval=_slider_tickinterval(CANNY_THRESHOLD1_MIN, CANNY_THRESHOLD1_MAX, 2), length=SLIDER_LENGTH, showvalue=False)
        c_threshold1_txt_field = Tkinter.Entry(canny_frame, textvariable=c_threshold1, width=len(str(CANNY_THRESHOLD1_MAX)) + 1)
        
        c_threshold2_slider = JumpScale(canny_frame, from_=CANNY_THRESHOLD2_MIN, to=CANNY_THRESHOLD2_MAX, orient=Tkinter.HORIZONTAL, label="threshold 2", variable=c_threshold2, tickinterval=_slider_tickinterval(CANNY_THRESHOLD2_MIN, CANNY_THRESHOLD2_MAX, 2), length=SLIDER_LENGTH, showvalue=False)
        c_threshold2_txt_field = Tkinter.Entry(canny_frame, textvariable=c_threshold2, width=len(str(CANNY_THRESHOLD2_MAX)) + 1)
        
        c_threshold1_slider.grid(row=0, column=0)
        c_threshold1_txt_field.grid(row=1, column=0, sticky="W")
        c_threshold2_slider.grid(row=2, column=0)
        c_threshold2_txt_field.grid(row=3, column=0, sticky="W")
        
        # Edge connector
        self.s_radius = s_radius = Tkinter.IntVar(master=self)
        s_radius_slider = JumpScale(connect_frame, from_=SEARCH_RADIUS_MIN, to=SEARCH_RADIUS_MAX, orient=Tkinter.HORIZONTAL, label="search radius", variable=s_radius, tickinterval=_slider_tickinterval(SEARCH_RADIUS_MIN, SEARCH_RADIUS_MAX), length=SLIDER_LENGTH, showvalue=False)
        s_radius_txt_field = Tkinter.Entry(connect_frame, textvariable=s_radius, width=len(str(SEARCH_RADIUS_MAX)) + 1)
        
        s_radius_slider.grid(row=0, column=0)
        s_radius_txt_field.grid(row=1, column=0, sticky="W")
        
        # Delete short lines
        self.min_length = min_length = Tkinter.IntVar(master=self)
        min_length_slider = JumpScale(delete_frame, from_=PIXEL_NUM_MIN, to=PIXEL_NUM_MAX, orient=Tkinter.HORIZONTAL, label="min line length", variable=min_length, tickinterval=_slider_tickinterval(PIXEL_NUM_MIN, PIXEL_NUM_MAX), length=SLIDER_LENGTH, showvalue=False)
        min_length_txt_field = Tkinter.Entry(delete_frame, textvariable=min_length, width=len(str(PIXEL_NUM_MAX)) + 1)
        
        min_length_slider.grid(row=0, column=0)
        min_length_txt_field.grid(row=1, column=0, sticky="W")
        
        # some settings
        self.immediately_apply = immediately_apply = Tkinter.IntVar(master=self)
        immediately_apply_box = Tkinter.Checkbutton(settings_frame, text="Immediately apply changes", variable=immediately_apply)
        apply_button = Tkinter.Button(settings_frame, text="Apply", command=self._apply_and_display)
        
        commit_button = Tkinter.Button(settings_frame, text="Commit", command=self._commit)
        
        immediately_apply_box.grid(row=0, column=0)
        apply_button.grid(row=1, column=0, sticky="W")
        commit_button.grid(row=1, column=1, sticky="W")
        
        # grid the subframes
        blur_frame.grid(row=1, column=0)
        canny_frame.grid(row=1, column=1)
        connect_frame.grid(row=2, column=0, sticky="WE", padx=10, pady=10)
        delete_frame.grid(row=2, column=1, sticky="WE")
        settings_frame.grid(row=3, column=0, columnspan=2, pady=10, sticky="WE", padx=10)
        area_frame.grid(row=0, column=0, sticky="WE", columnspan=2, padx=10)
        
        area_selection.trace("w", self._area_selection_callback)
        #self._set_parameter_values()
        # we also need a frame to display the result image
        image_frame = self.image_frame = Tkinter.LabelFrame(self, text="Result Image")
        
        image_label = self.image_label = Tkinter.Label(self.image_frame)
        image_label.bind("<Motion>", self._mouse_motion_callback)
        image_label.bind("<1>", self._mouse_click_callback)
        self._init_area_values()
        self._apply_and_display()
        
        # we also need radio buttons for the raiting
        raiting = self.raiting = Tkinter.IntVar(master=self, value=3)
        for i in range(1, 7):
            rb = Tkinter.Radiobutton(image_frame, text=str(i), variable=raiting, value=i)
            rb.grid(row=1, column=i-1)
        image_label.grid(row=0, column=0, columnspan=6)
        rate_button = Tkinter.Button(image_frame, text="Rate", relief=Tkinter.SUNKEN, command=self._rate_callback)
        rate_button.grid(row=2, column=0, columnspan=6, sticky="WE")
        
        image_frame.grid(row=0, column=3, rowspan=4, padx=10)
        
        self._set_display_image(self.as_py_image)
        immediately_apply.trace("w", self._area_selection_callback)
        
        parameter_value_changed = lambda p_name : lambda *args : self._parameter_value_changed(p_name, args)
        
        blur_width.trace("w", parameter_value_changed("blurwidth"))
        blur_height.trace("w", parameter_value_changed("blurheight"))
        
        c_threshold1.trace("w", parameter_value_changed("threshold1"))
        c_threshold2.trace("w", parameter_value_changed("threshold2"))

        s_radius.trace("w", parameter_value_changed("minNumPixels"))
        
        min_length.trace("w", parameter_value_changed("searchRadius"))
        
        # create a sql database connection
        sql_db = self.sql_db = sql_database.SQLImageDatabase(bridge=self.bridge)
        try:
            sql_db.load_file()
        except:
            self.sql_db = None
            tkMessageBox.showerror(message="Unable to load / create image information database file. Raiting button will not work!", parent=self, title="Error")
    
    # Member variable documentation
    ## @var bridge
    #  a cv_bridge that is used to transform images from sensor_msgs/Image to cvMat and vice versa
    
    ## @var original_image
    #  the original image as passed from the proposals as sensor_msgs/Image
    
    ## @var orignal_image_as_cvM
    #  also save the original image as cvMat - this is required to add information about the image in the database.
    
    ## @var areas
    #  All areas of this image - but packed in a python dictionary to speedup the lookup the filter settings when the currently selected area is used as identifier of the area
    
    ## @var list_areas
    #  All areas of this image - it's list of msg/image_area
    
    ## @var area_selection
    #  A Tkinter.StringVar that stores the name of the selected area
    
    ## @var blur_width
    #  Tkinter variable that stores the blur width parameter value
    
    ## @var blur_height
    #  Tkinter variable that stores the blur height parameter value
    
    ## @var c_threshold1
    #  Tkinter variable that stores the canny threshold1 parameter value
    
    ## @var c_threshold2
    #  Tkinter variable that stores the canny threshold2 parameter value
    
    ## @var s_radius
    #  Tkinter variable that stores the search radius paramter value for the edge connector
    
    ## @var min_length
    #  Tkinter variable that stores the min_length parameter value for delete short lines
    
    ## @var immediately_apply
    #  Tkinter variable that stores if changes of the filter values should always cause the preview image to update
    
    ## @var image_frame
    #  The Tkinter.LabelFrame that contains the preview label and raiting stuff
    
    ## @var image_label
    #  The Tkinter.Label that is used to display the preview image
    
    ## @var raiting
    #  Tkinter variable the stores the currently selected raiting value (in range 1 to 6)
    
    ## @var sql_db
    #  When the frame is generated it tries to connectoct to the image information database (class image_information.SQLImageDatabase) - however if opening the database failed it is set to None
    
    ## @var tk_img
    #  We have to keep a pointer to the Tk.PhotoImage (preview image) or python will destroy it even it is used in a frame...
    
    ## @var as_py_image
    #  stores the image (original image with applied filters) as python image (in RGB format)
        
    ## @brief This method is called when the users presses the "Rate" Button.
    #  @param self the object pointer
    #
    #  If there's an open connection to the sql database the new information is stored. If anything wents wrong an Error message is displayed.
    def _rate_callback(self):
        if self.sql_db is None:
            tkMessageBox.showerror(message="You don't have a image information database connection - so you can't rate images!", parent=self, title="Error")
            return
        try:
            self.sql_db.add_image(self.orignal_image_as_cvM, self.raiting.get(), self.list_areas)
        except Exception as e:
            tkMessageBox.showerror(message="Can't add new data to database.\nThis is really strange...", parent=self, title="Error")
            print(e)
        self.sql_db.get_images()
    
    ## @brief This method checks which image area is selected and sets the value of the sliders according to the values stored in the settings of the selected area.
    #  @param self the object pointer
    def _init_area_values(self):
        selected_area = self.areas[self.area_selection.get()]
        for _filter in selected_area.filters:
            # look up which filter we have and then set all of it's parameters
            if _filter.name == "GaussianBlur":
                for parameter in _filter.parameters:
                    if parameter.name == "blurwidth":
                        self.blur_width.set(int(parameter.value))
                    elif parameter.name == "blurheight":
                        self.blur_height.set(int(parameter.value))
            elif _filter.name == "Canny":
                for parameter in _filter.parameters:
                    if parameter.name == "threshold1":
                        self.c_threshold1.set(parameter.value)
                    elif parameter.name == "threshold2":
                        self.c_threshold2.set(parameter.value)
            elif _filter.name == "DeleteShortLines":
                for parameter in _filter.parameters:
                    if parameter.name == "minNumPixels":
                        self.min_length.set(parameter.value)
            elif _filter.name == "EdgeConnector":
                for parameter in _filter.parameters:
                    if parameter.name == "searchRadius":
                        self.s_radius.set(parameter.value)
                      
        ## @brief This method calculates the position of the selected image area according to new x and y positions. The positions are adjusted so that they cover an legal part of the image.
        #  @param self the object pointer
        #  @param x_center new supposed center x-position of the selected area
        #  @param y_center new supposed center y-position of the selected area
        #  @return left, top, width, height: left is the left bounding of the area, top is the upper bounding of the area and width and height are the width and height of the area
    def _adjust_positions(self, x_center, y_center):
        selected_area = self.areas[self.area_selection.get()]
        width, height = selected_area.area.width, selected_area.area.height
        half_width, half_height = int(width / 2.0), int(height / 2.0)
        left, right, top, down = x_center - half_width, x_center + half_width, y_center - half_height, y_center + half_height
        img_width, img_height = self.as_py_image.size
        if left < 0:
            left = 0
            right = width
        if top < 0:
            top = 0
            down = height
        if right > img_width - 1:
            right = img_width
            left = img_width - width
        if down > img_height - 1:
            down = img_height
            top = img_height - height
        return left, top, width, height
    
    ## @brief Callback function when the users clicks inside the preview image.
    #  @param self the object pointer
    #  @param evt the mouse event
    #
    #  Calculates the new position of the selected area and sets its values. It also forces a redraw of the preview. 
    def _mouse_click_callback(self, evt):
        left, top, width, height = self._adjust_positions(evt.x, evt.y)
        selected_area = self.areas[self.area_selection.get()]
        selected_area.area.x, selected_area.area.y = left, top
        self._apply_and_display()
        
    ## @brief Callback function whe the users moves the mouse inside the preview image
    #  @param self the object pointer
    #  @param evt the mouse event
    #
    #  Function is used to update the preview image so that the blue box, indicating the new position of the area, is displayed correctly.
    #  Draws the blue box inside the current image without decoration (as_py_image).
    def _mouse_motion_callback(self, evt):
        left, top, width, height = self._adjust_positions(evt.x, evt.y)
        blue = 0, 0, 255
        self._set_display_image( self._draw_area(self.as_py_image, left, top, width, height, blue))
    
    ## @brief Set the preview image.
    #  @param self the object pointer
    #  @param img the new image as python image
    #
    #  Converts the python image to a Tk Image and keeps a reference to the image so that it is not destroyed by python.
    def _set_display_image(self, img):
        # convert to tkinter image
        tk_img = ImageTk.PhotoImage(img)
        # keep reference
        self.tk_img = tk_img
        self.image_label.configure(image=tk_img)
    
    ## @brief Callback function for the OptionMenu (selected area has changed).
    #  @param self the object pointer
    #  @param *args whatever arguments are passed
    #
    #  Set the slider values to the values of the new area and display the image again to draw the rectangles and so on
    def _area_selection_callback(self, *args):
        self._init_area_values()
        self._apply_and_display()
    
    ## @brief Callback function when the "Commit" button is pressed
    #  @param self the object pointer
    #
    #  Destroys the master of this frame (usually a Tkinter.Toplevel). The gui_serivce now calls the main gui and transfers the edge image.
    def _commit(self):
        self.master.destroy()
    
    ## @brief For the selected area save all parameter values (from the sliders) and set the fields of the filter objects.
    #  @param self the object pointer
    #  @param parameter_name the new of the parameter that has changed and so called this method to set the parameters.
    #
    #  This method is used to copy the values from the sliders to the filter objects.  
    def _set_parameter_values(self, parameter_name):
        selected_area = self.areas[self.area_selection.get()]
        # set for this area all parameters
        for _filter in selected_area.filters:
            # look up which filter we have and then set all of it's parameters
            if _filter.name == "GaussianBlur":
                for parameter in _filter.parameters:
                    if parameter_name == "blurwidth" and parameter.name == "blurwidth":
                        parameter.value = str(self.blur_width.get()).encode("ascii")
                    elif parameter_name == "blurheight" and parameter.name == "blurheight":
                        parameter.value = str(self.blur_height.get()).encode("ascii")
            elif _filter.name == "Canny":
                for parameter in _filter.parameters:
                    if parameter_name == "threshold1" and parameter.name == "threshold1":
                        parameter.value = str(self.c_threshold1.get()).encode("ascii")
                    elif parameter_name == "threshold2" and parameter.name == "threshold2":
                        parameter.value = str(self.c_threshold2.get()).encode("ascii")
            elif _filter.name == "DeleteShortLines":
                for parameter in _filter.parameters:
                    if parameter_name == "minNumPixels" and parameter.name == "minNumPixels":
                        parameter.value = str(self.min_length.get()).encode("ascii")
            elif _filter.name == "EdgeConnector":
                for parameter in _filter.parameters:
                    if parameter_name == "searchRadius" and parameter.name == "searchRadius":
                        parameter.value = str(self.s_radius.get()).encode("ascii")           
    
    ## @brief Callback function if on of the sliders or the text field content changed
    #  @param self the object pointer
    #  @param parameter_name the name of the parameter that has changed
    #  @param *args whatever arguments are also passed
    #
    #  Updates all parameters, calculates the corresponding image (and sets current_image to the new image), draws area squares and displays the image
    def _parameter_value_changed(self, parameter_name, *args):
        self._set_parameter_values(parameter_name)
        if self.immediately_apply.get():
            self._apply_and_display()
    
    ## @brief Apply filter with current settings and display the resulting image.
    #  @param self the object pointer
    #  @param *args whatever arguments are also passed
    def _apply_and_display(self, *args):
        self._apply_filters()
        self._draw_selected_area()
        self._set_display_image(self.as_py_image)
    
    ## @brief Just apply the filters with current settings and update the pointers of the images that are used in this class.
    #  @param self the object pointer
    #  @param *args whatever arguments are also passed
    def _apply_filters(self, *args):
        # apply the filters
        f = rospy.ServiceProxy("apply_filters", ApplyFilters)
        resp = f(self.original_image, self.list_areas)
        res = resp.result_image
        # set the global current image
        global current_image
        current_image = res
        # generate a python image of the result
        img = cv.CloneMat(self.bridge.imgmsg_to_cv(res))
        img = Image.fromstring("L", cv.GetSize(img), img.tostring())
        img = img.convert("RGB")
        self.as_py_image = img
    
    ## @brief callback function if the immediately apply changes value changed
    #  @param self the object pointer
    #  @param *args whatever arguments are also passed
    #
    #  If the immediately apply value changed to True we should apply the filters right now and display the new image.
    def _immediately_callback(self, *args):
        if self.immediately_apply.get():
            self._apply_filters(args)
    
    ## @brief Draw in img a rectangle from positon x, y with respective width and height in color.
    #  @param self the object pointer
    #  @param img PIL image in which the area is drawn
    #  @param x x-position of the start point
    #  @param y y-position of the start point
    #  @param width width of the rectangle
    #  @param height height of the rectangle
    #  @param color RGB color (three tuple) defining the color of the rectangle
    #  @return A copy of this image containing the rectangle
    def _draw_area(self, img, x, y, width, height, color):
        copy = img.copy()
        x_range = range(x, x + width)
        y_range = range(y, y + height)
        for i in x_range:
            copy.putpixel((i, y), color)
            copy.putpixel((i, y + height - 1), color)
        for i in y_range:
            copy.putpixel((x, i), color)
            copy.putpixel((x + width - 1, i), color)
        return copy
     
     ## @brief draw the rectangle for the currently selected area
     #  @param self the object pointer   
    def _draw_selected_area(self):
        selected_area = self.areas[self.area_selection.get()]
        x, y, width, height = selected_area.area.x, selected_area.area.y, selected_area.area.width, selected_area.area.height
        red = 255, 0, 0
        self.as_py_image = self._draw_area(self.as_py_image, x, y, width, height, red)

## @brief Calculate appropriate interval for the sliders.
#  @param min_ the minimum value of the slider
#  @param max_ the maximum value of the slider
#  @param tick_count the amount of ticks on the slider. If omitted 4 is used.
def _slider_tickinterval(min_, max_, tick_count=None):
    if tick_count is None:
        tick_count = 4
    dif = max_ - min_ + 1
    if dif < 0:
        return 1
    else:
        return int(dif / tick_count)

## @brief Transform a sensor_msgs/Image to a ImageTk.PhotoImage. Image is transformed to a "mono8" photo.
def imgmsg_to_photo_image(imgmsg_img, bridge):
    cv_img = bridge.imgmsg_to_cv(imgmsg_img, "mono8")
    return ImageTk.PhotoImage( Image.fromstring("L", cv.GetSize(cv_img), cv_img.tostring()) )