more

Author: vladdez

scripts/runner.jl

@@ -52,5 +52,5 @@ begin
     for i in docs_entries
         format_file(i)
     end
-    cd(".")
+    cd("../")
 end

src/ERPExplorer.jl

@@ -22,6 +22,27 @@ include("functions.jl")
 include("widgets.jl")
 include("plot_data.jl")
 
+"""
+    explore(model::UnfoldModel; positions = nothing, size = (700, 600))
+Run the dashboard for explorative ERP analysis.
+
+Arguments:\\
+- `model::UnfoldLinearModel{Float64}` - Unfold linear model with categorical and continuous terms.
+- `positions::Vector{Point{2, Float32}}` - x an y coordinates of the channels.
+- `size::Tuple{Float64, Float64}` - size of the topoplot panel.
+
+Actions:
+- Extract formula terms and itheir features.
+- Create interactive formula with checkboxes. 
+- Arrange and map dropdown menus.
+- Create interactive topoplot.
+- Create Observable DataFrame with predicted values (yhats) and more.
+- Create `GridLayout`.
+- Use `Base.ReentrantLock`, a synchronization primitive_ to manage concurrent access to shared resources in multi-threaded programs
+
+
+**Return Value:** `res::Hyperscript.Node{Hyperscript.HTMLSVG}` - final HTML code of the dashboard.
+"""
 function explore(model::UnfoldModel; positions = nothing, size = (700, 600))
     App() do
         variables = extract_variables(model)
@@ -39,9 +60,8 @@ function explore(model::UnfoldModel; positions = nothing, size = (700, 600))
         else
             topo_widget, channel = topoplot_widget(positions; size = size .* 0.5)
         end
-        #@debug "mapping" mapping
-        #mapping = Observable(Dict(:color => :color, :fruit => :marker))
-        eff_signal = effects_signal(model, widget_signal, channel)
+
+        yhats_sig = yhats_signal(model, widget_signal, channel)
         on(mapping) do m
             ws = widget_signal.val
             ks_m = values(m)
@@ -50,11 +70,12 @@ function explore(model::UnfoldModel; positions = nothing, size = (700, 600))
                 widget_checkbox[k][] = k ∈ ks_m
             end
         end
+
         obs = Observable(S.GridLayout())
         l = Base.ReentrantLock()
-        Makie.onany_latest(eff_signal, mapping; update = true) do eff, mapping # update = true means only, that it is run once immediately
+
+        Makie.onany_latest(yhats_sig, mapping; update = true) do eff, mapping # update = true means only, that it is run once immediately
             lock(l) do
