enode-host 0.1.0__py3-none-any.whl

enode_host/backup/sandbox.py

@@ -0,0 +1,93 @@
+# %%
+import pandas as pd
+import matplotlib.pyplot as plt
+import matplotlib.dates as mdates
+
+import pandas as pd
+
+df = pd.read_hdf("data/daq-2025_0305_1719", key="df")
+
+def select_xrange(self):
+    """
+    Plots the current DataFrame (with datetime index),
+    shows a vertical line following mouse movement (when zoom tool is NOT active),
+    and captures two mouse clicks (when zoom tool is NOT active).
+    Returns the subset of the DataFrame between those two clicked x-coordinates.
+    """
+    # Create the plot
+    fig, ax = plt.subplots()
+    self.plot(ax=ax)
+
+    # Create an initial vertical line at the left edge of our data
+    # We'll move it around inside the 'motion_notify_event'
+    if len(self.index) == 0:
+        print("DataFrame is empty. Returning as-is.")
+        return self
+
+    # We'll place the vertical line initially at the first index
+    vline = ax.axvline(self.index[0], linestyle='--', color='gray')
+
+    # We'll store the two click times here
+    clicked_times = []
+
+    def on_mouse_move(event):
+        # Only move the line if we're NOT in "zoom rect" mode
+        if fig.canvas.manager.toolbar.mode != 'zoom rect':
+            if event.inaxes == ax and event.xdata is not None:
+                # Move the vertical line to the current mouse x
+                vline.set_xdata(event.xdata)
+                fig.canvas.draw_idle()  # Redraw efficiently
+
+    def on_click(event):
+        # Only record the click if we're NOT in "zoom rect" mode
+        if fig.canvas.manager.toolbar.mode != 'zoom rect':
+            if event.inaxes == ax and event.xdata is not None:
+                # Convert Matplotlib's float date to a Python datetime
+                dt = mdates.num2date(event.xdata)
+                clicked_times.append(dt)
+
+                if len(clicked_times) == 2:
+                    # We got two clicks—stop the event loop
+                    fig.canvas.stop_event_loop()
+
+    # Connect the callbacks
+    cid_move = fig.canvas.mpl_connect("motion_notify_event", on_mouse_move)
+    cid_click = fig.canvas.mpl_connect("button_press_event", on_click)
+
+    # Show the plot (non‐blocking)
+    plt.show(block=False)
+
+    # Start an event loop that blocks until we have two clicks (or the figure is closed).
+    fig.canvas.start_event_loop(timeout=-1)
+
+    # Disconnect events and close the figure
+    fig.canvas.mpl_disconnect(cid_move)
+    fig.canvas.mpl_disconnect(cid_click)
+    plt.close(fig)
+
+    # If we didn't get two valid clicks, just return the original DataFrame
+    if len(clicked_times) < 2:
+        print("Not enough clicks were registered. Returning the original DataFrame.")
+        return self
+
+    # Sort the times so t0 < t1
+    t0, t1 = sorted(clicked_times)
+
+    # Slice the DataFrame by those two times (inclusive)
+    return self.loc[t0 : t1]
+
+# Monkey‐patch the DataFrame class so any DataFrame can call df.select_xrange()
+pd.DataFrame.select_xrange = select_xrange
+
+
+# ----------------------------------------------------------------------------
+# Example usage:
+if __name__ == "__main__":
+    # Create a small example DataFrame with a DatetimeIndex
+    # dates = pd.date_range("2023-01-01", periods=30, freq="D")
+    # df = pd.DataFrame({"values": range(30)}, index=dates)
+    df = pd.read_hdf("data/daq-2025_0305_1719", key="df")
+    # Call our new method
+    subset = df.select_xrange()
+    print("Selected subset:\n", subset)
+    

enode_host/backup/shm.py

