foscat 3.0.30__py3-none-any.whl → 3.0.32__py3-none-any.whl

foscat/CNN.py

@@ -79,7 +79,7 @@ class CNN:
     def get_weights(self):
         return self.x
         
-    def eval(self,im):
+    def eval(self,im,indices=None,weights=None):
 
         x=self.x
         ww=self.scat_operator.backend.bk_reshape(x[0:self.KERNELSZ*self.KERNELSZ*self.n_chan_in*self.chanlist[0]],
@@ -93,7 +93,10 @@ class CNN:
             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(im,ww)
+            if indices is None:
+                im=self.scat_operator.healpix_layer(im,ww)
+            else:
+                im=self.scat_operator.healpix_layer(im,ww,indices=indices[k],weights=weights[k])
             im=self.scat_operator.backend.bk_relu(im)
             im=self.scat_operator.ud_grade_2(im,axis=0)
 

foscat/FoCUS.py

@@ -32,7 +32,7 @@ class FoCUS:
                  mpi_size=1,
                  mpi_rank=0):
 
-        self.__version__ = '3.0.30'
+        self.__version__ = '3.0.32'
         # P00 coeff for normalization for scat_cov
         self.TMPFILE_VERSION=TMPFILE_VERSION
         self.P1_dic = None
@@ -64,7 +64,7 @@ class FoCUS:
             except:
                 if not self.silent:
                     print('Impossible to create the directory %s'%(self.TEMPLATE_PATH))
-                exit(0)
+                return None
                 
         self.number_of_loss=0
 
@@ -82,7 +82,7 @@ class FoCUS:
         if JmaxDelta<-1:
             if not self.silent:
                 print('Warning : Jmax can not be smaller than -1')
-            exit(0)
+            return None
             
         self.OSTEP=JmaxDelta
         self.use_2D=use_2D
@@ -323,7 +323,7 @@ class FoCUS:
     # ---------------------------------------------−---------
     # make the CNN working : index reporjection of the kernel on healpix
     
-    def calc_indices_convol(self,nside,kernel):
+    def calc_indices_convol(self,nside,kernel,rotation=None):
         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)
 
@@ -346,7 +346,10 @@ class FoCUS:
                 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)
             t2,p2=hp.pix2ang(nside,idx2,nest=True)
