foscat 3.0.9__tar.gz → 3.0.11__tar.gz

{foscat-3.0.9 → foscat-3.0.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foscat
-Version: 3.0.9
+Version: 3.0.11
 Summary: Generate synthetic Healpix or 2D data using Cross Scattering Transform
 Home-page: https://github.com/jmdelouis/FOSCAT
 Author: Jean-Marc DELOUIS
@@ -9,6 +9,12 @@ 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.9 → foscat-3.0.11}/setup.py

@@ -3,7 +3,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='foscat',
-    version='3.0.9',
+    version='3.0.11',
     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.9 → foscat-3.0.11}/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.9 → foscat-3.0.11}/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):
+    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:
@@ -1677,6 +1769,11 @@ class funct(FOC.FoCUS):
             ####### S1 and P00
             ### Make the convolution I1 * Psi_j3
             conv1 = self.convol(I1, axis=1)  # [Nbatch, Npix_j3, Norient3]
+
+            if cmat is not None:
+                tmp2=self.backend.bk_repeat(conv1,4,axis=-1)
+                conv1=self.backend.bk_reduce_sum(self.backend.bk_reshape(cmat[j3]*tmp2,[1,cmat[j3].shape[0],4,4]),2)
+                
             ### Take the module M1 = |I1 * Psi_j3|
             M1_square = conv1*self.backend.bk_conjugate(conv1) # [Nbatch, Npix_j3, Norient3]
             M1 = self.backend.bk_L1(M1_square)  # [Nbatch, Npix_j3, Norient3]
@@ -1749,6 +1846,9 @@ class funct(FOC.FoCUS):
             else:  # Cross
                 ### Make the convolution I2 * Psi_j3
                 conv2 = self.convol(I2, axis=1)  # [Nbatch, Npix_j3, Norient3]
+                if cmat is not None:
+                    tmp2=self.backend.bk_repeat(conv2,4,axis=-1)
+                    conv2=self.backend.bk_reduce_sum(self.backend.bk_reshape(cmat[j3]*tmp2,[1,cmat[j3].shape[0],4,4]),2)
                 ### Take the module M2 = |I2 * Psi_j3|
                 M2_square = conv2*self.backend.bk_conjugate(conv2)  # [Nbatch, Npix_j3, Norient3]
                 M2 = self.backend.bk_L1(M2_square)  # [Nbatch, Npix_j3, Norient3]
@@ -1852,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:
@@ -1892,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:
@@ -2077,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
@@ -2094,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.9 → foscat-3.0.11}/src/foscat.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foscat
-Version: 3.0.9
+Version: 3.0.11
 Summary: Generate synthetic Healpix or 2D data using Cross Scattering Transform
 Home-page: https://github.com/jmdelouis/FOSCAT
 Author: Jean-Marc DELOUIS
@@ -9,6 +9,12 @@ 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.