×
Namespaces

Variants
Actions
Revision as of 09:30, 8 May 2013 by hamishwillee (Talk | contribs)

(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)

Archived:A simple PySymbian camera application using the view finder

From Nokia Developer Wiki
Jump to: navigation, search

Archived.pngAquivado: Este artigo foi arquivado, pois o conteúdo não é mais considerado relevante para se criar soluções comerciais atuais. Se você achar que este artigo ainda é importante, inclua o template {{ForArchiveReview|escreva a sua justificativa}}.

All PySymbian articles have been archived. PySymbian is no longer maintained by Nokia and is not guaranteed to work on more recent Symbian devices. It is not possible to submit apps to Nokia Store.

This code snippet creates a simple PySymbian camera app that uses the camera view finder. It does not support zooming or other more advanced functions. Readers are encouraged to extend the article as necessary.

Article Metadata
Tested with
Devices(s): Emulator
Compatibility
Platform(s): S60 3rd Edition and later
Article
Keywords: Camera, viewfinder
Created: lfd (18 May 2007)
Last edited: hamishwillee (08 May 2013)

Code Snippet

import appuifw, e32, camera, time
from key_codes import EScancodeSelect, EScancode5, EScancode1, EScancode3
 
if e32.in_emulator( ):
IMAGEPATH = 'D:\\Images\\%s.png'
else:
IMAGEPATH = 'E:\\Images\\%s.png'
 
IMAGERESOLUTION = (640, 480)
 
 
# I added this class in the source if you haven't already added it
# to the libraries.
class Keyboard( object ):
def __init__( self, onevent=lambda:None ):
self._keyboard_state = {}
self._downs = {}
self._onevent = onevent
 
def handle_event( self, event ):
if event['type'] == appuifw.EEventKeyDown:
code = event['scancode']
if not self.is_down( code ):
self._downs[code] = self._downs.get( code, 0 ) + 1
self._keyboard_state[code] = 1
elif event['type'] == appuifw.EEventKeyUp:
self._keyboard_state[event['scancode']] = 0
self._onevent( )
 
def is_down( self, scancode ):
return self._keyboard_state.get( scancode, 0 )
 
def pressed( self, scancode ):
if self._downs.get( scancode, 0 ):
self._downs[scancode] -= 1
return True
return False
 
 
# Here is the camera base class I use in few applications.
# This class could be added to your libraries so that you only have to import it.
class Camera( object, appuifw.Canvas ):
_iImageWidth = 160
_iImageHeight = 120
_iSartColor = 0x000000
_iCapturedColor = 0x0000ff
_iSavingColor = 0x00ff00
_iStopedColor = 0xff0000
 
def __init__( self, aHandleEvent ):
self._iReady = False
self._iTempImage = None
self._iSaving = False
self._iSaved = False
self._iViewerActive = False
appuifw.Canvas.__init__( self, self._redrawCallback, aHandleEvent )
appuifw.app.body = self
self._iReady = True
 
def _redrawCallback( self, aRect=None ):
self.clear( )
x = ( self.size[0] - self._iImageWidth ) / 2
y = ( self.size[1] - self._iImageHeight ) / 2
if self._iTempImage:
self.blit( self._iTempImage, target=( x+1, y ) )
 
if not self._iTempImage:
color = self._iSartColor
elif self._iSaving:
color = self._iSavingColor
elif self._iSaved:
color = self._iCapturedColor
else:
color = self._iStopedColor
 
if self._iReady:
self.line( ( x-2, y-3,x+5, y-3 ), outline=color )
self.line( ( x-2, y-3,x-2, y+4 ), outline=color )
self.line( ( self.size[0]-x+2, y-3,self.size[0]-x-4, y-3 ),
outline=color )
self.line( ( self.size[0]-x+3, y-3,self.size[0]-x+3, y+4 ),
outline=color )
self.line( ( x-2, self.size[1]-y+2,x+5, self.size[1]-y+2 ),
outline=color )
self.line( ( x-2, self.size[1]-y-4,x-2, self.size[1]-y+2 ),
outline=color )
self.line( ( self.size[0]-x+2, self.size[1]-y+2,self.size[0]-x-4,
self.size[1]-y+2 ), outline=color )
self.line( ( self.size[0]-x+3, self.size[1]-y-4, self.size[0]-x+3,
self.size[1]-y+3 ), outline=color )
 
def _viewFinderRedrawCallback( self, aImage ):
self.blit( aImage, target=( (self.size[0] - aImage.size[0])/2 +1,
(self.size[1] - aImage.size[1])/2) )
self._iTempImage = aImage
 