-            rot=[po[k]/np.pi*180.0,90+(-to[k])/np.pi*180.0]
+            if rotation is None:
+                rot=[po[k]/np.pi*180.0,90+(-to[k])/np.pi*180.0]
+            else:
+                rot=[po[k]/np.pi*180.0,90+(-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)
@@ -364,12 +367,46 @@ class FoCUS:
 
         indices=indices[0:nn]
         weights=weights[0:nn]
-        print('Nside=%d KenelSZ=%d Total Number of value=%d Ratio of the matrix %.2g%%'%(nside,
+        if k%(nside*nside)==nside*nside-1:
+            print('Nside=%d KenelSZ=%d Total Number of value=%d Ratio of the matrix %.2g%%'%(nside,
                                                                                          kernel,
                                                                                          nn,
                                                                                          100*nn/(kernel*12*nside**2*12*nside**2)))
         return indices,weights,xc,yc,zc
 
+    # ---------------------------------------------−---------
+    def calc_orientation(self,im): # im is [Ndata,12*Nside**2]
+        nside=int(np.sqrt(im.shape[1]//12))
+        l_kernel=self.KERNELSZ*self.KERNELSZ
+        norient=32
+        w=np.zeros([l_kernel,1,2*norient])
+        ca=np.cos(np.arange(norient)/norient*np.pi)
+        sa=np.sin(np.arange(norient)/norient*np.pi)
+        stat=np.zeros([12*nside**2,norient])
+        
+        if self.ww_CNN[nside] is None:
+            self.init_CNN_index(nside,transpose=False)
+                
+        y=self.Y_CNN[nside]
+        z=self.Z_CNN[nside]
+        
+        for k in range(norient):
+            w[:,0,k]=(np.exp(-0.5*nside**2*((y)**2+(z)**2))*np.cos(nside*(y*ca[k]+z*sa[k])*np.pi/2))
+            w[:,0,k+norient]=(np.exp(-0.5*nside**2*((y)**2+(z)**2))*np.sin(nside*(y*ca[k]+z*sa[k])*np.pi/2))
+            w[:,0,k]=w[:,0,k]-np.mean(w[:,0,k])
+            w[:,0,k+norient]=w[:,0,k]-np.mean(w[:,0,k+norient])
+
+        for k in range(im.shape[0]):
+            tmp=im[k].reshape(12*nside**2,1)
+            im2=self.healpix_layer(tmp,w)
+            stat=stat+im2[:,0:norient]**2+im2[:,norient:]**2
+
+        rotation=(np.argmax(stat,1)).astype('float')/32.*180.0
+        
+        indices,weights,x,y,z=self.calc_indices_convol(nside,9,rotation=rotation)
+
+        return indices,weights
+        
     def init_CNN_index(self,nside,transpose=False):
         l_kernel=int(self.KERNELSZ*self.KERNELSZ)
         try:
@@ -391,7 +428,6 @@ class FoCUS:
         self.X_CNN[nside]=xc
         self.Y_CNN[nside]=yc
         self.Z_CNN[nside]=zc
-        print(weights.min(),weights.max())
         self.ww_CNN[nside]=self.backend.bk_SparseTensor(indices,
                                                         weights,[12*nside*nside*l_kernel,
                                                                  12*nside*nside])
@@ -403,9 +439,9 @@ class FoCUS:
         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):
+    def healpix_layer_transpose(self,im,ww,indices=None,weights=None):
         nside=int(np.sqrt(im.shape[0]//12))
         l_kernel=self.KERNELSZ*self.KERNELSZ
             
@@ -413,13 +449,13 @@ class FoCUS:
             if not self.silent:
                 print('Weights channels should be equal to the input image channels')
             return -1
-        tmp=self.healpix_layer(im,ww)
-
+        tmp=self.healpix_layer(im,ww,indices=indices,weights=weights)
+        
         return self.up_grade(tmp,2*nside)
     
     # ---------------------------------------------−---------
     # ---------------------------------------------−---------
-    def healpix_layer(self,im,ww):
+    def healpix_layer(self,im,ww,indices=None,weights=None):
         nside=int(np.sqrt(im.shape[0]//12))
         l_kernel=self.KERNELSZ*self.KERNELSZ
             
@@ -427,12 +463,20 @@ class FoCUS:
             if not self.silent:
                 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)
+
+        if indices is None:
+            if self.ww_CNN[nside] is None:
+                self.init_CNN_index(nside,transpose=False)
+            mat=self.ww_CNN[nside]
+        else:
+            if weights is None:
+                print('healpix_layer : If indices is not none weights should be specify')
+                return 0
+            
+            mat=self.backend.bk_SparseTensor(indices,weights,[12*nside*nside*l_kernel,12*nside*nside])
             
-        tmp=self.backend.bk_sparse_dense_matmul(self.ww_CNN[nside],im)
-        print(tmp.shape)
+        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]]))
@@ -475,7 +519,7 @@ class FoCUS:
             if len(ishape)<axis+2:
                 if not self.silent:
                     print('Use of 2D scat with data that has less than 2D')
-                exit(0)
+                return None
                 
             npix=im.shape[axis]
             npiy=im.shape[axis+1]
@@ -536,7 +580,7 @@ class FoCUS:
             if len(ishape)<axis+2:
                 if not self.silent:
                     print('Use of 2D scat with data that has less than 2D')
-                exit(0)
+                return None
                 
             if nouty is None:
                 nouty=nout
@@ -1013,7 +1057,7 @@ class FoCUS:
                     if self.rank==0:
                         if not self.silent:
                             print('Only 3x3 and 5x5 kernel have been developped for Healpix and you ask for %dx%d'%(KERNELSZ,KERNELSZ))
-                        exit(0)
+                        return None
 
         self.barrier()  
         if self.use_2D:          
@@ -1298,7 +1342,7 @@ class FoCUS:
             if len(ishape)<axis+2:
                 if not self.silent:
                     print('Use of 2D scat with data that has less than 2D')
-                exit(0)
+                return None
                 
             npix=ishape[axis]
             npiy=ishape[axis+1]
@@ -1423,7 +1467,7 @@ class FoCUS:
             if len(ishape)<axis+2:
                 if not self.silent:
                     print('Use of 2D scat with data that has less than 2D')
-                exit(0)
+                return None
                 
             npix=ishape[axis]
             npiy=ishape[axis+1]

foscat/GCNN.py

@@ -40,7 +40,7 @@ class GCNN:
         
             if len(chanlist)!=nscale+1:
                 print('len of chanlist (here %d) should of nscale+1 (here %d)'%(len(chanlist),nscale+1))
-                exit(0)
+                return None
             
             self.chanlist=chanlist
             self.KERNELSZ= scat_operator.KERNELSZ
@@ -79,7 +79,7 @@ class GCNN:
     def get_weights(self):
         return self.x
         
-    def eval(self,param):
+    def eval(self,param,indices=None,weights=None):
 
         x=self.x
         
@@ -95,11 +95,15 @@ class GCNN:
             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)
+            if indices is None:
+                im=self.scat_operator.healpix_layer_transpose(im,ww)
+            else:
+                im=self.scat_operator.healpix_layer_transpose(im,ww,indices=indices[k],weights=weights[k])
             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)
         
         return im
-     
+
+        

foscat/GetGPUinfo.py

@@ -33,4 +33,4 @@ event.set()
 
 x.join()
 print('everything done')
-exit(0)
+

foscat/Synthesis.py

@@ -77,7 +77,7 @@ class Synthesis:
             
         if self.operation.BACKEND=='numpy':
             print('Synthesis does not work with numpy. Please select Torch or Tensorflow FOSCAT backend')
-            exit(0)
+            return None
 
     # ---------------------------------------------−---------
     def get_gpu(self,event,delay):

foscat/backend.py

@@ -29,7 +29,7 @@ class foscat_backend:
             print(' - tensorflow')
             print(' - torch')
             print(' - numpy (Impossible to do synthesis using numpy)')
-            exit(0)
+            return None
             
         if self.BACKEND=='tensorflow':
             import tensorflow as tf
@@ -70,7 +70,7 @@ class foscat_backend:
                 self.all_cbk_type=self.backend.complex128
             else:
                 print('ERROR INIT FOCUS ',all_type,' should be float32 or float64')
-                exit(0)
+                return None
         #===========================================================================
         # INIT 
         if mpi_rank==0:

foscat/scat.py

@@ -1044,15 +1044,15 @@ class funct(FOC.FoCUS):
             if list(image1.shape)!=list(image2.shape):
                 print('The two input image should have the same size to eval Scattering')
                     
-                exit(0)
+                return None
         if mask is not None:
             if list(image1.shape)!=list(mask.shape)[1:]:
                 print('The mask should have the same size than the input image to eval Scattering')
                 print('Image shape ',image1.shape,'Mask shape ',mask.shape)
-                exit(0)
+                return None
         if self.use_2D and len(image1.shape)<2:
             print('To work with 2D scattering transform, two dimension is needed, input map has only on dimension')
-            exit(0)
+            return None
             
             
         ### AUTO OR CROSS

foscat/scat1D.py

@@ -862,11 +862,11 @@ class funct(FOC.FoCUS):
             if len(image1.shape)==1:
                 if image1.shape[0]!=mask.shape[1]:
                     print('The mask should have the same size than the input timeline to eval Scattering')
-                    exit(0)
+                    return None
             else:
                 if image1.shape[1]!=mask.shape[1]:
                     print('The mask should have the same size than the input timeline to eval Scattering')
-                    exit(0)
+                    return None
             
         ### AUTO OR CROSS
         cross = False

foscat/scat_cov.py

@@ -1647,7 +1647,7 @@ class funct(FOC.FoCUS):
                 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)
