significant refactoring of the data structures

Author: dhonza

Project.toml

@@ -5,7 +5,9 @@ version = "0.1.0"
 
 [deps]
 CSV = "336ed68f-0bac-5ca0-87d4-7b16caf5d00b"
+CSVFiles = "5d742f6a-9f54-50ce-8119-2520741973ca"
 DSP = "717857b8-e6f2-59f4-9121-6e50c889abd2"
+DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0"
 DataStructures = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8"
 FFTViews = "4f61f5a4-77b1-5117-aa51-3ab5ef4ef0cd"
 FFTW = "7a1cc6ca-52ef-59f5-83cd-3a7055c09341"

src/SampleArrays.jl

@@ -12,9 +12,9 @@ using Interpolations
 using Unitful
 using Unitful: ns, ms, µs, s, Hz, kHz, MHz, GHz, THz
 
-include("magphase.jl")
+include("units.jl")
 
-include("freqtime.jl")
+include("magphase.jl")
 
 include("abstracttypes.jl")
 
@@ -30,11 +30,7 @@ include("impexp.jl")
 FFTW.rfft(x::SampleArray) = RFFTSpectrumArray(FFTW.rfft(data(x), 1), rate(x), nframes(x), names(x))
 FFTW.irfft(X::RFFTSpectrumArray{<:Complex}, d::Int) = SampleArray(FFTW.irfft(data(X), d, 1), rate(X), names(X))
 FFTW.irfft(X::RFFTSpectrumArray{MagPhase{E}}, d::Int) where E = SampleArray(FFTW.irfft(Complex{E}.(data(X)), d, 1), rate(X), names(X))
-function FFTW.irfft(X::RFFTSpectrumArray)
-    d = ntimeframes(X)
-    isnothing(d) && throw(ArgumentError("the number of original frames d not known, use irfft(a, d)"))
-    irfft(X, d)
-end
+FFTW.irfft(X::RFFTSpectrumArray) = irfft(X, ntimeframes(X))
 
 # ----- UTILS ---------------------------
 function DSP.unwrap!(Y::AbstractArray{T}, X::AbstractArray{T}; range=2E(pi), kwargs...) where {E, T <: MagPhase{E}}

src/abstracttypes.jl

@@ -1,6 +1,6 @@
 export AbstractSampleArray, nframes, nchannels, data, rate, rateHz, domain
 export names, names!
-export AbstractSpectrumArray, nfreqs, data_no0, domain_no0, slice, zerophase, zerophase!
+export AbstractSpectrumArray, nfreqs, data_no0, domain_no0, slice, zerophase, zerophase!, delay, delay!
 
 import Base: BroadcastStyle, IndexStyle, getindex, setindex!, show, similar, to_index, to_indices, ==
 import Base: cat, hcat, vcat, names
