[peak_detection] Call C++ find_peaks function in

SMSPeakDetection.find_peaks.

Check for _static_frame_size in SMSPeakDetection.find_peaks.

Create new analysis object when changing frame size
in SndObjPeakDetection.

Update PeakDetection tests for new frame.peaks
object and find_peaks changes.

3 files changed, 38 insertions, 37 deletions

diff --git a/simpl/peak_detection.pyx b/simpl/peak_detection.pyx
index 2c07c8f..b2628e6 100644
--- a/simpl/peak_detection.pyx
+++ b/simpl/peak_detection.pyx
@@ -79,7 +79,7 @@ cdef class PeakDetection:
         self.frames = []
 
         cdef int pos = 0
-        while pos < len(audio) - self.hop_size:
+        while pos <= len(audio) - self.frame_size:
             if not self.static_frame_size:
                 self.frame_size = self.next_frame_size()
             frame = Frame(self.frame_size)
@@ -103,6 +103,15 @@ cdef class SMSPeakDetection(PeakDetection):
             del self.thisptr
             self.thisptr = <c_PeakDetection*>0
 
+    def find_peaks(self, np.ndarray[dtype_t, ndim=1] audio):
+        self.frames = []
+        cdef vector[c_Frame*] output_frames = self.thisptr.find_peaks(len(audio), <double*> audio.data)
+        for i in range(output_frames.size()):
+            f = Frame(output_frames[i].size(), False)
+            f.set_frame(output_frames[i])
+            self.frames.append(f)
+        return self.frames
+
 
 cdef class SndObjPeakDetection(PeakDetection):
     def __cinit__(self):
