vcs.maemo.org Git - wifihood/blob - wifiscanner/wifiview

   1 #!/usr/bin/env python
   2
   3 import gtk
   4 import gobject
   5
   6 import urllib2
   7 import math
   8
   9 import os
  10
  11 class mapWidget(gtk.Image):
  12
  13   def __init__(self):
  14
  15     gtk.Image.__init__(self)
  16
  17     # Maximum width should be 800, but actually gets reduced
  18     self.win_x , self.win_y = 800 , 480
  19
  20     p = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, True, 8, self.win_x, self.win_y)
  21     self.set_from_pixbuf(p)
  22
  23     zoom = 17
  24     lat = 40.40491
  25     lon = -3.6774
  26     self.reftile_x , self.reftile_y = self.lon2tilex( lon , zoom ) , self.lat2tiley( lat , zoom )
  27     self.zoom = zoom
  28     # Half the size of a tile
  29     self.refpix_x , self.refpix_y = 128 , 128
  30     self.refpix_x , self.refpix_y = 0 , 0
  31
  32     self.composeMap( zoom )
  33
  34   def lon2tilex ( self , lon , zoom ) :
  35     return int( ( lon + 180 ) / 360 * 2 ** zoom )
  36
  37   def lat2tiley ( self , lat , zoom ) :
  38     lat = lat * math.pi / 180
  39     return int( ( 1 - math.log( math.tan( lat ) + 1 / math.cos( lat ) ) / math.pi ) / 2 * 2 ** zoom )
  40
  41   def composeMap( self , zoom ) :
  42     center_x , center_y = self.win_x / 2 , self.win_y / 2
  43
  44     # To get the central pixel in the window center, we must shift to the tile origin
  45     center_x -= self.refpix_x
  46     center_y -= self.refpix_y
  47
  48     # Ranges should be long enough as to fill the screen
  49     # Maybe they should be decided based on self.win_x, self.win_y
  50     for i in range(-3,4) :
  51       for j in range(-3,4) :
  52         file = self.tilename( i , j , zoom )
  53         if file is None :
  54           pixbuf = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, False, 8, 256, 256 )
  55           pixbuf.fill( 0x00000000 )
  56         else :
  57           try :
  58             pixbuf = gtk.gdk.pixbuf_new_from_file( file )
  59           except gobject.GError , ex :
  60             print "Corrupted file %s" % ( file )
  61             os.unlink( file )
  62             #file = self.tilename( self.reftile_x + i , self.reftile_y + j , zoom )
  63             file = self.tilename( i , j , zoom )
  64             try :
  65               pixbuf = gtk.gdk.pixbuf_new_from_file( file )
  66             except :
  67               print "Total failure for tile for %s,%s" % ( self.reftile_x + i , self.reftile_y + j )
  68               pixbuf = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, False, 8, 256, 256 )
  69
  70         dest_x = 256 * i + center_x
  71         dest_y = 256 * j + center_y
  72
  73         init_x = 0
  74         size_x = 256
  75         if dest_x < 0 :
  76            init_x = abs(dest_x)
  77            size_x = 256 + dest_x
  78            dest_x = 0
  79         if dest_x + 256 > self.win_x :
  80            size_x = self.win_x - dest_x
  81
  82         init_y = 0
  83         size_y = 256
  84         if dest_y < 0 :
  85            init_y = abs(dest_y)
  86            size_y = 256 + dest_y
  87            dest_y = 0
  88         if dest_y + 256 > self.win_y :
  89            size_y = self.win_y - dest_y
  90
  91         if ( size_x > 0 and size_y > 0 ) and ( init_x < 256 and init_y < 256 ) :
  92             pixbuf.copy_area( init_x, init_y, size_x, size_y, self.get_pixbuf(), dest_x , dest_y )
  93         del(pixbuf)
  94
  95   def tilename ( self , x , y , zoom ) :
  96     file = self.tile2file( self.reftile_x + x , self.reftile_y + y , zoom )
  97     try :
  98       os.stat(file)
  99     except :
 100     #  if mapDownload :
 101       if False :
 102         try :
 103           # useful members : response.code, response.headers
 104           response = urllib2.urlopen( "http://tile.openstreetmap.org/%s/%s/%s.png" % ( zoom , x , y ) )
 105           if response.geturl() == "http://tile.openstreetmap.org/11/0/0.png" :
 106               return None
 107           fd = open( file , 'w' )
 108           fd.write( response.read() )
 109           fd.close()
 110         except :
 111           return None
 112       else :
 113         return None
 114     return file
 115
 116   def tile2file( self , tilex , tiley , zoom ) :
 117     basedir = "/home/user/MyDocs/.maps/OpenStreetMap I"
 118     rootdir = "%s/%s" % ( basedir , zoom )
 119     if not os.path.isdir( rootdir ) :
 120       os.mkdir(rootdir)
 121     rootsubdir = "%s/%s" % ( rootdir , tilex )
 122     if not os.path.isdir( rootsubdir ) :
 123       os.mkdir(rootsubdir)
 124     return "%s/%s.png" % ( rootsubdir , tiley )
 125
 126   def Shift( self , dx , dy ) :
 127     self.hide()
 128
 129     tile_x , tile_y = ( self.refpix_x - dx ) / 256 , ( self.refpix_y - dy ) / 256
 130     self.reftile_x += tile_x
 131     self.reftile_y += tile_y
 132
 133     self.refpix_x -= dx + 256 * tile_x
 134     self.refpix_y -= dy + 256 * tile_y
 135
 136     self.composeMap( self.zoom )
 137     self.show()
 138
 139   def Up( self ) :
 140     self.hide()
 141     self.reftile_y -= 1
 142     self.composeMap( self.zoom )
 143     self.show()
 144
 145   def Down( self ) :
 146     self.hide()
 147     self.reftile_y += 1
 148     self.composeMap( self.zoom )
 149     self.show()
 150
 151   def Right( self ) :
 152     self.hide()
 153     self.reftile_x += 1
 154     self.composeMap( self.zoom )
 155     self.show()
 156
 157   def Left( self ) :
 158     self.hide()
 159     self.reftile_x -= 1
 160     self.composeMap( self.zoom )
 161     self.show()
 162
 163 class MapWindow:
 164
 165     def delete_event(self, widget, event, data=None):
 166         # If you return FALSE in the "delete_event" signal handler,
 167         # GTK will emit the "destroy" signal. Returning TRUE means
 168         # you don't want the window to be destroyed.
 169         # This is useful for popping up 'are you sure you want to quit?'
 170         # type dialogs.
 171         print "delete event occurred"
 172
 173         # Change FALSE to TRUE and the main window will not be destroyed
 174         # with a "delete_event".
 175         return False
 176
 177     def destroy(self, widget, data=None):
 178         print "destroy signal occurred"
 179         gtk.main_quit()
 180
 181     def press_event ( self, widget, event, *args ) :
 182       # FIXME : Set only if far enough from borders
 183       border_x = 40
 184       border_y = 30
 185       print "press  ",event.get_coords(),event.get_root_coords()
 186       if event.x > border_x and event.y > border_y and event.x < ( self.size_x - border_x ) and event.y < ( self.size_y - border_y ) :
 187         self.click_x = event.x
 188         self.click_y = event.y
 189
 190     def release_event ( self, widget, event, *args ) :
 191       min_shift = 50
 192       print "unpress",event.get_coords(),event.get_root_coords()
 193       if self.click_x is not None and self.click_y is not None :
 194         delta_x = int( event.x - self.click_x )
 195         delta_y = int( event.y - self.click_y )
 196         shift = math.sqrt( delta_x * delta_x + delta_y * delta_y )
 197         if shift > min_shift :
 198           self.map.Shift(delta_x, delta_y)
 199         #  if delta_x > 100 :
 200         #    self.map.Left()
 201         #  elif delta_x < -100 :
 202         #    self.map.Right()
 203         #  elif delta_y > 100 :
 204         #    self.map.Up()
 205         #  elif delta_y < -100 :
 206         #    self.map.Down()
 207       self.click_x , self.click_y = None , None
 208
 209     def screen_event ( self, widget, event, *args ) :
 210       print "REDIOS",event
 211       print "      ",widget
 212       print "      ",args
 213
 214
 215     def on_button_press ( self, widget, event, *args ) :
 216       print "HOLA",event
 217
 218     def on_key_press ( self, widget, event, *args ) :
 219       if event.keyval == gtk.keysyms.Up :
 220           self.map.Up()
 221       elif event.keyval == gtk.keysyms.Down :
 222           self.map.Down()
 223       elif event.keyval == gtk.keysyms.Right :
 224           self.map.Right()
 225       elif event.keyval == gtk.keysyms.Left :
 226           self.map.Left()
 227       else :
 228           print "UNKNOWN",event.keyval
 229
 230     def __init__(self):
 231
 232         self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
 233
 234         self.window.connect("delete_event", self.delete_event)
 235         self.window.connect("destroy", self.destroy)
 236
 237         self.window.set_border_width(10)
 238
 239         self.window.connect("key-press-event", self.on_key_press)
 240
 241         # To get explicit GDK_BUTTON_PRESS instead of paired GDK_LEAVE_NOTIFY & GDK_ENTER_NOTIFY
 242 #        self.window.add_events(gtk.gdk.BUTTON_MOTION_MASK | gtk.gdk.BUTTON_PRESS_MASK | gtk.gdk.BUTTON_RELEASE_MASK | gtk.gdk.POINTER_MOTION_MASK)
 243         self.window.set_events( gtk.gdk.BUTTON_PRESS_MASK | gtk.gdk.BUTTON_RELEASE_MASK )
 244         #
 245 #        self.window.connect('motion_notify_event', self.screen_event)
 246         self.window.connect('button_press_event', self.press_event)
 247         self.window.connect('button_release_event', self.release_event)
 248         #
 249         self.map = mapWidget()
 250         self.window.add( self.map )
 251
 252         # and the window
 253         self.window.show_all()
 254
 255         self.size_x , self.size_y = 800 , 480
 256         self.click_x , self.click_y = None , None
 257
 258     def main(self):
 259         gtk.main()
 260
 261 if __name__ == "__main__":
 262     map = MapWindow()
 263     map.main()
 264