-                #var_types = map(x -> x[2][3], variables)
                 obs[] = plot_data(
                     eff,
                     value_ranges,
@@ -67,7 +88,7 @@ function explore(model::UnfoldModel; positions = nothing, size = (700, 600))
         end
         css = Asset(joinpath(@__DIR__, "..", "style.css"))
         fig = plot(obs; figure = (size = size,))
-        return DOM.div(
+        res = DOM.div(
             css,
             Bonito.TailwindCSS,
             Grid(
@@ -90,6 +111,7 @@ function explore(model::UnfoldModel; positions = nothing, size = (700, 600))
                 "position" => :relative,
             ),
         )
+        return res
     end
 end
 export explore

src/functions.jl

@@ -46,7 +46,7 @@ Actions:
 - `widget_checkbox`: Dictionary with the current values of the widgets (term => values).
 - `widget_signal`: widget_checkbox but as Observable, a signal that emits a dictionary with the current values of the widgets.
 - `formular_widget`: The HTML element that can be displayed to interact with the the widgets.
-- `value_ranges`: A dictionaryy containing the value ranges of each formula term.
+- `value_ranges`: A dictionary containing the value ranges of each formula term.
 """
 function formular_widgets(variables)
     value_ranges = [k => value_range(v) for (k, v) in variables]
@@ -58,13 +58,18 @@ function formular_widgets(variables)
         c = checkboxes[k]
         w_cat_term = widgets[k].first
         w_value = widgets[k].second
-        push!(widget_names, formular_text("+"), formular_text(c), dropdown(w_cat_term, w_value))
+        push!(
+            widget_names,
+            formular_text("+"),
+            formular_text(c),
+            dropdown(w_cat_term, w_value),
+        )
     end
-    
+
     formular_widget = Row(widget_names...)
     widget_values = map(nw -> nw[2].value, widgets)
     checkbox_values = map(c -> c.value, checkboxes)
-    
+
     widget_signal =
         lift(widget_values..., checkbox_values...; ignore_equal_values = true) do args...
             result = []
@@ -77,34 +82,49 @@ function formular_widgets(variables)
         end
     widget_checkbox = Dict(k => c for (c, (k, v)) in zip(checkbox_values, variables))
 
-    return widget_checkbox,
-    widget_signal,
-    formular_widget,
-    value_ranges
+    return widget_checkbox, widget_signal, formular_widget, value_ranges
 end
 
-function effects_signal(model, widget_signal, channel)
-    effects_signal = Observable{Any}(nothing; ignore_equal_values = true)
+"""
+    yhats_signal(model, widget_signal, channel)
+Creates a dictionary with yhat values and more.\\
 
-    onany(widget_signal, channel; update = true) do widget_values, chan
+Arguments:\\
+- `model::UnfoldLinearModel{Float64}` - vector of key-value pairs with information about the model formula terms.
+- `widget_signal::Observable{Vector{Any}}` - a signal that emits a dictionary with the current values of the widgets.
+- `channel::Observable{Int64}` - number of selected channel- 
+
+Actions:
+- Compute predicted value (yhat) of the given model using `effects`.
+- Create `DataFrame` with columns: yhat, channel, dummy, time, eventname and unique columns for each formula term.
+- Make it Observable.
+
+**Return Value:** `yhats_signal::Observable{Any}` containing DataFrame with yhats. 
+"""
+function yhats_signal(model, widget_signal, channel)
+
+    yhats_signal = Observable{Any}(nothing; ignore_equal_values = true)
 
-        effect_dict = Dict(
+    onany(widget_signal, channel; update = true) do widget_values, chan
+        yhat_dict = Dict(
             k => widget_value(wv[2]) for (k, wv) in widget_values if !isempty(wv) && wv[1]
         )
-        if isempty(effect_dict)
-            effect_dict = Dict(:dummy => ["dummy"])
+        if isempty(yhat_dict)
+            yhat_dict = Dict(:dummy => ["dummy"])
         end
-        eff = effects(effect_dict, model)
+        yhats = effects(yhat_dict, model)
+
         for (k, wv) in widget_values
             if isempty(wv[2]) || !wv[1]
-                eff[!, k] .= "typical_value"
+                yhats[!, k] .= "typical_value"
             end
         end
 
-        filter!(x -> x.channel == chan, eff)
-        effects_signal[] = eff
+        filter!(x -> x.channel == chan, yhats)
+        yhats_signal[] = yhats
     end
-    return effects_signal
+
+    return yhats_signal
 end
 
 

src/plot_data.jl

@@ -1,16 +1,21 @@
 
 """
     plot_data(data, value_ranges, categorical_vars, continuous_vars, mapping_obs)
-- `data`: effects(Dict(...), m) 
-- `value_ranges`:
-- `categorical_vars`:
-- `continuous_vars`:
-- `mapping`: Dict name=>property.
+Plotting an interactive dashboard.
 
-**Return Value:** `DataFrames`.
+Action:
+- Create default palletes for colors, markers, line styles and colorstyles for continuous values.
+
+ Arguments:
+- `data::DataFrame` - the result of `effects(Dict(...), model) ` with columns: yhat, channel, dummy, time, eventname and unique columns for each formula term..
+- `value_ranges::Vector{Pair{Symbol}}` - value range for continuous variables, levels for categorical.
+- `categorical_vars::Vector{Symbol}` - categorical terms.
+- `continuous_vars::Vector{Symbol}` - continuous terms.
+- `mapping::Dict{Symbol, Symbol}` - dictionary with dropdown menus and their default values.
+
+**Return Value:** `Makie.GridLayoutSpec`.
 """
 function plot_data(data, value_ranges, cat_terms, continuous_vars, mapping_obs)
-    #mapping = Dict(:color => :color, :fruit => :marker)#, :fruit => :linestyle) will work in Makie 0.21
     mapping = to_value(mapping_obs)
 
     mpalette = [:circle, :xcross, :star4, :diamond]
@@ -23,7 +28,7 @@ function plot_data(data, value_ranges, cat_terms, continuous_vars, mapping_obs)
     # is the formula term even active?
     cat_active = Dict(cat => data[1, cat] != "typical_value" for cat in cat_terms)
     cont_active = Dict(cont => data[1, cont] != "typical_value" for cont in continuous_vars)
-    #    @debug "active?" cat_active cont_active
+
     # get the categorical values
     cat_levels = [unique(data[!, cat]) for cat in cat_terms]
 

src/widgets.jl

@@ -53,7 +53,7 @@ end
 
 """
     mapping_dropdowns(varnames, var_types)
-Maps dropdown menus on the left panel of the Figure.\\
+Map and arrange dropdown menus on the left panel of the dashboard.\\
 
 Arguments:\\
 - `varnames::Vector{Symbol}` - vector of the model formula terms.
@@ -87,7 +87,7 @@ function mapping_dropdowns(varnames, var_types)
         :col => $(col_dropdown.value),
         :row => $(row_dropdown.value),
     )
-    mapping_dom =  Col(
+    mapping_dom = Col(
         Row(DOM.div("color:"), c_dropdown, align_items = "center", justify_items = "end"),
         Row(DOM.div("marker:"), m_dropdown, align_items = "center", justify_items = "end"),
         Row(
@@ -210,9 +210,27 @@ function rectselect(ax)
     return selrect
 end
 
-function topoplot_widget(positions; size = ())
+"""
+    topoplot_widget(positions; size = ())
+Controls the topoplot in the lower left panel of the figure.\\
+Highlight the location of the current electrode and allows electrode selection.
 
-    strokecolor = Observable(repeat([:red], length(to_value(positions))))
+Arguments:\\
+- `positions::Vector{Point{2, Float32}}` - x an y coordinates of the channels.
+- `size::Tuple{Float64, Float64}` - size of the topoplot panel.
+
+Actions:
+- Create interactive scatter.
+- Highlight the selected electrode with white color, others are grayed out. 
+- Create a topolot with a null interpolator and define its style and behavior.
+- Hide decorations and spines. 
+
+**Return Values:**
+- `h_topo::Makie.FigureAxisPlot` - topoplot widget.
+- `interactive_scatter::Observable{Int64}` - number of the selected channel.
+"""
+function topoplot_widget(positions; size = ())
+    strokecolor = Observable(repeat([:red], length(to_value(positions)))) # crashing
     interactive_scatter = Observable(1)
 
     colorrange = vcat(0, 1)
@@ -239,7 +257,6 @@ function topoplot_widget(positions; size = ())
             if isa(plt, Makie.Scatter)
                 data_obs[] .= 0
                 data_obs[][p] = 1
-                @debug data_obs
                 notify(data_obs)
                 interactive_scatter[] = p
             end
@@ -248,7 +265,6 @@ function topoplot_widget(positions; size = ())
     end
     hidedecorations!(h_topo.axis)
     hidespines!(h_topo.axis)
-    #xlims!(h_topo.axis, [-0.25 1.25])
     return h_topo, interactive_scatter
 
 end

test/basic.jl

@@ -1,8 +1,10 @@
-dataS, evts, pos2d = gen_data()
-formulaS = @formula(0 ~ 1 + luminance + fruit + animal)
-times = range(0, length = size(dataS, 2), step = 1 ./ 100)
-model = Unfold.fit(UnfoldModel, formulaS, evts, dataS, times)
-_, positions = TopoPlots.example_data()
+begin
+    dataS, evts, pos2d = gen_data()
+    formulaS = @formula(0 ~ 1 + luminance + fruit + animal)
+    times = range(0, length = size(dataS, 2), step = 1 ./ 100)
+    model = Unfold.fit(UnfoldModel, formulaS, evts, dataS, times)
+    _, positions = TopoPlots.example_data()
+end
 
 @testset "basic test" begin
     explore(model; positions = positions)