comparison multires.cpp @ 5:5f3c32dc6e17

* Adjust comment syntax to permit Doxygen to generate HTML documentation; add Doxyfile

 //---------------------------------------------------------------------------
-
 
 #include <math.h>
 #include "multires.h"
 #include "arrayalloc.h"
 #include "procedures.h"
 
+/** \file multires.h */
+
 //---------------------------------------------------------------------------
 
 //function xlogx(x): returns x*log(x)
 inline double xlogx(double x)
 {

 //macro NORMAL_: a normalization step used for tiling
 #define NORMAL_(A, a) A=a*(A+log(a));
 //  #define NORMAL_(A, a) A=a*a*A;
 //  #define NORMAL_(A, a) A=sqrt(a)*A;
 
-/*
+/**
   function DoCutSpectrogramSquare: find optimal tiling of a square. This is a recursive procedure.
 
   In: Specs[0][1][N], Specs[1][2][N/2], ..., Specs[log2(N)][N][1], multiresolution power spectrogram
       e[Res]: total power of each level, e[i] equals the sum of Specs[i][][]
       NN: maximal tile height

   }
 
   return result;
 }//DoCutSpectrogramSquare
 
-/*
+/**
   function DoMixSpectrogramSquare: renders a composite spectrogram on a pixel grid. This is a recursive
   procedure.
 
   In: Specs[0][1][N], Specs[1][2][N/2], Specs[2][4][N/4], ..., Specs[][N][1]: multiresolution power
         spectrogram

 
     delete[] lSpec; delete[] rSpec; DeAlloc2(lSpecs); DeAlloc2(rSpecs);
   }
 }//DoMixSpectrogramSquare
 
-/*
+/**
   function DoMixSpectrogramSquare: retrieves a composite spectrogram as a vector. This is a recursive
   procedure.
 
   In: Specs[0][1][N], Specs[1][2][N/2], Specs[2][4][N/4], ..., Specs[][N][1]: multiresolution power
         spectrogram

     DeAlloc2(lSpecs); DeAlloc2(rSpecs);
   }
 }//DoMixSpectrogramSquare
 
 //---------------------------------------------------------------------------
-/*
+/**
   function HSplitSpec: split a spectrogram horizontally into lower and upper halves.
 
   In: Spec[X][Y]: spectrogram to split
   Out: lSpec[X][Y/2], uSpec[X][Y/2]: the two half spectrograms
 

   lSpec=new double*[X], uSpec=new double*[X];
   for (int i=0; i<X; i++)
     lSpec[i]=Spec[i], uSpec[i]=&Spec[i][Y/2];
 }//HSplitSpec
 
-/*
+/**
   function HSplitSpecs: split a multiresolution spectrogram horizontally into lower and upper halves
 
   A full spectrogram array is given in log2(N)+1 spectrograms, with the base spec of 1*N, 1st octave of
   2*(N/2), ..., last octave of N*1. When this array is split into two spectrogram arrays horizontally,
   the last spec (with the highest time resolution). Each of the two new arrays is given in log2(N)

   for (int i=0, Fr=1, n=N; i<nRes; i++, Fr*=2, n/=2)
     for (int j=0; j<Fr; j++) lSpecs[i][j]=Specs[i][j], uSpecs[i][j]=&Specs[i][j][n/2];
 }//HSplitSpecs
 
 //---------------------------------------------------------------------------
-/*
+/**
   function MixSpectrogramSquare: find composite spectrogram from multiresolution spectrogram,output as
   pixel grid
 
   In: Specs[0][1][N], Specs[1][2][N/2], ..., Specs[Res-1][N][1], multiresolution spectrogram
   Out: Spec[N][N]: composite spectrogram as pixel grid (N time redundant)

   if (createcuts) delete[] cuts;
   return result;
 }//MixSpectrogramSquare
 
 //---------------------------------------------------------------------------
-/*
+/**
   function MixSpectrogramSquare: find composite spectrogram from multiresolution spectrogram,output as
   vectors
 
   In: Specs[0][1][N], Specs[1][2][N/2], ..., Specs[Res-1][N][1], multiresolution spectrogram
   Out: spl[N-1], Spec[N]: composite spectrogram as tiling and value vectors

   DoMixSpectrogramSquare(Spec, spl, Specs, N, NormMix);
   return result;
 }//MixSpectrogramSquare
 
 //---------------------------------------------------------------------------
-/*
+/**
   function MixSpectrogramBlock: obtain the composite spectrogram of a waveform block as pixel grid.
 
   This method deals with the effective duration of WID/2 samples of a frame of WID samples. The maximal
   frame width is WID, minimal frame width is wid. The spectrum with frame width WID (base) is given in
   lSpecs[0][0], the spectra with frame width WID/2 (1st octave) is given in lSpecs[1][0] & lSpecs[1][1],

   DeAlloc2(lSpecs);
   if (createcuts) delete[] cuts;
   return result;
 }//MixSpectrogramBlock
 
-/*
+/**
   function MixSpectrogramBlock: obtain the composite spectrogram of a waveform block as vectors.
 
   In: Specs[0][1][WID], Specs[1][2][WID/2], ..., Specs[Res-1][WID/wid][wid], multiresolution spectrogram
   Out: spl[WID], Spec[WID], composite spectrogram as tiling and value vectors. Each of the vectors is
        made up of $wid subvectors, each subvector pair describing a N*N block of the composite

   return result;
 }//MixSpectrogramBlock
 
 
 //---------------------------------------------------------------------------
-/*
-  Functions names as ...Block2(...) implement the same functions as the above directly without
+/**
+  functions names as ...Block2(...) implement the same functions as the above directly without
   explicitly dividing the multiresolution spectrogram into square blocks.
 */
 
-/*
+/**
   function DoCutSpectrogramBlock2: find optimal tiling for a block
 
   In: Specs[R0][x0:x0+x-1][Y0:Y0+Y-1], [R0+1][2x0:2x0+2x-1][Y0/2:Y0/2+Y/2-1],...,
         Specs[R0+?][Nx0:Nx0+Nx-1][Y0/N:Y0/N+Y/N-1], multiresolution spectrogram
   Out: spl[Y-1], tiling of this block

     }
   }
   return ent;
 }//DoCutSpectrogramBlock2
 
-/*
+/**
   function DoMixSpectrogramBlock2: sampling multiresolution spectrogram according to given tiling
 
   In: Specs[R0][x0:x0+x-1][Y0:Y0+Y-1], [R0+1][2x0:2x0+2x-1][Y0/2:Y0/2+Y/2-1],...,
         Specs[R0+?][Nx0:Nx0+Nx-1][Y0/N:Y0/N+Y/N-1], multiresolution spectrogram
       spl[Y-1]; tiling of this block

     }
   }
   return 0;
 }//DoMixSpectrogramBlock2
 
-/*
+/**
   function MixSpectrogramBlock2: obtain the composite spectrogram of a waveform block as vectors.
 
   In: Specs[0][1][WID], Specs[1][2][WID/2], ..., Specs[Res-1][WID/wid][wid], multiresolution spectrogram
   Out: spl[WID], Spec[WID], composite spectrogram as tiling and value vectors. Each of the
        vectors is made up of $wid subvectors, each subvector pair describing a N*N block of the

   DoMixSpectrogramBlock2(spl, Spec, Specs, WID, 0, 0, 0, normmix, log2(WID/wid)+1, e);
   return result;
 }//MixSpectrogramBlock2
 
 //---------------------------------------------------------------------------
-/*
+/**
   function MixSpectrogram: obtain composite spectrogram from multiresolutin spectrogram as pixel grid
 
   This method deals with Fr (base) frames of WID samples. Each base frame may be divided into 2 1st-
   octave frames, 4 2nd-octave frames, ..., etc. The spectrogram calculated on base frame is given in
   Specs[0] (Fr frames); that of 1st octave is given in Specs[1] (2*Fr frames); etc. The method resamples

   delete[] lSpecs;
   if (createcuts) delete[] cuts;
   return 0;
 }//MixSpectrogram
 
-/*
+/**
   function MixSpectrogram: obtain composite spectrogram from multiresolutin spectrogram as vectors
 
   In: Specs[0][Fr][WID], Specs[1][Fr*2][WID/2], ..., Specs[Res-1] [Fr*(WID/wid)][wid], multiresolution
         spectrogram
   Out: spl[Fr][WID], Spec[Fr][WID], composite spectrogram as tiling and value vectors by frame.

   delete[] lSpecs;
   return 0;
 }//MixSpectrogram
 
 //---------------------------------------------------------------------------
-/*
+/**
   function VSplitSpec: split a spectrogram vertically into left and right halves.
 
   In: Spec[X][Y]: spectrogram to split
   Out: lSpec[X][Y/2], rSpec[X][Y/2]: the two half spectrograms
 

   lSpec=new double*[X/2], rSpec=new double*[X/2];
   for(int i=0; i<X/2; i++)
     lSpec[i]=Spec[i], rSpec[i]=Spec[i+X/2];
 }//VSplitSpec
 
-/*
+/**
   function VSplitSpecs: split a multiresolution spectrogram vertically into left and right halves
 
   A full spectrogram array is given in log2(N)+1 spectrograms, with the base spec of 1*N, 1st octave of
   2*(N/2), ..., last octave of N*1. When this array is split into two spectrogram arrays horizontally,
   the last spec (with the highest time resolution). Each of the two new arrays is given in log2(N)