From f00319d6d06987d7d1330aa5982a4ac28d4460e5 Mon Sep 17 00:00:00 2001 From: jstarck <jstarck@cea.fr> Date: Mon, 29 Apr 2024 11:35:25 +0300 Subject: [PATCH] gmca bug correction --- src/mc/mcmain1d/mr1d_gmca.cc | 41 ++-- src/mc/mcmain2d/mr_gmca.cc | 64 ++--- src/sparse/libsparse2d/GMCA.cc | 397 +++++++++++++++++-------------- src/sparse/libsparse2d/GMCA.h | 108 ++++----- src/sparse/libsparse2d/MR1D1D.cc | 50 ++++ src/sparse/libsparse2d/MR1D1D.h | 4 +- src/sparse/libsparse3d/MR2D1D.cc | 58 ++++- src/sparse/libsparse3d/MR2D1D.h | 1 + src/sparse/libtools/DefMath.cc | 45 ++++ src/sparse/libtools/DefMath.h | 7 +- src/sparse/libtools/OptMedian.cc | 4 + src/sparse/libtools/OptMedian.h | 3 + src/sparse/libtools/TempArray.h | 2 +- 13 files changed, 489 insertions(+), 295 deletions(-) diff --git a/src/mc/mcmain1d/mr1d_gmca.cc b/src/mc/mcmain1d/mr1d_gmca.cc index b65cd6b..412fc57 100644 --- a/src/mc/mcmain1d/mr1d_gmca.cc +++ b/src/mc/mcmain1d/mr1d_gmca.cc @@ -27,6 +27,7 @@ #include "Array.h" #include "NR.h" #include "IM_Obj.h" +#include "IM_IO.h" #include "GMCA.h" #include "MR1D1D.h" #include "IM_Noise.h" @@ -34,8 +35,8 @@ #include "MR1D_Filter.h" /****************************************************************************/ - -class GMCA_1D: public MR1D1D, public GMCA + +class GMCA_1D: public MR1D1D, public GMCA { public: Bool UseRMSMap; @@ -46,7 +47,7 @@ class GMCA_1D: public MR1D1D, public GMCA void inpainting_run(fltarray &TabCannels, fltarray & InpData); void transrecons_sources(fltarray &TabVect,fltarray &Recdata); void transform_sources(fltarray &Data,fltarray &TabVect); - void recons_sources(fltarray &DataIn, fltarray &EstSources); // Applying the matrix on the data + void recons_sources(dblarray &DataIn, dblarray &EstSources); // Applying the matrix on the data void HT_Sources(fltarray &TabSource, float &KThrd) ; ~GMCA_1D() {} ; @@ -170,12 +171,12 @@ void GMCA_1D::transrecons_sources(fltarray &TabVect,fltarray &Recdata) /****************************************************************************/ -void GMCA_1D::recons_sources(fltarray &DataIn, fltarray &EstSources) // Applying the matrix on the data +void GMCA_1D::recons_sources(dblarray &DataIn, dblarray &EstSources) // Applying the matrix on the data { int Nx = DataIn.nx(); int Ny = DataIn.ny(); int i,k,l; - fltarray RefData,RefSources; + dblarray RefData,RefSources; int Deb = 0; // cout << "NEW recons_sources " << endl; @@ -588,7 +589,7 @@ int test_main(int argc, char *argv[]) int main(int argc, char *argv[]) { - fltarray Dat; + dblarray Dat; /* Get command line arguments, open input file(s) if necessary */ fitsstruct Header; char Cmd[512]; @@ -624,7 +625,7 @@ int main(int argc, char *argv[]) if (Verbose == True) cout << "\n Reading the data"<< endl; - fits_read_fltarr(Name_Cube_In, Dat, &Header); + fits_read_dblarr(Name_Cube_In, Dat); int Nx = Dat.nx(); int Ny = Dat.ny(); @@ -676,8 +677,8 @@ int main(int argc, char *argv[]) // WT.write(Name_Out); // Compute the 2D1D transform - fltarray TabVect; - WT.transform_to_vectarray(Dat, TabVect); + dblarray TabVect; + WT.transform_to_vectdblarray(Dat, TabVect); // fits_write_fltarr ("xx_tabvect.fits", TabVect); // Initalize the class for GMCA @@ -699,7 +700,7 @@ int main(int argc, char *argv[]) WT.GlobThrd = GThrd; WT.SVConst = UsePCA; WT.MatNbrScale1D = Nbr_Plan; - fltarray QSVec; + dblarray QSVec; if (UsePCA == True) { @@ -709,13 +710,13 @@ int main(int argc, char *argv[]) if (UseMask == True) { - fits_read_fltarr (Name_Mask, WT.Mask); + fits_read_dblarr (Name_Mask, WT.Mask); } if (UseKnownColomn == True) { - fits_read_fltarr (Name_KnowColumn, WT.MatKnownColumn); + fits_read_dblarr (Name_KnowColumn, WT.MatKnownColumn); if (WT.MatKnownColumn.naxis() == 1) WT.NbrKnownColumn = 1; else WT.NbrKnownColumn = WT.MatKnownColumn.axis(2); } @@ -726,7 +727,7 @@ int main(int argc, char *argv[]) if (EstimNbSources == False) // THE NUMBER OF SOURCES IS FIXED { - fltarray TabSource; + dblarray TabSource; int NbrCoef = TabVect.nx(); TabSource.alloc(NbrCoef,NbrSources); WT.GMCA::Verbose = Verbose; @@ -749,7 +750,7 @@ int main(int argc, char *argv[]) NbrSources++; if (Verbose == True) cout << "Running GMCA ... Number of Estimated Sources : " << NbrSources << endl; WT.NbrSources = NbrSources; - fltarray TabSource; + dblarray TabSource; int NbrCoef = TabVect.nx(); TabSource.alloc(NbrCoef,NbrSources); WT.GMCA::Verbose = Verbose; @@ -782,7 +783,7 @@ int main(int argc, char *argv[]) // Reconstruction : if (Verbose == True) cout << "Reconstruction ... "<< endl; - fltarray EstSources; + dblarray EstSources; // cout << "GO REC" << endl; WT.recons_sources(Dat,EstSources); @@ -795,16 +796,16 @@ int main(int argc, char *argv[]) // fits_write_fltarr ("xx_InvMixingMat.fits", WT.InvMixingMat); // Header.origin = Cmd; - fits_write_fltarr(Name_Out, EstSources); - if (WriteMixing == True) fits_write_fltarr (Name_Out_2, WT.RecMixingMat); - if (WriteChannels == True) + fits_write_dblarr(Name_Out, EstSources); + if (WriteMixing == True) fits_write_dblarr (Name_Out_2, WT.RecMixingMat); + if (WriteChannels == True) { - fltarray EstChannels, TranspMixingMat; + dblarray EstChannels, TranspMixingMat; MatOper MAT; // See file $Tools/MatrixOper.cc and .h MAT.transpose(WT.MixingMat,TranspMixingMat); WT.apply_mat(EstSources, TranspMixingMat, EstChannels); // WT.apply_mat(EstSources, WT.MixingMat, EstChannels); - fits_write_fltarr (Name_Out_3, EstChannels); + fits_write_dblarr (Name_Out_3, EstChannels); } exit(0); } diff --git a/src/mc/mcmain2d/mr_gmca.cc b/src/mc/mcmain2d/mr_gmca.cc index c5baeb0..96d950a 100644 --- a/src/mc/mcmain2d/mr_gmca.cc +++ b/src/mc/mcmain2d/mr_gmca.cc @@ -229,20 +229,18 @@ static void usage(char *argv[]) fprintf(OUTMAN, " Apply a l_1 constraint also on the mixing matrix. Default is no. \n"); fprintf(OUTMAN, " [-d]\n"); fprintf(OUTMAN, " Estimate the number of sources. Default is no. \n"); - fprintf(OUTMAN, " [-d]\n"); - fprintf(OUTMAN, " Estimate the number of sources. Default is no. \n"); fprintf(OUTMAN, " [-m]\n"); fprintf(OUTMAN, " Mad-based stopping criterion when the number of sources is estimated. Default is 5 - default criterion is l2-based. \n"); fprintf(OUTMAN, " [-L]\n"); fprintf(OUTMAN, " L2-based stopping criterion when the number of sources is estimated. Default is 40 (in dB). \n"); - fprintf(OUTMAN, " [-D] \n"); - fprintf(OUTMAN, " Spectra with disjoint supports for thresholds higher than 7 Mad. \n"); // Should be an option +// fprintf(OUTMAN, " [-D] \n"); +// fprintf(OUTMAN, " Spectra with disjoint supports for thresholds higher than 7 Mad. \n"); // Should be an option fprintf(OUTMAN, " [-K Last K-Mad]\n"); fprintf(OUTMAN, " Last value of K for K-Mad Thresholding. \n"); fprintf(OUTMAN, " [-G Global Thresholding]\n"); - fprintf(OUTMAN, " [-O]\n"); - fprintf(OUTMAN, " Orthogonalization of the spectra\n"); - verbose_usage(); +// fprintf(OUTMAN, " [-O]\n"); +// fprintf(OUTMAN, " Orthogonalization of the spectra\n"); + verbose_usage(); vm_usage(); manline(); exit(-1); @@ -435,7 +433,7 @@ static void transinit(int argc, char *argv[]) int main(int argc, char *argv[]) { - fltarray Dat; + dblarray Dat; /* Get command line arguments, open input file(s) if necessary */ fitsstruct Header; char Cmd[512]; @@ -466,38 +464,44 @@ int main(int argc, char *argv[]) if (Verbose == True) cout << "\n Reading the data"<< endl; - io_3d_read_data(Name_Cube_In, Dat, &Header); - + // io_3d_read_data(Name_Cube_In, Dat, &Header); + fits_read_dblarr (Name_Cube_In, Dat); + int Nx = Dat.nx(); int Ny = Dat.ny(); int Nz = Dat.nz(); - if (Verbose == True) cout << "Nx = " << Dat.nx() << " Ny = " << Dat.ny() << " Nz = " << Dat.nz() << endl; - + if (Verbose == True) + cout << "Nx = " << Dat.nx() << " Ny = " << Dat.ny() << " Nz = " << Dat.nz() << endl; + // Dat.info("READ data"); + + if (Normalize == True) { double Mean = Dat.mean(); double Sigma = Dat.sigma(); + // cout << "Data mean = " << Mean << " Sigma = " << Sigma << endl; + // printf("Sigmad=f = %f", Sigma); for (int i=0;i<Nx;i++) for (int j=0;j<Ny;j++) for (int k=0;k<Nz;k++) Dat(i,j,k) = (Dat(i,j,k)-Mean)/Sigma; } - + // Dat.info("Normalized data"); + // MR2D1D WT; GMCA_2D WT; - if (Verbose == True) cout << "Alloc ... " << endl; WT.alloc(Nx, Ny, Nz, Transform, NbrScale2d, 1); // On ne regularise que la MixingMat if (Verbose == True) cout << "2d1d_trans ... "<< endl; //WT.transform (Dat); // Pas utile - + // WT.write(Name_Out); // Compute the 2D1D transform - fltarray TabVect; - WT.transform_to_vectarray(Dat, TabVect); - // fits_write_fltarr ("xx_tabvect.fits", TabVect); + dblarray TabVect; + WT.transform_to_vectdblarray(Dat, TabVect); + // fits_write_dblarr ("xx_tabvect.fits", TabVect); // Initalize the class for GMCA @@ -518,7 +522,7 @@ int main(int argc, char *argv[]) WT.GlobThrd = GThrd; WT.SVConst = UsePCA; WT.MatNbrScale1D = Nbr_Plan; - fltarray QSVec; + dblarray QSVec; if (UsePCA == True) { @@ -528,12 +532,12 @@ int main(int argc, char *argv[]) if (UseMask == True) { - fits_read_fltarr (Name_Mask, WT.Mask); + fits_read_dblarr (Name_Mask, WT.Mask); } if (UseKnownColomn == True) { - fits_read_fltarr (Name_KnowColumn, WT.MatKnownColumn); + fits_read_dblarr (Name_KnowColumn, WT.MatKnownColumn); if (WT.MatKnownColumn.naxis() == 1) WT.NbrKnownColumn = 1; else WT.NbrKnownColumn = WT.MatKnownColumn.axis(2); } @@ -543,7 +547,7 @@ int main(int argc, char *argv[]) if (EstimNbSources == False) // THE NUMBER OF SOURCES IS FIXED { - fltarray TabSource; + dblarray TabSource; int NbrCoef = TabVect.nx(); TabSource.alloc(NbrCoef,NbrSources); WT.GMCA::Verbose = Verbose; @@ -554,19 +558,19 @@ int main(int argc, char *argv[]) if (EstimNbSources == TRUE) // THE NUMBER OF SOURCES IS ESTIMATED { int NbrSourcesMax = NbrSources; - float RelError = 0; + double RelError = 0; //float SigmaData=TabVect.sigma(); NbrSources = 1; bool ExitCriterion = False; /// CHANGEDDDDD - float OldRelError=0; - float DiffRelError; + double OldRelError=0; + double DiffRelError; while (NbrSources <= NbrSourcesMax && ExitCriterion == False) { NbrSources++; if (Verbose == True) cout << "Running GMCA ... Number of Estimated Sources : " << NbrSources << endl; WT.NbrSources = NbrSources; - fltarray TabSource; + dblarray TabSource; int NbrCoef = TabVect.nx(); TabSource.alloc(NbrCoef,NbrSources); WT.GMCA::Verbose = Verbose; @@ -605,17 +609,17 @@ int main(int argc, char *argv[]) // Reconstruction : if (Verbose == True) cout << "Reconstruction ... "<< endl; - fltarray EstSources; + dblarray EstSources; WT.recons_sources(Dat,EstSources); // WT.Sort_Sources(EstSources); if (Verbose == True) cout << "Write results ... "<< endl; // fits_write_fltarr ("xx_EstSources.fits", EstSources); - fits_write_fltarr ("xx_EstMixmat.fits", WT.MixingMat); - fits_write_fltarr ("xx_InvMixingMat.fits", WT.InvMixingMat); + fits_write_dblarr ("xx_EstMixmat.fits", WT.MixingMat); + fits_write_dblarr ("xx_InvMixingMat.fits", WT.InvMixingMat); // Header.origin = Cmd; - fits_write_fltarr(Name_Out, EstSources); + fits_write_dblarr(Name_Out, EstSources); exit(0); } diff --git a/src/sparse/libsparse2d/GMCA.cc b/src/sparse/libsparse2d/GMCA.cc index 6c90dd8..dd15c8a 100644 --- a/src/sparse/libsparse2d/GMCA.cc +++ b/src/sparse/libsparse2d/GMCA.cc @@ -25,32 +25,49 @@ /****************************************************************************/ -void GMCA::run_gmca(fltarray &TabCannels, fltarray & TabSource) +void GMCA::run_gmca(dblarray &TabCannels, dblarray & TabSource) { // Declaring some local variables - + //cout << "IN" << endl; + + double SigmaData = TabCannels.sigma(); + if (Verbose == True) cout << "SigmaData = " << SigmaData << endl; + //cout << "SigmaData = " << SigmaData << endl; + + int Nmax = Max_GMCA_Iter; float KThrd; if (Inpainting == False) KThrd = 10; // For K-Mad filtering -- UN PEU ELEVE ? if (Inpainting == True) KThrd = 25; float KThrd_min = KMin; // May be an option ? float DiffKThrd = (KThrd-KThrd_min)/(Nmax-1);//,lsparse1=0,L1Crit=0; // For K-Mad filtering - defines the speed of convergence - fltarray WhiteMat,RecSource,Data,DataRec; + dblarray WhiteMat,RecSource,Data,DataRec; KStart = 1; - + // cout << "init_mixmat" << endl; + init_mixmat(TabCannels); // May use a random initialization + // cout << "init_mixmat" << endl; + //if (MatNbrScale1D < 2) MatNbrScale1D = get_nbr_scale (NbrCannels); FilterAnaSynt *PtrFAS; FAS.alloc(F_MALLAT_7_9); PtrFAS = &FAS; + MR_Mat.alloc(NbrCannels, TO1_MALLAT, MatNbrScale1D, PtrFAS, NORM_L2, False); - - if ((Verbose == True) && (L1_Matrix_Constraint == True)) + +// Verbose = True; + + if ((Verbose == True) && (L1_Matrix_Constraint == True)) cout << " WT1D of the mixing matrix: nbr of scales = " << MatNbrScale1D << endl; - + + // cout << " WT1D of the mixing matrix: nbr of scales = " << MatNbrScale1D << endl; + if (L1_Matrix_Constraint == True) KStart = (int) NbrCannels/pow((float) 2, (float) MatNbrScale1D-1); + // cout << " KStart = " << KStart << endl; + + // cout << "KStart" << KStart << endl; // { // mat_wt1d_trans(TabCannels); @@ -61,7 +78,8 @@ void GMCA::run_gmca(fltarray &TabCannels, fltarray & TabSource) // } // NbrCoef = TabCannels.nx(); - + if (Verbose == True) cout << "NbrCoef = " << NbrCoef << endl; + if (PositiveMatrix == True) { @@ -72,26 +90,33 @@ void GMCA::run_gmca(fltarray &TabCannels, fltarray & TabSource) { if (Verbose == True) cout << "Use mask and inpaint" << endl; recons_data(TabCannels,Data); - fits_write_fltarr ("DataIn.fits",Data); + // fits_write_dblarr ("DataIn.fits",Data); } - float SigmaData = TabCannels.sigma(); - + + // Main loop if (Verbose == True) cout << "Number of sources : " << NbrSources << endl; if (Verbose == True) cout << "Last K-Mad : " << KMin << endl; + // cout << "IN " << SigmaData << endl; for (int i=0; i < Nmax; i++) { // Update the sources : // Normalizing the mixing matrix - + // cout << "Normal_Mixmat " << endl; + Normal_Mixmat(); + // cout << "Update_Sources " << endl; + Update_Sources(TabCannels,TabSource, KThrd); - + + // TabCannels.info("TabCannels"); + // TabSource.info("TabSource"); + Sort_Sources(TabSource); // A retirer eventuellement if (PositiveSource == True) @@ -102,13 +127,15 @@ void GMCA::run_gmca(fltarray &TabCannels, fltarray & TabSource) } // Update the mixing matrix : - + + // cout << "Update_MixingMat: " << SigmaData << endl; + Update_MixingMat(TabCannels,TabSource,KThrd); - + // Compute the L2 error : - L2err = l2_error(TabCannels,TabSource); - L2err = -20.*log10(L2err/SigmaData + 1e-100); + L2err = l2_error(TabCannels,TabSource) / SigmaData; + // L2err = -20.*log10(L2err + 1e-100); if (PositiveMatrix == True) positive_mixmat_constraint(); @@ -119,8 +146,8 @@ void GMCA::run_gmca(fltarray &TabCannels, fltarray & TabSource) if (Inpainting == True) { reform_data(TabSource,DataRec); - fits_write_fltarr("DataRec.fits",DataRec); - apply_mask(Data,Mask,DataRec); + // fits_write_dblarr("DataRec.fits",DataRec); + apply_mask(Data,Mask,DataRec); transform_data(DataRec,TabCannels); } @@ -134,16 +161,16 @@ void GMCA::run_gmca(fltarray &TabCannels, fltarray & TabSource) } - //fits_write_fltarr ("cc_EstMixmat.fits", MixingMat); - //fits_write_fltarr ("cc_EstSources.fits", TabSource); + //fits_write_dblarr ("cc_EstMixmat.fits", MixingMat); + //fits_write_dblarr ("cc_EstSources.fits", TabSource); if (Inpainting == True) { transrecons_sources(TabSource,RecSource); - fits_write_fltarr ("xx_InpaintedSources.fits", RecSource); + fits_write_dblarr ("xx_InpaintedSources.fits", RecSource); reform_data(TabSource,DataRec); - fits_write_fltarr ("xx_InpaintedData.fits", DataRec); - cout << "Inpaint Fin" << endl; + fits_write_dblarr ("xx_InpaintedData.fits", DataRec); + //cout << "Inpaint Fin" << endl; } //if (L1_Matrix_Constraint == True) @@ -161,10 +188,10 @@ void GMCA::run_gmca(fltarray &TabCannels, fltarray & TabSource) void GMCA::PCAMixMat() { - fltarray Mat; - fltarray tMat; - fltarray Res; - fltarray Q(NbrCannels,NbrSources); + dblarray Mat; + dblarray tMat; + dblarray Res; + dblarray Q(NbrCannels,NbrSources); int i,k; for (i=0;i<NbrCannels;i++) for (k=0;k<NbrSources;k++) Q(i,k) = SingVec(i,k); @@ -179,8 +206,9 @@ void GMCA::PCAMixMat() void GMCA::positive_mixmat_constraint() { int i,k,s; - fltarray V(NbrSources),W(NbrSources),Q(NbrCannels); - + dblarray W(NbrSources),Q(NbrCannels); + fltarray V(NbrSources); + // Reconstruction if (L1_Matrix_Constraint == True) mat_wt1d_recons(MixingMat); @@ -210,7 +238,7 @@ void GMCA::positive_mixmat_constraint() for (k=0; k < NbrSources; k++) { - for (i=0;i<NbrCannels; i++) Vect(i) = MixingMat(i,k); + for (i=0;i<NbrCannels; i++) Vect(i) = (float) MixingMat(i,k); MR_Mat.transform(Vect); @@ -220,7 +248,7 @@ void GMCA::positive_mixmat_constraint() { for (i=0; i < MR_Mat.size_scale_np (s); i++) { - MixingMat(ind+i,k) = MR_Mat(s,i); + MixingMat(ind+i,k) = (double) MR_Mat(s,i); } @@ -233,10 +261,10 @@ void GMCA::positive_mixmat_constraint() /****************************************************************************/ -void GMCA::positive_cube_constraint(fltarray &Data) +void GMCA::positive_cube_constraint(dblarray &Data) { int i,j,z; - fltarray V(Data.nz()),W(Data.nz()),Frame(Data.nx(),Data.ny()); + dblarray V(Data.nz()),W(Data.nz()),Frame(Data.nx(),Data.ny()); for (z=0;z < Data.nz();z++) { @@ -259,11 +287,11 @@ void GMCA::positive_cube_constraint(fltarray &Data) /****************************************************************************/ -void GMCA::ortho_hypcube(fltarray &TabSource) +void GMCA::ortho_hypcube(dblarray &TabSource) { int i,k,l; int NbrCoef = TabSource.nx(); - fltarray P(NbrCoef*NbrCannels,NbrSources); + dblarray P(NbrCoef*NbrCannels,NbrSources); int Indo = 0; @@ -279,7 +307,7 @@ void GMCA::ortho_hypcube(fltarray &TabSource) } - fltarray MMV,tQ,Q; + dblarray MMV,tQ,Q; ortho_sources_svd(P,Q); @@ -292,21 +320,21 @@ void GMCA::ortho_hypcube(fltarray &TabSource) /****************************************************************************/ -void GMCA::pca(fltarray &Mat,fltarray &VMat) +void GMCA::pca(dblarray &Mat,dblarray &VMat) // Compute the Singular Vectors of the covariance matrix of Mat // Mat = TabCannels { void dsvdcmp(double **a, int m, int n, double w[], double **v); int i,j; - fltarray M1,tMat; - fltarray CovMatSources; + dblarray M1,tMat; + dblarray CovMatSources; float MMean; // 1) retirer la moyenne - fltarray NMat = Mat; - fltarray MeanMat(NMat.nx()); + dblarray NMat = Mat; + dblarray MeanMat(NMat.nx()); for(i=0; i < NMat.nx(); i++) { for(j=0; j < NMat.ny(); j++) MeanMat(j) = Mat(i,j); @@ -326,13 +354,13 @@ void GMCA::pca(fltarray &Mat,fltarray &VMat) int P = CovMatSources.ny(); // number of lines int Q = CovMatSources.nx(); // number of columns - fltarray U(Q,P); // composed of eigen value of B B^t - fltarray V(Q,Q); // composed of eigen vector of B^t B - fltarray Ut(P,Q); // composed of eigen value of B B^t - fltarray Vt(Q,Q); // composed of eigen vector of B^t B - fltarray EV; + dblarray U(Q,P); // composed of eigen value of B B^t + dblarray V(Q,Q); // composed of eigen vector of B^t B + dblarray Ut(P,Q); // composed of eigen value of B B^t + dblarray Vt(Q,Q); // composed of eigen vector of B^t B + dblarray EV; - fltarray Diag(Q,Q); + dblarray Diag(Q,Q); Diag.init(); double **a; // matrix P lines, Q columns double **v; // eigenvectors matrix @@ -371,14 +399,14 @@ void GMCA::pca(fltarray &Mat,fltarray &VMat) /****************************************************************************/ -void GMCA::ortho_sources_svd(fltarray &Mat,fltarray &VMat) +void GMCA::ortho_sources_svd(dblarray &Mat,dblarray &VMat) // Orthogonalization by svd - -{ + +{ void dsvdcmp(double **a, int m, int n, double w[], double **v); int i,j; - fltarray M1,tMat; - fltarray CovMatSources; + dblarray M1,tMat; + dblarray CovMatSources; MAT.transpose(Mat,tMat); MAT.mat_mult(Mat,tMat,CovMatSources); @@ -389,13 +417,13 @@ void GMCA::ortho_sources_svd(fltarray &Mat,fltarray &VMat) int P = CovMatSources.ny(); // number of lines int Q = CovMatSources.nx(); // number of columns - fltarray U(Q,P); // composed of eigen value of B B^t - fltarray V(Q,Q); // composed of eigen vector of B^t B - fltarray Ut(P,Q); // composed of eigen value of B B^t - fltarray Vt(Q,Q); // composed of eigen vector of B^t B - fltarray EV; + dblarray U(Q,P); // composed of eigen value of B B^t + dblarray V(Q,Q); // composed of eigen vector of B^t B + dblarray Ut(P,Q); // composed of eigen value of B B^t + dblarray Vt(Q,Q); // composed of eigen vector of B^t B + dblarray EV; - fltarray Diag(Q,Q); + dblarray Diag(Q,Q); Diag.init(); double **a; // matrix P lines, Q columns double **v; // eigenvectors matrix @@ -428,8 +456,8 @@ void GMCA::ortho_sources_svd(fltarray &Mat,fltarray &VMat) free_dmatrix(v, 1, Q, 1, Q); free_dvector(w, 1, Q); - fltarray MMat; - fltarray tV; + dblarray MMat; + dblarray tV; MAT.transpose(V,tV); MAT.mat_mult(tV,Mat,MMat); Mat = MMat; @@ -455,8 +483,8 @@ void GMCA::ortho_spectra_svd() { void dsvdcmp(double **a, int m, int n, double w[], double **v); int i,j; - fltarray M1,tMat; - fltarray CovMatSources; + dblarray M1,tMat; + dblarray CovMatSources; MAT.transpose(MixingMat,tMat); MAT.mat_mult(MixingMat,tMat,CovMatSources); @@ -467,13 +495,13 @@ void GMCA::ortho_spectra_svd() int P = CovMatSources.ny(); // number of lines int Q = CovMatSources.nx(); // number of columns - fltarray U(Q,P); // composed of eigen value of B B^t - fltarray V(Q,Q); // composed of eigen vector of B^t B - fltarray Ut(P,Q); // composed of eigen value of B B^t - fltarray Vt(Q,Q); // composed of eigen vector of B^t B - fltarray EV; + dblarray U(Q,P); // composed of eigen value of B B^t + dblarray V(Q,Q); // composed of eigen vector of B^t B + dblarray Ut(P,Q); // composed of eigen value of B B^t + dblarray Vt(Q,Q); // composed of eigen vector of B^t B + dblarray EV; - fltarray Diag(Q,Q); + dblarray Diag(Q,Q); Diag.init(); double **a; // matrix P lines, Q columns double **v; // eigenvectors matrix @@ -506,8 +534,8 @@ void GMCA::ortho_spectra_svd() free_dmatrix(v, 1, Q, 1, Q); free_dvector(w, 1, Q); - fltarray MMat; - fltarray tV; + dblarray MMat; + dblarray tV; MAT.transpose(V,tV); MAT.mat_mult(tV,MixingMat,MMat); MixingMat = MMat; @@ -530,7 +558,7 @@ void GMCA::ortho_spectra_svd() void GMCA::force_disjspec() { int i,k,m; - fltarray V(NbrSources),Q(NbrCannels),P(NbrSources); + dblarray V(NbrSources),Q(NbrCannels),P(NbrSources); // int MaxSpecIndex = (int) NbrCannels*(1-1/((float) MatNbrScale1D)); @@ -566,11 +594,11 @@ void GMCA::force_disjspec() /****************************************************************************/ -void GMCA::force_disjsources(fltarray &TabSource) +void GMCA::force_disjsources(dblarray &TabSource) { int i,k; int NbrCoef = TabSource.nx(); - fltarray V(NbrSources); + dblarray V(NbrSources); for (i=0;i<NbrCoef;i++) @@ -584,13 +612,13 @@ void GMCA::force_disjsources(fltarray &TabSource) } /****************************************************************************/ -void GMCA::subs_mean(fltarray &Data) +void GMCA::subs_mean(dblarray &Data) { int i,k; int NbC = Data.ny(); int NbS = Data.nx(); - fltarray V(NbS); + dblarray V(NbS); for (i=0;i<NbC;i++) { @@ -609,7 +637,7 @@ void GMCA::subs_mean(fltarray &Data) void GMCA::print_mixmatnorm() { int i,k; - fltarray V(NbrCannels); + dblarray V(NbrCannels); for (i=0;i<NbrSources;i++) { @@ -621,10 +649,10 @@ void GMCA::print_mixmatnorm() /****************************************************************************/ -void GMCA::Calc_InvMixingMat(fltarray &TabSource) +void GMCA::Calc_InvMixingMat(dblarray &TabSource) { - fltarray LeftA; - fltarray TabMMTemp,IndexA(NbrSources); + dblarray LeftA; + dblarray TabMMTemp,IndexA(NbrSources); int i,k,NbNzS = NbrSources,NLin_Mat = MixingMat.axis(1),NCol_Mat = MixingMat.axis(2); // Evalve the indices of the non-zero columns of the mixing matrix : @@ -661,11 +689,11 @@ void GMCA::Calc_InvMixingMat(fltarray &TabSource) /****************************************************************************/ -void GMCA::Update_MixingMat(fltarray &TabData,fltarray &TabSource , float &KThrd) +void GMCA::Update_MixingMat(dblarray &TabData,dblarray &TabSource , float &KThrd) { // Definitions - fltarray IndexS(NbrSources); - fltarray TabMMTemp,TabSTemp,RightS; + dblarray IndexS(NbrSources); + dblarray TabMMTemp,TabSTemp,RightS; int i,k,NbNzS = NbrSources,NLin_Mat = MixingMat.axis(1),NbrCoef = TabSource.nx(); @@ -701,7 +729,7 @@ void GMCA::Update_MixingMat(fltarray &TabData,fltarray &TabSource , float &KThrd // Thresholding : if (L1_Matrix_Constraint == True) { - fltarray TempM; + dblarray TempM; mat_wt1d_trans(TabMMTemp); HT_MixMat(TabMMTemp,KThrd); MAT.transpose(TabMMTemp,TempM); // Confusion transpose ou pas --- a controler @@ -726,10 +754,10 @@ void GMCA::Update_MixingMat(fltarray &TabData,fltarray &TabSource , float &KThrd } /****************************************************************************/ -void GMCA::init_TabSource(fltarray &TabSource,int &NbrSamples) +void GMCA::init_TabSource(dblarray &TabSource,int &NbrSamples) { int i,k; - fltarray Temp(NbrSamples,NbrSources); + dblarray Temp(NbrSamples,NbrSources); for (i=0;i<NbrSamples;i++) for (k=0;k<NbrSources;k++) Temp(i,k)=0; @@ -737,7 +765,7 @@ void GMCA::init_TabSource(fltarray &TabSource,int &NbrSamples) } /****************************************************************************/ -void GMCA::print_mat(fltarray &Mat) +void GMCA::print_mat(dblarray &Mat) { int Nx = Mat.nx(); int Ny = Mat.ny(); @@ -753,7 +781,7 @@ void GMCA::print_mat(fltarray &Mat) /****************************************************************************/ -void GMCA::Sort_Sources(fltarray &TabSource) +void GMCA::Sort_Sources(dblarray &TabSource) { void indexx(int n, double arr[], int indx[]); int i,k,l; @@ -785,7 +813,7 @@ void GMCA::Sort_Sources(fltarray &TabSource) // Sorting the mixing matrix : - fltarray MMTemp = MixingMat; + dblarray MMTemp = MixingMat; for (i=0;i<NbrSources;i++) { @@ -799,10 +827,10 @@ void GMCA::Sort_Sources(fltarray &TabSource) /****************************************************************************/ -void GMCA::RetrieveSourcesFromMixmat(fltarray &TabData,fltarray & TabSource) +void GMCA::RetrieveSourcesFromMixmat(dblarray &TabData,dblarray & TabSource) { // Definitions - fltarray TabMMTemp,TabSTemp,LeftA; + dblarray TabMMTemp,TabSTemp,LeftA; // Compute the pseudo-inverse: @@ -810,7 +838,7 @@ void GMCA::RetrieveSourcesFromMixmat(fltarray &TabData,fltarray & TabSource) InvMixingMat = LeftA; // Estimate the corresponding sources : - fltarray NLeftA=LeftA; + dblarray NLeftA=LeftA; MAT.transpose(NLeftA,LeftA); MAT.mat_mult(LeftA,TabData,TabSTemp); @@ -821,11 +849,11 @@ void GMCA::RetrieveSourcesFromMixmat(fltarray &TabData,fltarray & TabSource) /****************************************************************************/ -void GMCA::Update_Sources(fltarray &TabData,fltarray &TabSource , float &KThrd) +void GMCA::Update_Sources(dblarray &TabData,dblarray &TabSource , float &KThrd) { // Definitions - fltarray IndexA(NbrSources); - fltarray TabMMTemp,TabSTemp,LeftA; + dblarray IndexA(NbrSources); + dblarray TabMMTemp,TabSTemp,LeftA; int i,k,NbNzS = NbrSources,NLin_Mat = MixingMat.axis(1),NCol_Mat = MixingMat.axis(2),NbrCoef = TabSource.nx(); // Evalve the indices of the non-zero columns of the mixing matrix : @@ -852,14 +880,14 @@ void GMCA::Update_Sources(fltarray &TabData,fltarray &TabSource , float &KThrd) InvMixingMat = LeftA; // Estimate the corresponding sources : - fltarray NLeftA=LeftA; + dblarray NLeftA=LeftA; MAT.transpose(NLeftA,LeftA); MAT.mat_mult(LeftA,TabData,TabSTemp); // if (GetRelax == True) //{ - // fltarray TabTemp = TabData - ... + // dblarray TabTemp = TabData - ... // MAT.mat_mult(LeftA,TabData,TabSTemp); //} @@ -873,7 +901,7 @@ void GMCA::Update_Sources(fltarray &TabData,fltarray &TabSource , float &KThrd) { if (IndexA(i) == 1) { - //fltarray V(NbrCoef); + //dblarray V(NbrCoef); for (k=0; k < NbrCoef;k++) TabSource(k,i) = TabSTemp(k,Indi); //for (k=0; k < NbrCoef;k++) V(k) = TabSTemp(k,Indi); Indi++; @@ -883,10 +911,10 @@ void GMCA::Update_Sources(fltarray &TabData,fltarray &TabSource , float &KThrd) /****************************************************************************/ -void GMCA::Where_MixingMat(fltarray &Mat, fltarray &IndexA, int &NbNzS) +void GMCA::Where_MixingMat(dblarray &Mat, dblarray &IndexA, int &NbNzS) { int i,k,NLin_Mat = Mat.axis(1),NCol_Mat = Mat.axis(2); - fltarray V(NLin_Mat); + dblarray V(NLin_Mat); NbNzS = 0; @@ -909,10 +937,10 @@ void GMCA::Where_MixingMat(fltarray &Mat, fltarray &IndexA, int &NbNzS) /****************************************************************************/ -void GMCA::Where_Sources(fltarray &TabSource, fltarray &IndexS,int &NbNzS) +void GMCA::Where_Sources(dblarray &TabSource, dblarray &IndexS,int &NbNzS) { int i,k,NbrCoef = TabSource.nx(),Nyd = TabSource.ny(); - fltarray V(NbrCoef); + dblarray V(NbrCoef); NbNzS = 0; @@ -941,7 +969,7 @@ void GMCA::Normal_Mixmat() { int i,k; float Norm_V; - fltarray V(NbrCannels); + dblarray V(NbrCannels); for (i=0; i < NbrSources; i++) { @@ -960,10 +988,10 @@ void GMCA::Normal_Mixmat() /****************************************************************************/ -float GMCA::calc_L1norm(fltarray &TabSource) +double GMCA::calc_L1norm(dblarray &TabSource) { int i,k; - float L1n = 0; + double L1n = 0; for (i=0;i<TabSource.nx();i++) for (k=0;k<TabSource.ny();k++) L1n += ABS(TabSource(i,k)); return L1n; @@ -971,10 +999,10 @@ float GMCA::calc_L1norm(fltarray &TabSource) /****************************************************************************/ -float GMCA::calc_L0norm(fltarray &TabSource) +double GMCA::calc_L0norm(dblarray &TabSource) { int i,k; - float L0n = 0; + double L0n = 0; for (i=0;i<TabSource.nx();i++) for (k=0;k<TabSource.ny();k++) if(ABS(TabSource(i,k)) > ErrRate) L0n++; return L0n; @@ -982,11 +1010,11 @@ float GMCA::calc_L0norm(fltarray &TabSource) /****************************************************************************/ -float GMCA::l2_error(fltarray & TabData, fltarray & TabSource) -{ - fltarray TabChannel; - fltarray TranspMixingMat; - fltarray Mat= MixingMat; +double GMCA::l2_error(dblarray & TabData, dblarray & TabSource) +{ + dblarray TabChannel; + dblarray TranspMixingMat; + dblarray Mat= MixingMat; MAT.transpose(Mat,TranspMixingMat); MAT.mat_mult(TranspMixingMat, TabSource, TabChannel); TabChannel -= TabData; @@ -995,15 +1023,15 @@ float GMCA::l2_error(fltarray & TabData, fltarray & TabSource) /****************************************************************************/ -float GMCA::CountResiThrd(fltarray & TabData, fltarray & TabSource, float & Thrd) -{ - fltarray TabChannel; - fltarray TranspMixingMat; - fltarray Mat= MixingMat; +double GMCA::CountResiThrd(dblarray & TabData, dblarray & TabSource, float & Thrd) +{ + dblarray TabChannel; + dblarray TranspMixingMat; + dblarray Mat= MixingMat; MAT.transpose(Mat,TranspMixingMat); MAT.mat_mult(TranspMixingMat, TabSource, TabChannel); TabChannel -= TabData; - float count=0; + double count=0; int i,j; for (i=0; i<TabChannel.nx(); i++) for (j=0; j<TabChannel.ny(); j++) if (abs(TabChannel(i,j)) > Thrd) count++; return count; @@ -1011,17 +1039,17 @@ float GMCA::CountResiThrd(fltarray & TabData, fltarray & TabSource, float & Thrd /****************************************************************************/ -float GMCA::MyKurt(fltarray & TabData) -{ +double GMCA::MyKurt(dblarray & TabData) +{ int Nx = TabData.nx(); int Ny = TabData.ny(); - float KurtV,MeanVal,SigVal; + double KurtV,MeanVal,SigVal; int i,j,p=0; - fltarray V(Ny); + dblarray V(Ny); int NCol = Nx* Ny; - fltarray W(NCol); - - for (i=0; i<Nx; i++) + dblarray W(NCol); + + for (i=0; i<Nx; i++) { for (j=0; j<Ny; j++) V(j) = TabData(i,j); MeanVal = V.mean(); @@ -1032,20 +1060,20 @@ float GMCA::MyKurt(fltarray & TabData) p++; } } - - KurtV = curtosis(W.buffer(),NCol); + + KurtV = curtosis(W.buffer(),NCol); return KurtV; } /****************************************************************************/ -float GMCA::CalcSigmaMadResidual(fltarray & TabData, fltarray & TabSource) -{ - fltarray TabChannel; - fltarray TranspMixingMat; - fltarray Mat= MixingMat; - float MadValue; - fltarray V; +double GMCA::CalcSigmaMadResidual(dblarray & TabData, dblarray & TabSource) +{ + dblarray TabChannel; + dblarray TranspMixingMat; + dblarray Mat= MixingMat; + double MadValue; + dblarray V; int NCol_Mat; int p=0; int i,k; @@ -1074,14 +1102,14 @@ float GMCA::CalcSigmaMadResidual(fltarray & TabData, fltarray & TabSource) /****************************************************************************/ -float GMCA::CalcKurtosisResidual(fltarray & TabData) -{ - fltarray TabChannel; +double GMCA::CalcKurtosisResidual(dblarray & TabData) +{ + dblarray TabChannel; float KurtValue; // Definitions - fltarray TabMMTemp,TabSTemp,LeftA; + dblarray TabMMTemp,TabSTemp,LeftA; // Compute the pseudo-inverse: @@ -1089,13 +1117,13 @@ float GMCA::CalcKurtosisResidual(fltarray & TabData) InvMixingMat = LeftA; // Estimate the corresponding sources : - fltarray NLeftA=LeftA; + dblarray NLeftA=LeftA; MAT.transpose(NLeftA,LeftA); MAT.mat_mult(LeftA,TabData,TabSTemp); - fltarray TranspMixingMat; - fltarray Mat= MixingMat; + dblarray TranspMixingMat; + dblarray Mat= MixingMat; MAT.transpose(Mat,TranspMixingMat); MAT.mat_mult(TranspMixingMat, TabSTemp, TabChannel); @@ -1108,16 +1136,16 @@ float GMCA::CalcKurtosisResidual(fltarray & TabData) /****************************************************************************/ -void GMCA::init_mixmat(fltarray &TabCannels) // Devrait être fait dans le constructeur +void GMCA::init_mixmat(dblarray &TabCannels) // Devrait être fait dans le constructeur { int i,k; - fltarray Temp(NbrCannels,NbrSources); + dblarray Temp(NbrCannels,NbrSources); fltarray Vec(NbrCannels); // Initialize with a PCA //pca(TabCannels,Temp); - + // cout << " IN init_mixmat " << NbrCannels << " " << NbrSources << endl; for (i=0;i < NbrCannels;i++) { for (k=0;k < NbrSources;k++) @@ -1125,7 +1153,8 @@ void GMCA::init_mixmat(fltarray &TabCannels) // Devrait être fait dans le const Temp(i,k) = get_random(-1,1); } } - + // cout << " NbrColumnInit " << NbrColumnInit << endl; + if (NbrColumnInit > 0) // Initialize with a known sub-matrix { if (L1_Matrix_Constraint == True) @@ -1133,7 +1162,7 @@ void GMCA::init_mixmat(fltarray &TabCannels) // Devrait être fait dans le const if (NbrColumnInit > 1) { // Transform the known spectra - fltarray TempM(NbrColumnInit,NbrCannels); + dblarray TempM(NbrColumnInit,NbrCannels); MAT.transpose(MatColumnInit,TempM); mat_wt1d_trans(TempM); MAT.transpose(TempM,MatColumnInit); @@ -1141,7 +1170,7 @@ void GMCA::init_mixmat(fltarray &TabCannels) // Devrait être fait dans le const if (NbrColumnInit == 1) { - for (k=0;k<NbrCannels; k++) Vec(k) = MatColumnInit(k); + for (k=0;k<NbrCannels; k++) Vec(k) = (float) MatColumnInit(k); MR_Mat.transform(Vec); int ind=0; for (int s=0; s < MR_Mat.nbr_band (); s++) @@ -1171,7 +1200,7 @@ void GMCA::init_mixmat(fltarray &TabCannels) // Devrait être fait dans le const if (NbrKnownColumn > 1) { // Transform the known spectra - fltarray TempM(NbrKnownColumn,NbrCannels); + dblarray TempM(NbrKnownColumn,NbrCannels); MAT.transpose(MatKnownColumn,TempM); mat_wt1d_trans(TempM); MAT.transpose(TempM,MatKnownColumn); @@ -1192,7 +1221,8 @@ void GMCA::init_mixmat(fltarray &TabCannels) // Devrait être fait dans le const } - + // cout << " IN init_mixmat " << NbrKnownColumn << endl; + { for (i=0;i < NbrKnownColumn;i++) { @@ -1200,14 +1230,15 @@ void GMCA::init_mixmat(fltarray &TabCannels) // Devrait être fait dans le const if (NbrKnownColumn == 1) for (k=0;k < NbrCannels;k++) Temp(k,i)=MatKnownColumn(k); } } - + // cout << " IN init_mixmat " << NbrKnownColumn << endl; + MixingMat = Temp; RecMixingMat = Temp; } /****************************************************************************/ -void GMCA::mat_wt1d_trans(fltarray &Mat) // Il vaudrait mieux mettre un fltarray en entree car ce sont les colonnes de TabData que nous allons transformer +void GMCA::mat_wt1d_trans(dblarray &Mat) // Il vaudrait mieux mettre un dblarray en entree car ce sont les colonnes de TabData que nous allons transformer { int i,k,s; fltarray Vect(NbrCannels); @@ -1226,7 +1257,7 @@ void GMCA::mat_wt1d_trans(fltarray &Mat) // Il vaudrait mieux mettre un fltarra { for (k=0; k < MR_Mat.size_scale_np (s); k++) { - Mat(i,ind+k) = MR_Mat(s,k); + Mat(i,ind+k) = (double) MR_Mat(s,k); } @@ -1237,7 +1268,7 @@ void GMCA::mat_wt1d_trans(fltarray &Mat) // Il vaudrait mieux mettre un fltarra /****************************************************************************/ -void GMCA::mat_wt1d_recons(fltarray &Mat) +void GMCA::mat_wt1d_recons(dblarray &Mat) { int i,k; fltarray Vect(NbrCannels); @@ -1246,21 +1277,21 @@ void GMCA::mat_wt1d_recons(fltarray &Mat) { int ind=0; for (int s=0; s < MR_Mat.nbr_band (); s++) - for (k=0; k < MR_Mat.size_scale_np (s); k++) MR_Mat(s,k) = Mat(ind++,i); + for (k=0; k < MR_Mat.size_scale_np (s); k++) MR_Mat(s,k) = (float) Mat(ind++,i); MR_Mat.recons(Vect); - for (k=0;k<NbrCannels; k++) Mat(k,i) = Vect(k); + for (k=0;k<NbrCannels; k++) Mat(k,i) = (double) Vect(k); } } /****************************************************************************/ -void GMCA::leftpi_mat(fltarray &Mat,fltarray &LPIMat) // compute the inverse matrix (should be great to define a similar function to compute pseudo-inverses (left and right)) +void GMCA::leftpi_mat(dblarray &Mat,dblarray &LPIMat) // compute the inverse matrix (should be great to define a similar function to compute pseudo-inverses (left and right)) { - fltarray transpM; - fltarray cM; - fltarray IcM; - fltarray tempA; + dblarray transpM; + dblarray cM; + dblarray IcM; + dblarray tempA; MAT.transpose(Mat,transpM); // X -> X^T MAT.mat_mult(Mat,transpM,cM); // X -> X^T*X @@ -1274,12 +1305,12 @@ void GMCA::leftpi_mat(fltarray &Mat,fltarray &LPIMat) // compute the inverse ma /****************************************************************************/ -void GMCA::rightpi_mat(fltarray &Mat, fltarray &RPIMat) // compute the inverse matrix (should be great to define a similar function to compute pseudo-inverses (left and right)) +void GMCA::rightpi_mat(dblarray &Mat, dblarray &RPIMat) // compute the inverse matrix (should be great to define a similar function to compute pseudo-inverses (left and right)) { - fltarray transpM; - fltarray cM; - fltarray IcM; - fltarray tempA; + dblarray transpM; + dblarray cM; + dblarray IcM; + dblarray tempA; MAT.transpose(Mat,transpM); MAT.mat_mult(Mat,transpM,cM); @@ -1292,11 +1323,11 @@ void GMCA::rightpi_mat(fltarray &Mat, fltarray &RPIMat) // compute the inverse /******************** CalcMadMat ******************************/ -float GMCA::CalcMadMat(fltarray &TabSource) +double GMCA::CalcMadMat(dblarray &TabSource) { int i,k; int Nxd = TabSource.nx(),Nyd = TabSource.ny(); - fltarray V(Nxd*Nyd); + dblarray V(Nxd*Nyd); int Val = 0; for (i=0;i < Nxd;i++) @@ -1312,13 +1343,13 @@ float GMCA::CalcMadMat(fltarray &TabSource) /******************** Hard Threshold the sources******************************/ -void GMCA::HT_Sources(fltarray &TabSource, float &KThrd) // Applying the matrix on the data +void GMCA::HT_Sources(dblarray &TabSource, float &KThrd) // Applying the matrix on the data { int NbrCoef = TabSource.nx(); int Nyd = TabSource.ny(); int i,k; float Mad; - fltarray V(NbrCoef); + dblarray V(NbrCoef); float Thrd; if (GlobThrd == True) @@ -1350,13 +1381,13 @@ void GMCA::HT_Sources(fltarray &TabSource, float &KThrd) // Applying the matrix /******************** Hard Threshold the spectra******************************/ -void GMCA::HT_MixMat(fltarray &Mat, float &KThrd) // Applying the matrix on the data +void GMCA::HT_MixMat(dblarray &Mat, float &KThrd) // Applying the matrix on the data { int NLin_Mat = Mat.axis(1); int NCol_Mat = Mat.axis(2); int i,k; float Mad; - fltarray V; + dblarray V; V.alloc(1,NCol_Mat-KStart); @@ -1377,12 +1408,12 @@ void GMCA::HT_MixMat(fltarray &Mat, float &KThrd) // Applying the matrix on the /****************************************************************************/ -void GMCA::apply_mat(fltarray & TabData, fltarray &Mat, fltarray & Result) // Applying the matrix on the data +void GMCA::apply_mat(dblarray & TabData, dblarray &Mat, dblarray & Result) // Applying the matrix on the data { int NbrCoef = TabData.nx(); int Nyd = TabData.ny(); int i,k,NCol_Mat = Mat.axis(2); - fltarray V,R; + dblarray V,R; V.alloc(1,Nyd); R.alloc(1,NCol_Mat); @@ -1401,13 +1432,13 @@ void GMCA::apply_mat(fltarray & TabData, fltarray &Mat, fltarray & Result) // A /******************** Hard Threshold the sources******************************/ -void GMCA::recons_sources(fltarray &DataIn, fltarray &EstSources) // Applying the matrix on the data +void GMCA::recons_sources(dblarray &DataIn, dblarray &EstSources) // Applying the matrix on the data { int Nx = DataIn.nx(); int Ny = DataIn.ny(); int Nz = DataIn.nz(); int i,k,l; - fltarray RefData,RefSources; + dblarray RefData,RefSources; int Deb = 0; // Reform the data @@ -1442,7 +1473,7 @@ void GMCA::recons_sources(fltarray &DataIn, fltarray &EstSources) // Applying t /**********************************************************************************/ - void GMCA::apply_mask(fltarray &Data,fltarray &Mask,fltarray &DataRec) + void GMCA::apply_mask(dblarray &Data,dblarray &Mask,dblarray &DataRec) { int i,k,s; for (i=0;i<Data.nx();i++) @@ -1452,9 +1483,9 @@ void GMCA::recons_sources(fltarray &DataIn, fltarray &EstSources) // Applying t /**********************************************************************************/ - void GMCA::reform_data(fltarray &TabSources,fltarray &Data) + void GMCA::reform_data(dblarray &TabSources,dblarray &Data) { - fltarray TabCh(TabSources.nx(),NbrCannels); + dblarray TabCh(TabSources.nx(),NbrCannels); int i,k,l; for (i=0;i<TabSources.nx();i++) @@ -1474,7 +1505,7 @@ void GMCA::recons_sources(fltarray &DataIn, fltarray &EstSources) // Applying t /**********************************************************************************/ - void GMCA::transform_data(fltarray &DataRec,fltarray &TabCannels) + void GMCA::transform_data(dblarray &DataRec,dblarray &TabCannels) { //cout << DataRec.nx() << DataRec.ny() << endl; transform_sources(DataRec,TabCannels); @@ -1483,7 +1514,7 @@ void GMCA::recons_sources(fltarray &DataIn, fltarray &EstSources) // Applying t /**********************************************************************************/ - void GMCA::recons_data(fltarray &TabCannels,fltarray &Data) + void GMCA::recons_data(dblarray &TabCannels,dblarray &Data) { // First if 1D if (L1_Matrix_Constraint == True) @@ -1496,9 +1527,9 @@ void GMCA::recons_sources(fltarray &DataIn, fltarray &EstSources) // Applying t { int ind=0; for (int s=0; s < MR_Mat.nbr_band (); s++) - for (k=0; k < MR_Mat.size_scale_np (s); k++) MR_Mat(s,k) = TabCannels(i,ind++); + for (k=0; k < MR_Mat.size_scale_np (s); k++) MR_Mat(s,k) = (float) TabCannels(i,ind++); MR_Mat.recons(Vect); - for (k=0;k<NbrCannels; k++) TabCannels(i,k) = Vect(k); + for (k=0;k<NbrCannels; k++) TabCannels(i,k) = (double) Vect(k); } } @@ -1508,4 +1539,4 @@ void GMCA::recons_sources(fltarray &DataIn, fltarray &EstSources) // Applying t } -/****************************************************************************/ \ No newline at end of file +/****************************************************************************/ diff --git a/src/sparse/libsparse2d/GMCA.h b/src/sparse/libsparse2d/GMCA.h index 3d84f86..9d17d16 100644 --- a/src/sparse/libsparse2d/GMCA.h +++ b/src/sparse/libsparse2d/GMCA.h @@ -56,17 +56,17 @@ class GMCA { int NbrCannels; // Number of channels int NbrSources; // Number of Sources int Max_GMCA_Iter; // Maximum number of iterations in the GMCA algorithm - fltarray MixingMat; // Mixing matrice - fltarray RecMixingMat; // When sparsity is applied on the column of the mixing matrix, RecMixingMat is the reconctructed mixing matrix + dblarray MixingMat; // Mixing matrice + dblarray RecMixingMat; // When sparsity is applied on the column of the mixing matrix, RecMixingMat is the reconctructed mixing matrix int MatNbrScale1D; // Number of Wavelet Scale used when applying the l_1 norm constraint on the matrix - fltarray InvMixingMat; // Inverse Matrice (i.e. the matrice to be applied to the data to recover the sources) + dblarray InvMixingMat; // Inverse Matrice (i.e. the matrice to be applied to the data to recover the sources) int NbrKnownColumn; // Number of column which are known in the mixing matrix (a priori) int NbrColumnInit; // Number of column which are known in the mixing matrix (a priori) - fltarray MatKnownColumn; // Matrix containing the known column - fltarray MatColumnInit; // Initialize the mixing matrix with fixed columns - type_gmca_threshold_decrease TypeThresholdDecrease; // Select the decreasing threshold strategy + dblarray MatKnownColumn; // Matrix containing the known column + dblarray MatColumnInit; // Initialize the mixing matrix with fixed columns + type_gmca_threshold_decrease TypeThresholdDecrease; // Select the decreasing threshold strategy Bool Inpainting; // If true, GMCA consider missing data, and apply an inpainting technique - fltarray Mask; // if Inpainting==True, Mask contains the available data Mask(i) = 1 or 0 (0 for no data). + dblarray Mask; // if Inpainting==True, Mask contains the available data Mask(i) = 1 or 0 (0 for no data). Bool PositiveMatrix; // if True, the mixing matrice is assume to be positive Bool PositiveSource; // if True, the sources are assumed to be positive Bool OrthoSpectra; // if True, the spectra are orthogonalized @@ -76,122 +76,122 @@ class GMCA { Bool GlobThrd; // if True Global Thresholding on S (should also be made for A). float ErrRate; // float KMin; // Last K-Mad - fltarray SingVec; // Singular Vectors + dblarray SingVec; // Singular Vectors Bool SVConst; // Constrain the mixing matrix columns to span the same subspace as the SingVec int NbrCoef; - float L2err; + double L2err; int KStart; bool GetRelax; - float RelaxVal; + double RelaxVal; - GMCA () {NbrCannels=NbrSources=0;Max_GMCA_Iter=DEF_GMCA_MAX_ITER; NbrColumnInit=0; + GMCA () {NbrCannels=NbrSources=0;Max_GMCA_Iter=DEF_GMCA_MAX_ITER; NbrColumnInit=0; NbrKnownColumn=0; Inpainting=False;PositiveMatrix=False;PositiveSource=False;ErrRate=1e-7;KMin=3;MatNbrScale1D=0; Verbose=False;DisjSpec=False;OrthoSpectra=False;} - float l2_error(fltarray & TabData,fltarray & TabSource); + double l2_error(dblarray & TabData,dblarray & TabSource); // Return the l2 norm of an estimation, i.e. || TabData - MixingMat # TabSource ||^2 - float CalcSigmaMadResidual(fltarray & TabData,fltarray & TabSource); + double CalcSigmaMadResidual(dblarray & TabData,dblarray & TabSource); // Return the Sigma Mad of TabData - MixingMat # TabSource in the coefficient space - float CalcKurtosisResidual(fltarray & TabData); + double CalcKurtosisResidual(dblarray & TabData); // Return the kurtosis of TabData - MixingMat # TabSource in the coefficient space - void RetrieveSourcesFromMixmat(fltarray & TabData,fltarray & TabSource); + void RetrieveSourcesFromMixmat(dblarray & TabData,dblarray & TabSource); // Retrieve the sources from the data and the mixing matrix - void Calc_InvMixingMat(fltarray &TabSource); + void Calc_InvMixingMat(dblarray &TabSource); // Update the mixing matrix - void pca(fltarray &Mat,fltarray &VMat); + void pca(dblarray &Mat,dblarray &VMat); // Compute a PCA to initialize VMat void Normal_Mixmat(); // Normalize the mixing matrix - void leftpi_mat(fltarray &Mat, fltarray & LPIMat); + void leftpi_mat(dblarray &Mat, dblarray & LPIMat); // Compute the left pseudo-inverse of a matrix - void rightpi_mat(fltarray &Mat, fltarray & RPIMat); + void rightpi_mat(dblarray &Mat, dblarray & RPIMat); // Compute the left pseudo-inverse of a matrix - void Sort_Sources(fltarray &TabSource); + void Sort_Sources(dblarray &TabSource); // Sorting the sources with decreasing energy - void Where_MixingMat(fltarray &Mat,fltarray &IndexA, int &NbNzS); + void Where_MixingMat(dblarray &Mat,dblarray &IndexA, int &NbNzS); // Look for non-zero spectra - float CountResiThrd(fltarray & TabData, fltarray & TabSource, float & Thrd); + double CountResiThrd(dblarray & TabData, dblarray & TabSource, float & Thrd); - float MyKurt(fltarray & TabData); + double MyKurt(dblarray & TabData); void print_mixmatnorm(); // print the std of the columns of mixmat - float calc_L0norm(fltarray &TabSource); + double calc_L0norm(dblarray &TabSource); // Compute the left pseudo-inverse of a matrix - float calc_L1norm(fltarray &TabSource); + double calc_L1norm(dblarray &TabSource); // Compute the left pseudo-inverse of a matrix - float CalcMadMat(fltarray &TabSource); + double CalcMadMat(dblarray &TabSource); // Compute the mad of a matrix - void ortho_sources_svd(fltarray &Mat,fltarray &V); + void ortho_sources_svd(dblarray &Mat,dblarray &V); //Orthogonalization of the sources void ortho_spectra_svd(); //Orthogonalization of the spectra - void Where_Sources(fltarray &TabSource, fltarray &IndexS, int &NbNzS); + void Where_Sources(dblarray &TabSource, dblarray &IndexS, int &NbNzS); // Look for non-zero sources - void Update_Sources(fltarray &TabData,fltarray &TabSource , float &KThrd); + void Update_Sources(dblarray &TabData,dblarray &TabSource , float &KThrd); // Update the sources - void Update_MixingMat(fltarray &TabData,fltarray &TabSource, float &KThrd); + void Update_MixingMat(dblarray &TabData,dblarray &TabSource, float &KThrd); // Update the mixing matrix - void HT_Sources(fltarray & TabSource, float & KThrd); // Y faire egalement entrer le type de seuillage + void HT_Sources(dblarray & TabSource, float & KThrd); // Y faire egalement entrer le type de seuillage // Hard-threshold the sources - void HT_MixMat(fltarray &Mat, float &KThrd); + void HT_MixMat(dblarray &Mat, float &KThrd); // Hard-threshold the mixmat - void init_mixmat(fltarray &TabCannels); + void init_mixmat(dblarray &TabCannels); // Initialize the mixing matrix - void print_mat(fltarray &Mat); + void print_mat(dblarray &Mat); // Print a matrix - void subs_mean(fltarray &Data); + void subs_mean(dblarray &Data); // Substracting the mean value void force_disjspec(); // Force the mixing matrix to have disjoint supports for KThrd > 7 - void force_disjsources(fltarray &TabSource); + void force_disjsources(dblarray &TabSource); // Force the sources to have disjoint supports for KThrd > 7 - void apply_mat(fltarray & TabData,fltarray & Mat, fltarray & TabRes); + void apply_mat(dblarray & TabData,dblarray & Mat, dblarray & TabRes); // Apply the matrix to the data - void mat_wt1d_trans(fltarray &Mat); + void mat_wt1d_trans(dblarray &Mat); // 1D wavelet transform along the column of the matrix MixingMat - void mat_wt1d_recons(fltarray &Mat); + void mat_wt1d_recons(dblarray &Mat); // 1D wavelet reconstruction along the column of the matrix MixingMat - void recons_sources(fltarray &DataIn, fltarray &EstSources); + void recons_sources(dblarray &DataIn, dblarray &EstSources); // reconstruct the estimated sources from the mixing matrix estimate and the input data - void init_TabSource(fltarray &TabSource,int & NbrSamples); + void init_TabSource(dblarray &TabSource,int & NbrSamples); // Initialize TabSource - void ortho_hypcube(fltarray &TabSource); - // Orthogonalize the hyperspectral source cubes + void ortho_hypcube(dblarray &TabSource); + // Orthogonalize the hyperspectral source cubes - void positive_cube_constraint(fltarray &Data); + void positive_cube_constraint(dblarray &Data); // Constrain a cube to be positive void positive_mixmat_constraint(); @@ -200,27 +200,27 @@ class GMCA { void PCAMixMat(); // Constrain the subspace spaned by Mixing Mat - void recons_data(fltarray &TabCannels,fltarray &Data); + void recons_data(dblarray &TabCannels,dblarray &Data); // To reconstruct the data - void reform_data(fltarray &TabSources,fltarray &Data); + void reform_data(dblarray &TabSources,dblarray &Data); // To reconstruct the data - void transform_data(fltarray &DataRec,fltarray &TabCannels); + void transform_data(dblarray &DataRec,dblarray &TabCannels); - void apply_mask(fltarray &Data,fltarray &Mask,fltarray &DataRec); + void apply_mask(dblarray &Data,dblarray &Mask,dblarray &DataRec); - void run_gmca(fltarray &TabCannels, fltarray & TabSource); - // run the gmca method + void run_gmca(dblarray &TabCannels, dblarray & TabSource); + // run the gmca method - virtual void run(fltarray &TabCannels, fltarray & TabSource, fltarray & MixingMat, fltarray & InvMixingMat) {}; + virtual void run(dblarray &TabCannels, dblarray & TabSource, dblarray & MixingMat, dblarray & InvMixingMat) {}; // run the gmca method calling run_gmca - virtual void transrecons_sources(fltarray &TabVect,fltarray &Recdata) {}; + virtual void transrecons_sources(dblarray &TabVect,dblarray &Recdata) {}; - virtual void transform_sources(fltarray &Data,fltarray &TabVect) {}; + virtual void transform_sources(dblarray &Data,dblarray &TabVect) {}; - virtual void inpainting_run(fltarray &TabCannels, fltarray & InpData){}; + virtual void inpainting_run(dblarray &TabCannels, dblarray & InpData){}; // run the inpainting method calling run_gmca virtual ~GMCA(){}; diff --git a/src/sparse/libsparse2d/MR1D1D.cc b/src/sparse/libsparse2d/MR1D1D.cc index bc2171a..317e0dc 100644 --- a/src/sparse/libsparse2d/MR1D1D.cc +++ b/src/sparse/libsparse2d/MR1D1D.cc @@ -417,6 +417,56 @@ void MR1D1D::transform_to_vectarray(fltarray &Data, fltarray &TabVect) fltarray Vect(Ny); intarray TabPosBand(NbrBandX); + // 2D wt transform per frame + for (y=0; y < Ny; y++) + { + int Pix=0; + for (i=0; i < Nx; i++) Frame(i) = Data(i,y); + WT_x.transform(Frame); + for (b=0; b < NbrBandX; b++) + { + for (i=0; i < WT_x.size_scale_np (b); i++) TabVect(Pix++,y) = WT_x(b,i); + if (y == 0) TabPosBand(b) = Pix; + } + } +#ifdef DB_MR1D1D + cout << "1D_Y " << NbrBandY << endl; +#endif + // 1D wt + if (NbrBandY >= 2) + { + for (b=0; b < NbrBandX; b++) + for (i=0; i < WT_x.size_scale_np (b); i++) + { + for (y=0; y< Ny; y++) Vect(y) = TabBand[b](i,y); TabVect(TabPosBand(b)+i*WT_x.size_scale_np(b)+i, y); + WT_y.transform(Vect); + y = 0; + for (int b1=0; b1 < NbrBandY; b1++) + for (int p=0; p < WT_y.size_scale_np (b1); p++) TabVect(TabPosBand(b)+i* WT_x.size_scale_np(b)+i,y) = WT_y(b1,p); + } + } +#ifdef DB_MR1D1D + cout << "END TRANS " << endl; +#endif +} + +/****************************************************************************/ + +void MR1D1D::transform_to_vectdblarray(dblarray &Data, dblarray &TabVect) +{ + int Nsx = nbr_coef_x(); + int Nsy = nbr_coef_y(); +#ifdef DB_MR1D1D + cout << "ALLOC transform_to_vectarray " << Nsx << " " << Nsy << endl; +#endif + TabVect.alloc(nbr_coef_x(), nbr_coef_y()); + int x,b,y,i; + Nx = Data.nx(); + Ny = Data.ny(); + fltarray Frame(Nx); + fltarray Vect(Ny); + intarray TabPosBand(NbrBandX); + // 2D wt transform per frame for (y=0; y < Ny; y++) { diff --git a/src/sparse/libsparse2d/MR1D1D.h b/src/sparse/libsparse2d/MR1D1D.h index 1dc9735..07dcbd5 100755 --- a/src/sparse/libsparse2d/MR1D1D.h +++ b/src/sparse/libsparse2d/MR1D1D.h @@ -90,8 +90,10 @@ class MR1D1D { void read(char *Name); // Read a transformation from a file - + void transform_to_vectarray(fltarray &Data, fltarray &TabVect); + + void transform_to_vectdblarray(dblarray &Data, dblarray &TabVect); // Apply the 2D-1D transfrom, but the transformation is not stored in TabBand, and // reconstruction is possible // get_band, put_band, read, write routines cannot be used diff --git a/src/sparse/libsparse3d/MR2D1D.cc b/src/sparse/libsparse3d/MR2D1D.cc index e9d1f74..b042c91 100644 --- a/src/sparse/libsparse3d/MR2D1D.cc +++ b/src/sparse/libsparse3d/MR2D1D.cc @@ -432,7 +432,57 @@ void MR2D1D::transform_to_vectarray(fltarray &Data, fltarray &TabVect) { int Nsx = nbr_coef_2d(); int Nsy = nbr_coef_1d(); - cout << "ALLOC " << Nsx << " " << Nsy << endl; + // cout << "ALLOC " << Nsx << " " << Nsy << endl; + TabVect.alloc(nbr_coef_2d(), nbr_coef_1d()); + int i,j,b,z; + Nx = Data.nx(); + Ny = Data.ny(); + Nz = Data.nz(); + Ifloat Frame(Ny, Nx); + fltarray Vect(Nz); + intarray TabPosBand(nbr_band_2d()); + + // 2D wt transform per frame + for (z=0; z < Nz; z++) + { + int Pix=0; + for (i=0; i < Ny; i++) + for (j=0; j < Nx; j++) Frame(i,j) = Data(j,i,z); + WT2D.transform(Frame); + for (b=0; b < nbr_band_2d(); b++) + { + for (i=0; i < WT2D.size_band_nl(b); i++) + for (j=0; j < WT2D.size_band_nc(b); j++) TabVect(Pix++,z) = WT2D(b,i,j); + if (z == 0) TabPosBand(b) = Pix; + } + } + // cout << "1D " << NbrBand1D << endl; + // 1D wt + if (NbrBand1D >= 2) + { + for (b=0; b < nbr_band_2d(); b++) + for (i=0; i < WT2D.size_band_nl(b); i++) + for (j=0; j < WT2D.size_band_nc(b); j++) + { + for (z=0; z < Nz; z++) Vect(z) = TabVect(TabPosBand(b)+i*WT2D.size_band_nc(b)+j,z); // TabBand[b](j,i,z); + WT1D.transform(Vect); + z = 0; + for (int b1=0; b1 < NbrBand1D; b1++) + { + for (int p=0; p < WT1D.size_scale_np (b1); p++) TabVect(TabPosBand(b)+i*WT2D.size_band_nc(b)+j,z) = WT1D(b1,p); + } + } + } + // cout << "END TRANS " << endl; +} + +/****************************************************************************/ + +void MR2D1D::transform_to_vectdblarray(dblarray &Data, dblarray &TabVect) +{ + int Nsx = nbr_coef_2d(); + int Nsy = nbr_coef_1d(); + // cout << "ALLOC " << Nsx << " " << Nsy << endl; TabVect.alloc(nbr_coef_2d(), nbr_coef_1d()); int i,j,b,z; Nx = Data.nx(); @@ -456,8 +506,8 @@ void MR2D1D::transform_to_vectarray(fltarray &Data, fltarray &TabVect) if (z == 0) TabPosBand(b) = Pix; } } - cout << "1D " << NbrBand1D << endl; - // 1D wt + // cout << "1D " << NbrBand1D << endl; + // 1D wt if (NbrBand1D >= 2) { for (b=0; b < nbr_band_2d(); b++) @@ -473,7 +523,7 @@ void MR2D1D::transform_to_vectarray(fltarray &Data, fltarray &TabVect) } } } - cout << "END TRANS " << endl; +// cout << "END TRANS " << endl; } diff --git a/src/sparse/libsparse3d/MR2D1D.h b/src/sparse/libsparse3d/MR2D1D.h index 938fbca..bf212ce 100755 --- a/src/sparse/libsparse3d/MR2D1D.h +++ b/src/sparse/libsparse3d/MR2D1D.h @@ -95,6 +95,7 @@ class MR2D1D { void read(char *Name); // Read a transformation from a file + void transform_to_vectdblarray(dblarray &Data, dblarray &TabVect); void transform_to_vectarray(fltarray &Data, fltarray &TabVect); // Apply the 2D-1D transfrom, but the transformation is not stored in TabBand, and // reconstruction is possible diff --git a/src/sparse/libtools/DefMath.cc b/src/sparse/libtools/DefMath.cc index b08f767..6794deb 100644 --- a/src/sparse/libtools/DefMath.cc +++ b/src/sparse/libtools/DefMath.cc @@ -282,6 +282,22 @@ float get_sigma_mad(float *Image, int N) /***************************************************************************/ +double get_sigma_mad(double *Image, int N) +{ + double Noise, Med; + int i; + dblarray Buff(N); + + for (i = 0; i < N; i++) Buff(i) = Image[i]; + Med = get_median(Buff.buffer(), N); + + for (i = 0; i < N; i++) Buff(i) = ABS(Image[i] - Med); + Noise = get_median(Buff.buffer(), N); + return (Noise/0.6745); +} + +/***************************************************************************/ + float get_sigma_clip (float *Data, int N, int Nit, Bool Average_Non_Null, Bool UseBadPixel, float BadPVal) { @@ -423,7 +439,36 @@ double curtosis(float *Dat, int N) else Curt = 0.; return Curt; } +/****************************************************************************/ +double curtosis(double *Dat, int N) +{ + double Curt; + double x1,x2,x3,x4,Sigma; + int i; + x1=x2=x3=x4=0.; + for (i=0; i < N; i++) + { + x1 += Dat[i]; + x2 += pow((double) Dat[i], (double) 2.); + x3 += pow((double) Dat[i], (double) 3.); + x4 += pow((double) Dat[i], (double) 4.); + } + x1 /= (double) N; + x2 /= (double) N; + x3 /= (double) N; + x4 /= (double) N; + Sigma = x2 - x1*x1; + if (Sigma > 0.) + { + double x1_2 = x1*x1; + double x1_4 = x1_2*x1_2; + Sigma = sqrt(Sigma); + Curt = 1. / pow(Sigma,(double) 4.) * (x4 -4*x1*x3 + 6.*x2*x1_2 -3.*x1_4 ) - 3.; + } + else Curt = 0.; + return Curt; +} /****************************************************************************/ // old version diff --git a/src/sparse/libtools/DefMath.h b/src/sparse/libtools/DefMath.h index 2ee1020..ecae17a 100644 --- a/src/sparse/libtools/DefMath.h +++ b/src/sparse/libtools/DefMath.h @@ -238,11 +238,14 @@ float get_random(); double b3_spline (double x); double entropy (float *Data, int Npix, float StepHisto=1.); float get_sigma_mad(float *Data, int N); -float get_sigma_clip(float *Data, int N, int Nit=3, Bool Average_Non_Null=True, +double get_sigma_mad(double *Data, int N); + +float get_sigma_clip(float *Data, int N, int Nit=3, Bool Average_Non_Null=True, Bool UseBadPixel=False, float BadPVal=0.); double skewness(float *Dat, int N); double curtosis(float *Dat, int N); -void moment4(float *Dat, int N, double &Mean, double &Pow, +double curtosis(double *Dat, int N); +void moment4(float *Dat, int N, double &Mean, double &Pow, double &M3, double & M4, float & Min, float & Max, bool not_centered=false); void moment4(double *Dat, int N, double &Mean, double &Sigma, double &Skew, double & Curt, double & Min, double & Max); diff --git a/src/sparse/libtools/OptMedian.cc b/src/sparse/libtools/OptMedian.cc index 030a2c1..4576b13 100644 --- a/src/sparse/libtools/OptMedian.cc +++ b/src/sparse/libtools/OptMedian.cc @@ -27,3 +27,7 @@ #undef elem_type #define elem_type float #include "GenMedian.h" + +#undef elem_type +#define elem_type double +#include "GenMedian.h" diff --git a/src/sparse/libtools/OptMedian.h b/src/sparse/libtools/OptMedian.h index 8128fdc..7de30df 100644 --- a/src/sparse/libtools/OptMedian.h +++ b/src/sparse/libtools/OptMedian.h @@ -38,10 +38,13 @@ float opt_med7(float *p); float opt_med9(float *p); float kth_smallest(float a[], int n, int k); float get_median(float a[], int n); +double get_median(double a[], int n); + float abs_kth_smallest(float a[], int n, int k); float get_abs_median(float a[], int n); int hmedian(int *ra, int n); float hmedian(float *ra, int n); +double hmedian(double *ra, int n); #endif diff --git a/src/sparse/libtools/TempArray.h b/src/sparse/libtools/TempArray.h index 9bd0bc5..7a1e5a4 100644 --- a/src/sparse/libtools/TempArray.h +++ b/src/sparse/libtools/TempArray.h @@ -1211,7 +1211,7 @@ double to_array<PARAM_TYPE,ARRAY_TYPE>::sigma () const { ad_val = po_Buffer[i] - ao_moy; ad_sigma += ad_val*ad_val; } - if ((ad_sigma /= i_NbElem) > 1e-07) ad_sigma = sqrt (ad_sigma); + if ((ad_sigma /= i_NbElem) > 0) ad_sigma = sqrt (ad_sigma); else ad_sigma = 0.; return ad_sigma; }