refactoring directory strucrture, includes to brackets for libraries, quotes for files. Assuming 'include' is in the include path

Author: g-roma

examples/test_fluidbuffer.cpp

@@ -1,9 +1,8 @@
-
-#include "FluidBuffers.hpp"
-#include "Windows.hpp"
-
 #include <cmath>
 
+#include "data/FluidBuffers.hpp"
+#include "algorithms/Windows.hpp"
+
 using fluid::FluidTensor;
 using fluid::slice;
 using fluid::FluidSource;
@@ -12,40 +11,40 @@ int main(int argc, char* argv[])
 {
 //    using fluid::FluidSource;
 //    using fluid::FluidSink;
-//    
+//
 //    FluidSource<double> source(100);
-//    
+//
 //    FluidTensor<double, 2> input(1,55);
 //    std::iota(input.begin(), input.end(),0);
-//    std::cout << input << '\n'; 
+//    std::cout << input << '\n';
 //    source.push(input);
 //    source.push(input);
 //
 //    source.reset();
-//    
-//    
+//
+//
 //    FluidTensor<double, 2> ramp_to_99(1,100);
 //    std::iota(ramp_to_99.begin(),ramp_to_99.end(),0);
-//    source.push(ramp_to_99); 
-//    
+//    source.push(ramp_to_99);
+//
 //    for(int i = 0 ; i < 10; ++i)
 //    {
 //        FluidTensor<double,2> output = source.pull(10);
 //        std::cout << output << '\n';
 //    }
-//    
-//    
-//    
+//
+//
+//
 //    source.reset();
 //    source.resize(1024);
-//    
+//
 //    FluidTensor<double, 2> cycle(1,64);
 //    std::iota(cycle.begin(), cycle.end(), 0);
 //    cycle.apply([](double&x){
 //        x =  std::cos(2 * M_PI * x * (1/64));
 //    });
-//    
-//    
+//
+//
 //    //Simulate data coming in smaller packets than being pulled out (implies a latency...)
 //    //should see in the console that available grows, and then gets consumed
 //    for(int i = 0; i < 64; ++i)
@@ -58,14 +57,14 @@ int main(int argc, char* argv[])
 //        }
 //        std::cout << "After " << source.available() << '\n';
 //    }
-//    
+//
 ///************************************************************************
 // OLA end to end test
 // - Write in data to source, extract with hop
 // – window segment, ola into sink
 // – pull out from sink and compare with original
 // **************************************************************************/
-//    
+//
 //    size_t framesize = 1024;
 //    //read with overlap of four
 //    size_t hop = framesize >> 2;
@@ -74,7 +73,7 @@ int main(int argc, char* argv[])
 //
 //    size_t signal_length = framesize * n_frames;
 //    size_t padded_length = signal_length + framesize;
-//    
+//
 //    //Make a tensor for the signal, with half a frame's zero padding each end
 //    FluidTensor<double, 2> sine(1,padded_length);
 //    //Grab the bit without zero padding
@@ -88,42 +87,41 @@ int main(int argc, char* argv[])
 //    FluidTensor<double,2> window(1,framesize);
 //    std::vector<double> win=fluid::windows::windowFuncs[fluid::windows::WindowType::Hann](framesize);
 //    std::copy(win.begin(), win.end(), window.begin());
-//    
+//
 //    //Buffer in
 //    FluidSource<double> sine_in(padded_length);
 //    //Buffer out
 //    FluidSink<double> sine_out(1,padded_length);
 //    //Normalisation buffer for window
 //    FluidSink<double> norm_out(1,padded_length);
-//    
+//
 //    //push signal in
 //    sine_in.push(sine);
-//    
+//
 //    //Pull out frames from source, window and push in to sink
 //    for(int i = 0; i<n_hops;++i)
 //    {
 //        FluidTensor<double,2> frame = sine_in.pull(framesize,hop)
 //            .apply(window,[](double& x, double w){x*=w;});
-//        
+//
 //        norm_out.push(window,hop);
 //        sine_out.push(frame,hop);
 //    }
-//    
+//
 //    //Grab the whole result from sink
 //    FluidTensor<double,2> result = sine_out.pull(padded_length);
-//    
+//
 //    //Apply OLA normalisation
 //    result.apply(norm_out.pull(padded_length),[](double& x, double y)
 //                 {
 //                     if(x)
 //                         x /=  y > 0? y : 1 ;
 //                 });
-// 
+//
 //    //Subtract original from result
 //    result.apply(sine, [](double& x, double y){ x -= y; });
-//    //sum this difference 
+//    //sum this difference
 //    double sum_of_diff = std::accumulate(result.begin(), result.end(), 0.0);
 //    //we want it to be small, kthx
 //    std::cout << "Difference summed " << sum_of_diff << '\n';
 }
