correction des bugs de compilation et première implémentation de la fft

tests/examples/test-fft.cpp

@@ -1,51 +1,13 @@
-#include <fftw3.h>
+#include <math.hpp>
 #include <cmath>
-#include <libplotcpp/plotcpp.hpp>
-
-double pi() {
-	return 3.1415;
-}
-
-std::vector<double> tfd2vect(fftw_complex* tfd, int N) {
-	std::vector<double> res;
-	auto it = tfd;
-	for (int i = 0; i != N; ++i) {
-		fftw_complex c = {*it[0], *it[1]};
-		res.push_back(sqrt(c[0]*c[0] + c[1]*c[1]));
-		it++;
-	}
-
-	return res;
-}
 
 int main(int argc, char** argv) {
-	QApplication app(argc, argv);
+  math::csignal s;
-	fftw_complex *in, *out;
-	fftw_plan p;
 
-	int N = 500;
+  for (int i=0; i<100; ++i) {
-	in = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * N);
+    s.push_back(std::sin(2*math::pi()*50*i/100));
-	out = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * N);
+  }
-	p = fftw_plan_dft_1d(N, in, out, FFTW_FORWARD, FFTW_MEASURE);
+  math::csignal tfd = math::fft(s);
 
-	std::vector<double> xx;
+  return 0;
-	for (int i = 0; i != N; ++i) {
-		xx.push_back(i);
-	}
-
-	for (int i = 0; i != N; ++i) {
-		in[i][0] = sin(2*pi()*50*i/N);
-	}
-
-	fftw_execute(p); /* repeat as needed */
-
-	std::vector<double> res = tfd2vect(out, N);
-	PlotCpp g;
-	g.plot(xx, res);
-	g.draw();
-
-
-	fftw_destroy_plan(p);
-	fftw_free(in); fftw_free(out);
-	return app.exec();
 }

tests/src/CMakeLists.txt

@@ -1,11 +1,8 @@
 # file(GLOB headers   *.hpp)
 # file(GLOB lib_files *.cpp)
 
-# add_executable(traitement traitement.cpp)
+add_executable(traitement traitement.cpp)
-# target_link_libraries(traitement ${OpenCV_LIBS} fftw3)
+target_link_libraries(traitement ${OpenCV_LIBS} fftw3)
-
-add_executable(test-fft test-fft.cpp)
-target_link_libraries(test-fft)
 
 # target_include_directories(blk PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
 # target_compile_options    (blk PUBLIC -std=c++11                 )

tests/src/math.hpp

@@ -8,28 +8,42 @@
 
 namespace math {
 
-  using complex = std::complex<float>;
+  using complex = std::complex<double>;
   using signal = std::vector<double>;
   using csignal = std::vector<complex>;
   using contour = std::vector<cv::Point>;
   constexpr double pi() {return std::atan(1)*4;}
 
-  //TODO implémenter la fft
+  csignal cont2sig(const contour& cont) {
-  csignal fft(const signal& input) {
+    csignal sig;
-    //TODO: s'assurer que le signal est bien formé (i.e. bonne taille)
+    auto sig_it = sig.begin();
-    return fft_rec(input);
+    auto cont_it = cont.begin();
+
+    for (auto cont_it = cont.begin(); cont_it != cont.end(); ++cont_it) {
+      *(sig_it++) = complex((*cont_it).x, (*cont_it).y);
+    }
+    return sig;
   };
 
-  csignal fft_rec(const signal& input) {
+  complex mean(const csignal& sig) {
+    complex res = 0;
+    for (auto x: sig) {
+      res += x;
+    }
+    return complex(res.real()/sig.size(), res.imag()/sig.size());
+  };
+
+  //TODO implémenter la fft
+  csignal fft_rec(const csignal& input) {
     int size = input.size();
 
     if (size == 1) {
-      return input;
+      return csignal();
     } else {
-      signal odd;
+      csignal odd;
-      signal even;
+      csignal even;
-      std::back_insert_iterator<signal> odd_back_it(odd);
+      std::back_insert_iterator<csignal> odd_back_it(odd);
-      std::back_insert_iterator<signal> even_back_it(even);
+      std::back_insert_iterator<csignal> even_back_it(even);
       bool insert_in_even = false;
 
       for (auto it = input.begin(); it != input.end(); ++it) {
@@ -42,13 +56,13 @@ namespace math {
         }
       }
 
-      signal odd_fft = fft_rec(odd);
+      csignal odd_fft = fft_rec(odd);
-      signal even_fft = fft_rec(even);
+      csignal even_fft = fft_rec(even);
-      signal res;
+      csignal res;
       res.reserve(size);
 
       for (int k = 0; k<size/2; ++k) {
-        complex t = std::exp(complex(0, -2*pi()*k/size))*odd[k];
+        complex t = std::exp(complex(0, -2*pi()*k/size)) * odd[k];
         res[k] = even[k] + t;
         res[size/2+k] = even[k] - t;
       }
@@ -56,38 +70,31 @@ namespace math {
     }
   }
 
-  complex mean(const signal& sig) {
+  csignal fft(const csignal& input) {
-    complex res = 0;
+    //TODO: s'assurer que le signal est bien formé (i.e. bonne taille)
-    for (auto x: sig) {
+    return fft_rec(input);
-      res += x;
-    }
-    return complex(res.real()/sig.size(), res.imag()/sig.size());
   };
 
-  signal cont2sig(const contour& cont) {
+  contour coef2cont(const csignal& tfd, complex mean, int size, int cmax) {
-    signal sig;
-    auto sig_it = sig.begin();
-    auto cont_it = cont.begin();
-
-    for (auto cont_it = cont.begin(); cont_it != cont.end(); ++cont_it) {
-      *sig_it = complex((*cont_it).x, (*cont_it).y);
-      sig_it++;
-    }
-    return sig;
-  };
-
-  contour coef2cont(const signal& tfd, complex mean, int size, int cmax) {
     contour cont;
     auto tf_it = tfd.begin();
     auto cont_it = cont.begin();
 
     for (auto tf_it = tfd.begin(); tf_it != tfd.end(); ++tf_it) {
       //TODO retrouver la formule
-      //*cont_it = mean; 
+      //*cont_it = mean + ...; 
     }
     return cont;
   };
 
+  contour simplify_contour(const contour& cont, int cmax) {
+    contour res;
+    csignal z = cont2sig(cont);
+    complex zm = mean(z);
+    csignal tfd = fft(z);
+    return coef2cont(tfd, zm, 0, cmax);
+  };
+
   int max_cont(const std::vector<contour>& contours) {
     int max = 0;
     int id = 0;
@@ -99,13 +106,4 @@ namespace math {
     }
     return id;
   };
-
-  contour simplify_contour(const contour& cont, int cmax) {
-    contour res;
-    signal z = cont2sig(cont);
-    complex zm = mean(z);
-    signal tfd = fft(z);
-    res = coef2cont(tfd, zm, 0, cmax);
-    return res;
-  };
 }

tests/src/test-fft.cpp

@@ -1,13 +0,0 @@
-#include <math.hpp>
-#include <cmath>
-
-int main(int argc, char** argv) {
-  math::signal s;
-
-  for (int i=0; i<100; ++i) {
-    s.push_back(std::sin(2*math::pi()*50*i/100));
-  }
-  math::fft(s);
-
-  return 0;
-}