Laboratorium - Zastosowanie Technologii: Python, GTK oraz

Transkrypt

Laboratorium - Zastosowanie Technologii: Python, GTK oraz
Laboratorium - Zastosowanie Technologii:
Python, GTK oraz Gstreamer
Ćwiczenie laboratoryjne ma na celu prezentację zastosowania języka Python oraz bibliotek GTK
i Gstreamer do budowy mobilnych aplikacjach multimedialnych. Platformę do uruchamiania aplikacji
stanowi urządzenie Nokia N900 działające pod kontrolą systemu Maemo. Maemo bazuje na jądrze
Linuksa, posiada otwartą architekturę programową dzięki czemu programista posiada pełny dostęp do
mechanizmów działających w obrębie systemu operacyjnego. Rdzeń aplikacji multimedialnej, prezentowanej w tym ćwiczeniu, stanowi Gstreamer, natomiast graficzny interfejs użytkownika zrealizowany
jest przy pomocy biblioteki GTK. Do budowy aplikacji zastosowano pythonowe nakładki: PyGTK
oraz PyGST. Gstreamer, GTK oraz Python są technologiami multiplatformowymi, zatem prezentowana w tym ćwiczeniu aplikacja jest przenośna i może być z powodzeniem stosowana zarówno na
innych platformach mobilnych jak i na komputerach stacjonarnych.
Zadania
W ramach laboratorium proszę zapoznać się z podstawowymi właściwościami technologii Python,
GTK oraz Gstreamer w kontekście zastosowania ich na platformach mobilnych.
1
Uruchomienie aplikacji na platformie mobilnej (4 pkt)
Należy skopiować plik zawierający kod źródłowy aplikacji demonstracyjnej (z załącznika) na platformę
mobilną (1 pkt). Nadać plikowi odpowiednie prawa, aby mógł być wykonywany oraz opcjonalnie zainstalować wymagane pakiety (python, python-gst0.10, python-gtk2) (1 pkt). Należy zaprezentować
działanie aplikacji wyświetlając strumień wideo z kamery przedniej (1 pkt) oraz z kamery wstecznej
(1 pkt). W tym celu należy zmienić nazwę pliku specjalnego /dev/video0 w opisie łańcucha Gstreamera.
2
Modyfikacja aplikacji (6 pkt)
Należy do interfejsu graficznego dodać przycisk z etykietą „FOTO” (1 pkt). Zaproponować potok
Gstreamera zapisujący do pliku jedną klatkę obrazu ze strumienia wideo pochodzącego z kamery
(1.5 pkt). Zdefiniować reakcje dodanego przycisku tak aby uruchamiał zaproponowany potok (1 pkt).
Zademonstrować działanie aplikacji wykonując zdjęcie przyciskiem oraz wskazać to zdjęcie w systemie
plików Maemo (1 pkt). Należy także skopiować zrobione zdjęcie na komputer stacjonarny (0.5 pkt).
1
Załącznik - Graficzny Interfejs Użytkownika
Graficzny interfejs użytkownika należy zrealizować w oparciu o bibliotekę GTK. Interfejs do biblioteki GTK dla aplikacji napisanych w języku Python nosi nazwę PyGTK. Język Python jest zorientowany obiektowo. Jedną z konsekwencji, wynikających z tego, jest możliwość dziedziczenia metod
pomiędzy niektórymi klasami np. obiekty klasy gtk.Button mogą posługiwać się metodami zdefiniowanymi w klasie gtk.Widget.
• Klasa gobject.GObject - jest klasą bazową (nadrzędną).
c l a s s g o b j e c t . GObject :
def c o n n e c t ( d e t a i l e d s i g n a l
, handler )
Wskazówka: Funkcja connect może m.in. posłużyć do powiązania sygnału generowanego przez kliknicie
przycisku z funkcją, która ma zostać wykonana po kliknięciu.
• Klasa gtk.Widget - służy do tworzenia i manipulowania kontrolkami (ang. widget).
c l a s s gtk . Widget ( gtk . Ob jec t ) :
def s h o w a l l ( )
def s e t s i z e r e q u e s t ( width , h e i g h t )
• Klasa gtk.Window służy do tworzenia okna interfejsu graficznego GTK oraz do manipulowania
jego właściwościami.
c l a s s gtk . Window ( gtk . Bin ) :
gtk . Window ( type=gtk .WINDOW TOPLEVEL)
def s e t t i t l e ( t i t l e )
• Klasa gtk.Fixed - służy do tworzenia kontenerów, które umożliwiają precyzyjne pozycjonowanie
elementów interfejsu (kontrolek).
c l a s s gtk . Fixed ( gtk . C o n t a i n e r ) :
gtk . Fixed ( )
def put ( widget , x , y )
• Klasa gtk.Button - służy do tworzenia i manipulowania przyciskami.
c l a s s gtk . Button ( gtk . Bin ) :
gtk . Button ( l a b e l=None , s t o c k=None , u s e u n d e r l i n e=True )
def s e t l a b e l ( l a b e l )
def g e t l a b e l ( )
• Klasa gtk.DrawingArea służy do tworzenia elementów interfejsu, po których można rysować. W
programie demonstracyjnym (w instrukcji do laboratorium) obiekt tej klasy służy do wyświetlania strumienia wideo na ekranie wyświetlacza (monitora).
c l a s s gtk . DrawingArea ( gtk . Widget ) :
gtk . DrawingArea ( )
Poszczególne elementy komunikują się ze sobą za pomocą sygnałów, które są wyzwalane przez użytkownika przy pomocy komponentów interaktywnych interfejsu lub za pomocą sygnałów generowanych
automatycznie np. zegar.
2
Załącznik - Aplikacja Demonstracyjna
#! / u s r / b i n / python
# −∗− c o d i n g : u t f −8 −∗−
import g o b j e c t , s y s , o s
import pygtk
pygtk . r e q u i r e ( ” 2 . 0 ” )
import p y g s t
pygst . r e q u i r e ( ” 0.10 ” )
import gtk , g s t
class camer a frontfire :
def
init ( self ):
window = gtk . Window ( gtk .WINDOW TOPLEVEL)
window . s e t t i t l e ( ” camera−f r o n t f i r e ” )
window . c o n n e c t ( ” d e s t r o y ” , s e l f . zamknij )
f i x e d = gtk . Fixed ( )
window . add ( f i x e d )
s e l f . but1 = gtk . Button ( ”START” )
s e l f . but1 . s e t s i z e r e q u e s t ( 2 4 0 , 2 1 0 )
s e l f . but1 . c o n n e c t ( ” c l i c k e d ” , s e l f . s t a r t s t o p )
f i x e d . put ( s e l f . but1 , 5 6 0 , 0 )
s e l f . s c r = gtk . DrawingArea ( )
s e l f . s c r . s e t s i z e r e q u e s t (560 , 420)
f i x e d . put ( s e l f . s c r , 0 , 0 )
window . s h o w a l l ( )
s e l f . l a c z e s t r = ” v 4 l 2 s r c d e v i c e =/dev / v i d e o 0 ! a u t o v i d e o s i n k ”
s e l f . lacze = gst . parse launch ( s e l f . l a c z e s t r )
bus = s e l f . l a c z e . g e t b u s ( )
bus . e n a b l e s y n c m e s s a g e e m i s s i o n ( )
bus . c o n n e c t ( ” sync−message : : e l e m e n t ” , s e l f . s y n c h r o n i z a c j a )
def s t a r t s t o p ( s e l f , w i d g e t ) :
i f s e l f . but1 . g e t l a b e l ( ) == ”START” :
s e l f . but1 . s e t l a b e l ( ”STOP” )
s e l f . l a c z e . s e t s t a t e ( g s t . STATE PLAYING)
else :
s e l f . but1 . s e t l a b e l ( ”START” )
s e l f . l a c z e . s e t s t a t e ( g s t . STATE NULL)
def s y n c h r o n i z a c j a ( s e l f , bus , message ) :
i f message . s t r u c t u r e i s None :
return
message name = message . s t r u c t u r e . get name ( )
i f message name == ” p r e p a r e −xwindow−i d ” :
i m a g e s i n k = message . s r c
i m a g e s i n k . s e t p r o p e r t y ( ” f o r c e −a s p e c t −r a t i o ” , True )
i m a g e s i n k . s e t x w i n d o w i d ( s e l f . s c r . window . x i d )
def zamknij ( s e l f , w i d g e t ) :
s e l f . l a c z e . s e t s t a t e ( g s t . STATE NULL)
gtk . m a i n q u i t ( )
camera frontfire ()
gtk . gdk . t h r e a d s i n i t ( )
gtk . main ( )
3

Podobne dokumenty