-

examples/test_fluidtensor.cpp

@@ -1,7 +1,8 @@
-#include "FluidTensor.hpp"
 #include <stdio.h>
 #include <Eigen/Dense>
+#include "data/FluidTensor.hpp"
 #include "util/audiofile.hpp"
+
 using fluid::audiofile::AudioFileData;
 using fluid::audiofile::readFile;
 
@@ -35,8 +36,8 @@ int main(int argc, char* argv[])
 
     fluid::FluidTensor<double,1> r2(tinit2.row(1));
     std::cout << "1 2 3?" << r1 << '\n';
-    
-    
+
+
     //tinit2.row(1) = r2(fluid::slice(0,3));
     //Initialize with vector
     std::cout << "tinit2"<<tinit2 << '\n';
@@ -115,7 +116,7 @@ int main(int argc, char* argv[])
         //use() with integer types to get elements
         assert(c2[i] == twodeecee[i][col_offset]);
     }
-    std::cout << "Col 3: " << c2 << '\n'; 
+    std::cout << "Col 3: " << c2 << '\n';
 
     //Free memory from double**, we're done with it
     for(int i = 0; i < x; ++i)
@@ -132,7 +133,7 @@ int main(int argc, char* argv[])
     copy_col.row(0)(fluid::slice(0,3)) = c2(fluid::slice(0,3,2));
 
     fluid::FluidTensorView<double,1> aa = c2(fluid::slice(0,3,2));
-    
+
     std::cout<<"Original column " << c2 <<'\n';
 
     std::cout<<"Sub-column " << aa[0] <<'\n';
@@ -260,13 +261,13 @@ int main(int argc, char* argv[])
     std::cout << "Difference summed " << sum_of_diff << '\n';
 
     double* interleave = new double[100];
-    
+
     std::iota(interleave, interleave+100,0);
-    
-    //Test for assumption about reading from interleaved structure (e.g multichannel buffers in max and sc) 
+
+    //Test for assumption about reading from interleaved structure (e.g multichannel buffers in max and sc)
     fluid::FluidTensorView<double,2> interT = fluid::FluidTensorView<double,2>({0,{50,2}},interleave);
-    
+
     std::cout << interT.col(0) << '\n';
-    
-    
+
+
 }

examples/test_nmf.cpp

@@ -1,11 +1,12 @@
-#include "util/audiofile.hpp"
-#include <FluidTensor.hpp>
-#include <NMF.hpp>
-#include <RatioMask.hpp>
-#include <STFT.hpp>
 #include <iostream>
 #include <string>
 
