252 lines
9.9 KiB
Python
252 lines
9.9 KiB
Python
import operator
|
|
import os
|
|
import pickle
|
|
import re
|
|
import threading
|
|
from collections import deque, namedtuple
|
|
from functools import reduce
|
|
|
|
import numpy as np
|
|
from django.conf import settings
|
|
from django.core.exceptions import ValidationError
|
|
from django.utils.translation import ugettext_lazy as _
|
|
|
|
from c3nav.mapdata.models import MapUpdate, Space
|
|
from c3nav.mapdata.utils.locations import CustomLocation
|
|
from c3nav.routing.router import Router
|
|
|
|
|
|
class Locator:
|
|
filename = os.path.join(settings.CACHE_ROOT, 'locator')
|
|
|
|
def __init__(self, stations, spaces):
|
|
self.stations = stations
|
|
self.spaces = spaces
|
|
|
|
@classmethod
|
|
def rebuild(cls, update):
|
|
stations = LocatorStations()
|
|
spaces = {}
|
|
for space in Space.objects.prefetch_related('wifi_measurements'):
|
|
new_space = LocatorSpace(
|
|
pk=space.pk,
|
|
points=(LocatorPoint.from_measurement(measurement, stations)
|
|
for measurement in space.wifi_measurements.all())
|
|
)
|
|
if new_space.points:
|
|
spaces[space.pk] = new_space
|
|
|
|
locator = cls(stations, spaces)
|
|
pickle.dump(locator, open(cls.build_filename(update), 'wb'))
|
|
return locator
|
|
|
|
@classmethod
|
|
def build_filename(cls, update):
|
|
return os.path.join(settings.CACHE_ROOT, 'locator_%s.pickle' % MapUpdate.build_cache_key(*update))
|
|
|
|
@classmethod
|
|
def load_nocache(cls, update):
|
|
return pickle.load(open(cls.build_filename(update), 'rb'))
|
|
|
|
cached = None
|
|
cache_update = None
|
|
cache_lock = threading.Lock()
|
|
|
|
@classmethod
|
|
def load(cls):
|
|
from c3nav.mapdata.models import MapUpdate
|
|
update = MapUpdate.last_processed_update()
|
|
if cls.cache_update != update:
|
|
with cls.cache_lock:
|
|
cls.cache_update = update
|
|
cls.cached = cls.load_nocache(update)
|
|
return cls.cached
|
|
|
|
def locate(self, scan, permissions=None):
|
|
router = Router.load()
|
|
restrictions = router.get_restrictions(permissions)
|
|
|
|
scan = LocatorPoint.clean_scan(scan, ignore_invalid_stations=True)
|
|
scan_values = LocatorPoint.convert_scan(scan, self.stations, create=False)
|
|
if not scan_values:
|
|
return None
|
|
|
|
# convert scan values
|
|
scan_values = {station_id: value**2 for station_id, value in scan_values.items()}
|
|
|
|
# get visible spaces
|
|
spaces = tuple(space for pk, space in self.spaces.items() if pk not in restrictions.spaces)
|
|
|
|
# find best point
|
|
best_station_id = max(scan_values.items(), key=operator.itemgetter(1))[0]
|
|
best_location = None
|
|
best_score = float('inf')
|
|
for space in spaces:
|
|
point, score = space.get_best_point(scan_values, needed_station_id=best_station_id)
|
|
if point is None:
|
|
continue
|
|
if score < best_score:
|
|
location = CustomLocation(router.spaces[space.pk].level, point.x, point.y,
|
|
permissions=permissions, icon='my_location')
|
|
best_location = location
|
|
best_score = score
|
|
|
|
return best_location
|
|
|
|
|
|
class LocatorStations:
|
|
def __init__(self):
|
|
self.stations = []
|
|
self.stations_lookup = {}
|
|
|
|
def get(self, bssid, ssid, frequency, create=False):
|
|
station_id = self.stations_lookup.get((bssid, None), None)
|
|
if station_id is not None:
|
|
station = self.stations[station_id]
|
|
station.frequencies.add(frequency)
|
|
elif create:
|
|
station = LocatorStation(bssid, ssid, set((frequency, )))
|
|
station_id = len(self.stations)
|
|
self.stations_lookup[(bssid, None)] = station_id
|
|
self.stations.append(station)
|
|
return station_id
|
|
|
|
|
|
class LocatorSpace:
|
|
no_signal = int(-90)**2
|
|
|
|
def __init__(self, pk, points):
|
|
self.pk = pk
|
|
self.points = tuple(points)
|
|
self.stations_set = reduce(operator.or_, (frozenset(point.values.keys()) for point in self.points), frozenset())
|
|
self.stations = tuple(self.stations_set)
|
|
self.stations_lookup = {station_id: i for i, station_id in enumerate(self.stations)}
|
|
|
|
self.levels = np.full((len(self.points), len(self.stations)), fill_value=self.no_signal, dtype=np.int64)
|
|
for i, point in enumerate(self.points):
|
|
for station_id, value in point.values.items():
|
|
self.levels[i][self.stations_lookup[station_id]] = int(value)**2
|
|
|
|
def get_best_point(self, scan_values, needed_station_id=None):
|
|
# check if this space knows the needed station id, otherwise no results here
|
|
if needed_station_id not in self.stations_set:
|
|
return None, None
|
|
|
|
# stations that this space knows
|
|
station_ids = frozenset(scan_values.keys()) & self.stations_set
|
|
penalty = 0
|
|
for station_id, value in scan_values.items():
|
|
if station_id not in self.stations_set:
|
|
penalty += (value - self.no_signal)**2
|
|
|
|
stations = tuple(self.stations_lookup[station_id] for station_id in station_ids)
|
|
values = np.array(tuple(scan_values[station_id] for station_id in station_ids), dtype=np.int64)
|
|
|
|
# acceptable points need to have a value for the needed_station_id
|
|
points = tuple(
|
|
np.argwhere(self.levels[:, self.stations_lookup[needed_station_id]] > self.no_signal).ravel()
|
|
)
|
|
if not points:
|
|
return None, None
|
|
|
|
scores = (np.sum(
|
|
(self.levels[np.array(points, dtype=np.uint32).reshape((-1, 1)), stations] - values)**2,
|
|
axis=1
|
|
)+penalty) / len(scan_values)
|
|
best_point_i = np.argmin(scores).ravel()[0]
|
|
best_point = points[best_point_i]
|
|
return self.points[best_point], scores[best_point_i]
|
|
|
|
|
|
class LocatorPoint(namedtuple('LocatorPoint', ('x', 'y', 'values'))):
|
|
@classmethod
|
|
def from_measurement(cls, measurement, stations: LocatorStations):
|
|
return cls(x=measurement.geometry.x, y=measurement.geometry.y,
|
|
values=cls.convert_scans(measurement.data, stations, create=True))
|
|
|
|
@classmethod
|
|
def convert_scan(cls, scan, stations: LocatorStations, create=False):
|
|
values = {}
|
|
for scan_value in scan:
|
|
if settings.WIFI_SSIDS and scan_value['ssid'] not in settings.WIFI_SSIDS:
|
|
continue
|
|
station_id = stations.get(bssid=scan_value['bssid'], ssid=scan_value['ssid'],
|
|
frequency=scan_value['frequency'], create=create)
|
|
if station_id is not None:
|
|
# todo: convert to something more or less linear
|
|
values[station_id] = scan_value['level']
|
|
return values
|
|
|
|
@classmethod
|
|
def convert_scans(cls, scans, stations: LocatorStations, create=False):
|
|
values_list = deque()
|
|
for scan in scans:
|
|
values_list.append(cls.convert_scan(scan, stations, create))
|
|
|
|
station_ids = reduce(operator.or_, (frozenset(values.keys()) for values in values_list), frozenset())
|
|
return {
|
|
station_id: cls.average(tuple(values[station_id] for values in values_list if station_id in values))
|
|
for station_id in station_ids
|
|
}
|
|
|
|
@staticmethod
|
|
def average(items):
|
|
return sum(items) / len(items)
|
|
|
|
valid_frequencies = frozenset((
|
|
2412, 2417, 2422, 2427, 2432, 2437, 2442, 2447, 2452, 2457, 2462, 2467, 2472, 2484,
|
|
5180, 5190, 5200, 5210, 5220, 5230, 5240, 5250, 5260, 5270, 5280, 5290, 5300, 5310, 5320,
|
|
5500, 5510, 5520, 5530, 5540, 5550, 5560, 5570, 5580, 5590, 5600, 5610, 5620, 5630, 5640,
|
|
5660, 5670, 5680, 5690, 5700, 5710, 5720, 5745, 5755, 5765, 5775, 5785, 5795, 5805, 5825
|
|
))
|
|
needed_keys = frozenset(('bssid', 'ssid', 'level', 'frequency'))
|
|
allowed_keys = needed_keys | frozenset(('last', ))
|
|
|
|
@classmethod
|
|
def clean_scans(cls, data, ignore_invalid_stations=False):
|
|
if not isinstance(data, list):
|
|
raise ValidationError(_('Invalid Scan. Scans list list not a list.'))
|
|
return tuple(cls.clean_scan(scan) for scan in data)
|
|
|
|
@classmethod
|
|
def clean_scan(cls, data, ignore_invalid_stations=False):
|
|
if not isinstance(data, list):
|
|
raise ValidationError(_('Invalid Scan. Scan not a list.'))
|
|
cleaned_scan = deque()
|
|
for scan_value in data:
|
|
try:
|
|
cleaned_scan.append(cls.clean_scan_value(scan_value))
|
|
except ValidationError:
|
|
if not ignore_invalid_stations:
|
|
raise
|
|
return tuple(cleaned_scan)
|
|
|
|
@classmethod
|
|
def clean_scan_value(cls, data):
|
|
if not isinstance(data, dict):
|
|
raise ValidationError(_('Invalid Scan. Scan value not a dictionary.'))
|
|
keys = frozenset(data.keys())
|
|
if (keys - cls.allowed_keys) or (cls.needed_keys - keys):
|
|
raise ValidationError(_('Invalid Scan. Missing or forbidden keys.'))
|
|
if not isinstance(data['bssid'], str):
|
|
raise ValidationError(_('Invalid Scan. BSSID not a String.'))
|
|
data['bssid'] = data['bssid'].upper()
|
|
if not re.match(r'^([0-9A-F]{2}:){5}[0-9A-F]{2}$', data['bssid']):
|
|
raise ValidationError(_('Invalid Scan. Invalid BSSID.'))
|
|
if not isinstance(data['level'], int) or not (-1 >= data['level'] >= -100):
|
|
raise ValidationError(_('Invalid Scan. Invalid RSSI/Level.'))
|
|
if data['frequency'] not in cls.valid_frequencies:
|
|
raise ValidationError(_('Invalid Scan. Not an allowed frequency.'))
|
|
if 'last' in keys and (not isinstance(data['last'], int) or data['last'] <= 0):
|
|
raise ValidationError(_('Invalid Scan. Invalid last timestamp.'))
|
|
return data
|
|
|
|
|
|
class LocatorStation:
|
|
def __init__(self, bssid, ssid, frequencies=()):
|
|
self.bssid = bssid
|
|
self.ssid = ssid
|
|
self.frequencies = set(frequencies)
|
|
|
|
def __repr__(self):
|
|
return 'LocatorStation(%r, %r, frequencies=%r)' % (self.bssid, self.ssid, self.frequencies)
|