Ensure code works with Julia 0.6.
Create a new release.

To generate topoplots we will first need to define a transform to flatten the sensor positions

Move tests over to FactCheck.jl

To replace triggers type. Annotations are more general and can be used to encode things beyond triggers, such as bad segments, blinks, etc

Likely easier to fix once all packages are using the latest version (#92)

Take out code that has fallen in to disrepair through disuse.

Since we have switched to Plots.jl we could use Recipes for cleaner plotting.

Then SSR should inherit from EEG etc

• Docile (move to Documenter.jl)
• Synchrony (functionality was never used in EEG.jl)

Ensure code runs on Julia 1.0

Following #43 and #99. Need to find a relevant dataset for the SSR example (#35 ) or upload something myself. But all my data is 4GB so too big. And the MNE example data is .eeg format, which we don't support. So need to find a good example data

Rather than store figures in the repo, place them here and link.

How to change name of a package safely?

https://juliadocs.github.io/Documenter.jl/stable/man/guide/

From Logging.jl

For the functions above, there is always a small overhead for the function call even when there is no log output. Logging.jl provides macros which work like the functions above, but which remove this overhead.

Change trim_channel to crop.

Add support for using Unitful values e.g. crop(eeg, 30u"s")

is this possible? I assume so. Can we make the documentation example run and rebuild figure each time?

• AWS
• DSP
• BDF
• DataFrames
• SIUnits
• ProgressMeter
• Distributions
• Distances
• Logging
• Documenter
• FileFind (No tests but seems to work)
• Images
• MAT
• Plots
• Documenter

Write function to download test data using https://github.com/oxinabox/DataDeps.jl

I am thinking neuroimaging.jl as I will add support for MEG, fNIRS, etc

I remember seeing a head/brain visualisation on one of the plotting library demos, this can be a nice basis.

The data should be carefully selected as a standard head model from one of the well published sources with well described coordinates etc.

I really appreciate all the work you're doing on this. I'm currently deeply in neuroimaging research and trying to add EEG to my repertoire for my current lab. This package is looking very promising and I'm hoping to start using it in the coming months, but I personally would need some more tutorials and examples. Are there any currently available tutorials or notebooks available?

E.g. Add an ERP example

Do the same as here: https://github.com/rob-luke/AuditoryStimuli.jl/blob/main/.github/workflows/docs.yml

Add an example of how to process a steady state response using this data https://mne.tools/stable/generated/mne.datasets.ssvep.data_path.html#mne.datasets.ssvep.data_path

As described in https://discourse.julialang.org/t/ann-plans-for-removing-packages-that-do-not-yet-support-1-0-from-the-general-registry/ we are planning on removing packages that do not support 1.0 from the General registry. This package has been detected to not support 1.0 and is thus slated to be removed. The removal of packages from the registry will happen approximately a month after this issue is open.

To transition to the new Pkg system using Project.toml, see https://github.com/JuliaRegistries/Registrator.jl#transitioning-from-require-to-projecttoml.
To then tag a new version of the package, see https://github.com/JuliaRegistries/Registrator.jl#via-the-github-app.

If you believe this package has erroneously been detected as not supporting 1.0 or have any other questions, don't hesitate to discuss it here or in the thread linked at the top of this post.

Based on this we will likely have to drop support for previous Julia versions

The type system could be made clearer.

Top level split in to

abstract EvokedPotential
abstract SpontaneousPotential

Then different categories defined

abstract SteadyStateResponse <: EvokedPotential
abstract TransientResponse <: EvokedPotential
abstract RestingState <: SpontaneousPotential

Finally specific types are specified

type AuditorySteadyStateResponse <: SteadyStateResponse
    # Definitions
end

type VisualSteadyStateResponse <: SteadyStateResponse
    # Definitions
end

type AuditoryBrainstemResponse <: TransientResponses
    # Definition
end

This would reduce complexity as

assr = AuditorySteadyStateResponse()
isa(assr, SteadyStateResponse)      # true
isa(assr, EvokedPotential)          # true

This issue is used to trigger TagBot; feel free to unsubscribe.

If you haven't already, you should update your TagBot.yml to include issue comment triggers.
Please see this post on Discourse for instructions and more details.

If you'd like for me to do this for you, comment TagBot fix on this issue.
I'll open a PR within a few hours, please be patient!

Drop any old versions that require extra work to maintain.

Currently on the size of the dipole is compared. Add check for x, y and z coordinates.

Make a function to compare distances. Eg

function same_location(a, b) = distance(a, b) == 0

The tests are throwing the following warnings due to changes in the data frames dependency package. These need to be fixed as described in the warning.

┌ Warning: `getindex(df::DataFrame, col_ind::ColumnIndex)` is deprecated, use `df[!, col_ind]` instead.
│   caller = extract_epochs(data::Matrix{Float64}, triggers::Dict{String, AbstractArray}, valid_triggers::Vector{Int64}, remove_first::Int64, remove_last::Int64, trigger_offset::Int64) at epochs.jl:54
└ @ EEG ~/work/EEG.jl/EEG.jl/src/reshaping/epochs.jl:54

┌ Warning: `setindex!(df::DataFrame, v::AbstractVector, col_ind::ColumnIndex)` is deprecated, use `begin
│     df[!, col_ind] = v
│     df
│ end` instead.
│   caller = extract_epochs(data::Matrix{Float64}, triggers::Dict{String, AbstractArray}, valid_triggers::Vector{Int64}, remove_first::Int64, remove_last::Int64, trigger_offset::Int64) at epochs.jl:39
└ @ EEG ~/work/EEG.jl/EEG.jl/src/reshaping/epochs.jl:39

The current reader used is https://github.com/sam81/BDF.jl which hasn't been updated since 2018, this is only an issue as it is requiring old package dependencies.

Best plan seems to be to switch over to beacon-biosignals/EDF.jl#46 once its merged.

Obviously this is wack

a = read_SSR("test.bdf", channels = ["Cz", "P6"])
channelnames(a)

#2-element Array{AbstractString,1}:
# "Fp1"
# "AF7"

There are aspects of the code base that are specific to my old lab setup. Please note these as comments below and we can systematically remove them and make things more general.

Ensure code works with Julia 0.6.
Create a new release.

Very similar to BDF files, EDF is the standard format of biosignals for many EEG amplifiers, including the cheapest in the market: Emotiv Epoch, Emotiv Insight, and OpenBCI. Adding support to this format would allow a bigger community to use and support the project.
The description of the format can be found here, and an attempt at reading EDF from julia can be found here (although it seems like it's only some pasted python code)

From the google julia-users group I've found this code:

function load_edf(filename::String)

  header = Dict{ASCIIString,Any}()

  open(filename,"r") do fd
    version =  bytestring( read(fd, Uint8, 8) )
    header["version"] = version

    localPatientId =  bytestring( read(fd, Uint8, 80) )
    header["version"] = localPatientId

    ...

    # here the data would be read
  end
  return data, header
end

The conversation also points to @codles BDF.jl, but when trying to read an EDF with EEG.jl the following error appears:

WARNING:root:File type edf is unknown

I would love to help creating the functionality, but I'm still not very well acquainted with the library. If you can point me in the right direction I'll do my best to create it.

See coordinates for example

Currently we have

samplerate(s)
channelnames(s)
etc

need to add

triggers(s)

to return triggers rather than the current method of returning via access to the object property

Ensure code works with Julia 0.6.
Create a new release.

Probably following #7

Handy way to view which packages are out of date (in addition to CompatHelper)...

using Pkg

cd(joinpath(DEPOT_PATH[1], "registries", "General")) do
         deps = Pkg.dependencies()
         registry = Pkg.TOML.parse(read("Registry.toml", String))
         general_pkgs = registry["packages"]
    
         constrained = Dict{String, Tuple{VersionNumber,VersionNumber}}()
         for (uuid, dep) in deps
             suuid = string(uuid)
             dep.is_direct_dep || continue
             dep.version === nothing && continue
             haskey(general_pkgs, suuid) || continue
             pkg_meta = general_pkgs[suuid]
             pkg_path = joinpath(pkg_meta["path"], "Versions.toml")
             versions = Pkg.TOML.parse(read(pkg_path, String))
             newest = maximum(VersionNumber.(keys(versions)))
             if newest > dep.version
                 constrained[dep.name] = (dep.version, newest)
             end
         end
    
         return constrained
     end
end

From https://bkamins.github.io/julialang/2020/05/11/package-version-restrictions.html

The URL of this package does not match that stored in METADATA.jl.
cc: @rob-luke