+#include "util/audiofile.hpp"
+#include "data/FluidTensor.hpp"
+#include "algorithms/NMF.hpp"
+#include "algorithms/RatioMask.hpp"
+#include "algorithms/STFT.hpp"
+
 int main(int argc, char *argv[]) {
   const auto &epsilon = std::numeric_limits<double>::epsilon;
 

examples/test_sineextraction.cpp

@@ -1,10 +1,10 @@
-#include "util/audiofile.hpp"
-#include <ConvolutionTools.hpp>
 #include <Eigen/Dense>
-#include <FluidTensor.hpp>
-#include <HISSTools_FFT/HISSTools_FFT.h>
-#include <STFT.hpp>
-#include <SineExtraction.hpp>
+#include "util/audiofile.hpp"
+#include "algorithms/ConvolutionTools.hpp"
+#include "data/FluidTensor.hpp"
+#include "HISSTools_FFT/HISSTools_FFT.h"
+#include "algorithms/STFT.hpp"
+#include "algorithms/SineExtraction.hpp"
 
 int main(int argc, char *argv[]) {
   using std::complex;

examples/test_stft.cpp

@@ -1,6 +1,6 @@
 #include "util/audiofile.hpp"
-#include <STFT.hpp>
-#include <FluidTensor.hpp>
+#include "algorithms/STFT.hpp"
+#include "data/FluidTensor.hpp"
 
 int main(int argc, char* argv[])
 {

examples/test_transient_extractor.cpp

@@ -4,9 +4,9 @@
 #include <random>
 #include <vector>
 
-#include "../include/TransientExtraction.hpp"
-#include "../3rdparty/HISSTools_AudioFile/IAudioFile.h"
-#include "../3rdparty/HISSTools_AudioFile/OAudioFile.h"
+#include "algorithms/TransientExtraction.hpp"
+#include "HISSTools_AudioFile/IAudioFile.h"
+#include "HISSTools_AudioFile/OAudioFile.h"
 
 // ******************* Parameters ******************* //
 
@@ -48,17 +48,17 @@ bool paramCorruptInput = true;
 void corruptInput(double *output, const double *input, int size)
 {
   // Simple markov chain for probability of switching states
-  
+
   double pOn = paramCorruptInput ? 0.00006 : 0.0;
   double pStay = 0.989;
   double dev = 0.1;
-  
+
   bool corrupt = false;
   unsigned int seed = std::random_device()();
   std::mt19937_64 randomGenerator(seed);
   std::normal_distribution<double> gaussian(0.0, dev);
   std::uniform_real_distribution<double> uniform(0.0, 1.0);
-  
+
   for (int i = 0; i < size; i++)
   {
     corrupt = uniform(randomGenerator) < (corrupt ? pStay : pOn);
@@ -71,9 +71,9 @@ void corruptInput(double *output, const double *input, int size)
 void writeFile(const char *name, const double *output, int size, double samplingRate)
 {
   using namespace HISSTools;
-  
+
   OAudioFile file(name, BaseAudioFile::kAudioFileWAVE, BaseAudioFile::kAudioFileFloat32, 1, samplingRate);
-  
+
   file.writeChannel(output, size, 0);
 }
 
@@ -82,59 +82,58 @@ void writeFile(const char *name, const double *output, int size, double sampling
 int main(int argc, const char * argv[])
 {
   using fluid::transient_extraction::TransientExtraction;
-  
+
   if (argc < 5)
   {
     std::cout << "Not enough file paths specified\n";
     return -1;
   }
-  
+
   const char *inputPath = argv[1];
   const char *corruptedOutputPath = argv[2];
   const char *fixedOutputPath = argv[3];
   const char *transientsOutputPath = argv[4];
-  
+
   HISSTools::IAudioFile file(inputPath);
-  
+
   if (!file.isOpen())
   {
     std::cout << "File could not be opened\n";
     return -2;
   }
-  
+
   int frames = file.getFrames();
   auto samplingRate = file.getSamplingRate();
-  
+
   std::vector<double> input(frames, 0.0);
   std::vector<double> corrupted(frames + paramBlockSize, 0.0);
   std::vector<double> fixed(frames + paramBlockSize, 0.0);
   std::vector<double> transients(frames + paramBlockSize, 0.0);
-  
+
   file.readChannel(input.data(), frames, 0);
   corruptInput(corrupted.data(), input.data(), frames);
-  
+
   TransientExtraction extractor(paramOrder, paramIterations, paramRobustFactor, paramRefine);
-  
+
   extractor.prepareStream(paramBlockSize, paramPad);
   extractor.setDetectionParameters(paramDetectPower, paramDetectThreshHi, paramDetectThreshLo, paramDetectHalfWindow, paramDetectHold);
-  
+
   std::cout << "Starting Extraction\n";
-    
+
   for (int i = 0, hopSize = extractor.hopSize(); i < frames; i += hopSize)
   {
     int size = std::min(extractor.inputSize(), frames - i);
     extractor.extract(transients.data() + i, fixed.data() + i, corrupted.data() + i, size);
     std::cout << "Done " << (100 * (i + hopSize) / frames) << "%\n";
   }
-  
+
   std::cout << "Finished Extraction\n";
-  
+
   // Write files
-  
+
   writeFile(corruptedOutputPath, corrupted.data(), frames, samplingRate);
   writeFile(fixedOutputPath, fixed.data(), frames, samplingRate);
   writeFile(transientsOutputPath, transients.data(), frames, samplingRate);
-  
+
   return 0;
 }
-