gr-air-modes/python/gui_model.py

#!/usr/bin/env python
# Copyright 2012 Nick Foster
# 
# This file is part of gr-air-modes
# 
# gr-air-modes is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3, or (at your option)
# any later version.
# 
# gr-air-modes is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
# 
# You should have received a copy of the GNU General Public License
# along with gr-air-modes; see the file COPYING.  If not, write to
# the Free Software Foundation, Inc., 51 Franklin Street,
# Boston, MA 02110-1301, USA.
#

# This file contains data models, view delegates, and associated classes
# for handling the GUI back end data model.

from PyQt4 import QtCore, QtGui
import air_modes
import threading, math, time

#fades the ICAOs out as their last report gets older,
#and display ident if available, ICAO otherwise
class ICAOViewDelegate(QtGui.QStyledItemDelegate):
    def paint(self, painter, option, index):
        #draw selection rectangle
        if option.state & QtGui.QStyle.State_Selected:
            painter.setBrush(QtGui.QPalette().highlight())
            painter.drawRect(option.rect)

        #if there's an ident available, use it. otherwise print the ICAO
        if index.model().data(index.model().index(index.row(), 9)) != QtCore.QVariant():
            paintstr = index.model().data(index.model().index(index.row(), 9)).toString()
        else:
            paintstr = index.model().data(index.model().index(index.row(), 0)).toString()
        last_report = index.model().data(index.model().index(index.row(), 1)).toDouble()[0]
        age = (time.time() - last_report)
        max_age = 60. #age at which it grays out
        #minimum alpha is 0x40 (oldest), max is 0xFF (newest)
        age = min(age, max_age)
        alpha = int(0xFF - (0xBF / max_age) * age)
        painter.setPen(QtGui.QColor(0, 0, 0, alpha))
        painter.drawText(option.rect.left()+3, option.rect.top(), option.rect.width(), option.rect.height(), option.displayAlignment, paintstr)

#the data model used to display dashboard data.
class dashboard_data_model(QtCore.QAbstractTableModel):
    def __init__(self, parent):
        QtCore.QAbstractTableModel.__init__(self, parent)
        self._data = []
        self.lock = threading.Lock()
        self._colnames = ["icao", "seen", "rssi", "latitude", "longitude", "altitude", "speed", "heading", "vertical", "ident", "type", "range", "bearing"]
        #custom precision limits for display
        self._precisions = [None, None, None, 6, 6, 0, 0, 0, 0, None, None, 2, 0]
        for field in self._colnames:
            self.setHeaderData(self._colnames.index(field), QtCore.Qt.Horizontal, field)
    def rowCount(self, parent=QtCore.QVariant()):
        return len(self._data)
    def columnCount(self, parent=QtCore.QVariant()):
        return len(self._colnames)
    def data(self, index, role=QtCore.Qt.DisplayRole):
        if not index.isValid():
            return QtCore.QVariant()
        if index.row() >= self.rowCount():
            return QtCore.QVariant()
        if index.column() >= self.columnCount():
            return QtCore.QVariant()
        if (role != QtCore.Qt.DisplayRole) and (role != QtCore.Qt.EditRole):
            return QtCore.QVariant()
        if self._data[index.row()][index.column()] is None:
            return QtCore.QVariant()
        else:
            #if there's a dedicated precision for that column, print it out with the specified precision.
            #this only works well if you DON'T have other views/widgets that depend on numeric data coming out.
            #i don't like this, but it works for now. unfortunately it seems like Qt doesn't give you a
            #good alternative.
            if self._precisions[index.column()] is not None:
                return QtCore.QVariant("%.*f" % (self._precisions[index.column()], self._data[index.row()][index.column()]))
            else:
                if self._colnames[index.column()] == "icao":
                    return QtCore.QVariant("%06x" % self._data[index.row()][index.column()]) #return as hex string
                else:
                    return QtCore.QVariant(self._data[index.row()][index.column()])

    def setData(self, index, value, role=QtCore.Qt.EditRole):
        self.lock.acquire()
        if not index.isValid():
            return False
        if index.row() >= self.rowCount():
            return False
        if index.column >= self.columnCount():
            return False
        if role != QtCore.Qt.EditRole:
            return False
        self._data[index.row()][index.column()] = value
        self.lock.release()

    #addRecord implements an upsert on self._data; that is,
    #it updates the row if the ICAO exists, or else it creates a new row.
    def addRecord(self, record):
        self.lock.acquire()
        icaos = [x[0] for x in self._data]
        if record["icao"] in icaos:
            row = icaos.index(record["icao"])
            for column in record:
                self._data[row][self._colnames.index(column)] = record[column]
            #create index to existing row and tell the model everything's changed in this row
            #or inside the for loop, use dataChanged on each changed field (might be better)
            self.dataChanged.emit(self.createIndex(row, 0), self.createIndex(row, len(self._colnames)-1))

        #only create records for ICAOs with ADS-B reports
        elif ("latitude" or "speed" or "ident") in record:
            #find new inserted row number
            icaos.append(record["icao"])
            newrowoffset = sorted(icaos).index(record["icao"])
            self.beginInsertRows(QtCore.QModelIndex(), newrowoffset, newrowoffset)
            newrecord = [None for x in xrange(len(self._colnames))]
            for col in xrange(0, len(self._colnames)):
                if self._colnames[col] in record:
                    newrecord[col] = record[self._colnames[col]]
            self._data.append(newrecord)
            self._data = sorted(self._data, key = lambda x: x[0]) #sort by icao
            self.endInsertRows()
        self.lock.release()
        self.prune()

    #weeds out ICAOs older than 5 minutes
    def prune(self):
        self.lock.acquire()
        for (index,row) in enumerate(self._data):
            if time.time() - row[1] >= 60:
                self.beginRemoveRows(QtCore.QModelIndex(), index, index)
                self._data.pop(index)
                self.endRemoveRows()
        self.lock.release()
                