def setActive( self ):
appuifw.app.body = self
self._redrawCallback( )
 
def startViewFinder( self ):
self._iTempImage = None
self.showCapture( )
camera.start_finder( self._viewFinderRedrawCallback,
size = ( self._iImageWidth, self._iImageHeight ) )
self._iSaved = False
self._iViewerActive = True
 
def stopViewFinder( self ):
if self._iViewerActive:
camera.stop_finder( )
self.showCapture( )
self._iViewerActive = False
 
def showCapture(self):
self._redrawCallback( )
 
def capture( self ):
try:
self._iSaving = True
self.stopViewFinder( )
e32.ao_yield( )
ctime = time.localtime()
# Filename format: YYYYMMDDHHMMSS
picName = "%4i%02i%02i%02i%02i%02i" %+ \
((ctime[0]), (ctime[1]), (ctime[2]),\
(ctime[3]), (ctime[4]), (ctime[5]))
img = camera.take_photo( size=IMAGERESOLUTION )
img.save( IMAGEPATH%picName )
 
# if thumbnail size is good enough for your application just save
# the last image:
# self._iTempImage.save( IMAGEPATH )
self._iSaved = True
except Exception, error:
print error
self._iSaved = False
self._iSaving = False
self.showCapture( )
 
def isSaved( self ):
return self._iSaved
 
def isViewerActive( self ):
return self._iViewerActive
 
def __del__( self ):
if self._iViewerActive:
camera.stop_finder( )
 
 
# This class, where all the handler are defined, uses both of the classes above.
class CameraView( object ):
def __init__( self ):
self._iKeyboard = Keyboard( self._keyObserver )
self._iCamera = Camera( self._iKeyboard.handle_event )
 
def setActive( self ):
self._iCamera.setActive( )
self._menuDimmer( )
 
def _keyObserver( self ):
# select and 5 keys for capture
if self._iKeyboard.pressed( EScancodeSelect ) or \
self._iKeyboard.pressed( EScancode5 ):
if self._iCamera.isViewerActive():
self._handleCommands( "CAPTURE" )
 
# key 1 to start the viewer
elif self._iKeyboard.pressed( EScancode1 ):
if not self._iCamera.isViewerActive( ):
self._handleCommands( "NEW" )
 
# 3 key for stoping the viewer
elif self._iKeyboard.pressed( EScancode3 ):
if self._iCamera.isViewerActive( ) and \
not self._iCamera.isSaved( ) :
self._handleCommands( "STOP" )
 
 
def _handleCommands( self, aCommand ):
if aCommand == "NEW":
self._iCamera.startViewFinder( )
self._menuDimmer( )
 
elif aCommand == "STOP":
self._iCamera.stopViewFinder( )
self._menuDimmer( )
 
elif aCommand == "CAPTURE":
appuifw.note(u'Please wait', 'info', 1)
self._iCamera.capture( )
self._menuDimmer( )
if self._iCamera.isSaved( ):
appuifw.note(u'Saved', 'info')
else:
appuifw.note(u'Failed', 'error')
 
elif aCommand == "EXIT":
__exit__()
 
def _menuDimmer( self ):
menu = []
if self._iCamera.isSaved( ):
menu.append( ( u'New...', lambda:self._handleCommands( "NEW" ) ) )
 
elif self._iCamera.isViewerActive( ):
menu.append( ( u'Capture', lambda:self._handleCommands( "CAPTURE" ) ) )
menu.append( ( u'Stop', lambda:self._handleCommands( "STOP" ) ) )
 
else:
menu.append( ( u'New...', lambda:self._handleCommands( "NEW" ) ) )
menu.append( ( u'Exit', lambda:self._handleCommands( "EXIT" ) ) )
 
appuifw.app.menu = menu
 
def __del__( self ):
# clean exit
self._iCamera.__del__( )
 
 
def __exit__():
camView.__del__( )
APP_LOCK.signal()
 
if __name__ == '__main__':
APP_LOCK = e32.Ao_lock( )
appuifw.app.title = u"Cam using View Finder "
appuifw.app.exit_key_handler = __exit__
camView = CameraView( )
camView.setActive( )
APP_LOCK.wait( )
This page was last modified on 8 May 2013, at 09:30.
45 page views in the last 30 days.

Was this page helpful?

Your feedback about this content is important. Let us know what you think.

 

Thank you!

We appreciate your feedback.

×