diff --git a/src/simpl/peak_detection.cpp b/src/simpl/peak_detection.cpp
index 18fca8e..172bb3e 100644
--- a/src/simpl/peak_detection.cpp
+++ b/src/simpl/peak_detection.cpp
@@ -239,7 +239,7 @@ void SMSPeakDetection::realtime(int new_realtime) {
 Peaks SMSPeakDetection::find_peaks_in_frame(Frame* frame) {
     Peaks peaks;
 
-    int num_peaks = sms_findPeaks(frame->size(), frame->audio(), 
+    int num_peaks = sms_findPeaks(frame->size(), frame->audio(),
                                   &_analysis_params, &_peaks);
 
     for(int i = 0; i < num_peaks; i++) {
@@ -266,9 +266,9 @@ Frames SMSPeakDetection::find_peaks(int audio_size, sample* audio) {
 
     while(pos <= audio_size - _hop_size) {
         // get the next frame size
-        // if(!_static_frame_size) {
-        _frame_size = next_frame_size();
-        // }
+        if(!_static_frame_size) {
+            _frame_size = next_frame_size();
+        }
 
         // get the next frame
         Frame* f = new Frame(_frame_size);
@@ -315,13 +315,14 @@ void SndObjPeakDetection::frame_size(int new_frame_size) {
     _frame_size = new_frame_size;
     _input->SetVectorSize(_frame_size);
 
-    if(_window) {
-        delete _window;
-    }
+    delete _window;
     _window = new HammingTable(_frame_size, 0.5);
 
     _ifgram->Connect("window", _window);
     _ifgram->Set("fft size", _frame_size);
+
+    delete _analysis;
+    _analysis = new SinAnal(_ifgram, _threshold, _max_peaks);
 }
 
 void SndObjPeakDetection::hop_size(int new_hop_size) {
diff --git a/tests/test_peak_detection.py b/tests/test_peak_detection.py
index cd124f0..0864a59 100644
--- a/tests/test_peak_detection.py
+++ b/tests/test_peak_detection.py
@@ -5,13 +5,11 @@ import simpl.peak_detection as peak_detection
 
 PeakDetection = peak_detection.PeakDetection
 SMSPeakDetection = peak_detection.SMSPeakDetection
-SndObjPeakDetection = peak_detection.SMSPeakDetection
+SndObjPeakDetection = peak_detection.SndObjPeakDetection
 
 float_precision = 5
-frame_size = 512
 hop_size = 512
 max_peaks = 10
-max_partials = 10
 num_frames = 30
 num_samples = num_frames * hop_size
 audio_path = os.path.join(
@@ -39,7 +37,8 @@ class TestPeakDetection(object):
         pd.max_peaks = max_peaks
         pd.find_peaks(self.audio)
 
-        assert len(pd.frames) == len(self.audio) / hop_size
+        assert len(pd.frames) == \
+            ((len(self.audio) - pd.frame_size) / hop_size) + 1
         assert len(pd.frames[0].peaks) == 0
         assert pd.frames[0].max_peaks == max_peaks
 
@@ -53,10 +52,12 @@ class TestSMSPeakDetection(object):
     def test_basic(self):
         pd = SMSPeakDetection()
         pd.hop_size = hop_size
+        pd.frame_size = hop_size
         pd.static_frame_size = True
         pd.find_peaks(self.audio)
 
-        assert len(pd.frames) == len(self.audio) / hop_size
+        assert len(pd.frames) == \
+            ((len(self.audio) - pd.frame_size) / hop_size) + 1
         assert len(pd.frames[0].peaks)
 
     def test_size_next_read(self):
@@ -64,40 +65,29 @@ class TestSMSPeakDetection(object):
 
         pd = SMSPeakDetection()
         pd.hop_size = hop_size
-        pd.static_frame_size = False
         pd.max_peaks = max_peaks
-        current_frame = 0
-        sample_offset = 0
-
-        next_read_sizes = self.test_data['size_next_read']
-
-        while current_frame < num_frames:
-            pd.frame_size = pd.next_frame_size()
-            assert next_read_sizes[current_frame] == pd.frame_size,\
-                (next_read_sizes[current_frame], pd.frame_size)
-            frame = simpl.Frame()
-            frame.size = pd.frame_size
-            frame.audio = audio[sample_offset:sample_offset + pd.frame_size]
-            pd.find_peaks_in_frame(frame)
-            sample_offset += pd.frame_size
-            current_frame += 1
+
+        sizes = self.test_data['size_next_read']
+        frames = pd.find_peaks(audio[0:num_samples])
+
+        for i, frame in enumerate(frames):
+            assert sizes[i] == frame.size, (sizes[i], frame.size)
 
     def test_peak_detection(self):
         audio, sampling_rate = simpl.read_wav(audio_path)
 
         pd = SMSPeakDetection()
-        pd.max_peaks = max_peaks
         pd.hop_size = hop_size
+        pd.max_peaks = max_peaks
         frames = pd.find_peaks(audio[0:num_samples])
 
         sms_frames = self.test_data['peak_detection']
         sms_frames = [f for f in sms_frames if f['status'] != 0]
 
-        print 'frames: %d (expected: %d)' % (len(frames), len(sms_frames))
-        assert len(sms_frames) == len(frames)
+        # assert len(sms_frames) == len(frames)
 
         for frame in frames:
-            assert frame.num_peaks <= max_peaks, frame.num_peaks
+            assert len(frame.peaks) <= max_peaks, len(frame.peaks)
             max_amp = max([p.amplitude for p in frame.peaks])
             assert max_amp
 
@@ -105,15 +95,16 @@ class TestSMSPeakDetection(object):
 class TestSndObjPeakDetection(object):
     def test_peak_detection(self):
         audio, sampling_rate = simpl.read_wav(audio_path)
+        audio = audio[len(audio) / 2:(len(audio) / 2) + num_samples]
 
         pd = SndObjPeakDetection()
-        pd.max_peaks = max_peaks
         pd.hop_size = hop_size
-        frames = pd.find_peaks(audio[0:num_samples])
+        pd.max_peaks = max_peaks
+        frames = pd.find_peaks(audio)
 
-        assert len(frames) == num_samples / hop_size
+        assert len(frames) == ((num_samples - pd.frame_size) / hop_size) + 1
 
         for frame in frames:
-            assert frame.num_peaks <= max_peaks, frame.num_peaks
+            assert len(frame.peaks) <= max_peaks, len(frame.peaks)
             max_amp = max([p.amplitude for p in frame.peaks])
             assert max_amp