foscat 3.0.32__tar.gz → 3.0.34__tar.gz

{foscat-3.0.32 → foscat-3.0.34}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foscat
-Version: 3.0.32
+Version: 3.0.34
 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.32 → foscat-3.0.34}/setup.py

@@ -3,7 +3,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='foscat',
-    version='3.0.32',
+    version='3.0.34',
     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.32 → foscat-3.0.34}/src/foscat/FoCUS.py

@@ -32,7 +32,7 @@ class FoCUS:
                  mpi_size=1,
                  mpi_rank=0):
 
-        self.__version__ = '3.0.32'
+        self.__version__ = '3.0.34'
         # P00 coeff for normalization for scat_cov
         self.TMPFILE_VERSION=TMPFILE_VERSION
         self.P1_dic = None
@@ -328,33 +328,44 @@ class FoCUS:
         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:kernel]
+        x0,y0,z0=hp.pix2vec(nside,idx[0],nest=True)
+        t0,p0=hp.pix2ang(nside,idx[0],nest=True)
+        
+        idx=np.argsort((x-x0)**2+(y-y0)**2+(z-z0)**2)[0:kernel]
         im=np.ones([12*nside**2])*-1
         im[idx]=np.arange(len(idx))
+        
         xc,yc,zc=hp.pix2vec(nside,idx,nest=True)
+        
+        xc-=x0
+        yc-=y0
+        zc-=z0
 
         vec=np.concatenate([np.expand_dims(x,-1),
                             np.expand_dims(y,-1),
                             np.expand_dims(z,-1)],1)
 
-        tc,pc=hp.pix2ang(nside,idx,nest=True)
-
         indices=np.zeros([12*nside**2*250,2],dtype='int')
         weights=np.zeros([12*nside**2*250])
         nn=0
-        for k in range(0,12*nside*nside):
+        for k in range(12*nside*nside):
             if k%(nside*nside)==nside*nside-1:
                 print('Nside=%d KenelSZ=%d %.2f%%'%(nside,kernel,k/(12*nside**2)*100))
-            idx2=hp.query_disc(nside, vec[k], np.pi/nside, inclusive=True,nest=True)
+            if nside<4:
+                idx2=np.arange(12*nside**2)
+            else:
+                idx2=hp.query_disc(nside, vec[k], np.pi/nside, inclusive=True,nest=True)
             t2,p2=hp.pix2ang(nside,idx2,nest=True)
             if rotation is None:
-                rot=[po[k]/np.pi*180.0,90+(-to[k])/np.pi*180.0]
+                rot=[po[k]/np.pi*180.0,(t0-to[k])/np.pi*180.0]
             else:
-                rot=[po[k]/np.pi*180.0,90+(-to[k])/np.pi*180.0,rotation[k]]
+                rot=[po[k]/np.pi*180.0,(t0-to[k])/np.pi*180.0,rotation[k]]
+                
             r=hp.Rotator(rot=rot)
             t2,p2=r(t2,p2)
-            idx3=hp.ang2pix(nside,t2,p2,nest=True)
+            
             ii,ww=hp.get_interp_weights(nside,t2,p2,nest=True)
-
+            
             ii=im[ii]
 
             for l in range(4):
@@ -410,18 +421,18 @@ class FoCUS:
     def init_CNN_index(self,nside,transpose=False):
         l_kernel=int(self.KERNELSZ*self.KERNELSZ)
         try:
-            indices=np.load('%s/FOSCAT_%s_I%d_%d_%d_CNNV2.npy'%(self.TEMPLATE_PATH,TMPFILE_VERSION,l_kernel,self.NORIENT,nside))
-            weights=np.load('%s/FOSCAT_%s_W%d_%d_%d_CNNV2.npy'%(self.TEMPLATE_PATH,TMPFILE_VERSION,l_kernel,self.NORIENT,nside))
-            xc=np.load('%s/FOSCAT_%s_X%d_%d_%d_CNNV2.npy'%(self.TEMPLATE_PATH,TMPFILE_VERSION,l_kernel,self.NORIENT,nside))
-            yc=np.load('%s/FOSCAT_%s_Y%d_%d_%d_CNNV2.npy'%(self.TEMPLATE_PATH,TMPFILE_VERSION,l_kernel,self.NORIENT,nside))
-            zc=np.load('%s/FOSCAT_%s_Z%d_%d_%d_CNNV2.npy'%(self.TEMPLATE_PATH,TMPFILE_VERSION,l_kernel,self.NORIENT,nside))
+            indices=np.load('%s/FOSCAT_%s_I%d_%d_%d_CNNV3.npy'%(self.TEMPLATE_PATH,TMPFILE_VERSION,l_kernel,self.NORIENT,nside))
+            weights=np.load('%s/FOSCAT_%s_W%d_%d_%d_CNNV3.npy'%(self.TEMPLATE_PATH,TMPFILE_VERSION,l_kernel,self.NORIENT,nside))
+            xc=np.load('%s/FOSCAT_%s_X%d_%d_%d_CNNV3.npy'%(self.TEMPLATE_PATH,TMPFILE_VERSION,l_kernel,self.NORIENT,nside))
+            yc=np.load('%s/FOSCAT_%s_Y%d_%d_%d_CNNV3.npy'%(self.TEMPLATE_PATH,TMPFILE_VERSION,l_kernel,self.NORIENT,nside))
+            zc=np.load('%s/FOSCAT_%s_Z%d_%d_%d_CNNV3.npy'%(self.TEMPLATE_PATH,TMPFILE_VERSION,l_kernel,self.NORIENT,nside))
         except:
             indices,weights,xc,yc,zc=self.calc_indices_convol(nside,l_kernel)