@@ -0,0 +1,262 @@
+'''Tools for signal processing of SHM                                       
+'''
+
+#                                                                           
+#                                                                           
+#                                                                           
+#                                                                           
+
+# TODO:                                                                     
+#   - identify # of channles                                                
+#   - csv or bin                                                            
+
+# %matplotlib inline                                                        
+# %matplotlib notebook                                                      
+# %matplotlib widget                                                        
+
+import struct
+import datetime
+from datetime import timezone
+from numpy import *
+import matplotlib.pyplot as pl
+import matplotlib.dates as mdates
+
+from scipy.signal import welch, detrend, cheby1, sosfiltfilt
+from scipy.io import loadmat
+import sys
+import os
+
+import pandas as pd
+from bokeh.plotting import figure, show
+from bokeh.embed import components
+from bokeh.models import HoverTool
+from bokeh.models import ColumnDataSource, OpenURL, TapTool
+from bokeh.models import HoverTool
+from bokeh.models import DatetimeTickFormatter
+from bokeh.models import Range1d, LinearAxis
+from bokeh.palettes import Dark2_5 as palette
+import bokeh.layouts
+import pandas_bokeh
+
+#import ssi_dat
+import time
+
+class SHM:
+
+    df = []
+    t = []
+    y = []
+    mean = []
+    std = []
+
+    mp = []
+    nfft = 2**10
+    dt = []
+    fs = []
+    F = []
+    Pxx = []
+
+    dataPath = None
+    file_duration = {'acc': 600, 'wnd': 3600*24} # in seconds               
+
+    db_managers = {'File':None, 'Summary': None}
+
+    def __init__(self):
+        pass
+
+    # LOAD ---------------------------------------------------------------------------------
+    def load(self, src, *args, **kwargs):
+        """                                                                                                                                                                   
+        load(src = [raw|django-file|django-db])                                                                                                                               
+        """
+
+        def load_bin(fn, nch = 3):
+            with open(fn, 'rb') as fp:
+                data = fp.read()
+            bytes_per_sample = 4*2 + 4*nch
+            n = int(len(data)/bytes_per_sample)
+            t, y = [], []
+            for i in range(n):
+                res = list(struct.unpack('<LL' + 'f'*nch, data[i*bytes_per_sample:(i+1)*bytes_per_sample]))
+                t.append(res[0]*1000000 + res[1])  # in usec                                                                                                                  
+                y.append(res[2:])
+            t = pd.to_datetime(t, unit='us')
+            return pd.DataFrame(array(y), index = t)
+
+        def load_mat(fn, gain = 10):
+            mat_contents = loadmat(fn)
+            _keys = mat_contents.keys()
+            if 't' not in _keys or 'a' not in _keys:
+                raise Exception('loading mat failed: keys t and a are not found.')
+            t = mat_contents['t']
+            y = mat_contents['a']/10/gain # 10V per g, gain=10                                                                                                                
+            return pd.DataFrame(y, index = t.flatten())
+
+        def load_django_file(nodeName, sensorType, ti, duration=None, pos='start'):
+            if pos == 'start':
+                pass
+            elif pos == 'centre':
+                ti = ti - datetime.timedelta(seconds=duration/2)
+            elif pos == 'end':
+                ti = ti - datetime.timedelta(seconds=duration)
+            else:
+                raise Exception('unknown pos variable: {}'.format(pos))
+            te = ti + datetime.timedelta(seconds=duration)
+            recs = self.db_managers['File'].filter(nodeName = nodeName)\
+                                           .filter(sensorType = sensorType)\
+                                           .filter(timestamp__gte = ti)\
+                                           .filter(timestamp__lt  = te)\
+                                           .order_by('timestamp')
+            if len(recs) > 0:
+                dfs = []
+                for rec in recs:
+                    dfs.append(rec.load())
+                return pd.concat(dfs)
+            else:
+                return None
+
+        def read_db(tableName, fields, ti, duration):
+            te = ti + datetime.timedelta(seconds = duration)
+            recs = self.db_managers[tableName].filter(timestamp__gte = ti)\
+                                              .filter(timestamp__lt  = te)\
+                                              .order_by('timestamp')
+            t, y, columnnames = [], [], []
+            map = {
+                'WindDir': ['WindDir'],
+                'WindSpeed': ['WindSpeed'],
+                'rmsd': ['rmsd_x', 'rmsd_y', 'rmsd_z', 'rmsd_tot'],
+                'mean': ['mean_x', 'mean_y', 'mean_z'],
+                'freq': ['freq_m11', 'freq_m12', 'freq_m21', 'freq_m22', 'freq_m3'],
+                'xi': ['xi_m11', 'xi_m12', 'xi_m21', 'xi_m22', 'xi_m3'],
+                'uptime': ['uptime']
+                   }
+            # populate column names                                                                                                                                           
+            for field in fields:
+                if field in map.keys():
+                    columnnames += map[field]
+                else:
+                    columnnames += [field]
+            # populate data                                                                                                                                                   
+            for idx, rec in enumerate(recs):
+                t.append(rec.timestamp)
+                row = []
+                for field in fields:
+                    val = getattr(rec, field)
+                    # print(field, val)
+                    
+                    if isinstance(val, list):
+                        row += val
+                    else:
+                        row += [val]
+                y.append(row)
+                # print(row)
+            # print(len(row), len(columnnames))
+            return pd.DataFrame(y, index = t, columns = columnnames)
+
+        if src == 'raw':
+            if 'filename' not in kwargs.keys():
+                raise Exception("filename not specified")
+            else:
+                filename = kwargs['filename']
+                if 'mat' in filename:
+                    self.df = load_mat(filename)
+                else:
+                    self.df = load_bin(filename)
+                return self.df
+            
+        elif src == 'django-file':
+            self.df = load_django_file(*args, **kwargs)
+        elif src == 'django-db':
+            self.df = read_db(*args)
+        if self.df is not None:
+            if len(self.df.index) > 1:
+                dt = self.df.index[1] - self.df.index[0]
+                if isinstance(dt, datetime.timedelta):
+            	    dt = dt.total_seconds()
+                self.fs = 1/dt
+            else:
+                pass
+        return
+
+    # SAVE ---------------------------------------------------------------------------------                                                                                  
+
+    def save(self, tableName, timestamp, fields, values):
+        recs = self.db_managers[tableName].filter(timestamp = timestamp)
+        if len(recs) > 0:
+            rec = recs[0]
+            for field, value  in zip(fields, values):
+                setattr(rec, field, value)
+            rec.save()
+        else:
+            raise Exception("no record found")
+    # SIGNAL PROC ---------------------------------------------------------------------------------                                                                           
+
+    def get_statistics(self):
+        self.mean = self.df.mean().tolist()
+        self.std  = self.df.std().tolist()
+        
+#     def ssi(self, max_order = 100, i = 50, err = [0.01, 0.1, 0.99], max_poll = None, freq_ranges = None, **kwargs):
+#         ssi_dat.y = self.df.to_numpy().T
+#         ssi_dat.fs = self.fs
+#         ssi_dat.max_order = max_order
+#         ssi_dat.max_poll = max_poll
+#         ssi_dat.err = err
+#         if i is not None:
+#             ssi_dat.i = i
+#         ssi_dat.freq_ranges = freq_ranges
+#         ssi_dat.show_plots = False
+# 
+#         print('ssi_dat: i = {}, stab_criteria={}'.format(ssi_dat.i, err))
+#         t0 = time.time()
+#         ssi_dat.ssi_dat(**kwargs)
+#         self.ssi_dat = ssi_dat
+# 
+
+    # PLOT ---------------------------------------------------------------------------------                                                                                  
+
+    # def plot(self, **kwargs):                                                                                                                                               
+    #     # self.df.plot(**kwargs)                                                                                                                                            
+    #     pl.plot(self.t, self.y)                                                                                                                                             
+    #     pl.grid(True)                                                                                                                                                       
+
+    def plot_bokeh(self, **kwargs):
+        pd.set_option('plotting.backend', 'pandas_bokeh')
+        p = self.df.plot(**kwargs, show_figure = False)
+        p.toolbar.logo = None
+        script, div = components(p)
+        return script, div
+
+    def psd(self, plot=True, **kwargs):
+        # if 'figsize' in kwargs:
+            # figure(figsize=kwargs.get('figsize'))
+            # print(kwargs.get('figsize'))
+            # del kwargs['figsize']
+        f, Pxx_den = welch(self.df.to_numpy(), self.fs, nperseg=self.nfft, noverlap = fix(self.nfft*3/4), axis=0, **kwargs)
+        self.F = f
+        self.Pxx = Pxx_den
+        if plot:
+            pl.semilogy(f,sqrt(Pxx_den))
+            pl.xlim(0,self.fs/2)
+            pl.xlabel('Frequency (Hz)')
+            pl.ylabel('PSD g/sq(Hz)')
+            pl.grid(True)
+
+    def lpf(self, r, **kwargs):
+        sos = cheby1(8, 0.05, r, output='sos')
+        sos = asarray(sos, dtype = self.y.dtype)
+        self.y = sosfiltfilt(sos, self.y, **kwargs)
+
+
+
+if __name__ == "__main__":
+    s = SHM()
+    s.load(src='raw', filename='data/1hr/smartply_acc1_acc_202305022200')
+    # s.y = s.y[:2]                                                                                                                                                           
+    s.plot()
+    pl.figure()
+    s.ssi(max_order = 100, i = 50, max_poll = 20)
+    pl.show()
+
+
+
+

