josch/epydial
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
epydial/gps_map_screen.py
josch 71b560030a initial commit
2014-06-24 10:34:08 +02:00

346 lines
12 KiB
Python
Raw Permalink Blame History

#!/usr/bin/env python
# -*- coding: utf-8 -*-
__author__ = "Johannes 'josch' Schauer <j.schauer@email.de>, M. Dietrich <mdt@pyneo.org>, F. Gau <fgau@pyneo.org>"
__version__ = "prototype"
__copyright__ = "Copyright (c) 2008 J. Schauer, 2008 M. Dietrich"
__license__ = "GPLv3"
from pyneo.codings import decode_json
import re
import evas
from edje import decorators
import math
from epydial import *
class GpsMapScreen():
def register_pyneo_callbacks(self):
PyneoController.register_callback("gps_position_change", self.on_gps_position_change)
PyneoController.register_callback("on_map_new_file", self.on_map_new_file)
PyneoController.register_callback("on_get_geocoding", self.on_get_geocoding)
class Tile(evas.Image):
def __init__(self, canvas):
evas.Image.__init__(self, canvas)
self.pass_events = True
#we need this to store the original position while the zoom animations
self.position = (0, 0)
self.size = 256, 256
self.fill = 0, 0, 256, 256
def set_position(self, x, y):
self.position = (x, y)
self.move(x, y)
def __init__(self, screen_manager, latitude=0.0, longitude=0.0, zoom=0.0, map_type="OsmStreet"):
self.canvas = screen_manager.get_evas()
# self.pass_events = True
# self.position = (0, 0)
self.size = 480, 640
# self.fill = 0, 0, 256, 256
# def set_position(self, x, y):
# self.position = (x, y)
# self.move(x, y)
self.buttons = {}
self.config = ConfigParser(INI_PATH).get_section_config('map')
self.map_type = self.config.get("map_type") or map_type
self.pymapd_cache = ConfigParser('/etc/pyneod.ini').get_section_config('map').get('cache_directory')
self.cache_directory = '/'.join([self.pymapd_cache, self.map_type, "%d/%d/%d"])
#mouse position
self.x_pos, self.y_pos = (0, 0)
#global variable for zooming
self.zoom_step = 0.0
#initial latitude, longitude, zoom
self.latitude = latitude or float(self.config.get('latitude'))
self.longitude = longitude or float(self.config.get('longitude'))
self.altitude = 0.0
self.kph = 0.0
self.course = 0.0
self.x = 0
self.y = 0
self.zoom = zoom or int(self.config.get('zoom'))
self.offset_x = 0
self.offset_y = 0
self.overlay = evas.Text(self.canvas, font=("Sans:style=Bold, Edje-Vera", 24), color="#808080")
self.overlay_text = "lat:%0.4f lon:%0.4f a:%0.f v:%0.f"
self.overlay.layer = 2
self.overlay.on_mouse_up_add(self.on_edje_signal_dialer_status_triggered)
self.geo_text = evas.Text(self.canvas, font=("Sans:style=Bold, Edje-Vera", 18), color="#808080")
self.geo_text.layer = 2
self.geo_text.pos = (0, 30)
self.pinpoint = evas.Rectangle(self.canvas, pos=(238, 318), size=(4, 4), color="#ff0000")
self.pinpoint.layer = 2
self.arrow = evas.Image(self.canvas)
self.arrow.geometry = 190, 270, 100, 100
self.arrow.fill = 0, 0, 100, 100
self.arrow.layer = 2
self.arrow.pass_events = True
for pos, text in enumerate(["back", "player-minus", "player-plus", "info"]):
self.buttons[text] = self.init_button(text, (pos+1)*16+pos*100, 524, 100, 100)
#calculate size of tile raster
self.border_x = int(math.ceil(self.size[0]/256.0))
self.border_y = int(math.ceil(self.size[1]/256.0))
self.mouse_down = False
self.animate = False
self.fix = False
self.icons = []
self.init_icons()
self.set_current_tile(self.latitude, self.longitude, self.zoom)
def init_button(self, name, x, y, dx, dy):
def button_callback(source, event):
if name == 'back':
PyneoController.show_gps_status_screen()
elif name == "player-minus" and not self.animate:
ecore.timer_add(0.05, self.animate_zoom_out)
elif name == "player-plus" and not self.animate:
ecore.timer_add(0.05, self.animate_zoom_in)
elif name == "info":
PyneoController.get_geocoding(self.latitude, self.longitude)
print '---', name
button = evas.Image(self.canvas, pos=(x,y), size=(dx,dy), file="%s%s.png" % (THEME_IMAGES, name))
button.fill = 0, 0, dx, dy
button.layer = 2
button.on_mouse_up_add(button_callback)
return button
def on_gps_position_change(self, status):
if status:
self.fix = True
self.altitude = float(status.get('altitude', self.altitude))
self.kph = float(status.get('speed', self.kph))
if status.get('course', 0):
self.course = float(status.get('course', self.course))
self.arrow.show()
self.arrow.file_set('/'.join([IMAGE_FILES_PATH, "map", "arrow%02d.png"%(round(self.course/15)%24)]))
else:
self.course = 0.0
if not self.animate:
self.latitude = float(status.get('latitude', self.latitude))
self.longitude = float(status.get('longitude', self.longitude))
self.arrow.file_set('/'.join([IMAGE_FILES_PATH, "map", "arrow%02d.png"%int(self.course/15)]))
self.set_current_tile(self.latitude, self.longitude, self.zoom)
else:
self.fix = False
self.altitude = 0.0
self.kph = 0.0
self.course = 0.0
self.arrow.hide()
if not self.animate:
self.overlay.text = self.overlay_text%(self.latitude, self.longitude, self.altitude, self.kph)
def on_get_geocoding(self, status):
address_text = re.findall(r'address.*?\n', status['geo'].encode('utf-8'))
self.geo_text.text = address_text[0][11:]
# m = decode_json(status['geo'])
# for item in m('Placemark'):
# print 'MMMMMM:', item
def on_edje_signal_dialer_status_triggered(self, edje, emission, source):
if source == "label" and not self.animate:
maps_avail = PyneoController.map_tiles.keys()
self.map_type = maps_avail[(maps_avail.index(self.map_type)+1)%len(maps_avail)]
self.cache_directory = '/'.join([self.pymapd_cache, self.map_type, "%d/%d/%d"])
self.init_redraw()
print '--- map type: ', self.map_type
def on_map_new_file(self, d):
for filename, info in d.items():
if info.get("state") != "DOWNLOADED":
print "ERROR", filename, info
else:
assert filename.startswith('file://')
filename = filename[7:]
parts = filename.split("/")
x = int(parts[-2])
y = int(parts[-1])
for icon in self.not_downloaded_tiles:
if icon.x == x and icon.y == y:
icon.file_set(filename)
def hide(self):
for icon in self.icons:
icon.hide()
self.overlay.hide()
self.geo_text.hide()
self.arrow.hide()
self.pinpoint.hide()
for text in ["back", "player-plus", "player-minus", "info"]:
self.buttons[text].hide()
# when to store current settings permanently?
# self.config.set('map_type', self.map_type)
# self.config.set('longitude', self.longitude)
# self.config.set('latitude', self.latitude)
# self.config.set('zoom', self.zoom)
# self.config.config.save()
def show(self):
for icon in self.icons:
icon.show()
self.overlay.show()
self.geo_text.show()
self.pinpoint.show()
if self.fix:
self.arrow.show()
for text in ["back", "player-plus", "player-minus", "info"]:
self.buttons[text].show()
#jump to coordinates
def set_current_tile(self, latitude, longitude, zoom):
#update shown coordinates everytime they change
self.overlay.text = self.overlay_text%(latitude, longitude, self.altitude, self.kph)
# self.overlay.part_text_set("zoom", str(zoom))
x = (longitude+180)/360 * 2**zoom
y = (1-math.log(math.tan(latitude*math.pi/180) + 1/math.cos(latitude*math.pi/180))/math.pi)/2 * 2**zoom
offset_x, offset_y = int((x-int(x))*256), int((y-int(y))*256)
#only redraw if x, y, zoom, offset_x or offset_y differ from before
if int(x) != int(self.x) \
or int(y) != int(self.y) \
or zoom != self.zoom \
or offset_x != self.offset_x \
or offset_y != self.offset_y:
self.zoom = zoom
self.x = x
self.y = y
self.offset_x, self.offset_y = offset_x, offset_y
self.init_redraw()
def init_icons(self):
#clean up
for icon in self.icons:
icon.delete()
self.icons = []
#fill
for i in xrange((2*self.border_x+1)*(2*self.border_y+1)):
self.icons.append(GpsMapScreen.Tile(self.canvas))
def init_redraw(self):
self.not_downloaded_tiles = []
for i in xrange(2*self.border_x+1):
for j in xrange(2*self.border_y+1):
k = (2*self.border_y+1)*i+j
x = int(self.x)+i-self.border_x
y = int(self.y)+j-self.border_y
self.icons[k].x = x
self.icons[k].y = y
self.icons[k].set_position((i-self.border_x)*256+self.size[0]/2-self.offset_x, (j-self.border_y)*256+self.size[1]/2-self.offset_y)
filename = self.cache_directory%(self.zoom, self.x+i-self.border_x, self.y+j-self.border_y)
if exists(filename):
self.icons[k].file_set(filename)
else:
self.icons[k].file_set('/'.join([IMAGE_FILES_PATH, "map", "404.png"]))
self.not_downloaded_tiles.append(self.icons[k])
self.current_pos = (0, 0)
if self.not_downloaded_tiles:
PyneoController.map_request_tiles(self.latitude, self.longitude, self.zoom, self.map_type)
def update_coordinates(self):
x = int(self.x) + (self.offset_x-self.current_pos[0])/256.0
y = int(self.y) + (self.offset_y-self.current_pos[1])/256.0
self.longitude = (x*360)/2**self.zoom-180
n = math.pi*(1-2*y/2**self.zoom)
self.latitude = 180/math.pi*math.atan(0.5*(math.exp(n)-math.exp(-n)))
self.overlay.text = self.overlay_text%(self.latitude, self.longitude, self.altitude, self.kph)
# self.overlay.part_text_set("zoom", str(self.zoom))
def zoom_in(self, zoom):
for icon in self.icons:
x = (1+zoom)*(icon.position[0]-self.size[0]/2)+self.size[0]/2
y = (1+zoom)*(icon.position[1]-self.size[1]/2)+self.size[1]/2
icon.geometry = int(x), int(y), 256+int(256*zoom), 256+int(256*zoom)
icon.fill = 0, 0, 256+int(256*zoom), 256+int(256*zoom)
def zoom_out(self, zoom):
for icon in self.icons:
x = (1-zoom*0.5)*(icon.position[0]-self.size[0]/2)+self.size[0]/2
y = (1-zoom*0.5)*(icon.position[1]-self.size[1]/2)+self.size[1]/2
icon.geometry = int(x), int(y), 256-int(256*zoom*0.5), 256-int(256*zoom*0.5)
icon.fill = 0, 0, 256-int(256*zoom*0.5), 256-int(256*zoom*0.5)
def animate_zoom_in(self):
if self.zoom < 18:
self.animate = True
if self.zoom_step < 1.0:
self.zoom_in(self.zoom_step)
self.zoom_step+=0.125
return True
self.zoom_step = 0.0
self.set_current_tile(self.latitude, self.longitude, self.zoom+1)
for icon in self.icons:
icon.size = 256, 256
icon.fill = 0, 0, 256, 256
self.animate = False
return False
def animate_zoom_out(self):
if self.zoom > 5:
self.animate = True
if self.zoom_step < 1.0:
self.zoom_out(self.zoom_step)
self.zoom_step+=0.125
return True
self.zoom_step = 0.0
self.set_current_tile(self.latitude, self.longitude, self.zoom-1)
for icon in self.icons:
icon.size = 256, 256
icon.fill = 0, 0, 256, 256
self.animate = False
return False
@decorators.signal_callback("mouse,down,1", "*")
def on_mouse_down(self, emission, source):
if not self.animate:
self.x_pos, self.y_pos = self.canvas.pointer_canvas_xy
self.mouse_down = True
@decorators.signal_callback("mouse,up,1", "*")
def on_mouse_up(self, emission, source):
self.mouse_down = False
if not self.animate:
#redraw if moved further than one tile in each direction 'cause the preoload will only download one tile further than requested
if abs(self.current_pos[0]) > 256 or abs(self.current_pos[1]) > 256:
self.x = int(self.x) + (self.offset_x-self.current_pos[0])/256.0
self.y = int(self.y) + (self.offset_y-self.current_pos[1])/256.0
self.offset_x, self.offset_y = int((self.x-int(self.x))*256), int((self.y-int(self.y))*256)
self.update_coordinates()
self.init_redraw()
if abs(self.current_pos[0]) > 0 or abs(self.current_pos[1]) > 0:
#on mouse up + move: update current coordinates
self.update_coordinates()
if self.not_downloaded_tiles:
PyneoController.map_request_tiles(self.latitude, self.longitude, self.zoom, self.map_type)
@decorators.signal_callback("mouse,move", "*")
def on_mouse_move(self, emission, source):
if self.mouse_down and not self.animate and not self.fix:
x_pos, y_pos = self.canvas.pointer_canvas_xy
delta_x = self.x_pos - x_pos
delta_y = self.y_pos - y_pos
self.x_pos, self.y_pos = x_pos, y_pos
for icon in self.icons:
icon.set_position(icon.pos[0]-delta_x, icon.pos[1]-delta_y)
self.current_pos = (self.current_pos[0]-delta_x, self.current_pos[1]-delta_y)
# vim:tw=0:nowrap
Reference in a new issue View git blame Copy permalink