PyFT8 3.6.2__tar.gz → 3.6.4__tar.gz

{pyft8-3.6.2 → pyft8-3.6.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyFT8
-Version: 3.6.2
+Version: 3.6.4
 Summary: FT8 Decoding and Encoding in Python with test/loopback code
 Author-email: G1OJS <g1ojs@yahoo.com>
 License-Expression: GPL-3.0-or-later
@@ -110,11 +110,11 @@ upload = Y
 2m = 144.174
 ```
 
-## Performance Compared with FT8_lib and WSJT-x
+## Performance Compared with WSJT-x
 
-The image below shows the number of decodes from PyFT8, WSJT-x V2.7.0 running in NORM mode, and FT8_lib, using the same 10 minutes of busy 20m audio that is used to test ft8_lib. 
+The image below shows the number of decodes from PyFT8, WSJT-x V2.7.0 running in NORM mode, using the same 10 minutes of busy 20m audio that is used to test ft8_lib. On this dataset, WSJT-x performs almost the same on DEEP mode as it does on NORM, and both beat PyFT8. However, PyFT8 gets very close to WSJT-x's performance on FAST mode.
 
-<img width="900" height="898" alt="batch test performance" src="https://github.com/user-attachments/assets/513d4121-5483-4e7b-81df-785dc4db3d37" />
+<img width="900" height="900" alt="live playback vs wsjtx_v2 7 0" src="https://github.com/user-attachments/assets/853e98b2-5b9b-4241-b5f3-181fe193642e" />
 
 ## Limitations
 PyFT8 doesn't decode / encode *all* message types. The table below shows which are handled.

pyft8-3.6.4/PyFT8/gui.py

@@ -0,0 +1,311 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib import rcParams
+import queue
+from matplotlib.widgets import Button
+from PyFT8.time_utils import time_utils
+
+rcParams['toolbar'] = 'None'
+MAIN_TEXT_COLOR = '#f0f9fa'
+TEXT_BACKGROUND_COLOR = '#2a2b2b'
+INFO_TEXT_COLOR = 'white'
+BUTTONCOLOR = 'grey'
+HOVERCOLOR = 'darkgreen'
+ACTIVE_BUTTON_COLOR = 'cyan'
+INACTIVE_BUTTON_COLOR = '#edeef0'
+MAX_FONT_SIZE_MAIN = 10
+L = {'pmargin':0.04, 'sidebar_width': 0.17, 'banner_height':0.1, 'vsep1':0.01, 'hsep1':0.02}
+
+def add_my_axes(fig, pos):
+    ax = fig.add_axes(pos)
+    ax.set_xticks([])
+    ax.set_yticks([])
+    ax.set_facecolor(TEXT_BACKGROUND_COLOR)
+    return ax
+
+MESSAGE_TYPES = {'generic':{'bg':'blue', 'fg':'white', 'alpha':0.5}, 'CQ':{'bg':'green', 'fg':'white', 'alpha':0.8},
+                 'from_me': {'bg':'yellow', 'fg':'black', 'alpha':0.95}, 'to_me':{'bg':'red', 'fg':'white', 'alpha':0.9}} 
+class Msg_box:
+    def __init__(self, fig, ax, x, y, w, h, message):
+        from matplotlib.patches import Rectangle
+        self.fig, self.ax = fig, ax
+        message_type_params = MESSAGE_TYPES[message['message_type']]
+        rect = Rectangle((x, y), w, h, edgecolor='lime', lw=2)
+        self.patch = self.ax.add_patch(rect)
+        self.patch.set_visible(False)
+        text_inst = self.ax.text(x, y+1, message['display_text'], fontsize='small', fontweight = 'bold' )
+        text_inst.set_visible(False)
+        text_inst.set_color(message_type_params['fg'])
+        self.patch.set_facecolor(message_type_params['bg'])
+        self.patch.set_alpha(message_type_params['alpha'])
+        self.message = message
+        self.cycle = message['their_tx_cycle']
+        self.artists = [self.patch, text_inst]
+        for a in self.artists:
+            a.set_visible(True)
+
+    def contains(self, x, y):
+        if self.patch.get_visible():
+            return self.patch.get_extents().contains(x, y)
+
+    def draw(self):
+        for a in self.artists:
+            self.ax.draw_artist(a)
+
+    def hide(self):
+        for a in self.artists:
+            a.set_visible(False)
+
+    def remove(self):
+        for a in self.artists:
+            a.set_visible(False)
+            a.remove()
+            self.artists.remove(a)
+        self = None
+
+class Panel:
+    def __init__(self, fig, pos):
+        self.fig = fig
+        self.ax = self.fig.add_axes(pos)
+        self.ax.set_xticks([])
+        self.ax.set_yticks([])
+        self.ax.set_facecolor(TEXT_BACKGROUND_COLOR)
+        box_h = self.ax.get_window_extent().height
+        font_h = 10
+        self.nlines = int(0.5*box_h / font_h)
+        self.artists = []
+
+    def clear(self):
+        for a in self.artists:
+            a.set_visible(False)
+            a.remove()
+        self.artists = [a for a in self.artists if a.get_visible()]
+
+    def print_row(self, row_text, row_number, color = None):
+        a = self.ax.text(0.03, 0.03+(self.nlines - row_number)/self.nlines, row_text)
+        a.set_fontfamily('monospace')
+        if color is not None:
+            a.set_color(color)
+        self.artists.append(a)
+        self.ax.draw_artist(a)
+
+class ButtonBox:
+    def __init__(self, fig, box, btn_pc = 30, btn_text = ' ', info_text = ' '):
+        self.id = btn_text
+        btnbox, infobox = box.copy(), box.copy()
+        btnbox[2] = box[2] * btn_pc /100
+        infobox[2] = box[2] * (100-btn_pc) /100
+        infobox[0] = box[0] + box[2] * (btn_pc /100)
+        self.btn_axs = add_my_axes(fig, btnbox)
+        self.btn_axs.set_facecolor(BUTTONCOLOR)
+        self.bbox = self.btn_axs.bbox
+        self.btn_widg = Button(self.btn_axs, btn_text, color = BUTTONCOLOR, hovercolor = HOVERCOLOR)
+        self.info_axs = add_my_axes(fig, infobox)
+        self.info_art = self.info_axs.text(0.03, 0.5, info_text, color = INFO_TEXT_COLOR, verticalalignment = 'center', clip_on = True)        
+        self.state_is_active = None
+        self.set_state(False)
+
+    def set_state(self, is_active: bool):
+        if is_active != self.state_is_active:
+            self.state_is_active = is_active
+            color = ACTIVE_BUTTON_COLOR if is_active else INACTIVE_BUTTON_COLOR
+            self.btn_widg.label.set_color(color)
+            self.set_info_text(info_text = None, color = color)
+
+    def set_info_text(self, info_text, color = None):
+        if info_text is not None:
+            self.info_art.set_text(info_text)
+        if color is not None:
+            self.info_art.set_color(color)
+
+class Gui:
+    def __init__(self, message_broker, rig_control, console_print, configured_bands, hearing_me_since_mins = 5):
+        self.hearing_me_since_mins = hearing_me_since_mins
+        self.waterfall_data = message_broker.waterfall_data
+        self.history = message_broker.history
+        self.qso_manager = None
+        self.configured_bands = configured_bands
+        self.console_print = console_print
+        self.myCall, self.myGrid = message_broker.myCall, message_broker.myGrid
+        self.band_info = {'current_band': None, 'fMHz':0, 'time_set':0}
+        
+        self.plt = plt
+        self.fig = plt.figure(figsize = (10,10), facecolor=(.18, .71, .71, 0.4))
+        self.fig.canvas.manager.set_window_title('PyFT8 by G1OJS')
+        self.wf_top = 1-L['pmargin']-L['banner_height']-L['vsep1']
+        self.wf_left = L['pmargin']+L['sidebar_width']+L['hsep1']
+        self.needs_redraw = False
+
+        self.ax_wf = add_my_axes(self.fig, [self.wf_left, L['pmargin'], 1-self.wf_left-L['pmargin'], self.wf_top-L['pmargin']])
+        self.image = self.ax_wf.imshow(self.waterfall_data['data'],vmax=120,vmin=90,origin='lower',interpolation='none', aspect = 'auto')
+
+        self.home_panel = Panel(self.fig, [L['pmargin'], self.wf_top+L['vsep1'], L['sidebar_width'], L['banner_height']])
+        ax = self.home_panel.ax
+        ax.draw_artist(ax.text(-0.15,0.75,'Tx'))
+        ax.draw_artist(ax.text(-0.15,0.125,'Rx'))
+       
+        self.hearing_page = 0
+        self.msg_boxes = []
+        self.button_boxes = []
+
+        bh, bsep = 0.02, 0.002
+        bx, bw = L['pmargin'], L['sidebar_width']
+        bxs = self.button_boxes
+        self.button_boxes.append(ButtonBox(self.fig, [bx, self.wf_top - (len(bxs)+1)*bh + bsep, bw, bh-bsep], btn_text = "CQ", btn_pc = 100) )
+        self.button_boxes.append(ButtonBox(self.fig, [bx, self.wf_top - (len(bxs)+1)*bh + bsep, bw, bh-bsep], btn_text = "Repeat last", btn_pc = 100) )
+        self.button_boxes.append(ButtonBox(self.fig, [bx, self.wf_top - (len(bxs)+1)*bh + bsep, bw, bh-bsep], btn_text = "Tx off", btn_pc = 100) )           
+        for band in self.configured_bands:
+            self.button_boxes.append(ButtonBox(self.fig, [bx, self.wf_top - (len(self.button_boxes)+1) * bh + bsep, bw, bh-bsep], btn_pc = 30, btn_text = band))
+            
+        hm_top = self.wf_top - (len(self.button_boxes)+2) * bh + bsep - L['vsep1']
+
+        self.console = Panel(self.fig, [self.wf_left, self.wf_top+L['vsep1'], 1-self.wf_left-L['pmargin'], L['banner_height']])
+        self.console_rows_text = None
+        self.hearing_panel = Panel(self.fig, [L['pmargin'], L['pmargin'], L['sidebar_width'], hm_top])
+
+        self.cid = self.fig.canvas.mpl_connect('button_press_event', self._oncanvasclick)
+
+    def main_loop(self):
+        last_ptr = 0
+        self.plt.show(block = False)
+        while True:
+            self.image.set_data(self.waterfall_data['data'])
+            if self.needs_redraw:
+                self.needs_redraw = False
+                plt.pause(0.01)
+            else:
+                self.ax_wf.draw_artist(self.image)
+                for mb in self.msg_boxes:
+                    mb.draw()
+                self.fig.canvas.update()
+                self.fig.canvas.flush_events()
+
+    def before_search(self, curr_cycle):
+        self._hide_msg_boxes(curr_cycle)
+        
+    def after_search(self,curr_cycle):
+        self._refresh_hearing()
+        self._refresh_band_buttons()
+        self._refresh_home_panel()
+        self._clear_msg_boxes(curr_cycle)
+
+    def display_message(self, message):
+        x = int(message['t0'] / self.waterfall_data['dt'] + message['their_tx_cycle'] * self.waterfall_data['pixels_per_cycle'])
+        y = int(message['fHz'] / self.waterfall_data['df'])
+        mb = Msg_box(self.fig, self.ax_wf, x, y, self.waterfall_data['sig_w'], self.waterfall_data['sig_h'], message)
+        self.msg_boxes.append(mb)
+        
+    def get_band_info(self):
+        return self.band_info
+
+    def register_qso_manager(self, qsm):
+        self.qso_manager = qsm
+
+    def set_bandstats_title(self, txt):
+        self.home_panel.ax.set_title(txt, fontsize = 10)
+        
+    def update_console(self, text, color):
+        if self.console_rows_text is None:
+            self.console_rows_text = [{'text':'','color':'white'} for i in range(self.console.nlines)]
+        self.console_rows_text[1:] = self.console_rows_text[:-1]
+        self.console_rows_text[0] = {'text':text,'color':color}
+        self.console.clear()
+        for row_number, row_text in enumerate(self.console_rows_text):
+            self.console.print_row(row_text['text'], self.console.nlines - row_number,
+                                   color = row_text['color'])
+        self.needs_redraw = True
+
+    def _set_band(self, band):
+        if band in self.configured_bands:
+            self.band_info = {'current_band':band, 'fMHz':self.configured_bands[band], 'time_set':time_utils.time()}
+            self.console_print(f"[PyFT8] Set band: {self.band_info['current_band']} {self.band_info['fMHz']}")
+
+    def _oncanvasclick(self, clickargs):
+        #print(f"Click at {time_utils.cycle_time():6.2f}")
+         
+        if clickargs.inaxes is self.ax_wf:
+            for mb in self.msg_boxes:
+                if mb.contains(clickargs.x, clickargs.y):
+                    self.console_print(f"[GUI] Clicked on message '{mb.message['msg_text']}'")
+                    self.qso_manager.on_click({'action':"MESSAGE_CLICK", 'message':mb.message})
+                    return
+        for bb in self.button_boxes:
+            if bb.bbox.contains(clickargs.x, clickargs.y):
+                if bb.id[:-1].isnumeric():
+                    self.needs_redraw = True
+                    self._set_band(bb.id)
+                    self.qso_manager.on_click({'action':"SET_BAND", 'fMHz':self.configured_bands[bb.id]})
+                    self.after_search(curr_cycle = None)
+                else:
+                    action = ["CQ", "RPT_LAST", "TX_OFF"][['CQ', 'Repeat last', 'Tx off'].index(bb.id)]
+                    self.qso_manager.on_click({'action':action})
+
+    def _hide_msg_boxes(self, curr_cycle):
+        to_hide = [mb for mb in self.msg_boxes if mb.cycle == curr_cycle]
+        for mb in to_hide:
+            mb.hide()
+        self.needs_redraw = True
+
+    def _clear_msg_boxes(self, curr_cycle = None):
+        to_remove = [mb for mb in self.msg_boxes if mb.cycle == curr_cycle or curr_cycle is None]
+        self.msg_boxes = [mb for mb in self.msg_boxes if mb.cycle != curr_cycle]
+        for mb in to_remove:
+            mb.remove()
+        self.needs_redraw = True
+
+    def _text_row(self, ax, x, y, text = '', color = 'white', **args):
+        art = ax.text(x, y, text, color = color)
+        art.set_fontfamily('monospace')
+        return art
+   
+    def _refresh_home_panel(self):
+        current_band = self.band_info['current_band']
+        if current_band is not None and self.history is not None:
+            if current_band in self.history.home_most_remotes:
+                tx_lead,  rx_lead = self.history.home_most_remotes[current_band]
+                n_spotted, n_spotting = self.history.get_spot_counts(current_band, self.myCall)
+                self.home_panel.clear()
+                self.home_panel.print_row(f"{self.myCall:<7} {tx_lead[0]:<7}", 1, color = '#ff756b' )
+                self.home_panel.print_row(f"{n_spotting:<7} {tx_lead[1]:<7}", 2, color = '#ff756b' )
+                self.home_panel.print_row(f"{self.myCall:<7} {rx_lead[0]:<7}", 4, color = '#b6f0c6' )
+                self.home_panel.print_row(f"{n_spotted:<7} {rx_lead[1]:<7}", 5, color = '#b6f0c6' )
+
+    def _refresh_band_buttons(self):
+        current_band = self.band_info['current_band']
+        grd = self.myGrid[:4]
+        for bb in self.button_boxes:
+            bb.set_state(bb.id == current_band)
+            if bb.id in self.history.home_activity:
+                cnts = self.history.home_activity[bb.id]
+                bb.set_info_text(f"{cnts[0]}Tx, {cnts[1]}Rx")
+        self.needs_redraw = True
+
+    def _refresh_hearing(self):
+        current_band = self.band_info['current_band']
+        if current_band is not None and self.history is not None:
+            historic_data = self.history.hearing_me.data if self.hearing_page  == 1 else self.history.heard_by_me.data
+            new_calls_data = self.history.hearing_me_new if self.hearing_page  == 1 else self.history.heard_by_me_new
+            timewindow_str = f"<{self.hearing_me_since_mins:.0f} mins"
+            title_txt = f"Hearing me {timewindow_str}" if self.hearing_page==1 else f"Heard by me {timewindow_str}"
+            self.hearing_panel.clear()
+            self.hearing_panel.print_row(title_txt, 2, color = 'white')
+            if current_band in historic_data:
+                tnow = time_utils.time()
+                band_rpts = historic_data[current_band]
+                calls_now = [call for call in band_rpts if (tnow - band_rpts[call]['t']) < 60*self.hearing_me_since_mins]
+                calls_now.sort(key = lambda c: band_rpts[c]['t'], reverse = True)
+                subtitle_txt = f"{len(calls_now)}/{len(band_rpts)} now/ever"
+                self.hearing_panel.print_row(subtitle_txt, 3, color = 'white')
+                for i, remote_call in enumerate(calls_now[:self.hearing_panel.nlines - 3]):
+                    rpt = band_rpts[remote_call]
+                    row_txt = f"{remote_call:<7} {self.history.get_geo_text(remote_call)}"
+                    color = 'white' if self.history.is_in_new_alert(current_band, remote_call, new_calls_data) else 'lime'
+                    self.hearing_panel.print_row(row_txt, i+4, color = color)            
+        self.hearing_page = (self.hearing_page +1 )%2
+
+
+
+
+
+
+        

{pyft8-3.6.2 → pyft8-3.6.4}/PyFT8/message_broker.py

@@ -22,28 +22,25 @@ class Broker():
     def process_message(self, message_dict):
         hail, their_call, grid_rpt = message_dict['hail'], message_dict['their_call'], message_dict['grid_rpt']
         cyclestart_string, their_snr = message_dict['cyclestart_string'], message_dict['their_snr']
-        m = message_dict
-        screen_format = f"{cyclestart_string} {their_snr} {m['dt']:4.1f} {m['fHz']:4.0f} ~ {hail} {their_call} {grid_rpt}"
-        print(f"{screen_format:50s} decoded@ {m['decode_completed']:5.1f}s, dec = {m['decode_status']}")
-
         mtype_val = 0 + 1*(their_call == self.myCall) + 2*(hail == self.myCall) + 3*(their_call != self.myCall and hail.startswith('CQ'))
         mtype = ['generic', 'from_me', 'to_me', 'CQ'][mtype_val]        
         message_dict.update( {'message_type':mtype, 'display_text':f"{hail} {their_call} {grid_rpt}",
                               'priority':(mtype == 'to_me' or mtype == 'CQ')} )
-        
         if self.history:
             current_band = self.gui.get_band_info()['current_band'] 
             hearing_me, wb_text, geo_text = self.history.get_message_extra_info(their_call, current_band)
             display_text = f"{message_dict['hail']} {message_dict['their_call']} {message_dict['grid_rpt']} {hearing_me} {wb_text} {geo_text}"
             message_dict.update( {'hearing_me':hearing_me, 'wb_text':wb_text, 'geo_text':geo_text, 'display_text':display_text } )            
+
         if message_dict['priority']:
             if self.gui:
                 self.gui.display_message(message_dict)
-
-        self.message_queue_non_time_critical.put(message_dict)
-
         if self.on_decode:
             self.on_decode(message_dict)
+        m = message_dict
+        screen_format = f"{cyclestart_string} {their_snr} {m['dt']:4.1f} {m['fHz']:4.0f} ~ {hail} {their_call} {grid_rpt}"
+        print(f"{screen_format:50s} decoded@ {m['decode_completed']:5.1f}s, dec = {m['decode_status']}")
+        self.message_queue_non_time_critical.put(message_dict)
 
     def _process_message_ntc(self):
         while True:

{pyft8-3.6.2 → pyft8-3.6.4}/PyFT8/pyft8.py

@@ -11,7 +11,7 @@ from PyFT8.databases import ADIF
 from PyFT8.qso_manager import QSO_manager
 from PyFT8.message_broker import Broker
 
-VER = '3.6.2'
+VER = '3.6.4'
 PSKR_REFRESH_MINS = 20
 message_broker = None
 
@@ -129,12 +129,13 @@ def cli():
         message_broker.soundcard_out = soundcard_out
         message_broker.adif_logging = ADIF(f"{config_folder}/PyFT8.adi")
         message_broker.history = History(config_folder, myCall, myGrid, config['gui']['loc'])
-        configured_bands = []
-        for b,f in config['bands'].items():
-            configured_bands.append({'band':b, 'fMHz':f})
+        configured_bands = {}
+        for b, f in config['bands'].items():
+            configured_bands[b] = f
         message_broker.gui = Gui(message_broker, rig_control, console_print,  configured_bands)
         qso_manager = QSO_manager(message_broker, rig_control, console_print)
         message_broker.gui.register_qso_manager(qso_manager)
+        message_broker.rx.register_before_search(message_broker.gui.before_search)
         message_broker.rx.register_after_search(message_broker.gui.after_search)
         message_broker.history.incorporate_log_data(qso_manager.adif_logging.cache)
         message_broker.history.start_collect_new()
@@ -153,7 +154,7 @@ def cli():
             pass
     else:
         message_broker.gui.set_bandstats_title(f"Pskreporter Spots\nto/from {config['station']['grid'][:4]} <{PSKR_REFRESH_MINS:.0f} mins")
-        message_broker.gui.monitor_waterfall()
+        message_broker.gui.main_loop()
 
 
 

{pyft8-3.6.2 → pyft8-3.6.4}/PyFT8/qso_manager.py

@@ -11,7 +11,7 @@ class QSO_manager:
         self.find_clear_freq = message_broker.rx.find_clear_freq
         self.adif_logging = message_broker.adif_logging
         self.in_qso_with = False
-        self.tx_payload = None
+        self.tx_payload, self.last_tx_payload = None, None
         self.transmitting = False
         self.tx_cycle = 0
         self.console_print = console_print

{pyft8-3.6.2 → pyft8-3.6.4}/PyFT8/receiver.py

@@ -481,6 +481,7 @@ class Receiver():
         self.audio_in = AudioIn(search_freq_range, input_device_keywords, wav_files)
         self.process_message = message_broker.process_message
         message_broker.waterfall_data = self.audio_in.waterfall_data
+        self.before_search = None
         self.after_search = None
         self.sync_score_min, self.max_cands = sync_score_min, max_cands
         self.wav_files = wav_files
@@ -503,6 +504,9 @@ class Receiver():
         time_utils.sleep(0.5)
         threading.Thread(target=self.manage_cycle, daemon=True).start()
 
+    def register_before_search(self, func):
+        self.before_search = func
+
     def register_after_search(self, func):
         self.after_search = func
 
@@ -518,6 +522,8 @@ class Receiver():
         return clearest_frequency
 
     def search(self, cyclestart, odd_even, cycle_h0):
+        if self.before_search is not None:
+            self.before_search(odd_even)
         cands = []
         hops_per_sig = self.audio_in.search_hps * PAYLOAD_SYMB_IDXS[-1]
         for f0_idx in range(self.audio_in.search_f0_idx_range[0], self.audio_in.search_f0_idx_range[1], 2):
@@ -583,6 +589,7 @@ class Receiver():
                         duplicate_filter.add(key)
                         hail, their_call, grid_rpt = c.msg_tuple
                         message_dict = {'cyclestart_string':c.cyclestart['string'], 'hail':hail, 'their_call':their_call, 'grid_rpt':grid_rpt,
+                                        'msg_text':f"{hail} {their_call} {grid_rpt}",
                                         'their_snr':f"{c.snr:+03d}", 'their_tx_cycle':c.origin['odd_even'], 
                                         't0':c.origin['t0'], 'dt':c.origin['t0'] - 0.5, 'fHz':c.origin['f0'],
                                         'decode_status':c.decode_status, 'decode_completed':time_utils.cycle_time()}

{pyft8-3.6.2 → pyft8-3.6.4}/PyFT8.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyFT8
-Version: 3.6.2
+Version: 3.6.4
 Summary: FT8 Decoding and Encoding in Python with test/loopback code
 Author-email: G1OJS <g1ojs@yahoo.com>
 License-Expression: GPL-3.0-or-later
@@ -110,11 +110,11 @@ upload = Y
 2m = 144.174
 ```
 
-## Performance Compared with FT8_lib and WSJT-x
+## Performance Compared with WSJT-x
 
-The image below shows the number of decodes from PyFT8, WSJT-x V2.7.0 running in NORM mode, and FT8_lib, using the same 10 minutes of busy 20m audio that is used to test ft8_lib. 
+The image below shows the number of decodes from PyFT8, WSJT-x V2.7.0 running in NORM mode, using the same 10 minutes of busy 20m audio that is used to test ft8_lib. On this dataset, WSJT-x performs almost the same on DEEP mode as it does on NORM, and both beat PyFT8. However, PyFT8 gets very close to WSJT-x's performance on FAST mode.
 
-<img width="900" height="898" alt="batch test performance" src="https://github.com/user-attachments/assets/513d4121-5483-4e7b-81df-785dc4db3d37" />
+<img width="900" height="900" alt="live playback vs wsjtx_v2 7 0" src="https://github.com/user-attachments/assets/853e98b2-5b9b-4241-b5f3-181fe193642e" />
 
 ## Limitations
 PyFT8 doesn't decode / encode *all* message types. The table below shows which are handled.

{pyft8-3.6.2 → pyft8-3.6.4}/PyFT8.egg-info/SOURCES.txt

@@ -20,8 +20,10 @@ PyFT8.egg-info/dependency_links.txt
 PyFT8.egg-info/entry_points.txt
 PyFT8.egg-info/requires.txt
 PyFT8.egg-info/top_level.txt
-tests/plot_baseline.py
+tests/play_wavs.py
+tests/plot_decode_times.py
 tests/spare.py
+tests/spare2.py
 tests/test_batch_and_live.py
 tests/misc/CQ AAAA.py
 tests/misc/animation.py

{pyft8-3.6.2 → pyft8-3.6.4}/README.md

@@ -88,11 +88,11 @@ upload = Y
 2m = 144.174
 ```
 
-## Performance Compared with FT8_lib and WSJT-x
+## Performance Compared with WSJT-x
 
-The image below shows the number of decodes from PyFT8, WSJT-x V2.7.0 running in NORM mode, and FT8_lib, using the same 10 minutes of busy 20m audio that is used to test ft8_lib. 
+The image below shows the number of decodes from PyFT8, WSJT-x V2.7.0 running in NORM mode, using the same 10 minutes of busy 20m audio that is used to test ft8_lib. On this dataset, WSJT-x performs almost the same on DEEP mode as it does on NORM, and both beat PyFT8. However, PyFT8 gets very close to WSJT-x's performance on FAST mode.
 
-<img width="900" height="898" alt="batch test performance" src="https://github.com/user-attachments/assets/513d4121-5483-4e7b-81df-785dc4db3d37" />
+<img width="900" height="900" alt="live playback vs wsjtx_v2 7 0" src="https://github.com/user-attachments/assets/853e98b2-5b9b-4241-b5f3-181fe193642e" />
 
 ## Limitations
 PyFT8 doesn't decode / encode *all* message types. The table below shows which are handled.

{pyft8-3.6.2 → pyft8-3.6.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "PyFT8"
-version = "3.6.2"
+version = "3.6.4"
 license = "GPL-3.0-or-later"
 
 authors = [

pyft8-3.6.4/tests/play_wavs.py

@@ -0,0 +1,54 @@
+import threading, pyaudio
+from PyFT8.time_utils import time_utils
+SAMP_RATE =12000
+
+class SoundcardOut:
+    def __init__(self, outputcard_keywords, wav_files):
+        self.output_device_index = None
+        self.pya = pyaudio.PyAudio()
+        threading.Thread(target = self.play_wavs, args = (wav_files,), daemon = True).start()
+        
+        if outputcard_keywords:
+            for dev_idx in range(self.pya.get_device_count()):
+                name = self.pya.get_device_info_by_index(dev_idx)['name']
+                match = True
+                for pattern in outputcard_keywords.replace(' ','').split(','):
+                    if (not pattern in name): match = False
+                if(match):
+                    self.output_device_index = dev_idx
+                    break
+            if not self.output_device_index:
+                time_utils.tlog(f"[Audio Out] No output audio device found matching {outputcard_keywords}", verbose = True)
+                sys.exit(1)
+
+    def play_wavs(self, wav_files, sr=12000):
+        import wave
+        t = 15.05-time_utils.cycle_time()
+        print(t)
+        time_utils.sleep(t)
+        dt = 0.6/4
+        for i, w in enumerate(wav_files):
+            print(f"File {i}")
+            wv = wave.open(w, 'rb')
+            audio_bytes = wv.readframes(sr*16)
+            audio_bytes = audio_bytes[-int(sr*(15-dt))*2:]
+
+            stream = self.pya.open(format=pyaudio.paInt16, channels=1, rate = sr, output=True,
+                              output_device_index = self.output_device_index)
+            stream.write(audio_bytes)
+            stream.stop_stream()
+            stream.close()
+
+def play_wavs(i0, i1):
+    wav_files = []
+    for idx in range(i0, i1):
+        wav_files.append(f"{wav_folder}/test_{idx:02d}.wav")
+    soundout = SoundcardOut("CABLE, Input", wav_files)
+ 
+wav_folder = "C:/Users/drala/Documents/Projects/GitHub/ft8_lib/test/wav/20m_busy"
+play_wavs(1,30)
+
+
+
+
+

pyft8-3.6.4/tests/plot_decode_times.py

@@ -0,0 +1,26 @@
+import numpy as np
+import matplotlib.pyplot as plt
+import pickle
+
+
+def plot_from_file(ax, fname, label, color):
+    print(fname)
+    with open(fname, 'rb') as f:
+        times = pickle.load(f)
+        ax.plot(times, np.array(range(len(times))), label = label, color = color)
+
+i0, i1 = 1, 39
+    
+fig, ax = plt.subplots(figsize = (9,9))
+
+plot_from_file(ax, 'live_decode_times_PyFT8.pkl', 'PyFT8', 'limegreen')
+
+plot_from_file(ax, 'live_decode_times_WSJTx_2.7.0_1_FAST.pkl', 'WSJT-x_2.7.0_FAST', 'grey')
+plot_from_file(ax, 'live_decode_times_WSJTx_2.7.0_2_NORM.pkl', 'WSJT-x_2.7.0_NORM', 'purple')
+plot_from_file(ax, 'live_decode_times_WSJTx_2.7.0_3_DEEP.pkl', 'WSJT-x_2.7.0_DEEP', 'black')
+        
+ax.set_xlabel("Time, seconds")
+ax.set_ylabel("Cumulative decodes (unique per cycle)")
+fig.suptitle("Cumulative decode count against time")
+ax.legend()
+plt.show()

{pyft8-3.6.2 → pyft8-3.6.4}/tests/spare.py

@@ -12,11 +12,11 @@ bg = np.random.rand(SIZE,SIZE)
 
 def sender():
     global msg_box_display_queue, bg
-    x, y = SIZE*np.random.rand(50), SIZE*np.random.rand(50)
-    for i in range(20):
+    while True:
+        time.sleep(0.5)
         bg = np.random.rand(SIZE,SIZE)
-        time.sleep(0.16)
-        msg_box_display_queue.put({'x':x[i], 'y':y[i]})
+        x, y = SIZE*np.random.rand(1)[0], SIZE*np.random.rand(1)[0]
+        msg_box_display_queue.put({'x':x, 'y':y})
     
 class Msg_box():
     def __init__(self, message):
@@ -47,6 +47,6 @@ while True:
 
     t = time.time()
     fig.canvas.draw()
-    print(time.time() - t)
+    #print(time.time() - t)
     fig.canvas.flush_events()
     time.sleep(0.01)

pyft8-3.6.4/tests/spare2.py

@@ -0,0 +1,28 @@
+
+import numpy as np
+import matplotlib.pyplot as plt
+import time
+SIZE = 500
+
+fig, ax = plt.subplots( figsize=(8,8) )
+ax.set_xlim(0,SIZE)
+ax.set_ylim(0,SIZE)
+plt.show(block = False)
+
+arts = []
+
+from matplotlib.patches import Rectangle
+for i in range(10):
+    x, y = SIZE*np.random.rand(1)[0], SIZE*np.random.rand(1)[0]
+    rect = Rectangle((x, y), width=100, height=6, alpha=0.6, edgecolor='lime', lw=2)
+    art = ax.add_patch(rect)
+    arts.append(art)
+    ax.draw_artist(art)
+fig.canvas.update()
+fig.canvas.flush_events()
+    
+time.sleep(1)
+for a in arts:
+    a.remove()
+plt.pause(0.001)
+

{pyft8-3.6.2 → pyft8-3.6.4}/tests/test_batch_and_live.py

@@ -5,6 +5,7 @@ from matplotlib.animation import FuncAnimation
 from PyFT8.time_utils import time_utils
 from PyFT8.receiver import Receiver
 from PyFT8.message_broker import Broker
+from PyFT8.transmitter import SoundcardOut
 from PyFT8.gui import Gui
 
 class Wsjtx_all_tailer:
@@ -79,6 +80,7 @@ def test_common(input_source):
     t_start = time_utils.time()
 
 def batch_test(i0, i1):
+    soundout = SoundcardOut(["CABLE","Input"])
     wav_files = []
     for idx in range(i0, i1):
         wav_files.append(f"{wav_folder}/test_{idx:02d}.wav")
@@ -109,10 +111,10 @@ def batch_test(i0, i1):
     plt.show()
 
 
-def live_test():
+def live_test(audio_source):
     global both_started
     both_started = False
-    test_common(["Mic", "CODEC"])
+    test_common(audio_source)
     wsjtx_all_tailer = Wsjtx_all_tailer(on_wsjtx_decode, silent = True)
     
     ws_line = ax.plot([], [], label = 'WSJT-X')[0]
@@ -131,6 +133,10 @@ def live_test():
             ax.set_ylim(0, n_max)
         if any(py_times):
             ax.set_xlim(0, np.max(py_times))
+            with open('live_decode_times_PyFT8.pkl', 'wb') as f:
+                pickle.dump(py_times, f)
+            with open('live_decode_times_WSJTx.pkl', 'wb') as f:
+                pickle.dump(ws_times, f)
         return ws_line, py_line,
     ani = FuncAnimation(fig, anim, interval = 5000, frames=(100000), blit=False)
     plt.show()
@@ -142,9 +148,12 @@ data_folder = "C:/Users/drala/Documents/Projects/GitHub/PyFT8/tests/data/ft8_lib
 wav_folder = "C:/Users/drala/Documents/Projects/GitHub/ft8_lib/test/wav/20m_busy"
 
 gui = None
-
-#live_test()
-batch_test(1,39)
+t = 15.05-time_utils.cycle_time()
+print(t)
+time_utils.sleep(t)
+#live_test("Mic, CODEC")
+live_test("CABLE, Output")
+#batch_test(1,39)
 
 
 

pyft8-3.6.2/PyFT8/gui.py

@@ -1,298 +0,0 @@
-import numpy as np
-import matplotlib.pyplot as plt
-from matplotlib import rcParams
-import queue
-from matplotlib.widgets import Button
-from PyFT8.time_utils import time_utils
-
-rcParams['toolbar'] = 'None'
-MAIN_TEXT_COLOR = '#f0f9fa'
-TEXT_BACKGROUND_COLOR = '#2a2b2b'
-INFO_TEXT_COLOR = 'white'
-BUTTONCOLOR = 'grey'
-HOVERCOLOR = 'darkgreen'
-ACTIVE_BUTTON_COLOR = 'cyan'
-INACTIVE_BUTTON_COLOR = '#edeef0'
-MAX_FONT_SIZE_MAIN = 10
-L = {'pmargin':0.04, 'sidebar_width': 0.17, 'banner_height':0.1, 'vsep1':0.01, 'hsep1':0.02}
-
-
-class ButtonBox:
-    def __init__(self, fig, _reset_axis, box, btn_pc = 30, onclick = None, clickargs=None, btn_text = ' ', info_text = ' '):
-        self._reset_axis = _reset_axis
-        self.clickargs = clickargs
-        btnbox, infobox = box.copy(), box.copy()
-        btnbox[2] = box[2] * btn_pc /100
-        infobox[2] = box[2] * (100-btn_pc) /100
-        infobox[0] = box[0] + box[2] * (btn_pc /100)
-        self.btn_axs = fig.add_axes(btnbox)
-        self.btn_widg = Button(self.btn_axs, btn_text, color = BUTTONCOLOR, hovercolor = HOVERCOLOR)
-        self.btn_widg.on_clicked(lambda x: onclick(clickargs))
-        self.info_axs = fig.add_axes(infobox)
-        self.info_text_inst = self.info_axs.text(0.03, 0.5, info_text, color = INFO_TEXT_COLOR, verticalalignment = 'center', clip_on = True)        
-        self.set_info_text(info_text)
-        self.state_is_active = None
-        self.set_state(False)
-
-    def set_state(self, is_active: bool):
-        if is_active != self.state_is_active:
-            self.state_is_active = is_active
-            color = ACTIVE_BUTTON_COLOR if is_active else INACTIVE_BUTTON_COLOR
-            self.btn_widg.label.set_color(color)
-            self.btn_axs.draw_artist(self.btn_widg.label)
-            if self.info_text_inst: 
-                self.info_text_inst.set_color(color)
-                self.info_axs.draw_artist(self.info_text_inst)
-
-    def set_info_text(self, info_text):
-        self._reset_axis(self.info_axs)
-        self.info_text_inst.set_text(info_text)
-        self.info_axs.draw_artist(self.info_text_inst)
-
-
-MESSAGE_TYPES = {'generic':{'bg':'blue', 'fg':'white', 'alpha':0.5}, 'CQ':{'bg':'green', 'fg':'white', 'alpha':0.8},
-                 'from_me': {'bg':'yellow', 'fg':'black', 'alpha':0.95}, 'to_me':{'bg':'red', 'fg':'white', 'alpha':0.9}} 
-class Msg_box:
-    def __init__(self, fig, ax, w, h, onclick):
-        from matplotlib.patches import Rectangle
-        self.onclick = onclick
-        self.fig, self.ax = fig, ax
-        rect = Rectangle((0, 0), w, h, edgecolor='lime', lw=2)
-        self.patch = self.ax.add_patch(rect)
-        self.text_inst = self.ax.text(0, 0, '', fontsize='small', fontweight = 'bold' )
-        self.cid = fig.canvas.mpl_connect('button_press_event', self._onclick)
-        self.active = False
-
-    def set_properties(self, x, y, message):
-        self.patch.set_xy((x, y))
-        self.text_inst.set_position((x, y+1))
-        self.text_inst.set_text(message['display_text'])
-        message_type_params = MESSAGE_TYPES[message['message_type']]
-        self.text_inst.set_color(message_type_params['fg'])
-        self.patch.set_facecolor(message_type_params['bg'])
-        self.patch.set_alpha(message_type_params['alpha'])
-        self.message = message
-        self.cycle = message['their_tx_cycle']
-        self.active = True
-
-    def _onclick(self, event):
-        if self.active:
-            b, _ = self.patch.contains(event)
-            if(b):
-                self.onclick({'action': 'MESSAGE_CLICK', 'message':self.message})
-    
-class Gui:
-    def __init__(self, message_broker, rig_control, console_print, configured_bands, hearing_me_since_mins = 5):
-        self.hearing_me_since_mins = hearing_me_since_mins
-        self.waterfall_data = message_broker.waterfall_data
-        self.history = message_broker.history
-        self.qso_manager = None
-        self.configured_bands = configured_bands
-        self.console_print = console_print
-        self.myCall, self.myGrid = message_broker.myCall, message_broker.myGrid
-        self.band_info = {'current_band': None, 'fMHz':0, 'time_set':0}
-        
-        self.plt = plt
-        self.fig = plt.figure(figsize = (10,10), facecolor=(.18, .71, .71, 0.4))
-        self.fig.canvas.manager.set_window_title('PyFT8 by G1OJS')
-        self.wf_top = 1-L['pmargin']-L['banner_height']-L['vsep1']
-        self.wf_left = L['pmargin']+L['sidebar_width']+L['hsep1']
-
-        self.ax_wf = self.fig.add_axes([self.wf_left, L['pmargin'], 1-self.wf_left-L['pmargin'], self.wf_top-L['pmargin']])
-        self.ax_wf.set_xticks([])
-        self.ax_wf.set_yticks([])
-
-        self.image = self.ax_wf.imshow(self.waterfall_data['data'],vmax=120,vmin=90,origin='lower',interpolation='none', aspect = 'auto')
-        self.ax_ss = self.fig.add_axes([L['pmargin'], self.wf_top+L['vsep1'], L['sidebar_width'], L['banner_height']])
-        self.ax_cs = self.fig.add_axes([self.wf_left, self.wf_top+L['vsep1'], 1-self.wf_left-L['pmargin'], L['banner_height']])
-
-        self.console_rows = [('','white'),('','white'),('','white'),('','white'),('','white')]
-        self.hearing_page = 0
-        self.active_msg_boxes = []
-        self.inactive_msg_boxes = []
-        self.button_boxes = []
-
-        bh, bs = 0.02, 0.002
-        bb = ButtonBox(self.fig, self._reset_axis, [L['pmargin'], self.wf_top - (len(self.button_boxes)+1) * bh + bs, L['sidebar_width'], bh-bs], btn_pc = 100,
-                        btn_text = "CQ", onclick = self._on_click_local, clickargs = {'action':'CQ'})                            
-        self.button_boxes.append(bb)
-        bb = ButtonBox(self.fig, self._reset_axis, [L['pmargin'], self.wf_top - (len(self.button_boxes)+1) * bh + bs, L['sidebar_width'], bh-bs], btn_pc = 100,
-                        btn_text = "Repeat last", onclick = self._on_click_local, clickargs = {'action':'RPT_LAST'})                            
-        self.button_boxes.append(bb)
-        bb = ButtonBox(self.fig, self._reset_axis, [L['pmargin'], self.wf_top - (len(self.button_boxes)+1) * bh + bs, L['sidebar_width'], bh-bs], btn_pc = 100,
-                        btn_text = "Tx off", onclick = self._on_click_local, clickargs = {'action':'TX_OFF'})                            
-        self.button_boxes.append(bb)            
-        for band_info in self.configured_bands:
-            band, fMHz = band_info['band'], band_info['fMHz']
-            bb = ButtonBox(self.fig, self._reset_axis, [L['pmargin'], self.wf_top - (len(self.button_boxes)+1) * bh + bs, L['sidebar_width'], bh-bs], btn_pc = 30,
-                            btn_text = band, onclick = self._on_click_local, clickargs = {'action':'SET_BAND', 'band':band, 'fMHz':fMHz})
-            self.button_boxes.append(bb)
-            
-        hm_top = self.wf_top - (len(self.button_boxes)+2) * bh + bs - L['vsep1']
-        self.ax_hm = self.fig.add_axes([L['pmargin'], L['pmargin'], L['sidebar_width'], hm_top])
-
-        self.tlast = 0
-        self.band_info = {'current_band': None, 'fMHz':0, 'time_set':0}
-        self._refresh_hearing()
-        self._refresh_band_buttons()
-        self._refresh_square_stats()
-
-    def get_band_info(self):
-        return self.band_info
-
-    def register_qso_manager(self, qsm):
-        self.qso_manager = qsm
-
-    def set_bandstats_title(self, txt):
-        self.ax_ss.set_title(txt, fontsize = 10)
-        
-    def update_console(self, text, color, nlines = 5):
-        ax = self.ax_cs
-        bbox = ax.get_window_extent().transformed(self.fig.dpi_scale_trans.inverted())
-        rowheight = bbox.height * self.fig.dpi / nlines
-        fontsize = np.min([0.5 * rowheight, MAX_FONT_SIZE_MAIN])
-        self._reset_axis(ax)
-        self.console_rows[1:] = self.console_rows[:-1]
-        self.console_rows[0] = (text, color)
-        for i, rw in enumerate(self.console_rows):
-            ax.draw_artist(self._text_row(ax, 0.03, .03+0.9*i/len(self.console_rows), rw[0], color = rw[1], fontsize = fontsize))
-
-    def monitor_waterfall(self):
-        last_ptr = 0
-        self.plt.show(block = False)
-        t0 = time_utils.time()
-        while True:
-            time_utils.sleep(0.05)
-            self.image.set_data(self.waterfall_data['data'])
-            self.ax_wf.draw_artist(self.image)
-            for mb in self.active_msg_boxes:
-                self.ax_wf.draw_artist(mb.patch)
-                self.ax_wf.draw_artist(mb.text_inst)
-            self.fig.canvas.update()
-            self.fig.canvas.flush_events()
-            t = time_utils.time()
-            #print(f"{t - t0:6.3f}")
-            t0 = t
-
-    def after_search(self, curr_cycle):
-        self._refresh_hearing()
-        self._clear_msg_boxes(curr_cycle)
-        self._refresh_band_buttons()
-        self._refresh_square_stats()
-
-    def display_message(self, message):
-        x = int(message['t0'] / self.waterfall_data['dt'] + message['their_tx_cycle'] * self.waterfall_data['pixels_per_cycle'])
-        y = int(message['fHz'] / self.waterfall_data['df'])
-        mb = self._get_msg_box()
-        self.active_msg_boxes.append(mb)
-        mb.set_properties(x, y, message)
-
-    def _reset_axis(self, ax):
-        from matplotlib.patches import Rectangle
-        rect = Rectangle((0, 0), 1, 1, facecolor = TEXT_BACKGROUND_COLOR)
-        ax.draw_artist(ax.add_patch(rect))
-        ax.set_xticks([])
-        ax.set_yticks([])
-
-    def _on_click_local(self, clickargs):
-        btn_action = clickargs['action']
-        if(btn_action == 'SET_BAND'):
-            current_band, freqMHz = clickargs['band'], clickargs['fMHz']
-            self.band_info = {'current_band':current_band, 'fMHz':freqMHz, 'time_set':time_utils.time()}
-            self.console_print(f"[PyFT8] Set band: {self.band_info['current_band']} {self.band_info['fMHz']}")
-            self._refresh_hearing()
-            for cyc in range(2):
-                self._clear_msg_boxes(cyc)
-            self._refresh_band_buttons()
-            self._refresh_square_stats()
-        if clickargs['action'] == "MESSAGE_CLICK":
-            m = clickargs['message']
-            m_string = f"{m['hail']} {m['their_call']} {m['grid_rpt']}"
-            self.console_print(f"[GUI] Clicked on message '{m_string}'")
-        self.qso_manager.on_click(clickargs)
-
-    def _clear_msg_boxes(self, curr_cycle):
-        to_remove = [mb for mb in self.active_msg_boxes if mb.cycle == curr_cycle]
-        for mb in to_remove:
-            mb.active = False
-            self.inactive_msg_boxes.append(mb)
-            self.active_msg_boxes.remove(mb)
-
-    def _get_msg_box(self):
-        if len(self.inactive_msg_boxes) == 0:
-            mb = Msg_box(self.fig, self.ax_wf, self.waterfall_data['sig_w'], self.waterfall_data['sig_h'], onclick = self._on_click_local)
-        else:
-            mb = self.inactive_msg_boxes.pop()
-        return mb
-
-    def _text_row(self, ax, x, y, text = '', color = 'white', **args):
-        art = ax.text(x, y, text, color = color)
-        art.set_fontfamily('monospace')
-        return art
-   
-    def _refresh_square_stats(self):
-        ax = self.ax_ss
-        self._reset_axis(ax)
-        ax.draw_artist(ax.text(-0.2,0.75,'Tx'))
-        ax.draw_artist(ax.text(-0.2,0.25,'Rx'))
-        current_band = self.band_info['current_band']
-        if current_band is not None and self.history is not None:
-            if current_band in self.history.home_most_remotes:
-                tx_lead,  rx_lead = self.history.home_most_remotes[current_band]
-                n_spotted, n_spotting = self.history.get_spot_counts(current_band, self.myCall)
-                ax.draw_artist(self._text_row(ax, 0.03, .75, f"{self.myCall:<7} {tx_lead[0]:<7}", color = '#ff756b' ))
-                ax.draw_artist(self._text_row(ax, 0.03, .6, f"{n_spotting:<7} {tx_lead[1]:<7}", color = '#ff756b' ))
-                ax.draw_artist(self._text_row(ax, 0.03, .25, f"{self.myCall:<7} {rx_lead[0]:<7}", color = '#b6f0c6' ))
-                ax.draw_artist(self._text_row(ax, 0.03, .1, f"{n_spotted:<7} {rx_lead[1]:<7}", color = '#b6f0c6' ))
-
-    def _refresh_band_buttons(self):
-        current_band = self.band_info['current_band']
-        grd = self.myGrid[:4]
-        for bb in self.button_boxes:
-            button_band = bb.clickargs.get('band',None)
-            if button_band is not None:
-                bb.set_state(button_band == current_band)
-                if button_band in self.history.home_activity:
-                    cnts = self.history.home_activity[button_band]
-                    bb.set_info_text(f"{cnts[0]}Tx, {cnts[1]}Rx")
-        self.fig.canvas.update()
-        self.fig.canvas.flush_events()
-
-    def _refresh_hearing(self):
-        current_band = self.band_info['current_band']
-        ax = self.ax_hm
-        self._reset_axis(ax)
-        line_height = 0.03
-        bbox = ax.get_window_extent().transformed(self.fig.dpi_scale_trans.inverted())
-        nlines = int(0.9 / line_height)
-        row_artists = []
-        if current_band is not None and self.history is not None:
-            historic_data = self.history.hearing_me.data if self.hearing_page  == 1 else self.history.heard_by_me.data
-            new_calls_data = self.history.hearing_me_new if self.hearing_page  == 1 else self.history.heard_by_me_new
-            timewindow_str = f"<{self.hearing_me_since_mins:.0f} mins"
-            title_txt = f"Hearing me {timewindow_str}" if self.hearing_page==1 else f"Heard by me {timewindow_str}"
-            row_artists.append(self._text_row(ax, 0.03, 1 - line_height, title_txt, color = 'white'))
-            if current_band in historic_data:
-                tnow = time_utils.time()
-                band_rpts = historic_data[current_band]
-                calls_now = [call for call in band_rpts if (tnow - band_rpts[call]['t']) < 60*self.hearing_me_since_mins]
-                calls_now.sort(key = lambda c: band_rpts[c]['t'], reverse = True)
-                subtitle_txt = f"{len(calls_now)}/{len(band_rpts)} now/ever"
-                row_artists.append(self._text_row(ax, 0.03, 1 - 2*line_height, subtitle_txt, color = 'white'))
-                for i, remote_call in enumerate(calls_now[:nlines - 3]):
-                    rpt = band_rpts[remote_call]
-                    row_txt = f"{remote_call:<7} {self.history.get_geo_text(remote_call)}"
-                    color = 'white' if self.history.is_in_new_alert(current_band, remote_call, new_calls_data) else 'lime'
-                    row_artists.append(self._text_row(ax, 0.03, 1 - line_height*(i+3.2), row_txt, color = color))
-        for row_art in row_artists:
-            ax.draw_artist(row_art)
-        self.fig.canvas.update()
-        self.fig.canvas.flush_events()
-        self.hearing_page = (self.hearing_page +1 )%2
-
-
-
-
-
-
-        

pyft8-3.6.2/tests/plot_baseline.py

@@ -1,38 +0,0 @@
-import numpy as np
-import matplotlib.pyplot as plt
-import pickle
-
-data_folder = "C:/Users/drala/Documents/Projects/GitHub/PyFT8/tests/data/ft8_lib_20m_busy"
-
-i0, i1 = 1, 39
-
-def get_cumulative_from_text_files(i0, i1, postfix):
-    times = []
-    t = 0
-    for idx in range(i0, i1):
-        with open(f"{data_folder}/test_{idx:02d}{postfix}", "r") as f:
-            t += avg_cycle # approximate until real times folded in
-            for l in f.readlines():
-                times.append(t)
-    return times
-
-avg_cycle = 15.1
-
-ws_times = get_cumulative_from_text_files(i0, i1, "_wsjtx_2.7.0_NORM.txt")
-fl_times = get_cumulative_from_text_files(i0, i1, "_ft8_lib.txt")
-    
-fig, ax = plt.subplots(figsize = (9,9))
-ws_line = ax.plot(ws_times, np.array(range(len(ws_times))), label = 'WSJT-X', color = 'gray')[0]
-filename ='baseline.pkl'
-with open(filename, 'rb') as f:
-    py_times = pickle.load(f)
-    ax.plot(py_times, np.array(range(len(py_times))), label = 'PyFT8 ' + filename, color = 'lightgreen')
-ft_line = ax.plot(fl_times, np.array(range(len(fl_times))), label = 'ft8_lib', color = 'blue')[0]
-        
-ax.set_xlabel("Time, seconds")
-ax.set_ylabel("Cumulative decodes (unique per cycle)")
-fig.suptitle("Cumulative decode count against time")
-ax.set_xlim(0, np.max(ws_times) + 15)
-ax.set_ylim(0, len(ws_times))
-ax.legend()
-plt.show()