+                return None
                 """
                 iph=(4*phase/(2*np.pi)).astype('int')
                 alpha=(4*phase/(2*np.pi)-iph)
@@ -1720,14 +1720,14 @@ class funct(FOC.FoCUS):
         if image2 is not None:
             if list(image1.shape)!=list(image2.shape):
                 print('The two input image should have the same size to eval Scattering Covariance')
-                exit(0)
+                return None
         if mask is not None:
             if list(image1.shape)!=list(mask.shape)[1:]:
-                print('The mask should have the same size ',mask.shape,'than the input image ',image1.shape,'to eval Scattering Covariance')
-                exit(0)
+                print('The LAST COLUMN of the mask should have the same size ',mask.shape,'than the input image ',image1.shape,'to eval Scattering Covariance')
+                return None
         if self.use_2D and len(image1.shape)<2:
             print('To work with 2D scattering transform, two dimension is needed, input map has only on dimension')
-            exit(0)
+            return None
 
         ### AUTO OR CROSS
         cross = False

foscat/scat_cov1D.py

@@ -1056,11 +1056,11 @@ class funct(FOC.FoCUS):
         if image2 is not None:
             if list(image1.shape)!=list(image2.shape):
                 print('The two input image should have the same size to eval Scattering Covariance')
-                exit(0)
+                return None
         if mask is not None:
             if list(image1.shape)!=list(mask.shape)[1:]:
                 print('The mask should have the same size ',mask.shape,'than the input image ',image1.shape,'to eval Scattering Covariance')
-                exit(0)
+                return None
 
         ### AUTO OR CROSS
         cross = False

{foscat-3.0.30.dist-info → foscat-3.0.32.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foscat
-Version: 3.0.30
+Version: 3.0.32
 Summary: Generate synthetic Healpix or 2D data using Cross Scattering Transform
 Home-page: https://github.com/jmdelouis/FOSCAT
 Author: Jean-Marc DELOUIS

foscat-3.0.32.dist-info/RECORD

@@ -0,0 +1,25 @@
+foscat/CNN.py,sha256=M7i9gdPQvFTPxKySrlaKsCnOXK0iwXBKcQ2FqdPK-JM,4408
+foscat/CircSpline.py,sha256=610sgsWeZzRXYh7gYEqUmGQVrXoHSaFGKjH5mCdh4jU,1684
+foscat/FoCUS.py,sha256=gpLSjh7hLclDvsZDWzZDGjBu4OhmxFTCuxglxaR5LLA,70710
+foscat/GCNN.py,sha256=G-M1yqLtqTfT3ddu-6vXhEFPGDgbtcEKVTRajgYHzUs,4026
+foscat/GetGPUinfo.py,sha256=c01MFYCk38niYCTp0vX3WP24zVDHIsex-Cu42hc9Q18,724
+foscat/Softmax.py,sha256=UDc8Kbl0qWfH1bqDDwfLnkxhON7p93ueZ-Qg2oY4Ke4,2874
+foscat/Spline1D.py,sha256=9oeM8SSHjpfUE5z72YxGt1RVt22vJYM1zhHbNBW8phw,1232
+foscat/Synthesis.py,sha256=aqV_3Npcl2RQj-wxQ0hDMCo650lrN6YRaMd0fAoCrQ4,12615
+foscat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+foscat/backend.py,sha256=qw02rs8yVQsO12SR-SshtekX3ZjXLUAX6o04SiG3Krw,31074
+foscat/backend_tens.py,sha256=zEFZ71j0nMNP9_91tz21ZVBTayr75l-sfONOLkJ8DyI,1432
+foscat/loss_backend_tens.py,sha256=WbGC4vy1pBg_bxUXnlCRiXX9WszN6MaUWUc_lUvZNvQ,1667
+foscat/loss_backend_torch.py,sha256=Fj_W3VwGgeD79eQ4jOxOmhZ548UKDRUb3JjUo2-gSWM,1755
+foscat/scat.py,sha256=tqJ1N5ih5ibHFBw5WV5JQH45OY8Q_6Qw4PG5763OkLM,60073
+foscat/scat1D.py,sha256=GalTfBmPVNy3wC2ddsckwE3KmgkSJS2sZyplKBi9ugM,45855
+foscat/scat2D.py,sha256=Xtisjc5KsbLQAlbn71P0Xg1UIu3r1gUKXoYG2vIMK1M,523
+foscat/scat_cov.py,sha256=kTE6Dur_bOxNZL5-87SUYkSRCy8gbTYw1DCRdM5oLwA,110223
+foscat/scat_cov1D.py,sha256=1bhzaW-5Pcr1aEPOYIXiwu8KOy38JE0g_Y5PvFzGQs8,60599
+foscat/scat_cov2D.py,sha256=8_XvC-lOEVUWP9vT3Wx10G_ATeVeh0SdrSWuBV7Xf5k,536
+foscat/scat_cov_map.py,sha256=ocU2xd41GtJhiU9S3dEv38KfPCvz0tJKY2f8lPxpm5c,2729
+foscat/scat_cov_map2D.py,sha256=t4llIt7DVIyU1b_u-dJSX4lBr2FhDict8RnNnHpRvHM,2754
+foscat-3.0.32.dist-info/METADATA,sha256=hT7P_aLrB3sRXdnQCdYqNxUjSp-B9SQ7fh6J3P5wuvA,1013
+foscat-3.0.32.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+foscat-3.0.32.dist-info/top_level.txt,sha256=AGySXBBAlJgb8Tj8af6m_F-aiNg2zNTcybCUPVOKjAg,7
+foscat-3.0.32.dist-info/RECORD,,

foscat-3.0.30.dist-info/RECORD

@@ -1,25 +0,0 @@
-foscat/CNN.py,sha256=BVf-uD5K-_Tb_Q9xdckLF7PZq-Wcs6qexP9J2K8KCq0,4231
-foscat/CircSpline.py,sha256=610sgsWeZzRXYh7gYEqUmGQVrXoHSaFGKjH5mCdh4jU,1684
-foscat/FoCUS.py,sha256=A_rppGtJOcxZ96sNa6cyWpFWjNDFkVrTYDcI0Dxt_d0,68791
-foscat/GCNN.py,sha256=TEW81DGRM4WL7RzH50VKQ-_oHbl5i3iQKuhdkkgKEO8,3831
-foscat/GetGPUinfo.py,sha256=6sJWKO_OeiA0SoGQQdCT_h3D8rZtrv_4hpBc8H3nZls,731
-foscat/Softmax.py,sha256=UDc8Kbl0qWfH1bqDDwfLnkxhON7p93ueZ-Qg2oY4Ke4,2874
-foscat/Spline1D.py,sha256=9oeM8SSHjpfUE5z72YxGt1RVt22vJYM1zhHbNBW8phw,1232
-foscat/Synthesis.py,sha256=oYtHFVTqalVzBQs5okJBnP4pzXFhBMds-pytdEm4Bqs,12611
-foscat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-foscat/backend.py,sha256=43Q-OtWlB-S14LH5IiUTxg9j_1WvOBZea3DkuEET7aY,31066
-foscat/backend_tens.py,sha256=zEFZ71j0nMNP9_91tz21ZVBTayr75l-sfONOLkJ8DyI,1432
-foscat/loss_backend_tens.py,sha256=WbGC4vy1pBg_bxUXnlCRiXX9WszN6MaUWUc_lUvZNvQ,1667
-foscat/loss_backend_torch.py,sha256=Fj_W3VwGgeD79eQ4jOxOmhZ548UKDRUb3JjUo2-gSWM,1755
-foscat/scat.py,sha256=Ht_xyo7XKJJrUIbQIeucjhIrJo4RGrE63EyhTH8IYig,60061
-foscat/scat1D.py,sha256=fiGxyWSASGik9BimBKz_Z07jSPywJckLXaHDB_v5HHQ,45847
-foscat/scat2D.py,sha256=Xtisjc5KsbLQAlbn71P0Xg1UIu3r1gUKXoYG2vIMK1M,523
-foscat/scat_cov.py,sha256=uST8ij9o1sJh2AKhFffxMUr0WFQX9vz3VK4LGfiSOlE,110188
-foscat/scat_cov1D.py,sha256=I2GgEo7ASkb7JW443SAp25tmI2Rvuy4xggW8WMHI-L4,60591
-foscat/scat_cov2D.py,sha256=8_XvC-lOEVUWP9vT3Wx10G_ATeVeh0SdrSWuBV7Xf5k,536
-foscat/scat_cov_map.py,sha256=ocU2xd41GtJhiU9S3dEv38KfPCvz0tJKY2f8lPxpm5c,2729
-foscat/scat_cov_map2D.py,sha256=t4llIt7DVIyU1b_u-dJSX4lBr2FhDict8RnNnHpRvHM,2754
-foscat-3.0.30.dist-info/METADATA,sha256=5w2eBts5NhenffKMyMXGVM7_G5nzt62aimtutSjsNjM,1013
-foscat-3.0.30.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-foscat-3.0.30.dist-info/top_level.txt,sha256=AGySXBBAlJgb8Tj8af6m_F-aiNg2zNTcybCUPVOKjAg,7
-foscat-3.0.30.dist-info/RECORD,,