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;
 }