class dashboard_output(air_modes.parse):
    def __init__(self, mypos, model):
        air_modes.parse.__init__(self, mypos)
        self.model = model
    def output(self, msg):
        [data, ecc, reference, timestamp] = msg.split()
        data = air_modes.modes_reply(long(data, 16))
        ecc = long(ecc, 16)
        rssi = 10.*math.log10(float(reference))
        msgtype = data["df"]
        now = time.time()
        newrow = {"rssi": rssi, "seen": now}
        if msgtype in [0, 4, 20]:
            newrow["altitude"] = air_modes.altitude.decode_alt(data["ac"], True)
            newrow["icao"] = ecc
            self.model.addRecord(newrow)
        
        elif msgtype == 17:
            icao = data["aa"]
            newrow["icao"] = icao
            subtype = data["ftc"]
            if subtype == 4:
                (ident, actype) = self.parseBDS08(data)
                newrow["ident"] = ident
                newrow["type"] = actype
            elif 5 <= subtype <= 8:
                (ground_track, decoded_lat, decoded_lon, rnge, bearing) = self.parseBDS06(data)
                newrow["heading"] = ground_track
                newrow["latitude"] = decoded_lat
                newrow["longitude"] = decoded_lon
                newrow["altitude"] = 0
                if rnge is not None:
                    newrow["range"] = rnge
                    newrow["bearing"] = bearing
            elif 9 <= subtype <= 18:
                (altitude, decoded_lat, decoded_lon, rnge, bearing) = self.parseBDS05(data)
                newrow["altitude"] = altitude
                newrow["latitude"] = decoded_lat
                newrow["longitude"] = decoded_lon
                if rnge is not None:
                    newrow["range"] = rnge
                    newrow["bearing"] = bearing
            elif subtype == 19:
                subsubtype = data["sub"]
                velocity = None
                heading = None
                vert_spd = None
                if subsubtype == 0:
                    (velocity, heading, vert_spd) = self.parseBDS09_0(data)
                elif 1 <= subsubtype <= 2:
                    (velocity, heading, vert_spd) = self.parseBDS09_1(data)
                newrow["speed"] = velocity
                newrow["heading"] = heading
                newrow["vertical"] = vert_spd

            self.model.addRecord(newrow)