enode_host/backup/shmtools.py

@@ -0,0 +1,70 @@
+import pandas as pd
+from matplotlib.pyplot import *
+from numpy import *
+import matplotlib.dates as mdates
+
+
+
+def detrend(self):
+    return self - self.mean()
+
+
+def subset(self):
+    if hasattr(self, 't0') and hasattr(self, 't1'):
+        mask = (self.index >= self.t0.replace(tzinfo=None)) & (self.index < self.t1.replace(tzinfo=None))
+        return self.loc[mask, :]
+    else:
+        raise Exception('t0 or t1 doesn''t exist')
+
+
+# _orig_plot = pd.DataFrame.plot
+
+# def custom_plot(self, *args, **kwargs):
+#     if "figsize" not in kwargs:
+#         kwargs["figsize"] = (8, 4)
+#     elif "grid" not in kwargs:
+#         kwargs['grid'] = True
+    
+#     # Call the original plot method
+#     return _orig_plot(self)(*args, **kwargs)
+
+# pd.DataFrame.plot = custom_plot
+
+def select(self):
+    fig, ax = subplots()
+    self.plot(ax=ax)
+    toolbar = fig.canvas.manager.toolbar
+
+    vline = ax.axvline(nan, linestyle="--")
+
+    def on_mouse_move(event):
+        if len(toolbar.mode) > 0:
+            vline.set_xdata(nan)
+        elif event.inaxes == ax and event.xdata is not None:
+            vline.set_xdata(event.xdata)
+            fig.canvas.draw_idle()  # efficient redraw
+
+    def onclick(event):
+        nonlocal self
+        # event.xdata and event.ydata give the mouse click in data coordinates
+        # print("toolbar.mode", toolbar.mode, ' ', len(toolbar.mode))
+        if len(toolbar.mode) == 0:
+            if event.button == 1:
+                t0 = mdates.num2date(event.xdata)
+                self.t0 = t0
+                print("x =", event.xdata, ", y =", event.ydata)
+            if event.button == 3:
+                t1 = mdates.num2date(event.xdata)
+                self.t1 = t1
+                print("x =", event.xdata, ", y =", event.ydata)
+                close()
+
+    # Connect the event to the figure
+    fig.canvas.mpl_connect("motion_notify_event", on_mouse_move)
+    fig.canvas.mpl_connect('button_press_event', onclick)
+    show()
+
+pd.DataFrame.detrend = detrend
+pd.DataFrame.select = select
+pd.DataFrame.subset = subset
+