@@ -120,7 +120,7 @@ function Base.similar(bc::Broadcast.Broadcasted{Broadcast.ArrayStyle{T}}, ::Type
     a = saslist[imax]
     sim = similar(a, ElType, dims)
     for o in saslist
-        if o.names != a.names[1:nchannels(o)]
+        if names(o) != names(a)[1:nchannels(o)]
             names!(sim, _default_channel_names(nchannels(a)))
             break
         end
@@ -170,4 +170,12 @@ function zerophase!(X::AbstractSpectrumArray{<:Complex})
     X
 end
 
-zerophase(a) = zerophase!(deepcopy(a)) 
+zerophase(a) = zerophase!(deepcopy(a))
+
+function delay(X::AbstractSpectrumArray{T}, Δt::Time) where T
+    T.(MagPhase.(abs.(X), angle.(X) .- 2π .* domain(X) .* tos(Δt)))
+end
+
+function delay!(X::AbstractSpectrumArray, shift)
+    X .= delay(X, shift)
+end

src/freqtime.jl

@@ -1,7 +1,10 @@
+using CSVFiles
+using DataFrames
+using FileIO
 using FLAC
 using WAV
 
-export normalize, normalize!, readwav, readflac, readwav_rfft, writewav
+export normalize, normalize!, readwav, readflac, readwav_rfft, writewav, readfrd
 
 function normalize!(a::SampleArray)
     a ./= maximum(abs.(a))
@@ -10,30 +13,37 @@ end
 
 normalize(a::SampleArray) = normalize!(similar(a))
 
-function readwav(fname; format="double")
+function readwav(fname; format="double", names=nothing)
     y, Fs, nbits, opt = wavread(fname; format=format)
-    SampleArray(y, Fs)
+    SampleArray(y, Fs, names)
 end
 
-function readflac(fname)
+function readflac(fname; names=nothing)
     y, Fs = load(fname)
-    SampleArray(y, Fs)
+    SampleArray(y, Fs, names)
 end
 
-function readwav_rfft(fname; normalized=false, format="double")
-    x = readwav(fname; format=format)
+function readwav_rfft(fname; normalized=false, format="double", names=nothing)
+    x = readwav(fname; format=format, names=names)
     if normalized
         normalize!(x)
     end
     x, rfft(x)
 end
 
-function readflac_rfft(fname; normalized=false)
-    x = readflac(fname)
+function readflac_rfft(fname; normalized=false, names=nothing)
+    x = readflac(fname; names=names)
     if normalized
         normalize!(x)
     end
     x, rfft(x)
 end
 
 writewav(x::SampleArray, fname::String; kwargs...) = wavwrite(data(x), fname; Fs=rate(x), kwargs...)
+
+function readfrd(fname, rate; name=nothing, magf=db2amp, phasef=deg2rad)
+    df = DataFrame(load(File(format"TSV", fname); header_exists=false, colnames=[:freq, :mag, :phase]))
+    sort!(df, [:freq])
+    df = df[df.freq .<= toHz(rate)/2, :]
+    SpectrumArray(Complex.(MagPhase.(magf.(df.mag), phasef.(df.phase))), rate, df.freq, isnothing(name) ? nothing : [name])
+end

src/impexp.jl

@@ -4,25 +4,19 @@ export RFFTSpectrumArray, resamplefreq, ntimeframes
 struct RFFTSpectrumArray{T} <: AbstractSpectrumArray{T}
     data::Matrix{T} # non-interleaving frequencies x channels
     rate::Float64 # sampling frequency in Hz
-    ntimeframes::Union{Int,Nothing} # number of original signal frames or nothing if not known
+    ntimeframes::Int # number of original signal frames or nothing if not known
     names::Vector{Symbol}
 
-    function RFFTSpectrumArray{T}(X::Matrix{T}, rate::Float64, ntimeframes::Union{Int,Nothing}, names::Vector{Symbol}) where T
-        isnothing(ntimeframes) || (ntimeframes >> 1 + 1 == size(X, 1) || throw(DimensionMismatch("ntimeframes >> 1 + 1 = $(ntimeframes >> 1 + 1) != size(X, 1) = $(size(X, 1))")))
+    function RFFTSpectrumArray{T}(X::Matrix{T}, rate::Float64, ntimeframes::Int, names::Vector{Symbol}) where T
+        ntimeframes >> 1 + 1 == size(X, 1) || throw(DimensionMismatch("ntimeframes >> 1 + 1 = $(ntimeframes >> 1 + 1) != size(X, 1) = $(size(X, 1))"))
         _check_channel_names(names)
         length(names) == size(X, 2) || throw(DimensionMismatch("the number of names ($(length(names))) does not match the number of channels ($(size(X, 2)))!"))
-        new(X, rate, ntimeframes, names)
+        new{T}(X, rate, ntimeframes, names)
     end
 end
 
-RFFTSpectrumArray(X::AbstractMatrix{T}, rate::Frequency, ntimeframes::Union{Int,Nothing}, names::Vector{Symbol}) where T = 
-    RFFTSpectrumArray{T}(X, toHz(rate), ntimeframes, names)
-RFFTSpectrumArray(X::AbstractMatrix{T}, rate::Frequency, ntimeframes::Union{Int,Nothing}) where T = 
-    RFFTSpectrumArray{T}(X, toHz(rate), ntimeframes,  _default_channel_names(size(X, 2)))
-RFFTSpectrumArray(X::AbstractMatrix{T}, rate::Frequency, names::Vector{Symbol}) where T = 
-    RFFTSpectrumArray{T}(X, toHz(rate), nothing, names)
-RFFTSpectrumArray(X::AbstractMatrix{T}, rate::Frequency) where T =  
-    RFFTSpectrumArray{T}(X, toHz(rate), nothing,  _default_channel_names(size(X, 2)))
+RFFTSpectrumArray(X::AbstractMatrix{T}, rate::Frequency, ntimeframes::Integer, names::Union{Nothing,Vector{Symbol}}=nothing) where T = 
+    RFFTSpectrumArray{T}(X, toHz(rate), Int(ntimeframes), isnothing(names) ? _default_channel_names(size(X, 2)) : names)
 
 ntimeframes(X::RFFTSpectrumArray) = X.ntimeframes
 domain(X::RFFTSpectrumArray) = range(0, rate(X) / 2; length=nframes(X))
@@ -32,28 +26,32 @@ data_no0(X::RFFTSpectrumArray) = @view data(X)[2:end, :]
 domain_no0(X::RFFTSpectrumArray) = @view domain(X)[2:end]
 
 
-function Base.similar(X::RFFTSpectrumArray, t::Type{T}, dims::Dims, ntimeframes::Union{Int,Nothing}=nothing) where T
+function Base.similar(X::RFFTSpectrumArray, t::Type{T}, dims::Dims) where T
     # tries to copy channel names
     # if there are fever names in the source array use default ones
     # changing number of frames (frequencies) looses information on number of original timeframes.
     ns = dims[2] ≤ nchannels(X) ? X.names[1:dims[2]] : _default_channel_names(dims[2])
-    ntimeframes_ = dims[1] != nframes(X) ? nothing : ntimeframes
-    RFFTSpectrumArray(similar(data(X), t, dims), rate(X), ntimeframes_, ns)
+    if dims[1] != nframes(X)
+        throw(ArgumentError("can not change the number of frequencies!"))
+    else
+        return RFFTSpectrumArray(similar(data(X), t, dims), rate(X), ntimeframes(X), ns)
+    end
 end
 
 # redefined so frequencies & channel names are treated
-function Base.getindex(X::RFFTSpectrumArray{T}, I::R, J::S) where {T, R <: FrameIndex, S <: ChannelIndex}
-    I2 = toframeidx(X, I)
+Base.getindex(X::RFFTSpectrumArray{T}, I::R, J::S) where {T, R <: FrameIndex, S <: ChannelIndex} = throw(ArgumentError("frame index ($R) not allowed, use Colon!"))
+
+function Base.getindex(X::RFFTSpectrumArray{T}, ::Colon, J::S) where {T, S <: ChannelIndex}
     J2 = tochannelidx(X, J)
     names_ = names(X)[J2]
-    data_ = data(X)[I2, J2]
-    ntimeframes_ = size(data_, 1) != nframes(X) ? nothing : ntimeframes(X)
-    RFFTSpectrumArray{T}(data_, rate(X), ntimeframes_, names_)
+    data_ = data(X)[:, J2]
+    return RFFTSpectrumArray(data_, rate(X), ntimeframes(X), names_)
 end
 
 function Base.hcat(X::RFFTSpectrumArray...) 
     length(unique(rate.(X))) == 1 || throw(ArgumentError("hcat: non-unique rates!"))
     length(unique(nframes.(X))) == 1 || throw(DimensionMismatch("hcat: non-unique number of frames/frequencies!"))
+    length(unique(ntimeframes.(X))) == 1 || throw(DimensionMismatch("hcat: non-unique number of original frames!"))
     newnames = _unique_channel_names(X...)
     data_ = hcat(map(data, X)...)
     return eltype(X)(data_, rate(X[1]), ntimeframes(X[1]), newnames) # eltype gives common supertype
@@ -66,7 +64,7 @@ end
 function Base.show(io::IO, ::MIME"text/plain", X::RFFTSpectrumArray{T}) where T
     d = domain(X)
     step = d[2] - d[1]
-    nframesstr = isnothing(ntimeframes(X)) ? "" : " from $(ntimeframes(X)) frames"
+    nframesstr = " from $(ntimeframes(X)) frames"
     clist = join([":$(n)" for n in names(X)], ", ")
     print(io, "RFFTSpectrumArray{$T}: $(nchannels(X)) channels: $(clist)\n $(nframes(X)) freqs $(first(d)) - $(last(d)) Hz, step ≈ $(step) Hz sampled at $(rate(X)) Hz$(nframesstr):\n ")
     print(io, data(X))

src/rfftspectrumarray.jl

@@ -1,6 +1,6 @@
 # ----- SampleArray ---------------------
 
-export SampleArray, getduration
+export SampleArray, getduration, toindexdelta
 
 struct SampleArray{T} <: AbstractSampleArray{T}
     # data::AbstractMatrix{T} # MUCH SLOWER! non-interleaving frames x channels
@@ -15,11 +15,11 @@ struct SampleArray{T} <: AbstractSampleArray{T}
     end
 end
 
-SampleArray(x::AbstractMatrix{T}, rate::Frequency, names::Vector{Symbol}) where T = SampleArray{T}(x, toHz(rate), names)
-SampleArray(x::AbstractMatrix{T}, rate::Frequency) where T = SampleArray{T}(x, toHz(rate), _default_channel_names(size(x, 2)))
+SampleArray(x::AbstractMatrix{T}, rate::Frequency, names::Union{Nothing,Vector{Symbol}}=nothing) where T = 
+    SampleArray{T}(x, toHz(rate), isnothing(names) ? _default_channel_names(size(x, 2)) : names)
 
-SampleArray(x::AbstractVector{T}, rate::Frequency, names::Vector{Symbol}) where T = SampleArray{T}(reshape(x, :, 1), toHz(rate), names)
-SampleArray(x::AbstractVector{T}, rate::Frequency) where T = SampleArray{T}(reshape(x, :, 1), toHz(rate), _default_channel_names(1))
+SampleArray(x::AbstractVector{T}, rate::Frequency, names::Union{Nothing,Vector{Symbol}}=nothing) where T = 
+    SampleArray{T}(reshape(x, :, 1), toHz(rate), isnothing(names) ? _default_channel_names(size(x, 2)) : names)
 
 domain(x::SampleArray) = range(0, ((nframes(x)-1)/rate(x)); length=nframes(x))
 

src/samplearray.jl

@@ -1,33 +1,34 @@
-export SpectrumArray, tologfreq
+export SpectrumArray, SpectrumDomain, tologfreq
 
 # ----- SpectrumArray ---------------------------
+const SpectrumDomain = Union{AbstractVector{<:Frequency}, AbstractRange{<:Frequency}}
+const SpectrumDomainReal = Union{AbstractVector{<:Real}, AbstractRange{<:Real}}
 
-struct SpectrumArray{T} <: AbstractSpectrumArray{T} # TODO complete implemetation!
+struct SpectrumArray{T,F<:SpectrumDomainReal} <: AbstractSpectrumArray{T}
     data::Matrix{T} # non-interleaving frequencies x channels
     rate::Float64 # original sampling rate
-    freqs::Vector{Float64}
+    freqs::F # in Hz
     names::Vector{Symbol}
 
-    function SpectrumArray{T}(data::Matrix{T}, rate::Float64, freqs::Vector{Float64}, names::Vector{Symbol}) where T
+    function SpectrumArray{T,F}(data::Matrix{T}, rate::Float64, freqs::F, names::Vector{Symbol}) where {T,F}
         if length(freqs) != size(data, 1)
             throw(DimensionMismatch("data size $(size(data, 1)) does not match the number of frequencies $(length(freqs))"))
         end
         _check_channel_names(names)
         length(names) == size(data, 2) || throw(DimensionMismatch("the number of names ($(length(names))) does not match the number of channels ($(size(data, 2)))!"))
         length(unique(freqs)) == length(freqs) || throw(ArgumentError("non-unique freqs!"))
-        new(data, rate, freqs, copy(names))
+        new{T,F}(data, rate, freqs, copy(names))
     end
 end
 
-SpectrumArray(X::AbstractMatrix{T}, rate::Frequency, freqs::AbstractVector{<:Frequency}, names::Vector{Symbol}) where T = 
-    SpectrumArray{T}(X, toHz(rate), Float64.(toHz.(freqs)), names)
-SpectrumArray(X::AbstractMatrix{T}, rate::Frequency, freqs::AbstractVector{<:Frequency}) where T = 
-    SpectrumArray{T}(X, toHz(rate), Float64.(toHz.(freqs)),  _default_channel_names(size(X, 2)))
+function SpectrumArray(X::AbstractMatrix{T}, rate::Frequency, freqs::SpectrumDomain, names::Union{Nothing,Vector{Symbol}}=nothing) where {T}
+    freqs_ = toHz(freqs)
+    F = typeof(freqs_)
+    SpectrumArray{T,F}(X, toHz(rate), freqs_, isnothing(names) ? _default_channel_names(size(X, 2)) : names)
+end
 
-SpectrumArray(X::AbstractVector{T}, rate::Frequency, freqs::AbstractVector{<:Frequency}, names::Vector{Symbol}) where T = 
-    SpectrumArray{T}(reshape(X, :, 1), toHz(rate), Float64.(toHz.(freqs)), names)
-SpectrumArray(X::AbstractVector{T}, rate::Frequency, freqs::AbstractVector{<:Frequency}) where T = 
-    SpectrumArray{T}(reshape(X, :, 1), toHz(rate), Float64.(toHz.(freqs)), _default_channel_names(1))
+SpectrumArray(X::AbstractVector{T}, rate::Frequency, freqs::F, names::Union{Nothing,Vector{Symbol}}=nothing) where {T, F<:SpectrumDomain} = 
+    SpectrumArray(reshape(X, :, 1), rate, freqs, names)
 
 domain(X::SpectrumArray) = X.freqs
 _findno0freqs(X::SpectrumArray) = findall(!iszero, domain(X))
@@ -39,7 +40,7 @@ function toindex(X::SpectrumArray{T}, t::Frequency) where T
     findmin(diffs)[2]
 end
 
-function Base.similar(X::SpectrumArray, t::Type{T}, dims::Dims, freqs::AbstractVector{<:Frequency}) where T
+function Base.similar(X::SpectrumArray, t::Type{T}, dims::Dims, freqs::SpectrumDomain) where T
     # tries to copy channel names
     # if there are fever names in the source array use default ones
     # TODO: move to abstracttypes.jl?
@@ -55,13 +56,13 @@ function Base.similar(X::SpectrumArray, t::Type{T}, dims::Dims) where T
 end
 
 # redefined so frequencies & channel names are treated
-function Base.getindex(X::SpectrumArray{T}, I::R, J::S) where {T, R <: FrameIndex, S <: ChannelIndex}
+function Base.getindex(X::SpectrumArray{T,F}, I::R, J::S) where {T, F, R <: FrameIndex, S <: ChannelIndex}
     I2 = toframeidx(X, I)
     J2 = tochannelidx(X, J)
     freqs_ = domain(X)[I2]
     names_ = names(X)[J2]
     data_ = data(X)[I2, J2]
-    SpectrumArray{T}(data_, rate(X), freqs_, names_)
+    SpectrumArray{T,F}(data_, rate(X), freqs_, names_)
 end
 
 Base.getindex(X::SpectrumArray{T}, I::R) where {T, R <: FrameIndex} = X[I, :]
@@ -72,7 +73,9 @@ function Base.hcat(X::SpectrumArray...)
     length(unique(domain.(X))) == 1 || throw(ArgumentError("hcat: non-unique domains!"))
     newnames = _unique_channel_names(X...)
     data_ = hcat(map(data, X)...)
-    return eltype(X)(data_, rate(X[1]), domain(X[1]), newnames) # eltype gives common supertype
+    rate_ = rate(X[1])
+    domain_ = domain(X[1]) 
+    return SpectrumArray{eltype(data_),typeof(domain_)}(data_, rate_, domain_, newnames) # eltype gives common supertype
 end
 
 function Base.vcat(X::SpectrumArray...)
@@ -82,7 +85,7 @@ function Base.vcat(X::SpectrumArray...)
     length(unique(namelists)) == 1 || throw(ArgumentError("vcat: non-unique channel names!"))
     data_ = vcat(map(data, X)...)
     freqs_ = vcat(map(domain, X)...)
-    return eltype(X)(data_, rate(X[1]), freqs_, namelists[1])
+    return SpectrumArray{eltype(data_),typeof(freqs_)}(data_, rate(X[1]), freqs_, namelists[1])
 end
 
 function Base.show(io::IO, ::MIME"text/plain", X::SpectrumArray{T}) where T

src/spectrumarray.jl

@@ -0,0 +1,31 @@
+export Frequency, Time, Distance, Velocity
+export toHz, tos, tom, tomps
+
+# ----- Frequency and Time ----------------------
+const Frequency = Union{Real, Unitful.Frequency}
+
+toHz(f::Real) = Float64(f)
+toHz(f::Unitful.Frequency) = ustrip(Float64, Hz, f)
+toHz(fa::AbstractArray{<:Frequency}) = toHz.(fa)
+toHz(fr::AbstractRange{<:Unitful.Frequency}) = toHz(minimum(fr)):toHz(step(fr)):toHz(maximum(fr))
+
+const Time = Union{Real, Unitful.Time}
+
+tos(t::Real) = Float64(t)
+tos(t::Unitful.Time) = ustrip(Float64, s, t)
+tos(ta::AbstractArray{<:Time}) = tos.(ta)
+tos(tr::AbstractRange{<:Unitful.Time}) = tos(minimum(tr)):tos(step(tr)):tos(maximum(tr))
+
+const Distance = Union{Real, Unitful.Length}
+
+tom(s::Real) = Float64(s)
+tom(s::Unitful.Length) = ustrip(Float64, u"m", s)
+tom(sa::AbstractArray{<:Distance}) = tom.(sa)
+tom(sr::AbstractRange{<:Unitful.Length}) = tom(minimum(sr)):tom(step(sr)):tom(maximum(sr))
+
+const Velocity = Union{Real, Unitful.Velocity}
+
+tomps(v::Velocity) = Float64(v)
+tomps(v::Unitful.Velocity) = ustrip(Float64, u"m/s", v)
+tomps(va::AbstractArray{<:Velocity}) = tomps.(va)
+tomps(vr::AbstractRange{<:Unitful.Velocity}) = tomps(minimum(vr)):tomps(step(vr)):tomps(maximum(vr))