I am a little bit surprised about the performance of argmaxima compared with a direct implementation:

using Test, BenchmarkTools
using Peaks

function localmaxmin!(y, maxs::Vector{Int}, mins::Vector{Int})
   empty!(maxs)
   empty!(mins)
   for i in 2:length(y)-1
       if y[i+1] < y[i] > y[i-1]
           push!(maxs, i)
       elseif y[i+1] > y[i] < y[i-1]
           push!(mins, i)
       end
   end
end

function localmaxmin2!(x, maxs, mins)
   append!(maxs2, argmaxima(x))
   append!(mins2, argminima(x))
   maxs2, mins2
end

function localmax(y)
   maxs = Int[]
   for i in 2:length(y)-1
       if y[i+1] < y[i] > y[i-1]
           push!(maxs, i)
       end
   end
   maxs
end

function localmax2(x)
   maxs2 = argmaxima(x)
end

maxs = Int[]
mins  = Int[]
maxs2= Int[]
mins2 = Int[]
x = zeros(100000)
x_max = 2:100:100000
x[x_max] .= 1
x_min = 5:100:100000
x[x_min] .= -1
localmaxmin!(x, maxs, mins)
localmaxmin2!(x, maxs2, mins2)

@test maxs == maxs2
@test mins == mins2

@btime localmax(x)
@btime localmax2(x)
@test localmax(x) == localmax2(x)

On my laptop, this returns

102.428 μs (10 allocations: 16.39 KiB)
380.387 μs (6 allocations: 398.92 KiB)
Test Passed

which is 3 times slower.

from a cursory glance there shouldn't be any issues with that

Calculating the extrema of an array with peakprom it would be nice to be able to switch off the strictbounds imposed by the maxima/minima.
Maybe something like

...
@eval begin
    function peakprom(x::AbstractVector{T}, ::$Extrema, w=1, minprom::T=zero(T), strictbounds::Bool=true) where T
        if ($Extrema) === Maxima
            m = maxima(x, w, strictbounds)
        else
            m = minima(x, w, strictbounds)
        end
...

would already be enough.

Again, this is not hard to implement manually. But it would be very nice to be able to specify a lower bound for not only the peak prominence, but also the absolute value.

It is currently not hard to do manually, but it would be very convenient to have a keyword argument to some function see #24 that set the maximal and/or minimal number of peaks to look for, defaulting to 0 and Inf. I am using this in the context of calibrating a spectrogram, where I know the number of peaks I am looking for in advance, and in reality I just want the 4 most prominent peaks.

It would be very nice to get an option to get a minimal peak separation, such as that found in https://github.com/tungli/Findpeaks.jl.

Currently, the readme and plot therein look to me like they demo the package. However, they do not show examples of setting the minimum window width w, nor do they demo the peakheights function.

I suggest:
a) All functions are shown in the readme, perhaps in a complete list, or that
b) the readme is made more barebones, and that users are referred to the documentation for fuller examples, which should include examples using peakheight and w?

Or some combination of the two:
"The filtering functions are seen in the table below, and full examples can be found in the docs"

HI,
Do you have some bibliography explaining the implemented code?
I would like to understand how the algorithm of finding peaks (and the prominences) works
Thank you!
Ignacio

Hello,

I'm trying to use this code to find peak position from an array of floats. However I'm getting this error:

If I run the example code with this array x = [0,5,2,3,3,1,4,0]; I do get a result, any idea of what is the problem?

Thanks in advance!

thanks for this package!

i'd suggest providing links to these alternatives in your README and differentiating your features from them. or join forces to provide the ultimate peak finder!

tungli/Findpeaks.jl#2

https://github.com/JuliaImages/Images.jl/blob/master/src/algorithms.jl#L464

I tried to to find the local maxima of my data with this package. It worked very well except for two points where the results seem wrong. An example with reduced data:

Here is the code to reproduce this with the attached data (with CSV.jl):

w = 327
CSVData = CSV.File("WrongPeak.csv")
x = CSVData.Column1
y = CSVData.Column2
pks, vals = findmaxima(y, w)
plotpeaks(x, y, peaks=pks, scale=:log10)

WrongPeak.csv

Am I doing something wrong here?

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!

Maxima of an array of all zeros is

julia> peakprom(zeros(10), Maxima())
([2, 4, 6, 8], [0.0, 0.0, 0.0, 0.0])

instead of (Int64[], Float64[]).

hi,

I've implemented findpeaks as found in the pracma R package (https://github.com/cran/pracma). The original author gave his OK for a transcription into Julia, now the question is, if you are open to accept this function as a PR. (I don't want to create/register/maintain a package just for a single function, and your package Peaks.jl looks like a good candidate to include such a function).

EDIT: See later comments, as the proposed API has changed significantly during this thread.

I find the current implementation of

1. finding peaks
2. redefining pks with the return values from peakproms and peakwidths
   to be rather weird and un-ergonomic. Something like what is implemented in https://github.com/tungli/Findpeaks.jl seems way more inntuitive for me, where there is only one function, and the peaks can be filtered by prominence and width directly by keyword arguments.

If a redo is on the table, I just want to mention an idea I have had:
With the package called "Peaks", I was expecting "findpeaks" to be the main function. It could return a FoundPeaks object (Can not be same as package, perhaps other names for the type is better) that contains the peaks, the indices, the prominence, and the widths. It would also be nice to be able to provide the x-values, and get the corresponding x-values for the peaks and widths in terms of x-values, rather than having to work with indices always. Ofc the indices should also be part of the returned object.

Then, the API could be something like

xs = 0:0.1:10
ys = rand(length(xs))
pks = findpeaks(ys)  # Only have indices as x-units
pks = findpeaks(xs, ys)  # Return x-coordinate of peaks, and width in units of the x-coordinate

# Access fields, reads almost like english words.
# Internal implementation could be pks.fieldname, allowing 
# internal changes to be non-breaking in the future to remain flexible

index(pks)
location(pks)  # for getting x-vals
width(pks)
width(pks, ind=false)  # kwarg to select indices or x-vals as unit
prominence(pks)
seperation(pks)  # Or just exemplify with  `diff(index(pks))` or `diff(location(pks)`

On Julia v1.0 I installed the package Pkg.add("Peaks") and then using Peaks and none of the functions are usable. My interpreter doesn't recognize the commands.

If I have a vector v, and want to find all peaks so that it is the highest value in the interval [i-w:i+w], how do I do it? The docs says

findmaxima(x[, w=1; strict=true]) -> (idxs, vals)

but I really do not understand what syntax to use, e.g.

findmaxima(x[, w=1; strict=true])

does not work. I can do

findmaxima(x)

but then I have w=1, which I not necessarily want.