-            np.save('%s/FOSCAT_%s_I%d_%d_%d_CNNV2.npy'%(self.TEMPLATE_PATH,TMPFILE_VERSION,l_kernel,self.NORIENT,nside),indices)
-            np.save('%s/FOSCAT_%s_W%d_%d_%d_CNNV2.npy'%(self.TEMPLATE_PATH,TMPFILE_VERSION,l_kernel,self.NORIENT,nside),weights)
-            np.save('%s/FOSCAT_%s_X%d_%d_%d_CNNV2.npy'%(self.TEMPLATE_PATH,TMPFILE_VERSION,l_kernel,self.NORIENT,nside),xc)
-            np.save('%s/FOSCAT_%s_Y%d_%d_%d_CNNV2.npy'%(self.TEMPLATE_PATH,TMPFILE_VERSION,l_kernel,self.NORIENT,nside),yc)
-            np.save('%s/FOSCAT_%s_Z%d_%d_%d_CNNV2.npy'%(self.TEMPLATE_PATH,TMPFILE_VERSION,l_kernel,self.NORIENT,nside),zc)
+            np.save('%s/FOSCAT_%s_I%d_%d_%d_CNNV3.npy'%(self.TEMPLATE_PATH,TMPFILE_VERSION,l_kernel,self.NORIENT,nside),indices)
+            np.save('%s/FOSCAT_%s_W%d_%d_%d_CNNV3.npy'%(self.TEMPLATE_PATH,TMPFILE_VERSION,l_kernel,self.NORIENT,nside),weights)
+            np.save('%s/FOSCAT_%s_X%d_%d_%d_CNNV3.npy'%(self.TEMPLATE_PATH,TMPFILE_VERSION,l_kernel,self.NORIENT,nside),xc)
+            np.save('%s/FOSCAT_%s_Y%d_%d_%d_CNNV3.npy'%(self.TEMPLATE_PATH,TMPFILE_VERSION,l_kernel,self.NORIENT,nside),yc)
+            np.save('%s/FOSCAT_%s_Z%d_%d_%d_CNNV3.npy'%(self.TEMPLATE_PATH,TMPFILE_VERSION,l_kernel,self.NORIENT,nside),zc)
             if not self.silent:
                 print('Write %s/FOSCAT_%s_W%d_%d_%d_CNNV2.npy'%(self.TEMPLATE_PATH,TMPFILE_VERSION,l_kernel,self.NORIENT,nside))
 
@@ -433,33 +444,45 @@ class FoCUS:
                                                                  12*nside*nside])
             
     # ---------------------------------------------−---------
