foscat 3.0.10__tar.gz → 3.0.13__tar.gz

{foscat-3.0.10 → foscat-3.0.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foscat
-Version: 3.0.10
+Version: 3.0.13
 Summary: Generate synthetic Healpix or 2D data using Cross Scattering Transform
 Home-page: https://github.com/jmdelouis/FOSCAT
 Author: Jean-Marc DELOUIS
@@ -9,12 +9,6 @@ Maintainer: Theo Foulquier
 Maintainer-email: theo.foulquier@ifremer.fr
 License: MIT
 Keywords: Scattering transform,Component separation,denoising
-Requires-Dist: imageio
-Requires-Dist: imagecodecs
-Requires-Dist: matplotlib
-Requires-Dist: numpy
-Requires-Dist: tensorflow
-Requires-Dist: healpy
 
 Utilize the Cross Scattering Transform (described in https://arxiv.org/abs/2207.12527) to synthesize Healpix or 2D data that is suitable for component separation purposes, such as denoising. 
  A demo package for this process can be found at https://github.com/jmdelouis/FOSCAT_DEMO. 

{foscat-3.0.10 → foscat-3.0.13}/setup.py

@@ -3,7 +3,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='foscat',
-    version='3.0.10',
+    version='3.0.13',
     description='Generate synthetic Healpix or 2D data using Cross Scattering Transform' ,
     long_description='Utilize the Cross Scattering Transform (described in https://arxiv.org/abs/2207.12527) to synthesize Healpix or 2D data that is suitable for component separation purposes, such as denoising. \n A demo package for this process can be found at https://github.com/jmdelouis/FOSCAT_DEMO. \n Complete doc can be found at https://foscat-documentation.readthedocs.io/en/latest/index.html. \n\n List of developers : J.-M. Delouis, T. Foulquier, L. Mousset, T. Odaka, F. Paul, E. Allys ' ,
     license='MIT',

{foscat-3.0.10 → foscat-3.0.13}/src/foscat/FoCUS.py

@@ -126,6 +126,8 @@ class FoCUS:
             
         self.ww_Real  = {} 
         self.ww_Imag  = {} 
+        self.ww_CNN_Transpose  = {}
+        self.ww_CNN  = {}
         
         wwc=np.zeros([KERNELSZ**2,l_NORIENT]).astype(all_type)
         wws=np.zeros([KERNELSZ**2,l_NORIENT]).astype(all_type)
@@ -271,6 +273,8 @@ class FoCUS:
             self.nest2R4[lout]=None
             self.inv_nest2R[lout]=None
             self.remove_border[lout]=None
+            self.ww_CNN_Transpose[lout]=None
+            self.ww_CNN[lout]=None
 
         self.loss={}
 
@@ -296,7 +300,92 @@ class FoCUS:
         res=x
         res[idx]=y[idx]
         return(res)
+
+    # ---------------------------------------------−---------
+    # make the CNN working : index reporjection of the kernel on healpix
+    
+    def init_CNN_index(self,nside,transpose=False):
+        l_kernel=int(self.KERNELSZ*self.KERNELSZ)
+        weights=self.backend.bk_cast(np.ones([12*nside*nside*l_kernel],dtype='float'))
+        try:
+            if transpose:
+                indices=np.load('%s/FOSCAT_%s_W%d_%d_%d_CNN_Transpose.npy'%(self.TEMPLATE_PATH,TMPFILE_VERSION,l_kernel,self.NORIENT,nside))
+            else:
+                indices=np.load('%s/FOSCAT_%s_W%d_%d_%d_CNN.npy'%(self.TEMPLATE_PATH,TMPFILE_VERSION,l_kernel,self.NORIENT,nside))
+        except:
+            to,po=hp.pix2ang(nside,np.arange(12*nside*nside),nest=True)
+            x,y,z=hp.pix2vec(nside,np.arange(12*nside*nside),nest=True)
+
+            idx=np.argsort((x-1.0)**2+y**2+z**2)[0:l_kernel]
+            tc,pc=hp.pix2ang(nside,idx,nest=True)
+            
+            indices=np.zeros([12*nside*nside,l_kernel,2],dtype='int')
+            for k in range(12*nside*nside):
+                if k%(nside*nside)==0:
+                    print('Pre-compute nside=%6d %.2f%%'%(nside,100*k/(12*nside*nside)))
+        
+                rot=[po[k]/np.pi*180.0,90+(-to[k])/np.pi*180.0]
+                r=hp.Rotator(rot=rot).get_inverse()            
+                # get the coordinate
+                ty,tx=r(tc,pc)
+    
+                indices[k,:,0]=k*l_kernel+np.arange(l_kernel).astype('int')
+                indices[k,:,1]=hp.ang2pix(nside,ty,tx,nest=True)
+            if transpose:
+                indices[:,:,1]=indices[:,:,1]//4
+                np.save('%s/FOSCAT_%s_W%d_%d_%d_CNN_Transpose.npy'%(self.TEMPLATE_PATH,TMPFILE_VERSION,l_kernel,self.NORIENT,nside),indices)
+                print('Write %s/FOSCAT_%s_W%d_%d_%d_CNN_Transpose.npy'%(self.TEMPLATE_PATH,TMPFILE_VERSION,l_kernel,self.NORIENT,nside))
+            else:
+                np.save('%s/FOSCAT_%s_W%d_%d_%d_CNNnpy'%(self.TEMPLATE_PATH,TMPFILE_VERSION,l_kernel,self.NORIENT,nside),indices)
+                print('Write %s/FOSCAT_%s_W%d_%d_%d_CNN.npy'%(self.TEMPLATE_PATH,TMPFILE_VERSION,l_kernel,self.NORIENT,nside))
+
+                
+        if transpose:
+            self.ww_CNN_Transpose[nside]=self.backend.bk_SparseTensor(indices.reshape(12*nside*nside*l_kernel,2),
+                                                                      weights,[12*nside*nside*l_kernel,
+                                                                                         3*nside*nside])
+        else:
+            self.ww_CNN[nside]=self.backend.bk_SparseTensor(indices.reshape(12*nside*nside*l_kernel,2),
+                                                            weights,[12*nside*nside*l_kernel,
+                                                                     12*nside*nside])
+            
+    # ---------------------------------------------−---------
+    def healpix_layer_transpose(self,im,ww):
+        nside=2*int(np.sqrt(im.shape[0]//12))
+        l_kernel=self.KERNELSZ*self.KERNELSZ
+            
+        if im.shape[1]!=ww.shape[1]:
+            print('Weights channels should be equal to the input image channels')
+            return -1
+        
+        if self.ww_CNN_Transpose[nside] is None:
+            self.init_CNN_index(nside,transpose=True)
+            
+        tmp=self.backend.bk_sparse_dense_matmul(self.ww_CNN_Transpose[nside],im)
+        
+        density=self.backend.bk_reshape(tmp,[12*nside*nside,l_kernel*im.shape[1]])
+        
+        return self.backend.bk_matmul(density,self.backend.bk_reshape(ww,[l_kernel*im.shape[1],ww.shape[2]]))
+    
+    # ---------------------------------------------−---------
+    # ---------------------------------------------−---------
+    def healpix_layer(self,im,ww):
+        nside=int(np.sqrt(im.shape[0]//12))
+        l_kernel=self.KERNELSZ*self.KERNELSZ
+            
+        if im.shape[1]!=ww.shape[1]:
+            print('Weights channels should be equal to the input image channels')
+            return -1
+        
+        if self.ww_CNN[nside] is None:
+            self.init_CNN_index(nside,transpose=False)
+            
+        tmp=self.backend.bk_sparse_dense_matmul(self.ww_CNN[nside],im)
+        density=self.backend.bk_reshape(tmp,[12*nside*nside,l_kernel*im.shape[1]])
         
+        return self.backend.bk_matmul(density,self.backend.bk_reshape(ww,[l_kernel*im.shape[1],ww.shape[2]]))
+    # ---------------------------------------------−---------
+    
     # ---------------------------------------------−---------
     def get_rank(self):
         return(self.rank)
@@ -882,6 +971,7 @@ class FoCUS:
                 return tmp
             
         return wr,wi,ws,tmp
+
         
     # ---------------------------------------------−---------
     # Compute x [....,a,....] to [....,a*a,....]

foscat-3.0.13/src/foscat/GCNN.py

@@ -0,0 +1,100 @@
+import numpy as np
+import pickle
+import foscat.scat_cov as sc
+  
+
+class GCNN:
+        
+    def __init__(self,
+                 scat_operator=None,
+                 nparam=1,
+                 nscale=1,
+                 chanlist=[],
+                 in_nside=1,
+                 nbatch=1,
+                 SEED=1234,
+                 filename=None):
+
+        if filename is not None:
+
+            outlist=pickle.load(open("%s.pkl"%(filename),"rb"))
+        
+            self.scat_operator=sc.funct(KERNELSZ=outlist[3],all_type=outlist[7])
+            self.KERNELSZ= self.scat_operator.KERNELSZ
+            self.all_type= self.scat_operator.all_type
+            self.npar=outlist[2]
+            self.nscale=outlist[5]
+            self.chanlist=outlist[0]
+            self.in_nside=outlist[4] 
+            self.nbatch=outlist[1]
+        
+            self.x=self.scat_operator.backend.bk_cast(outlist[6])
+        else:
+            self.nscale=nscale
+            self.nbatch=nbatch
+            self.npar=nparam
+            self.scat_operator=scat_operator
+        
+            if len(chanlist)!=nscale+1:
+                print('len of chanlist (here %d) should of nscale+1 (here %d)'%(len(chanlist),nscale+1))
+                exit(0)
+            
+            self.chanlist=chanlist
+            self.KERNELSZ= scat_operator.KERNELSZ
+            self.all_type= scat_operator.all_type
+            self.in_nside=in_nside
+
+            np.random.seed(SEED)
+            self.x=scat_operator.backend.bk_cast(np.random.randn(self.get_number_of_weights())/(self.KERNELSZ*self.KERNELSZ))
+
+    def save(self,filename):
+        
+        outlist=[self.chanlist, \
+                 self.nbatch, \
+                 self.npar, \
+                 self.KERNELSZ, \
+                 self.in_nside, \
+                 self.nscale, \
+                 self.get_weights().numpy(), \
+                 self.all_type]
+        myout=open("%s.pkl"%(filename),"wb")
+        pickle.dump(outlist,myout)
+        myout.close()
+    
+    def get_number_of_weights(self):
+        totnchan=0
+        for i in range(self.nscale):
+            totnchan=totnchan+self.chanlist[i]*self.chanlist[i+1]
+        return self.npar*12*self.in_nside**2*self.chanlist[0] \
+            +totnchan*self.KERNELSZ*self.KERNELSZ+self.chanlist[self.nscale]
+
+    def set_weights(self,x):
+        self.x=x
+        
+    def get_weights(self):
+        return self.x
+        
+    def eval(self,param):
+
+        x=self.x
+        
+        ww=self.scat_operator.backend.bk_reshape(x[0:self.npar*12*self.in_nside**2*self.chanlist[0]], \
+                                            [self.npar,12*self.in_nside**2*self.chanlist[0]])
+        
+        im=self.scat_operator.backend.bk_matmul(self.scat_operator.backend.bk_reshape(param,[1,self.npar]),ww)
+        im=self.scat_operator.backend.bk_reshape(im,[12*self.in_nside**2,self.chanlist[0]])
+        im=self.scat_operator.backend.bk_relu(im)
+
+        nn=self.npar*12*self.chanlist[0]*self.in_nside**2
+        for k in range(self.nscale):
+            ww=self.scat_operator.backend.bk_reshape(x[nn:nn+self.KERNELSZ*self.KERNELSZ*self.chanlist[k]*self.chanlist[k+1]],
+                                                [self.KERNELSZ*self.KERNELSZ,self.chanlist[k],self.chanlist[k+1]])
+            nn=nn+self.KERNELSZ*self.KERNELSZ*self.chanlist[k]*self.chanlist[k+1]
+            im=self.scat_operator.healpix_layer_transpose(im,ww)
+            im=self.scat_operator.backend.bk_relu(im)
+            
+        ww=self.scat_operator.backend.bk_reshape(x[nn:],[self.chanlist[self.nscale],1])
+        im=self.scat_operator.backend.bk_matmul(im,ww)
+        
+        return self.scat_operator.backend.bk_reshape(im,[im.shape[0]])
+     

{foscat-3.0.10 → foscat-3.0.13}/src/foscat/Synthesis.py

@@ -49,6 +49,7 @@ class Synthesis:
 
         self.loss_class=loss_list
         self.number_of_loss=len(loss_list)
+        self.__iteration__=1234
         self.nlog=0
         self.m_dw, self.v_dw = 0.0, 0.0
         self.beta1 = beta1
@@ -115,7 +116,7 @@ class Synthesis:
             
         self.nlog=self.nlog+1
         self.itt2=0
-        
+            
         if self.itt%self.EVAL_FREQUENCY==0 and self.mpi_rank==0:
             end = time.time()
             cur_loss='%10.3g ('%(self.ltot[self.ltot!=-1].mean())
@@ -131,6 +132,7 @@ class Synthesis:
                 for k in range(info_gpu.shape[0]):
                     mess=mess+'[GPU%d %.0f/%.0f MB %.0f%%]'%(k,info_gpu[k,0],info_gpu[k,1],info_gpu[k,2])
                 
+            
             print('%sItt %6d L=%s %.3fs %s'%(self.MESSAGE,self.itt,cur_loss,(end-self.start),mess))
             sys.stdout.flush()
             if self.KEEP_TRACK is not None:
@@ -140,13 +142,14 @@ class Synthesis:
             self.start = time.time()
             
         self.itt=self.itt+1
-        
+
     # ---------------------------------------------−---------
     def calc_grad(self,in_x):
         
         g_tot=None
         l_tot=0.0
 
+            
         if self.do_all_noise and self.totalsz>self.batchsz:
             nstep=self.totalsz//self.batchsz
         else:
@@ -158,6 +161,7 @@ class Synthesis:
         
         for istep in range(nstep):
             
+        
             for k in range(self.number_of_loss):
                 if self.loss_class[k].batch is None:
                     l_batch=None
@@ -271,6 +275,7 @@ class Synthesis:
         self.SHOWGPU=SHOWGPU
         self.axis=axis
         self.in_x_nshape=in_x.shape[0]
+        self.seed=1234
 
         np.random.seed(self.mpi_rank*7+1234)
             
@@ -347,7 +352,7 @@ class Synthesis:
         start_x=x.copy()
 
         for iteration in range(NUM_STEP_BIAS):
-
+        
             x,l,i=opt.fmin_l_bfgs_b(self.calc_grad,
                                     x.astype('float64'),
                                     callback=self.info_back,
@@ -357,17 +362,17 @@ class Synthesis:
 
             # update bias input data
             if iteration<NUM_STEP_BIAS-1:
-                if self.mpi_rank==0:
-                    print('%s Hessian restart'%(self.MESSAGE))
+                #if self.mpi_rank==0:
+                #    print('%s Hessian restart'%(self.MESSAGE))
 
                 omap=self.xtractmap(x,axis)
 
                 for k in range(self.number_of_loss):
                     if self.loss_class[k].batch_update is not None:
                         self.loss_class[k].batch_update(self.loss_class[k].batch_data,omap)
+                    if self.loss_class[k].batch is not None:
                         l_batch=self.loss_class[k].batch(self.loss_class[k].batch_data,0,init=True)
                 #x=start_x.copy()
-                    
 
         if self.mpi_rank==0 and SHOWGPU:
             self.stop_synthesis()

{foscat-3.0.10 → foscat-3.0.13}/src/foscat/backend.py

@@ -480,6 +480,41 @@ class foscat_backend:
                 return(self.backend.mean(data,axis))
             if self.BACKEND==self.NUMPY:
                 return(np.mean(data,axis))
+            
+    def bk_reduce_min(self,data,axis=None):
+        
+        if axis is None:
+            if self.BACKEND==self.TENSORFLOW:
+                return(self.backend.reduce_min(data))
+            if self.BACKEND==self.TORCH:
+                return(self.backend.min(data))
+            if self.BACKEND==self.NUMPY:
+                return(np.min(data))
+        else:
+            if self.BACKEND==self.TENSORFLOW:
+                return(self.backend.reduce_min(data,axis=axis))
+            if self.BACKEND==self.TORCH:
+                return(self.backend.min(data,axis))
+            if self.BACKEND==self.NUMPY:
+                return(np.min(data,axis))
+            
+    def bk_random_seed(self,value):
+        
+        if self.BACKEND==self.TENSORFLOW:
+            return(self.backend.random.set_seed(value))
+        if self.BACKEND==self.TORCH:
+            return(self.backend.random.set_seed(value))
+        if self.BACKEND==self.NUMPY:
+            return(np.random.seed(value))
+        
+    def bk_random_uniform(self,shape):
+        
+        if self.BACKEND==self.TENSORFLOW:
+            return(self.backend.random.uniform(shape))
+        if self.BACKEND==self.TORCH:
+            return(self.backend.random.uniform(shape))
+        if self.BACKEND==self.NUMPY:
+            return(np.random.rand(shape))
 
     def bk_reduce_std(self,data,axis=None):
         

{foscat-3.0.10 → foscat-3.0.13}/src/foscat/scat_cov.py

@@ -1491,8 +1491,100 @@ class funct(FOC.FoCUS):
             
         return scat_cov(mS0, mP00, mC01, mC11, s1=mS1,c10=mC10,backend=self.backend), \
             scat_cov(sS0, sP00, sC01, sC11, s1=sS1,c10=sC10,backend=self.backend)
+
+    # compute local direction to make the statistical analysis more efficient
+    def stat_cfft(self,im,upscale=False,smooth_scale=0):
+        tmp=im
+        if upscale:
+            l_nside=int(np.sqrt(tmp.shape[1]//12))
+            tmp=self.up_grade(tmp,l_nside*2,axis=1)
+            
+        l_nside=int(np.sqrt(tmp.shape[1]//12))
+        nscale=int(np.log(l_nside)/np.log(2))
+        cmat={}
+        cmat2={}
+        for k in range(nscale):
+            sim=self.backend.bk_abs(self.convol(tmp,axis=1))
+            cc=self.backend.bk_reduce_mean(sim[:,:,0]-sim[:,:,2],0)
+            ss=self.backend.bk_reduce_mean(sim[:,:,1]-sim[:,:,3],0)
+            for m in range(smooth_scale):
+                if cc.shape[0]>12:
+                    cc=self.ud_grade_2(self.smooth(cc))
+                    ss=self.ud_grade_2(self.smooth(ss))
+            if cc.shape[0]!=tmp.shape[0]:
+                ll_nside=int(np.sqrt(tmp.shape[1]//12))
+                cc=self.up_grade(cc,ll_nside)
+                ss=self.up_grade(ss,ll_nside)
+            phase=np.fmod(np.arctan2(ss.numpy(),cc.numpy())+2*np.pi,2*np.pi)
+            iph=(4*phase/(2*np.pi)).astype('int')
+            alpha=(4*phase/(2*np.pi)-iph)
+            mat=np.zeros([sim.shape[1],4*4])
+            lidx=np.arange(sim.shape[1])
+            for l in range(4):
+                mat[lidx,4*((l+iph)%4)+l]=1.0-alpha
+                mat[lidx,4*((l+iph+1)%4)+l]=alpha
+            
+            cmat[k]=self.backend.bk_cast(mat.astype('complex64'))
+            
+            mat2=np.zeros([k+1,sim.shape[1],4,4*4])
+            
+            for k2 in range(k+1):
+                tmp2=self.backend.bk_repeat(sim,4,axis=-1)
+                sim2=self.backend.bk_reduce_sum(self.backend.bk_reshape(mat.reshape(1,mat.shape[0],16)*tmp2,
+                                                                  [sim.shape[0],cmat[k].shape[0],4,4]),2)
+                sim2=self.backend.bk_abs(self.convol(sim2,axis=1))
+                
+                cc=self.smooth(self.backend.bk_reduce_mean(sim2[:,:,0]-sim2[:,:,2],0))
+                ss=self.smooth(self.backend.bk_reduce_mean(sim2[:,:,1]-sim2[:,:,3],0))
+                for m in range(smooth_scale):
+                    if cc.shape[0]>12:
+                        cc=self.ud_grade_2(self.smooth(cc))
+                        ss=self.ud_grade_2(self.smooth(ss))
+                if cc.shape[0]!=sim.shape[1]:
+                    ll_nside=int(np.sqrt(sim.shape[1]//12))
+                    cc=self.up_grade(cc,ll_nside)
+                    ss=self.up_grade(ss,ll_nside)
+                    
+                phase=np.fmod(np.arctan2(ss.numpy(),cc.numpy())+2*np.pi,2*np.pi)
+                """
+                for k in range(4):
+                    hp.mollview(np.fmod(phase+np.pi,2*np.pi),cmap='jet',nest=True,hold=False,sub=(2,2,1+k))
+                plt.show()
+                exit(0)
+                """
+                iph=(4*phase/(2*np.pi)).astype('int')
+                alpha=(4*phase/(2*np.pi)-iph)
+                lidx=np.arange(sim.shape[1])
+                for m in range(4):
+                    for l in range(4):
+                        mat2[k2,lidx,m,4*((l+iph[:,m])%4)+l]=1.0-alpha[:,m]
+                        mat2[k2,lidx,m,4*((l+iph[:,m]+1)%4)+l]=alpha[:,m]
+                
+            cmat2[k]=self.backend.bk_cast(mat2.astype('complex64'))
+            """
+            tmp=self.backend.bk_repeat(sim[0],4,axis=1)
+            sim2=self.backend.bk_reduce_sum(self.backend.bk_reshape(mat*tmp,[12*nside**2,4,4]),1)
+            
+            cc2=(sim2[:,0]-sim2[:,2])
+            ss2=(sim2[:,1]-sim2[:,3])
+            phase2=np.fmod(np.arctan2(ss2.numpy(),cc2.numpy())+2*np.pi,2*np.pi)
+            
+            plt.figure()
+            hp.mollview(phase,cmap='jet',nest=True,hold=False,sub=(2,2,1))
+            hp.mollview(np.fmod(phase2+np.pi,2*np.pi),cmap='jet',nest=True,hold=False,sub=(2,2,2))
+            plt.figure()
+            for k in range(4):
+                hp.mollview((sim[0,:,k]).numpy().real,cmap='jet',nest=True,hold=False,sub=(2,4,1+k),min=-10,max=10)
+                hp.mollview((sim2[:,k]).numpy().real,cmap='jet',nest=True,hold=False,sub=(2,4,5+k),min=-10,max=10)
+        
+            plt.show()
+            """
+        
+            if k<l_nside-1:
+                tmp=self.ud_grade_2(tmp,axis=1)
+        return cmat,cmat2
     
-    def eval(self, image1, image2=None, mask=None, norm=None, Auto=True, calc_var=False,cmat=None):
+    def eval(self, image1, image2=None, mask=None, norm=None, Auto=True, calc_var=False,cmat=None,cmat2=None):
         """
         Calculates the scattering correlations for a batch of images. Mean are done over pixels.
         mean of modulus:
@@ -1860,19 +1952,19 @@ class funct(FOC.FoCUS):
                 ### C01_auto = < (I1 * Psi)_j3 x (|I1 * Psi_j2| * Psi_j3)^* >_pix
                 if not cross:
                     if calc_var:
-                        c01,vc01 = self._compute_C01(j2,
+                        c01,vc01 = self._compute_C01(j2,j3,
                                                      conv1,
                                                      vmask,
                                                      M1_dic,
                                                      M1convPsi_dic,
-                                                     calc_var=True)  # [Nbatch, Nmask, Norient3, Norient2]
+                                                     calc_var=True,cmat2=cmat2)  # [Nbatch, Nmask, Norient3, Norient2]
                     else:
-                        c01 = self._compute_C01(j2,
+                        c01 = self._compute_C01(j2,j3,
                                                 conv1,
                                                 vmask,
                                                 M1_dic,
                                                 M1convPsi_dic,
-                                                return_data=return_data)  # [Nbatch, Nmask, Norient3, Norient2]
+                                                return_data=return_data,cmat2=cmat2)  # [Nbatch, Nmask, Norient3, Norient2]
                         
                     if return_data:
                         if C01[j3] is None:
@@ -1900,31 +1992,31 @@ class funct(FOC.FoCUS):
                 ### C10_cross = < (I2 * Psi)_j3 x (|I1 * Psi_j2| * Psi_j3)^* >_pix
                 else:
                     if calc_var:
-                        c01,vc01 = self._compute_C01(j2,
+                        c01,vc01 = self._compute_C01(j2,j3,
                                                      conv1,
                                                      vmask,
                                                      M2_dic,
                                                      M2convPsi_dic,
-                                                     calc_var=True)
-                        c10,vc10 = self._compute_C01(j2,
+                                                     calc_var=True,cmat2=cmat2)
+                        c10,vc10 = self._compute_C01(j2,j3,
                                                      conv2,
                                                      vmask,
                                                      M1_dic,
                                                      M1convPsi_dic,
-                                                     calc_var=True)
+                                                     calc_var=True,cmat2=cmat2)
                     else: 
-                        c01 = self._compute_C01(j2,
+                        c01 = self._compute_C01(j2,j3,
                                                 conv1,
                                                 vmask,
                                                 M2_dic,
                                                 M2convPsi_dic,
-                                                return_data=return_data)
-                        c10 = self._compute_C01(j2,
+                                                return_data=return_data,cmat2=cmat2)
+                        c10 = self._compute_C01(j2,j3,
                                                 conv2,
                                                 vmask,
                                                 M1_dic,
                                                 M1convPsi_dic,
-                                                return_data=return_data)
+                                                return_data=return_data,cmat2=cmat2)
                     
                     if return_data:
                         if C01[j3] is None:
@@ -2085,11 +2177,12 @@ class funct(FOC.FoCUS):
         self.P2_dic = None
         return
 
-    def _compute_C01(self, j2, conv,
+    def _compute_C01(self, j2, j3,conv,
                      vmask, M_dic,
                      MconvPsi_dic,
                      calc_var=False,
-                     return_data=False):
+                     return_data=False,
+                     cmat2=None):
         """
         Compute the C01 coefficients (auto or cross)
         C01 = < (Ia * Psi)_j3 x (|Ib * Psi_j2| * Psi_j3)^* >_pix
@@ -2102,7 +2195,10 @@ class funct(FOC.FoCUS):
         ### Compute |I1 * Psi_j2| * Psi_j3 = M1_j2 * Psi_j3
         # Warning: M1_dic[j2] is already at j3 resolution [Nbatch, Npix_j3, Norient3]
         MconvPsi = self.convol(M_dic[j2], axis=1)  # [Nbatch, Npix_j3, Norient3, Norient2]
-
+        if cmat2 is not None:
+            tmp2=self.backend.bk_repeat(MconvPsi,4,axis=-1)
+            MconvPsi=self.backend.bk_reduce_sum(self.backend.bk_reshape(cmat2[j3][j2]*tmp2,[1,cmat2[j3].shape[1],4,4,4]),3)
+        
         # Store it so we can use it in C11 computation
         MconvPsi_dic[j2] = MconvPsi  # [Nbatch, Npix_j3, Norient3, Norient2]
 

{foscat-3.0.10 → foscat-3.0.13}/src/foscat.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foscat
-Version: 3.0.10
+Version: 3.0.13
 Summary: Generate synthetic Healpix or 2D data using Cross Scattering Transform
 Home-page: https://github.com/jmdelouis/FOSCAT
 Author: Jean-Marc DELOUIS
@@ -9,12 +9,6 @@ Maintainer: Theo Foulquier
 Maintainer-email: theo.foulquier@ifremer.fr
 License: MIT
 Keywords: Scattering transform,Component separation,denoising
-Requires-Dist: imageio
-Requires-Dist: imagecodecs
-Requires-Dist: matplotlib
-Requires-Dist: numpy
-Requires-Dist: tensorflow
-Requires-Dist: healpy
 
 Utilize the Cross Scattering Transform (described in https://arxiv.org/abs/2207.12527) to synthesize Healpix or 2D data that is suitable for component separation purposes, such as denoising. 
  A demo package for this process can be found at https://github.com/jmdelouis/FOSCAT_DEMO. 

{foscat-3.0.10 → foscat-3.0.13}/src/foscat.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@ setup.cfg
 setup.py
 src/foscat/CircSpline.py
 src/foscat/FoCUS.py
+src/foscat/GCNN.py
 src/foscat/GetGPUinfo.py
 src/foscat/Softmax.py
 src/foscat/Spline1D.py