X-Git-Url: http://git.cascardo.eti.br/?p=cascardo%2Fmovie.git;a=blobdiff_plain;f=gzv.py;fp=gzv.py;h=ac4dce3a9d94ee3563ba8c87219eaecd97517152;hp=0000000000000000000000000000000000000000;hb=70d7df1f9bc3678b1137779990ab2c6364bb959a;hpb=dacb100ef24f4c8ad4de8de0d7368c0d9e32cabb diff --git a/gzv.py b/gzv.py new file mode 100644 index 0000000..ac4dce3 --- /dev/null +++ b/gzv.py @@ -0,0 +1,508 @@ +# -*- coding: utf-8; -*- +# gzv.py - an user interface to select people in a picture +# +# Copyright (C) 2008 Lincoln de Sousa +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +import os +import gtk +import gtk.glade +import gobject +import math +import cairo +from ConfigParser import ConfigParser + +_ = lambda x:x + +class Point(object): + def __init__(self, x, y): + self.x = x + self.y = y + + @staticmethod + def pythagorean(p1, p2): + return math.sqrt((p2.x - p1.x)**2 + (p2.y - p1.y)**2) + +class Ball(object): + DEFAULT_WIDTH = 10 + + def __init__(self, x, y, r, name='', position=0, selected=False): + self.position = position + self.selected = selected + self.p = Point(int(x), int(y)) + self.radius = int(r) + self.name = name + +class BallManager(list): + def __init__(self, *args, **kwargs): + super(BallManager, self).__init__(*args, **kwargs) + + def save_to_file(self, path): + target = open(path, 'w') + for i in self: + target.write('%d,%d %d %s\n' % (i.p.x, i.p.y, i.radius, i.name)) + target.close() + +class GladeLoader(object): + def __init__(self, fname, root=''): + self.ui = gtk.glade.XML(fname, root) + self.ui.signal_autoconnect(self) + + def get_widget(self, wname): + return self.ui.get_widget(wname) + + # little shortcut + wid = get_widget + + # glade callbacks + + def gtk_widget_show(self, widget, *args): + widget.show() + return True + + def gtk_widget_hide(self, widget, *args): + widget.hide() + return True + + def gtk_main_quit(self, *args): + gtk.main_quit() + + def gtk_main(self, *args): + gtk.main() + +class Project(object): + def __init__(self, image, width, height): + self.image = image + self.width = width + self.height = height + self.focus_points_file = '' + + def save_to_file(self, path): + if not self.focus_points_file: + bn = os.path.basename(path) + name = os.path.splitext(bn)[0] + self.focus_points_file = \ + os.path.join(os.path.dirname(path), name + '_fpf') + + cp = ConfigParser() + cp.add_section('Project') + cp.set('Project', 'image', self.image) + cp.set('Project', 'width', self.width) + cp.set('Project', 'height', self.height) + cp.set('Project', 'focus_points', self.focus_points_file) + + cp.write(open(path, 'w')) + + @staticmethod + def parse_file(path): + cp = ConfigParser() + cp.read(path) + + image = cp.get('Project', 'image') + width = cp.getint('Project', 'width') + height = cp.getint('Project', 'height') + x = cp.getint('Project', 'height') + + proj = Project(image, width, height) + proj.focus_points_file = cp.get('Project', 'focus_points') + + return proj + +class NewProject(GladeLoader): + def __init__(self, parent=None): + super(NewProject, self).__init__('gzv.glade', 'new-project') + self.dialog = self.wid('new-project') + if parent: + self.dialog.set_transient_for(parent) + + def get_project(self): + # This '1' was defined in the glade file + if not self.dialog.run() == 1: + return None + + fname = self.wid('image').get_filename() + width = self.wid('width').get_text() + height = self.wid('height').get_text() + return Project(fname, width, height) + + def destroy(self): + self.dialog.destroy() + +class Gzv(GladeLoader): + def __init__(self): + super(Gzv, self).__init__('gzv.glade', 'main-window') + self.window = self.wid('main-window') + self.window.connect('delete-event', lambda *x: gtk.main_quit()) + + self.evtbox = self.wid('eventbox') + self.evtbox.connect('button-press-event', self.button_press) + self.evtbox.connect('button-release-event', self.button_release) + self.evtbox.connect('motion-notify-event', self.motion_notify) + self.evtbox.connect('motion-notify-event', self.ball_motion) + + # making it possible to grab motion events when the mouse is + # over the widget. + self.evtbox.set_events(gtk.gdk.POINTER_MOTION_MASK) + + self.model = gtk.ListStore(int, str) + self.treeview = self.wid('treeview') + self.treeview.set_model(self.model) + self.treeview.connect('button-press-event', self.select_fp) + + self.draw = self.wid('draw') + self.draw.connect_after('expose-event', self.expose_draw) + + # Starting with an empty project with no image loaded + self.project = None + self.image = None + + # This attr may be overriten, if so, call the method (load_balls_to_treeview) + self.balls = BallManager() + + self.load_balls_to_treeview() + self.setup_treeview() + + self.new_ball = False + self.move_ball = None + + # drawing stuff + self.start_x = -1 + self.start_y = -1 + self.last_x = -1 + self.last_y = -1 + self.radius = Ball.DEFAULT_WIDTH + + def show(self): + self.window.show_all() + + def setup_treeview(self): + self.model.connect('rows-reordered', self.on_rows_reordered) + + renderer = gtk.CellRendererText() + column = gtk.TreeViewColumn(_('Position'), renderer, text=0) + column.set_property('visible', False) + self.treeview.append_column(column) + + renderer = gtk.CellRendererText() + renderer.connect('edited', self.on_cell_edited) + renderer.set_property('editable', True) + self.fpcolumn = gtk.TreeViewColumn(_('Name'), renderer, text=1) + self.treeview.append_column(self.fpcolumn) + + def on_rows_reordered(self, *args): + print + + def on_cell_edited(self, renderer, path, value): + self.balls[int(path)].name = value + self.load_balls_to_treeview() + + def new_project(self, button): + proj = NewProject(self.window) + project = proj.get_project() + proj.destroy() + + if project: + self.load_project(project) + + def open_project(self, *args): + fc = gtk.FileChooserDialog(_('Choose a gzv project'), self.window, + buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, + gtk.STOCK_OK, gtk.RESPONSE_OK)) + if fc.run() == gtk.RESPONSE_OK: + proj_file = fc.get_filename() + self.load_project(Project.parse_file(proj_file)) + fc.destroy() + + def save_project(self, *args): + fc = gtk.FileChooserDialog(_('Save project'), self.window, + action=gtk.FILE_CHOOSER_ACTION_SAVE, + buttons=(gtk.STOCK_CANCEL, + gtk.RESPONSE_CANCEL, + gtk.STOCK_SAVE, + gtk.RESPONSE_OK)) + if fc.run() == gtk.RESPONSE_OK: + self.project.save_to_file(fc.get_filename()) + self.balls.save_to_file(self.project.focus_points_file) + fc.destroy() + + def load_project(self, project): + self.project = project + self.balls = self.load_balls_from_file(project.focus_points_file) + self.image = project.image + + # I'm loading a pixbuf first because I need to get its + # dimensions this with a pixbuf is easier than with an image. + try: + pixbuf = gtk.gdk.pixbuf_new_from_file(project.image) + except gobject.GError: + msg = _("Couldn't recognize the image file format.") + dialog = gtk.MessageDialog(self.window, + gtk.DIALOG_MODAL, + gtk.MESSAGE_ERROR, + gtk.BUTTONS_CLOSE) + dialog.set_markup(msg) + dialog.run() + dialog.destroy() + return self.unload_project() + + self.draw.set_from_pixbuf(pixbuf) + self.load_balls_to_treeview() + self.set_widgets_sensitivity(True) + + def unload_project(self): + self.project = None + self.image = None + self.balls = BallManager() + self.draw.queue_draw() + self.set_widgets_sensitivity(False) + + def set_widgets_sensitivity(self, sensitive): + for i in 'toolbutton1', 'toolbutton5', 'scrolledwindow1', \ + 'hbox2', 'imagemenuitem3': + self.wid(i).set_sensitive(sensitive) + + def load_balls_to_treeview(self): + self.model.clear() + for i in self.balls: + self.model.append([i.position, i.name]) + + def load_balls_from_file(self, fname): + balls = BallManager() + if not os.path.exists(fname): + return balls + + for index, line in enumerate(file(fname)): + if not line: + continue + pos, radius, name = line.split(None, 2) + x, y = pos.split(',') + balls.append(Ball(x, y, radius, name.strip(), index)) + return balls + + def remove_fp(self, *args): + selection = self.treeview.get_selection() + model, path = selection.get_selected() + if path: + position = model[path][0] + for i in self.balls: + if i.position == int(position): + self.balls.remove(i) + del model[path] + self.draw.queue_draw() + + def select_fp(self, treeview, event): + path, column, x, y = \ + self.treeview.get_path_at_pos(int(event.x), int(event.y)) + if path: + model = self.treeview.get_model() + ball = self.balls[model[path][0]] + + # making sure that only one ball is selected + for i in self.balls: + i.selected = False + ball.selected = True + + # available space to the image + w = self.evtbox.get_allocation().width + h = self.evtbox.get_allocation().height + + # point begining from the left image border + wib = self.point_with_border(ball) + + #self.wid('viewport').get_vadjustment().value = wib.x # + (w / 2) + #self.wid('viewport').get_hadjustment().value = wib.y # + (h / 2) + + self.draw.queue_draw() + + def select_fp_from_image(self, ball): + selection = self.treeview.get_selection() + selection.select_path(str(ball.position)) + + # making sure that only one ball is selected + for i in self.balls: + i.selected = False + ball.selected = True + + self.draw.queue_draw() + + def save_fp_list(self, *args): + assert self.project is not None + + # if the project has no + if self.project and not self.project.focus_points_file: + fc = gtk.FileChooserDialog(_('Save the focus points file'), + self.window, + action=gtk.FILE_CHOOSER_ACTION_SAVE, + buttons=(gtk.STOCK_CANCEL, + gtk.RESPONSE_CANCEL, + gtk.STOCK_SAVE, + gtk.RESPONSE_OK)) + if fc.run() == gtk.RESPONSE_OK: + self.project.focus_points_file = fc.get_filename() + fc.destroy() + else: + fc.destroy() + return + + self.balls.save_to_file(self.project.focus_points_file) + + def move_fp_up(self, *args): + selection = self.treeview.get_selection() + model, path = selection.get_selected() + if not path: + return + + pos = model[path][0] + newpos = max(pos - 1, 0) + self.balls.insert(newpos, self.balls.pop(pos)) + + # normalizing the position of elements. + for index, item in enumerate(self.balls): + item.position = index + + self.load_balls_to_treeview() + selection.select_path(str(newpos)) + + def move_fp_down(self, *args): + selection = self.treeview.get_selection() + model, path = selection.get_selected() + if not path: + return + + pos = model[path][0] + newpos = min(pos + 1, len(self.balls)) + self.balls.insert(newpos, self.balls.pop(pos)) + + # normalizing the position of elements. + for index, item in enumerate(self.balls): + item.position = index + + self.load_balls_to_treeview() + selection.select_path(str(newpos)) + + def expose_draw(self, draw, event): + if not self.image: + return + + for i in self.balls: + self.draw_ball(i) + + if self.start_x < 0: + return False + + if self.new_ball: + ball = Ball(self.start_x, self.start_y, self.radius) + self.draw_ball(ball) + + return False + + def point_with_border(self, ball): + iw, ih = self.draw.size_request() + w = self.draw.get_allocation().width + h = self.draw.get_allocation().height + + x = ((w / 2) - (iw / 2)) + ball.p.x + y = ((h / 2) - (ih / 2)) + ball.p.y + return Point(x, y) + + def point_without_border(self, point): + iw, ih = self.draw.size_request() + w = self.draw.get_allocation().width + h = self.draw.get_allocation().height + + x = point.x - ((w / 2) - (iw / 2)) + y = point.y - ((h / 2) - (ih / 2)) + return Point(x, y) + + def draw_ball(self, ball): + ctx = self.draw.window.cairo_create() + ctx.arc(self.point_with_border(ball).x, + self.point_with_border(ball).y, + ball.radius, 0, 64*math.pi) + ctx.set_source_rgba(0.0, 0.0, 0.5, 0.4) + ctx.fill() + + if ball.selected: + ctx.set_source_rgba(0.0, 0.5, 0.0, 0.4) + ctx.set_line_width(5) + ctx.arc(self.point_with_border(ball).x, + self.point_with_border(ball).y, + ball.radius+1, 0, 64*math.pi) + ctx.stroke() + + def button_press(self, widget, event): + self.new_ball = True + + self.last_x = event.x + self.last_y = event.y + + if event.button == 1: + for i in self.balls: + p1 = Point(event.x, event.y) + p2 = self.point_with_border(i) + if Point.pythagorean(p1, p2) < i.radius: + self.last_x = event.x - i.p.x + self.last_y = event.y - i.p.y + self.select_fp_from_image(i) + + self.new_ball = False + self.move_ball = i + break + + self.start_x = self.point_without_border(event).x + self.start_y = self.point_without_border(event).y + + def button_release(self, widget, event): + self.move_ball = None + + if event.button == 1: + self.finish_drawing() + + def motion_notify(self, widget, event): + if not self.new_ball: + return + + self.draw.queue_draw() + + if event.x > self.last_x: + self.radius += 3 + else: + self.radius -= 3 + + self.last_x = event.x + + def ball_motion(self, widget, event): + if not self.move_ball: + return + + self.move_ball.p.x = self.point_without_border(event).x + self.move_ball.p.y = self.point_without_border(event).y + + self.draw.queue_draw() + + def finish_drawing(self): + if self.new_ball: + position = len(self.balls) + ball = Ball(self.start_x, self.start_y, self.radius, '', position) + self.balls.append(ball) + self.model.append([position, '']) + self.treeview.set_cursor(str(position), self.fpcolumn, True) + self.new_ball = False + + # reseting to the default coordenades + self.start_x = -1 + self.start_y = -1 + self.radius = Ball.DEFAULT_WIDTH + +if __name__ == '__main__': + Gzv().show() + gtk.main()