enode_host/backup/smarts.py

@@ -0,0 +1,243 @@
+#!/usr/local/bin/python3
+# -*- coding: utf-8 -*-
+
+###########################################################################
+## Python code generated with wxFormBuilder (version 4.2.1-0-g80c4cb6)
+## http://www.wxformbuilder.org/
+##
+## PLEASE DO *NOT* EDIT THIS FILE!
+###########################################################################
+
+import wx
+import wx.xrc
+import wx.grid
+
+import gettext
+_ = gettext.gettext
+
+###########################################################################
+## Class MyFrame1
+###########################################################################
+
+class MyFrame1 ( wx.Frame ):
+
+    def __init__( self, parent ):
+        wx.Frame.__init__ ( self, parent, id = wx.ID_ANY, title = _(u"Wireless Sensor DAQ"), pos = wx.DefaultPosition, size = wx.Size( 1024,600 ), style = wx.DEFAULT_FRAME_STYLE|wx.TAB_TRAVERSAL )
+
+        self.SetSizeHints( wx.DefaultSize, wx.DefaultSize )
+
+        bSizer1 = wx.BoxSizer( wx.VERTICAL )
+
+        bSizer2 = wx.BoxSizer( wx.HORIZONTAL )
+
+        self.m_staticText2 = wx.StaticText( self, wx.ID_ANY, _(u"Sensor Nodes:"), wx.DefaultPosition, wx.DefaultSize, 0 )
+        self.m_staticText2.Wrap( -1 )
+
+        bSizer2.Add( self.m_staticText2, 0, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 5 )
+
+        self.m_textCtrl2 = wx.TextCtrl( self, wx.ID_ANY, wx.EmptyString, wx.DefaultPosition, wx.DefaultSize, 0 )
+        bSizer2.Add( self.m_textCtrl2, 1, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 5 )
+
+        self.m_staticText3 = wx.StaticText( self, wx.ID_ANY, _(u"Fs="), wx.DefaultPosition, wx.DefaultSize, 0 )
+        self.m_staticText3.Wrap( -1 )
+
+        bSizer2.Add( self.m_staticText3, 0, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 5 )
+
+        m_choice1Choices = [ _(u"62.5"), _(u"125") ]
+        self.m_choice1 = wx.Choice( self, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, m_choice1Choices, 0 )
+        self.m_choice1.SetSelection( 0 )
+        bSizer2.Add( self.m_choice1, 0, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 5 )
+
+        self.m_staticText4 = wx.StaticText( self, wx.ID_ANY, _(u"Hz"), wx.DefaultPosition, wx.DefaultSize, 0 )
+        self.m_staticText4.Wrap( -1 )
+
+        bSizer2.Add( self.m_staticText4, 0, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 5 )
+
+        self.m_button1 = wx.Button( self, wx.ID_ANY, _(u"Start DAQ"), wx.DefaultPosition, wx.DefaultSize, 0 )
+        bSizer2.Add( self.m_button1, 0, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 5 )
+
+        self.m_button2 = wx.Button( self, wx.ID_ANY, _(u"Stop DAQ"), wx.DefaultPosition, wx.DefaultSize, 0 )
+        bSizer2.Add( self.m_button2, 0, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 5 )
+
+
+        bSizer1.Add( bSizer2, 0, wx.EXPAND, 5 )
+
+        bSizer3 = wx.BoxSizer( wx.HORIZONTAL )
+
+        bSizer4 = wx.BoxSizer( wx.VERTICAL )
+
+        self.m_staticText21 = wx.StaticText( self, wx.ID_ANY, _(u"WiFi Mesh Status"), wx.DefaultPosition, wx.DefaultSize, 0 )
+        self.m_staticText21.Wrap( -1 )
+
+        bSizer4.Add( self.m_staticText21, 0, wx.ALL, 5 )
+
+        self.m_grid2 = wx.grid.Grid( self, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, 0 )
+
+        # Grid
+        self.m_grid2.CreateGrid( 5, 6 )
+        self.m_grid2.EnableEditing( True )
+        self.m_grid2.EnableGridLines( True )
+        self.m_grid2.EnableDragGridSize( True )
+        self.m_grid2.SetMargins( 0, 0 )
+
+        # Columns
+        self.m_grid2.SetColSize( 0, 70 )
+        self.m_grid2.SetColSize( 1, 100 )
+        self.m_grid2.SetColSize( 2, 20 )
+        self.m_grid2.SetColSize( 3, 40 )
+        self.m_grid2.SetColSize( 4, 40 )
+        self.m_grid2.SetColSize( 5, 45 )
+        self.m_grid2.EnableDragColMove( False )
+        self.m_grid2.EnableDragColSize( True )
+        self.m_grid2.SetColLabelValue( 0, _(u"Node ID") )
+        self.m_grid2.SetColLabelValue( 1, _(u"Status") )
+        self.m_grid2.SetColLabelValue( 2, _(u"L") )
+        self.m_grid2.SetColLabelValue( 3, _(u"RSSI") )
+        self.m_grid2.SetColLabelValue( 4, _(u"PPS") )
+        self.m_grid2.SetColLabelValue( 5, _(u"Data") )
+        self.m_grid2.SetColLabelSize( wx.grid.GRID_AUTOSIZE )
+        self.m_grid2.SetColLabelAlignment( wx.ALIGN_CENTER, wx.ALIGN_CENTER )
+
+        # Rows
+        self.m_grid2.EnableDragRowSize( True )
+        self.m_grid2.SetRowLabelSize( wx.grid.GRID_AUTOSIZE )
+        self.m_grid2.SetRowLabelAlignment( wx.ALIGN_CENTER, wx.ALIGN_CENTER )
+
+        # Label Appearance
+
+        # Cell Defaults
+        self.m_grid2.SetDefaultCellAlignment( wx.ALIGN_LEFT, wx.ALIGN_TOP )
+        bSizer4.Add( self.m_grid2, 1, wx.ALL|wx.EXPAND, 5 )
+
+
+        bSizer3.Add( bSizer4, 0, wx.EXPAND, 5 )
+
+        self.m_notebook2 = wx.Notebook( self, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, 0 )
+        self.m_panel1 = wx.Panel( self.m_notebook2, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.TAB_TRAVERSAL )
+        self.m_notebook2.AddPage( self.m_panel1, _(u"Time history plot"), True )
+        self.m_panel2 = wx.Panel( self.m_notebook2, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.TAB_TRAVERSAL )
+        self.m_notebook2.AddPage( self.m_panel2, _(u"PSD plot"), False )
+
+        bSizer3.Add( self.m_notebook2, 1, wx.ALL|wx.EXPAND, 5 )
+
+
+        bSizer1.Add( bSizer3, 1, wx.EXPAND, 5 )
+
+        self.m_textCtrl21 = wx.TextCtrl( self, wx.ID_ANY, _(u"\"test line 1\ntest2 line|\""), wx.DefaultPosition, wx.Size( -1,100 ), 0 )
+        bSizer1.Add( self.m_textCtrl21, 0, wx.ALL|wx.EXPAND, 5 )
+
+
+        self.SetSizer( bSizer1 )
+        self.Layout()
+
+        self.Centre( wx.BOTH )
+
+        # Connect Events
+        self.m_textCtrl2.Bind( wx.EVT_TEXT, self.test )
+
+    def __del__( self ):
+        pass
+
+
+    # Virtual event handlers, override them in your derived class
+    def test( self, event ):
+        event.Skip()
+
+import wx
+import wx.lib.agw.aui as aui
+import wx.lib.mixins.inspection as wit
+from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg as FigureCanvas
+from matplotlib.backends.backend_wxagg import \
+    NavigationToolbar2WxAgg as NavigationToolbar
+from matplotlib.figure import Figure
+
+class Plot(wx.Panel):
+    def __init__(self, parent, id=-1, dpi=None, **kwargs):
+        super().__init__(parent, id=id, **kwargs)
+        self.figure = Figure(dpi=dpi, figsize=(2, 2))
+        self.canvas = FigureCanvas(self, -1, self.figure)
+        self.toolbar = NavigationToolbar(self.canvas)
+        self.toolbar.Realize()
+
+        sizer = wx.BoxSizer(wx.VERTICAL)
+        sizer.Add(self.canvas, 1, wx.EXPAND)
+        sizer.Add(self.toolbar, 0, wx.LEFT | wx.EXPAND)
+        self.SetSizer(sizer)
+
+class PlotNotebook(wx.Panel):
+    def __init__(self, parent, id=-1):
+        super().__init__(parent, id=id)
+        self.nb = aui.AuiNotebook(self)
+        sizer = wx.BoxSizer()
+        sizer.Add(self.nb, 1, wx.EXPAND)
+        self.SetSizer(sizer)
+
+    def add(self, name="plot"):
+        page = Plot(self.nb)
+        self.nb.AddPage(page, name)
+        return page.figure
+
+
+import wx.grid as gridlib
+import configparser
+import os
+
+CONFIG_FILE = 'config.ini'
+
+def save_config(options):
+    config = configparser.ConfigParser()
+
+    config['Settings'] = {
+        'option1': options['option1'],
+        'option2': options['option2']
+    }
+
+    with open(CONFIG_FILE, 'w') as configfile:
+        config.write(configfile)
+
+def load_config():
+    config = configparser.ConfigParser()
+
+    if not os.path.exists(CONFIG_FILE):
+        # Return default options if config file doesn't exist
+        return {
+            'option1': 'default_value1',
+            'option2': 'default_value2'
+        }
+
+    config.read(CONFIG_FILE)
+    options = {
+        'option1': config.get('Settings', 'option1', fallback='default_value1'),
+        'option2': config.get('Settings', 'option2', fallback='default_value2')
+    }
+
+    return options
+
+app = wx.App() 
+# window = wx.Frame(None, title = "wxPython Frame", size = (300,200)) 
+frame1 = MyFrame1(None)
+
+
+fig1 = Plot(frame1.m_panel1)
+# plotter = PlotNotebook(frame1.m_notebook2)
+axes1 = fig1.figure.add_subplot()
+axes1.plot([1, 2, 3], [2, 1, 4])
+fig2 = Plot(frame1.m_panel2)
+axes2 = fig2.figure.add_subplot()
+axes2.plot([1, 2, 3, 4, 5], [2, 1, 4, 2, 3])
+
+canvas = FigureCanvas(frame1.m_panel1, -1, fig1.figure)
+sizer = wx.BoxSizer(wx.VERTICAL)
+sizer.Add(canvas, 1, wx.EXPAND)
+
+# Set the sizer for the panel
+frame1.m_panel1.SetSizer(sizer)
+
+# Change the background color of cell (1, 1)
+attr = gridlib.GridCellAttr()
+attr.SetBackgroundColour(wx.Colour(255, 255, 0))  # Yellow
+frame1.m_grid2.SetAttr(1, 1, attr)
+
+
+frame1.Show(True) 
+app.MainLoop()