-    def healpix_layer_coord(self,im):
-        nside=int(np.sqrt(im.shape[0]//12))
+    def healpix_layer_coord(self,im,axis=0):
+        nside=int(np.sqrt(im.shape[axis]//12))
         l_kernel=self.KERNELSZ*self.KERNELSZ
         if self.ww_CNN[nside] is None:
             self.init_CNN_index(nside)
         return self.X_CNN[nside],self.Y_CNN[nside],self.Z_CNN[nside]
 
     # ---------------------------------------------−---------
-    def healpix_layer_transpose(self,im,ww,indices=None,weights=None):
-        nside=int(np.sqrt(im.shape[0]//12))
+    def healpix_layer_transpose(self,im,ww,indices=None,weights=None,axis=0):
+        nside=int(np.sqrt(im.shape[axis]//12))
         l_kernel=self.KERNELSZ*self.KERNELSZ
             
-        if im.shape[1]!=ww.shape[1]:
+        if im.shape[1+axis]!=ww.shape[1]:
             if not self.silent:
                 print('Weights channels should be equal to the input image channels')
             return -1
-        tmp=self.healpix_layer(im,ww,indices=indices,weights=weights)
+        if axis==1:
+            results=[]
         
-        return self.up_grade(tmp,2*nside)
+            for k in range(im.shape[0]):
+                
+                tmp=self.healpix_layer(im[k],ww,indices=indices,weights=weights,axis=0)
+                tmp=self.backend.bk_reshape(self.up_grade(tmp,2*nside),[12*4*nside**2,ww.shape[2]])
+                
+                results.append(tmp)
+            
+            return self.backend.bk_stack(results,axis=0)
+        else:
+            tmp=self.healpix_layer(im,ww,indices=indices,weights=weights,axis=axis)
+        
+            return self.up_grade(tmp,2*nside)
     
     # ---------------------------------------------−---------
     # ---------------------------------------------−---------
-    def healpix_layer(self,im,ww,indices=None,weights=None):
-        nside=int(np.sqrt(im.shape[0]//12))
+    def healpix_layer(self,im,ww,indices=None,weights=None,axis=0):
+        nside=int(np.sqrt(im.shape[axis]//12))
         l_kernel=self.KERNELSZ*self.KERNELSZ
-            
-        if im.shape[1]!=ww.shape[1]:
+
+        if im.shape[1+axis]!=ww.shape[1]:
             if not self.silent:
                 print('Weights channels should be equal to the input image channels')
             return -1
@@ -475,11 +498,26 @@ class FoCUS:
             
             mat=self.backend.bk_SparseTensor(indices,weights,[12*nside*nside*l_kernel,12*nside*nside])
             
-        tmp=self.backend.bk_sparse_dense_matmul(mat,im)
+        if axis==1:
+            results=[]
         
-        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]]))
+            for k in range(im.shape[0]):
+                
+                tmp=self.backend.bk_sparse_dense_matmul(mat,im[k])
+                
+                density=self.backend.bk_reshape(tmp,[12*nside*nside,l_kernel*im.shape[1+axis]])
+                
+                density=self.backend.bk_matmul(density,self.backend.bk_reshape(ww,[l_kernel*im.shape[1+axis],ww.shape[2]]))
+                
+                results.append(self.backend.bk_reshape(density,[12*nside**2,ww.shape[2]]))
+            
+            return self.backend.bk_stack(results,axis=0)
+        else:
+            tmp=self.backend.bk_sparse_dense_matmul(mat,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]]))
     # ---------------------------------------------−---------
     
     # ---------------------------------------------−---------

{foscat-3.0.32 → foscat-3.0.34}/src/foscat/GCNN.py

@@ -79,15 +79,21 @@ class GCNN:
     def get_weights(self):
         return self.x
         
-    def eval(self,param,indices=None,weights=None):
+    def eval(self,param,indices=None,weights=None,axis=0):
 
         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]])
+
+        if axis==0:
+            nval=1
+        else:
+            nval=param.shape[0]
+            
+        im=self.scat_operator.backend.bk_reshape(param,[nval,self.npar])
+        im=self.scat_operator.backend.bk_matmul(im,ww)
+        im=self.scat_operator.backend.bk_reshape(im,[nval,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
@@ -96,14 +102,15 @@ class GCNN:
                                                 [self.KERNELSZ*self.KERNELSZ,self.chanlist[k],self.chanlist[k+1]])
             nn=nn+self.KERNELSZ*self.KERNELSZ*self.chanlist[k]*self.chanlist[k+1]
             if indices is None:
-                im=self.scat_operator.healpix_layer_transpose(im,ww)
+                im=self.scat_operator.healpix_layer_transpose(im,ww,axis=1)
             else:
-                im=self.scat_operator.healpix_layer_transpose(im,ww,indices=indices[k],weights=weights[k])
+                im=self.scat_operator.healpix_layer_transpose(im,ww,indices=indices[k],weights=weights[k],axis=1)
             im=self.scat_operator.backend.bk_relu(im)
-            
+
         ww=self.scat_operator.backend.bk_reshape(x[nn:],[self.chanlist[self.nscale],self.n_chan_out])
         im=self.scat_operator.backend.bk_matmul(im,ww)
-        
+        if axis==0:
+            im=self.scat_operator.backend.bk_reshape(im,[im.shape[1],im.shape[2]])
         return im
 
         

{foscat-3.0.32 → foscat-3.0.34}/src/foscat/backend.py

@@ -253,6 +253,14 @@ class foscat_backend:
         if self.BACKEND==self.NUMPY:
             return self.scipy.sparse.coo_matrix((w,(indice[:,0],indice[:,1])),shape=dense_shape)
         
+    def bk_stack(self,list,axis=0):
+        if self.BACKEND==self.TENSORFLOW:
+            return self.backend.stack(list,axis=axis) 
+        if self.BACKEND==self.TORCH:
+            return self.backend.stack(list,axis=axis) 
+        if self.BACKEND==self.NUMPY:
+            return self.backend.stack(list,axis=axis) 
+        
     def bk_sparse_dense_matmul(self,smat,mat):
         if self.BACKEND==self.TENSORFLOW:
             return self.backend.sparse.sparse_dense_matmul(smat,mat) 

{foscat-3.0.32 → foscat-3.0.34}/src/foscat.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foscat
-Version: 3.0.32
+Version: 3.0.34
 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.