31:T4e3,md`With a threshold set to 0.001, we notice that 6 cars are detected out of 7. The problem is located between 7.0 and 8.5 seconds where the two cars aren't separated. This problem is solved when increasing the threshold to 0.1. However we can see that other cars are separated in several peaks. Thus, we will apply **a post process to merge peaks that are too close but only if they are not wide enough.** Indeed, the peaks of the two cars between 7 and 8.5 seconds are very close but we want to keep their peaks separate. So we will introduce two parameters which are the minimum width of a peak and the minimum distance between two peaks. If two peaks are too close to each other and one of them is too thin, then we merge these two peaks into one. Experimentally, we determined that under normal conditions on the working webcam, the cars stayed on the line for an average of 0.5 seconds. We therefore set the minimum distance between two cars to 0.5 and the minimum width of a peak corresponding to one car to 0.3. Applying this post-process, we obtain the following result. Green lines indicates a peak, i.e the passage of a car, while light green band indicates the width of this peak, i.e the time during which the car crosses on the line.`32:T891,mergePeaks = function(peaks,signal,minPeakWidth,minPeaksDistance){ let mergedPeaks = [peaks[0]]; for(let i = 1; i < peaks.length; i++){ let previousPeak = mergedPeaks[mergedPeaks.length-1]; let currentPeak = peaks[i]; // test if the previous peak is large enough if((previousPeak.endTime - previousPeak.beginTime)<=minPeakWidth){ if(currentPeak.beginTime - previousPeak.endTime<=minPeaksDistance){ // merge peaks mergedPeaks[mergedPeaks.length-1]= { 'peakStart':previousPeak.peakStart, 'onePeak':previousPeak.peakStart + Math.trunc((currentPeak.peakEnd-previousPeak.peakStart)/2), 'peakEnd':currentPeak.peakEnd, 'beginTime':signal[previousPeak.peakStart].time, 'peakTime':signal[previousPeak.peakStart + Math.trunc((currentPeak.peakEnd-previousPeak.peakStart)/2)].time, 'endTime':signal[currentPeak.peakEnd].time } } // if not close, add the peak to merge list else{ mergedPeaks.push(currentPeak); } } // else test if the current peak is large enough else{ if((currentPeak.endTime - currentPeak.beginTime)<=minPeakWidth){ if(currentPeak.beginTime - previousPeak.endTime<=minPeaksDistance){ // merge peaks mergedPeaks[mergedPeaks.length-1]= { 'peakStart':previousPeak.peakStart, 'onePeak':previousPeak.peakStart + Math.trunc((currentPeak.peakEnd-previousPeak.peakStart)/2), 'peakEnd':currentPeak.peakEnd, 'beginTime':signal[previousPeak.peakStart].time, 'peakTime':signal[previousPeak.peakStart + Math.trunc((currentPeak.peakEnd-previousPeak.peakStart)/2)].time, 'endTime':signal[currentPeak.peakEnd].time } } // if not too close to another peak we push it to mergedPeaks else{ mergedPeaks.push(currentPeak); } } // if not too thin we push it to mergedPeaks else{ mergedPeaks.push(currentPeak); } } } return mergedPeaks }33:T686,getPeaksThreshold = function(signal,options = {}){ // signal is an array of Objects {'time':time,'value':value} /////// Options /////// // choose to merge peaks if they are too close and if the peak is too thin let mergeClosedPeaks = options.hasOwnProperty('mergeClosedPeaks') ? options.mergeClosedPeaks : true; let minPeaksDistance = options.minPeaksDistance || 0.5; // Visually a car is 0.5s on the line let minPeakWidth = options.minPeakWidth || 0.3; // a peak thinner than this value can be merged /////// Thld Signal /////// // Assign to each point 1 if above the threeshold else 0 let signalThreshold = getSignalThreshold(signal,options); /////// Deduce Peaks /////// // compute peaks from the score let index = 0; let peaks = []; while (index < signalThreshold.length){ let peakStart = index; if(signalThreshold[index].value==1){ while (index < signalThreshold.length && signalThreshold[index].value==1){ index++ } let peakEnd = index-1; let onePeak = peakStart + Math.trunc((peakEnd-peakStart)/2); peaks.push({ 'peakStart':peakStart, 'onePeak':onePeak, 'peakEnd':peakEnd, 'beginTime':signal[peakStart].time, 'peakTime':signal[onePeak].time, 'endTime':signal[peakEnd].time }) } index++ } /////// Merge Peaks /////// // merge peaks that are too thin and to close if(mergeClosedPeaks){ let mergedPeaks = mergePeaks(peaks,signal,minPeakWidth,minPeaksDistance); return {'peaks':mergedPeaks,'signalThld':signalThreshold} } return {'peaks':peaks,'signalThld':signalThreshold} }34:T662,md` --- ### Use z-scores In the [previous notebook](https://observablehq.com/d/6132bf34340e84c4), we tried to obtain a signal that allows us to distinguish the passage of cars, ie a signal that is 0 when there are no cars. Thus, we could see that the application of a threshold can allow us to detect cars. However, when there is a lot of car traffic, the signal may not be as perfect since there will not be enough space between two cars. In order to anticipate this, we try to implement a more robust method. For this purpose, we compute an approach inspired by [@yurivish one's](https://observablehq.com/@yurivish/peak-detection) and by this [paper](https://www.researchgate.net/publication/228853276_Simple_Algorithms_for_Peak_Detection_in_Time-Series/related)[1]. The method consists in calculating the z-score for each point of the signal which is defined by ${tex`z=\frac{x-m}{\sigma}`} with m (resp ${tex`\sigma`}) the average (resp standard deviation) of a window of values around x (lookaround parameter). This z-score will be used to filter the peaks to keep only the ones above a certain value (h parameter). Moreover, to avoid to detect noise when there's no car for a long time, we add a threshold to avoid a noise peak to be detected. We keep the post-process method that consists in merging peaks that are too close and too thin. Below is an example of the peaks detected by the algorithm in green. The orange line below shows which signal points are above the threshold and whose z-score is above h before the merging of the peaks. The peaks are given the value 1 while the *normal* points are given the value 0.`35:T859,getPeaksZScore = function(signal,options={}){ /////// Options /////// // choose to merge peaks if they are too close and if the peak is too thin let mergeClosedPeaks = options.hasOwnProperty('mergeClosedPeaks') ? options.mergeClosedPeaks : true; let minPeaksDistance = options.minPeaksDistance || 0.5; // Visually a car is 0.5s on the line let minPeakWidth = options.minPeakWidth || 0.3; // a peak thinner than this value can be merged let h = options.h || 1; // keep only peak above h*standard deviations let lookaround = options.lookaround || 12; let thld = options.threshold || 0.1; /////// ZScore Signal /////// // for each signal point compute zScoreAndThld that looks // if the point is above the h*std with std the standard deviation of the values around the point // and if the point is above a threshold let zScoresSignal = signal.map( (d, i) => ({ 'value':zScoreAndThld( signal.slice(Math.max(0, i - lookaround), i), d.value, signal.slice(i + 1, i + lookaround + 1), h, thld, ), 'time':d.time }) ) /////// Deduce Peaks /////// // compute peaks from the score let index = 0; let peaks = []; while (index < zScoresSignal.length){ let peakStart = index; if(zScoresSignal[index].value==1){ while (index < zScoresSignal.length && zScoresSignal[index].value==1){ index++ } let peakEnd = index-1; let onePeak = peakStart + Math.trunc((peakEnd-peakStart)/2); peaks.push({ 'peakStart':peakStart, 'onePeak':onePeak, 'peakEnd':peakEnd, 'beginTime':signal[peakStart].time, 'peakTime':signal[onePeak].time, 'endTime':signal[peakEnd].time }) } index++ } /////// Merge Peaks /////// // merge peaks that are too thin and too close if(mergeClosedPeaks){ let mergedPeaks = mergePeaks(peaks,zScoresSignal,minPeakWidth,minPeaksDistance); return {'peaks':mergedPeaks,'signalThld':zScoresSignal} } return {'peaks':peaks,'signalThld':zScoresSignal} }36:[] 2f:{"title":"Detect peaks on a signal to detect cars passage","cells":[{"id":0,"value":"md`# Detect peaks on a signal to detect cars passage\nIn order to detect the number of cars passing on a road, we seek to detect the peaks corresponding to the passage of a car on a signal extracted from data evolution of a line of pixels on the road. Previous steps :\n1. [Select a line of pixels and extract data evolution from this line](https://observablehq.com/d/66467e3b94445c09?collection=@grolland/trackfic-public-version).\n2. [Extract signals that allows to detect cars](https://observablehq.com/d/6132bf34340e84c4).\n\nAt this stage, we have a **signal (actually signals) that transcribes the evolution of the difference between the line of pixels and a standard line on which we know that there are no cars.** It is from this signal that we want to try to detect the cars that cross the line.\n\n*A demonstration of the final result which consists in counting the number of cars in circulation is available [here](https://observablehq.com/d/b4945894fb574964?collection=@grolland/trackfic-public-version).*`","pinned":false,"hidden":false,"mode":"ojs"},{"id":160,"value":"md`\n## Example\nThe example below shows the result obtained when peaks (green lines) are detected on the signal (blue line) that translates the evolution of the difference between the line of pixels drawn above the graph and a standard line on which we know that there are no cars.`","pinned":false,"hidden":false,"mode":"ojs"},{"id":2466,"value":"displayLineDataEvol(lineDataEvol,{hFactor:3.5,drawCursor:true,tCursor:thldTimeExample,leftPad:56,w:4.2})","pinned":false,"hidden":false,"mode":"ojs"},{"id":2459,"value":"graph([signalRGB.signal],{peaks:peaksExample.peaks,\n ytitle:'Difference to the std line',\n t:thldTimeExample,\n h:100,\n showLegend:true,\n legendDomain:['Signal'],\n })","pinned":false,"hidden":false,"mode":"ojs"},{"id":2463,"value":"viewof thldTimeExample = Scrubber(times)","pinned":false,"hidden":false,"mode":"ojs"},{"id":1021,"value":"md`\n## Detailed approach`","pinned":false,"hidden":false,"mode":"ojs"},{"id":1016,"value":"md`\n### Use already implemented peaks detection process\nAt first, we tried to apply the detectPeak function implemented by [@yurivish](https://observablehq.com/@yurivish) in [this notebook](https://observablehq.com/@yurivish/peak-detection). This method consists in calculating a peak score for each point of the signal. Then, we keep only the peaks that have a score above a certain threshold and finally we merge the peaks that are too close to each other.\n\nUsing the default parameters we obtain the following result. We added a proccess to detect the peak width which is drawn in green as *range car detection*.`","pinned":false,"hidden":false,"mode":"ojs"},{"id":97,"value":"graph([signalRGB.signal],\n {peaks:peaksOriginalExample,\n //t:t1,\n ytitle:'Difference to the std line',\n showLegend:true,\n h:100,\n groundTruth:groundTruthTimes,\n legendDomain:['Signal']})","pinned":false,"hidden":false,"mode":"ojs"},{"id":213,"value":"md`We can notice the following errors \n* Between 1.5 and 2 seconds, we can see that the algorithm detects two peaks but there is only one car. \n* Conversely, between 7 and 8.5 seconds, the algorithm detects only one peak or there are two cars following each other.\n\nIt is possible to try to tune the parameters to solve this problem but the fact that on the one hand we are trying to bring together two peaks that are too close and on the other hand to separate one peak into two reveals the complexity of the task when using this method. After several tests on different signals and different videos, we decided to put aside this method.`","pinned":false,"hidden":false,"mode":"ojs"},{"id":1148,"value":"md`\n---\n### Use a threshold (thld)\nThe signals extracted from the evolution of the pixel line allowing a priori to separate well the cars in the simple cases, so we decided to start by using a simple threshold. That is, if the signal is above a certain threshold, it means that there is a car and then as soon as the signal goes below this threshold, it means that the car has passed.\n\nBelow we show the result for two different thresholds. The evolution of a trigger signal is drawn in orange, a value of 1 means that the signal is above the threshold while a value of 0 means it is under the threshold.`","pinned":false,"hidden":false,"mode":"ojs"},{"id":1325,"value":"graph([signalRGB.signal],{ytitle:'Difference to the std line',t:thldTime,h:100,showLegend:true,groundTruth:groundTruthTimes,xAxis:{ticks:false,title:null,tickslabel:null,labels:false},legendDomain:['Signal']})","pinned":false,"hidden":false,"mode":"ojs"},{"id":2173,"value":"graph([peaksThld0001.signalThld],{ytitle:' ',t:thldTime,h:30,showLegend:true,xAxis:{ticks:false,title:null,tickslabel:null,labels:false},legendDomain:['Thld trigger 0.001'],color:['orange']})","pinned":false,"hidden":false,"mode":"ojs"},{"id":2187,"value":"graph([peaksThld01.signalThld],{ytitle:' ',t:thldTime,h:30,showLegend:true,legendDomain:['Thld trigger 0.1'],color:['orange']})","pinned":false,"hidden":false,"mode":"ojs"},{"id":2218,"value":"viewof thldTime = Scrubber(times)","pinned":false,"hidden":false,"mode":"ojs"},{"id":1378,"value":"$31","pinned":false,"hidden":false,"mode":"ojs"},{"id":1387,"value":"graph([signalRGB.signal],{peaks:peaksThld01.peaks,\n ytitle:'Difference to the std line',\n t:thldTimeBis,\n h:100,\n showLegend:true,\n legendDomain:['Signal'],\n groundTruth:groundTruthTimes,\n xAxis:{ticks:false,title:null,tickslabel:null,labels:false}\n })","pinned":false,"hidden":false,"mode":"ojs"},{"id":2197,"value":"graph([peaksThld01.signalThld],{ytitle:' ',t:thldTimeBis,h:30,showLegend:true,legendDomain:['Thld trigger 0.1'],color:['orange']})","pinned":false,"hidden":false,"mode":"ojs"},{"id":2254,"value":"viewof thldTimeBis = Scrubber(times)","pinned":false,"hidden":false,"mode":"ojs"},{"id":1399,"value":"md`We can see that applying this post-procedure after the 0.1 threshold allows to distinguish the 7 cars. Note that it would have been possible to find a threshold interval between 0.001 and 0.1 which would have allowed this too but this procedure would not have been very robust on other videos. Applying a \"high\" threshold and then gathering the peaks that are too close seems to us to be a more robust procedure.\n`","pinned":false,"hidden":false,"mode":"ojs"},{"id":1184,"value":"md`**Functions**\n\nTo get the peaks from a signal, you have to use the *getPeaksThreshold* function which will perform two steps: detect the points above the threshold thanks to the *getSignalThreshold* function then apply the *mergePeaks* function which will merge the peaks separated by less than minDistancePeaks if one of the two peaks is thinner than minPeaksWidth.\n\nThe function returns an Object with 2 keys, the peaks and the threshold signal. \n`","pinned":false,"hidden":false,"mode":"ojs"},{"id":357,"value":"getSignalThreshold = function(data,options = {}) {\n // data is an array of Objects {'time':time,'value':value}\n \n let threshold = options.threshold || 0.1;\n\n // Assign to each point 1 if above the threeshold else 0\n let aboveThreshold =\n data.map(\n (d, index) => {\n if(d.value>threshold){return {'value':1,'time':d.time}}\n else{return {'value':0,'time':d.time}}\n }\n )\n \n return aboveThreshold\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":1484,"value":"$32","pinned":false,"hidden":false,"mode":"ojs"},{"id":483,"value":"$33","pinned":false,"hidden":false,"mode":"ojs"},{"id":1179,"value":"md`**Test the parameters**`","pinned":false,"hidden":false,"mode":"ojs"},{"id":1247,"value":"viewof signalThldTest = Select([\n {label:\"RGB Signal\", \n value:signalRGB.signal},\n {label:\"Value Mask Inf Signal\",\n value:signalMaskValue.signalInf},\n {label:\"Value Mask Sup Signal\",\n value:signalMaskValue.signalSup},\n {label:\"Saturation Mask Inf Signal\",\n value:signalMaskSaturation.signalInf},\n {label:\"Saturation Mask Sup Signal\",\n value:signalMaskSaturation.signalSup}],{\n format: x => x.label,\n value:signalRGB.signal,\n title :\"Signal\"\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":2033,"value":"viewof parametersThld = inputsGroup(\n \n[\n [\n slider({ value: 0.1, min: 0, max: 0.99, step: 0.001, title: 'Threshold',description:'Peaks detected above this threshold'}),\n slider({ value: 0.3, min: 0, max: 2, step: 0.01, title: 'Min Peak width',description:'A peak thinner than this value can be merged'}),\n slider({ value: 0.5, min: 0, max: 3, step: 0.1, title: 'Min Distance btw peaks',description:'Two peaks within this time can be merged'}),\n ]\n],\n[\n ['peaksThld','minPeakWidth','minPeaksDistance']\n]\n)","pinned":false,"hidden":false,"mode":"ojs"},{"id":1293,"value":"md`**${peaksThldTest.peaks.length} cars detected out of 7**`","pinned":false,"hidden":false,"mode":"ojs"},{"id":1244,"value":"graph([signalThldTest.value,\n thdlTest,\n //peaksThldTest.signalThld\n ],\n {peaks:peaksThldTest.peaks,\n t:thldTime2,\n ytitle:'Difference to the std line',\n showLegend:true,\n h:100,\n groundTruth:groundTruthTimes,\n xAxis:{ticks:false,title:null,tickslabel:null,labels:false},\n legendDomain:[\n signalThldTest.label,\n 'Treshold value'\n //'Thld evolution'\n ],\n color:['steelblue','black']})","pinned":false,"hidden":false,"mode":"ojs"},{"id":2203,"value":"graph([peaksThldTest.signalThld],{ytitle:' ',t:thldTime2,h:30,showLegend:true,legendDomain:[`Thld trigger ${parametersThld.peaksThld}`],color:['orange']})","pinned":false,"hidden":false,"mode":"ojs"},{"id":2259,"value":"viewof thldTime2 = Scrubber(times)","pinned":false,"hidden":false,"mode":"ojs"},{"id":1276,"value":"peaksThldTest = getPeaksThreshold(signalThldTest.value,{minPeaksDistance:parametersThld.minPeaksDistance,minPeakWidth:parametersThld.minPeakWidth,threshold:parametersThld.peaksThld})","pinned":false,"hidden":false,"mode":"ojs"},{"id":1187,"value":"$34","pinned":false,"hidden":false,"mode":"ojs"},{"id":2417,"value":"graph([signalMaskSaturation.signalSup],{peaks:peaksZScore.peaks,\n ytitle:'Difference to the std line',\n t:thldTime4,\n h:100,\n showLegend:true,\n legendDomain:['Signal'],\n groundTruth:groundTruthTimes,\n xAxis:{ticks:false,title:null,tickslabel:null,labels:false}\n })","pinned":false,"hidden":false,"mode":"ojs"},{"id":2426,"value":"graph([peaksZScore.signalThld],{ytitle:' ',t:thldTime4,h:30,showLegend:true,legendDomain:[`Thld & Zscore trigger`],color:['orange']})","pinned":false,"hidden":false,"mode":"ojs"},{"id":2430,"value":"viewof thldTime4 = Scrubber(times)","pinned":false,"hidden":false,"mode":"ojs"},{"id":1443,"value":"md`**Functions**`","pinned":false,"hidden":false,"mode":"ojs"},{"id":868,"value":"$35","pinned":false,"hidden":false,"mode":"ojs"},{"id":602,"value":"zScoreAndThld = (left, value, right,h=3,thld=0.1) => {\n // return if the value is above m+h*std and above thld\n \n // assume zero outside the boundary\n let m = d3.mean(left.concat(right),d => d.value);\n let std = d3.deviation(left.concat(right),d => d.value) ? \n d3.deviation(left.concat(right),d => d.value):0;\n let aboveDeviation = (value - m) > h*std ? 1:0; \n // if you want to detect negative peak replace (value - m) by Math.abs(value - m)\n \n // we add a thld because when the signal is flat for a long time (no cars) a little noise can be detected as a peak\n let aboveThld = value>thld ? 1 :0;\n return aboveDeviation*aboveThld\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":1446,"value":"md`**Test parameters**`","pinned":false,"hidden":false,"mode":"ojs"},{"id":1564,"value":"viewof signalZScoreTest = Select([\n {label:\"RGB Signal\", \n value:signalRGB.signal},\n {label:\"Value Mask Inf Signal\",\n value:signalMaskValue.signalInf},\n {label:\"Value Mask Sup Signal\",\n value:signalMaskValue.signalSup},\n {label:\"Saturation Mask Inf Signal\",\n value:signalMaskSaturation.signalInf},\n {label:\"Saturation Mask Sup Signal\",\n value:signalMaskSaturation.signalSup}],{\n format: x => x.label,\n value:signalRGB.signal,\n title :\"Signal\"\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":2084,"value":"viewof parametersZScore = inputsGroup(\n \n[\n [\n slider({ value: 0.1, min: 0.0001, max: 0.99, step: 0.001, title: 'Threshold',description:'Peaks detected above this threshold'}),\n slider({ value: 0.3, min: 0.0001, max: 2, step: 0.01, title: 'Peak width',description:'A peak thinner than this value can be merged'}),\n slider({ value: 0.5, min: 0.0001, max: 3, step: 0.1, title: 'Distance btw peaks',description:'Two peaks within this time can be merged'}),\n ],\n [\n slider({ value: 1, min: 0, max: 4, step: 0.1, title: 'h',description:'Values > mean + h*(std dev) considered as peaks'}),\n slider({ value: 12, min: 1, max: 30, step: 1, title: 'Lookaround',description:'The number of neighbors to look at in each direction to compute mean and std dev'})\n ]\n],\n[\n ['peaksThld','minPeakWidth','minPeaksDistance'],\n ['hTest','lookaround']\n]\n)","pinned":false,"hidden":false,"mode":"ojs"},{"id":2145,"value":"md`**${peaksZScoreTest.peaks.length} cars detected out of 7**`","pinned":false,"hidden":false,"mode":"ojs"},{"id":2010,"value":"graph([\n signalZScoreTest.value,\n //movingAverageTest,\n zScoreThldTest,\n //peaksZScoreTest.signalThld\n],\n {\n peaks:peaksZScoreTest.peaks,\n t:thldTime3,\n ytitle:'Difference to the std line',\n showLegend:true,\n h:100,\n groundTruth:groundTruthTimes,\n xAxis:{ticks:false,title:null,tickslabel:null,labels:false},\n color:['steelblue','black'],\n legendDomain:[\n 'Signal',\n //signalZScoreTest.label,\n //'moving avg',\n 'Avg+h*std',\n //'z-score evolution'\n ]\n}\n)","pinned":false,"hidden":false,"mode":"ojs"},{"id":2267,"value":"graph([peaksZScoreTest.signalThld],{ytitle:' ',t:thldTime3,h:30,showLegend:true,legendDomain:[`Thld & Zscore trigger`],color:['orange']})","pinned":false,"hidden":false,"mode":"ojs"},{"id":2264,"value":"viewof thldTime3 = Scrubber(times)","pinned":false,"hidden":false,"mode":"ojs"},{"id":1995,"value":"peaksZScoreTest = getPeaksZScore(signalZScoreTest.value,{minPeaksDistance:parametersZScore.minPeaksDistance,\n minPeakWidth:parametersZScore.minPeakWidth,\n threshold:parametersZScore.peaksThld,\n h:parametersZScore.hTest,\n lookaround:parametersZScore.lookaround})","pinned":false,"hidden":false,"mode":"ojs"},{"id":2498,"value":"graph([\n signalZScoreTest.value,\n //movingAverageTest,\n zScoreThldTest,\n //peaksZScoreTest.signalThld\n],\n {\n peaks:peaksZScoreTest.peaks,\n t:thldTime3,\n ytitle:'Difference to std line',\n showLegend:true,\n h:100,\n xAxis:{ticks:false,title:null,tickslabel:null,labels:false},\n color:['steelblue','black'],\n legendDomain:[\n 'Signal',\n //signalZScoreTest.label,\n //'moving avg',\n 'Threshold',\n //'z-score evolution'\n ]\n}\n)","pinned":true,"hidden":false,"mode":"ojs"},{"id":1040,"value":"md`\n---\n## Credits\n\n*Developed by Gabin Rolland, Bob-Dylan Bety, Lucas Heinry and Thomas Brisson as part of a student project at École Centrale de Lyon, supervised by Romain Vuillemot.*\n\n---`","pinned":false,"hidden":false,"mode":"ojs"},{"id":2400,"value":"md`## References\n[1] Brakel, J.P.G. van (2014). \"Robust peak detection algorithm using z-scores\". Stack Overflow. Available at: https://stackoverflow.com/questions/22583391/peak-signal-detection-in-realtime-timeseries-data/22640362#22640362 (version: 2020-11-08).\n\n[2] Palshikar, G. (2009, June). Simple algorithms for peak detection in time-series. In Proc. 1st Int. Conf. Advanced Data Analysis, Business Analytics and Intelligence (Vol. 122).`","pinned":false,"hidden":false,"mode":"ojs"},{"id":1037,"value":"md`## Appendix : code`","pinned":false,"hidden":false,"mode":"ojs"},{"id":214,"value":"md`## State`","pinned":false,"hidden":false,"mode":"ojs"},{"id":2226,"value":"timeRes = signalRGB.signal[signalRGB.signal.length-1].time/(signalRGB.signal.length-1)","pinned":false,"hidden":false,"mode":"ojs"},{"id":1119,"value":"md`**Use already implemented peaks detection process**`","pinned":false,"hidden":false,"mode":"ojs"},{"id":125,"value":"getPeaksId = function(distanceColumn, parameters) {\n return detectPeaksWidth(distanceColumn, \n d => d.value,\n parameters,\n 4)}","pinned":false,"hidden":false,"mode":"ojs"},{"id":128,"value":"peaksTimeFromId = function(peaksId,distanceColumn){\n const peaks = [];\n peaksId.forEach(d=>{\n peaks.push({'beginTime' : distanceColumn[d[0]].time,\n 'peakTime' : distanceColumn[d[1]].time,\n 'endTime' : distanceColumn[d[2]].time,\n });\n })\n return peaks\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":122,"value":"function detectPeaksWidth(data, accessor, options, thresholdFactor) {\n let peaks = originalDetectPeaks(data, accessor, options)\n let peaksWidth = []\n for (let onePeak of peaks){\n let peakHeight = accessor(data[onePeak]) \n let peakStart = onePeak\n let peakEnd = onePeak\n let peakEndValue = peakHeight/thresholdFactor\n while (accessor(data[peakStart]) > peakEndValue && peakStart>0) {\n peakStart--\n }\n while (accessor(data[peakEnd]) > peakEndValue && peakEnd ({'time':d.time,'value':parametersThld.peaksThld}))","pinned":false,"hidden":false,"mode":"ojs"},{"id":1991,"value":"md`**Use z-scores**`","pinned":false,"hidden":false,"mode":"ojs"},{"id":2453,"value":"peaksExample = getPeaksZScore(signalRGB.signal)","pinned":false,"hidden":false,"mode":"ojs"},{"id":2421,"value":"peaksZScore = getPeaksZScore(signalMaskSaturation.signal)","pinned":false,"hidden":false,"mode":"ojs"},{"id":2274,"value":"movingAverageTest = {\n let signal = signalZScoreTest.value;\n let movingAverage =\n signal.map(\n (d, i) => {\n let left = signal.slice(Math.max(0, i - parametersZScore.lookaround), i);\n let right = signal.slice(i + 1, i + parametersZScore.lookaround + 1);\n return {\n 'value':d3.mean(left.concat(right),d => d.value),\n 'time':d.time\n }\n }\n )\n return movingAverage\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":2292,"value":"zScoreThldTest = {\n let signal = signalZScoreTest.value;\n let zScoreThld =\n signal.map(\n (d, i) => {\n let left = signal.slice(Math.max(0, i - parametersZScore.lookaround), i);\n let right = signal.slice(i + 1, i + parametersZScore.lookaround + 1);\n let m = d3.mean(left.concat(right),d => d.value);\n let std = d3.deviation(left.concat(right),d => d.value) ? \n d3.deviation(left.concat(right),d => d.value):0;\n\n return {\n 'value':m+std*parametersZScore.hTest,\n 'time':d.time\n }\n }\n )\n return zScoreThld\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":2494,"value":"zScoreThldExample = {\n let signal = signalZScoreTest.value;\n let h = 1;\n let lookaround = 12;\n let zScoreThld =\n signal.map(\n (d, i) => {\n let left = signal.slice(Math.max(0, i - lookaround), i);\n let right = signal.slice(i + 1, i + lookaround + 1);\n let m = d3.mean(left.concat(right),d => d.value);\n let std = d3.deviation(left.concat(right),d => d.value) ? \n d3.deviation(left.concat(right),d => d.value):0;\n\n return {\n 'value':m+std*h,\n 'time':d.time\n }\n }\n )\n return zScoreThld\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":34,"value":"md`## Imports`","pinned":false,"hidden":false,"mode":"ojs"},{"id":196,"value":"d3 = require(\"d3\")","pinned":false,"hidden":false,"mode":"ojs"},{"id":37,"value":"import {graph,displayLineDataEvol,Scrubber} from 'd0a0a267bb0e0626'","pinned":false,"hidden":false,"mode":"ojs"},{"id":79,"value":"import {signalRGB, signalMaskValue,signalMaskSaturation,groundTruthTimes, times,lineDataEvol} from '6132bf34340e84c4'","pinned":false,"hidden":false,"mode":"ojs"},{"id":107,"value":"import {slider} from '@jashkenas/inputs'","pinned":false,"hidden":false,"mode":"ojs"},{"id":1257,"value":"import {Select} from \"@observablehq/inputs\"","pinned":false,"hidden":false,"mode":"ojs"},{"id":2030,"value":"import {inputsGroup} from '@bumbeishvili/input-groups'","pinned":false,"hidden":false,"mode":"ojs"},{"id":118,"value":"import {detectPeaks as originalDetectPeaks} from '@yurivish/peak-detection'","pinned":false,"hidden":false,"mode":"ojs"}],"files":"$W36","stdlib":"1","titling":"auto"}