foscat 3.6.0__tar.gz → 3.6.1__tar.gz

{foscat-3.6.0/src/foscat.egg-info → foscat-3.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.1
 Name: foscat
-Version: 3.6.0
+Version: 3.6.1
 Summary: Generate synthetic Healpix or 2D data using Cross Scattering Transform
 Author-email: Jean-Marc DELOUIS <jean.marc.delouis@ifremer.fr>
 Maintainer-email: Theo Foulquier <theo.foulquier@ifremer.fr>
@@ -19,13 +19,6 @@ Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENCE
-Requires-Dist: imageio
-Requires-Dist: imagecodecs
-Requires-Dist: matplotlib
-Requires-Dist: numpy
-Requires-Dist: tensorflow
-Requires-Dist: healpy
-Requires-Dist: spherical
 
 # foscat
 

{foscat-3.6.0 → foscat-3.6.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "foscat"
-version = "3.6.0"
+version = "3.6.1"
 description = "Generate synthetic Healpix or 2D data using Cross Scattering Transform"
 readme = "README.md"
 license = { text = "BSD-3-Clause" }

{foscat-3.6.0 → foscat-3.6.1}/src/foscat/FoCUS.py

@@ -38,7 +38,7 @@ class FoCUS:
         mpi_rank=0,
     ):
 
-        self.__version__ = "3.6.0"
+        self.__version__ = "3.6.1"
         # P00 coeff for normalization for scat_cov
         self.TMPFILE_VERSION = TMPFILE_VERSION
         self.P1_dic = None

{foscat-3.6.0 → foscat-3.6.1}/src/foscat/alm.py

@@ -377,8 +377,15 @@ class alm():
             r_inv=self.backend.bk_reverse(self.backend.bk_conjugate(r[:,1:-1]),axis=axis)
         return self.backend.bk_concat([r,r_inv],axis=axis)
     
+    def irfft2fft(self,val,N,axis=0):
+        if axis==0:
+            return self.backend.bk_irfft(val[0:N//2+1])
+        else:
+            return self.backend.bk_irfft(val[:,0:N//2+1])
+    
     def comp_tf(self,im,nside,realfft=False):
         
+        self.shift_ph(nside)
         n=0
         
         ft_im=[]
@@ -438,6 +445,61 @@ class alm():
             return self.backend.bk_concat([result,lastresult],axis=0)*self.matrix_shift_ph[nside]
         else:
             return result*self.matrix_shift_ph[nside]
+
+    
+    def icomp_tf(self,i_im,nside,realfft=False):
+        
+        self.shift_ph(nside)
+        
+        n=0
+        im=[]
+        ft_im=i_im*self.backend.bk_conjugate(self.matrix_shift_ph[nside])
+        
+        for k in range(nside-1):
+            N=4*(k+1)
+            
+            if realfft:
+                tmp=self.irfft2fft(ft_im[k],N)
+            else:
+                tmp=self.backend.bk_ifft(im[k],N)
+                
+            im.append(tmp[0:N])
+            
+            n+=N
+            
+        if nside>1:
+            result=self.backend.bk_concat(im,axis=0)
+        
+        N=4*nside*(2*nside+1)    
+        v=ft_im[nside-1:3*nside,0:2*nside+1]
+        if realfft:
+            v_fft=self.backend.bk_reshape(self.irfft2fft(v,N,axis=1),[4*nside*(2*nside+1)])
+        else:
+            v_fft=self.backend.bk_ifft(v)
+
+        n+=N
+        if nside>1:
+            result=self.backend.bk_concat([result,v_fft],axis=0)
+        else:
+            result=v_fft
+        
+        if nside>1:
+            im=[]
+            for k in range(nside-1):
+                N=4*(nside-1-k)
+            
+                if realfft:
+                    tmp=self.irfft2fft(ft_im[k+3*nside],N)
+                else:
+                    tmp=self.backend.bk_ifft(im[k+3*nside],N)
+                
+                im.append(tmp[0:N])
+            
+                n+=N
+
+            return self.backend.bk_concat([result]+im,axis=0)
+        else:
+            return result
         
     def anafast(self,im,map2=None,nest=False,spin=2):
         
@@ -621,6 +683,8 @@ class alm():
     def map2alm(self,im,nest=False):
         nside=int(np.sqrt(im.shape[0]//12))
         
+        ph=self.shift_ph(nside)
+        
         if nest:
             idx=hp.ring2nest(nside,np.arange(12*nside**2))
             ft_im=self.comp_tf(self.backend.bk_cast(self.backend.bk_gather(im,idx)),nside,realfft=True)
@@ -645,6 +709,51 @@ class alm():
             
         return alm
 
+    
+    def alm2map(self,nside,alm):
+
+        lth=self.ring_th(nside)
+
+        co_th=np.cos(lth)
+        
+        ft_im=[]
+
+        n=0
+
+        lmax=3*nside-1
+        
+        for m in range(lmax+1):
+            plm=self.compute_legendre_m(co_th,m,3*nside-1,nside)/(12*nside**2)
+
+            print(alm[n:n+lmax-m+1].shape,plm.shape)
+            ft_im.append(self.backend.bk_reduce_sum(self.backend.bk_reshape(alm[n:n+lmax-m+1],[lmax-m+1,1])*plm,0))
+
+            n=n+lmax-m+1
+            
+        return self.backend.bk_reshape(self.backend.bk_concat(ft_im,0),[lmax+1,4*nside-1])
+        
+            
+        if nest:
+            idx=hp.ring2nest(nside,np.arange(12*nside**2))
+            ft_im=self.comp_tf(self.backend.bk_cast(self.backend.bk_gather(im,idx)),nside,realfft=True)
+        else:
+            ft_im=self.comp_tf(self.backend.bk_cast(im),nside,realfft=True)
+            
+
+        lmax=3*nside-1
+    
+        alm=None
+        for m in range(lmax+1):
+            plm=self.compute_legendre_m(co_th,m,3*nside-1,nside)/(12*nside**2)
+            
+            tmp=self.backend.bk_reduce_sum(plm*ft_im[:,m],1)
+            if m==0:
+                alm=tmp
+            else:
+                alm=self.backend.bk_concat([alm,tmp],axis=0)
+            
+        return o_map
+
     def map2alm_spin(self,im_Q,im_U,spin=2,nest=False):
         
         if spin==0:

{foscat-3.6.0 → foscat-3.6.1}/src/foscat/backend.py

@@ -978,6 +978,16 @@ class foscat_backend:
             return self.backend.rfft(data)
         if self.BACKEND == self.NUMPY:
             return self.backend.fft.rfft(data)
+
+        
+    def bk_irfft(self, data):
+        if self.BACKEND == self.TENSORFLOW:
+            return self.backend.signal.irfft(data)
+        if self.BACKEND == self.TORCH:
+            return self.backend.irfft(data)
+        if self.BACKEND == self.NUMPY:
+            return self.backend.fft.irfft(data)
+        
     def bk_conjugate(self, data):
 
         if self.BACKEND == self.TENSORFLOW:

{foscat-3.6.0 → foscat-3.6.1}/src/foscat/scat_cov.py

@@ -2488,15 +2488,16 @@ class funct(FOC.FoCUS):
         )
 
     def eval(
-        self,
-        image1,
-        image2=None,
-        mask=None,
-        norm=None,
-        Auto=True,
-        calc_var=False,
-        cmat=None,
-        cmat2=None,
+            self,
+            image1,
+            image2=None,
+            mask=None,
+            norm=None,
+            Auto=True,
+            calc_var=False,
+            cmat=None,
+            cmat2=None,
+            out_nside=None
     ):
         """
         Calculates the scattering correlations for a batch of images. Mean are done over pixels.
@@ -2708,6 +2709,8 @@ class funct(FOC.FoCUS):
 
         if return_data:
             s0 = I1
+            if out_nside is not None:
+                s0 = self.backend.bk_reduce_mean(self.backend.bk_reshape(s0,[s0.shape[0],12*out_nside**2,(nside//out_nside)**2]),2)
         else:
             if not cross:
                 s0, l_vs0 = self.masked_mean(I1, vmask, axis=1, calc_var=True)
@@ -2778,6 +2781,12 @@ class funct(FOC.FoCUS):
                 if return_data:
                     if S2 is None:
                         S2 = {}
+                    if out_nside is not None and out_nside<nside_j3:
+                        s2 = self.backend.bk_reduce_mean(
+                            self.backend.bk_reshape(s2,[s2.shape[0],
+                                                        12*out_nside**2,
+                                                        (nside_j3//out_nside)**2,
+                                                        s2.shape[2]]),2)
                     S2[j3] = s2
                 else:
                     if norm == "auto":  # Normalize S2
@@ -2818,6 +2827,12 @@ class funct(FOC.FoCUS):
                 if return_data:
                     if S1 is None:
                         S1 = {}
+                    if out_nside is not None and out_nside<nside_j3:
+                        s1 = self.backend.bk_reduce_mean(
+                            self.backend.bk_reshape(s1,[s1.shape[0],
+                                                        12*out_nside**2,
+                                                        (nside_j3//out_nside)**2,
+                                                        s1.shape[2]]),2)
                     S1[j3] = s1
                 else:
                     ### Normalize S1
@@ -2904,6 +2919,12 @@ class funct(FOC.FoCUS):
                 if return_data:
                     if S2 is None:
                         S2 = {}
+                    if out_nside is not None and out_nside<nside_j3:
+                        s2 = self.backend.bk_reduce_mean(
+                            self.backend.bk_reshape(s2,[s2.shape[0],
+                                                        12*out_nside**2,
+                                                        (nside_j3//out_nside)**2,
+                                                        s2.shape[2]]),2)
                     S2[j3] = s2
                 else:
                     ### Normalize S2_cross
@@ -2949,6 +2970,12 @@ class funct(FOC.FoCUS):
                 if return_data:
                     if S1 is None:
                         S1 = {}
+                    if out_nside is not None and out_nside<nside_j3:
+                        s1 = self.backend.bk_reduce_mean(
+                            self.backend.bk_reshape(s1,[s1.shape[0],
+                                                        12*out_nside**2,
+                                                        (nside_j3//out_nside)**2,
+                                                        s1.shape[2]]),2)
                     S1[j3] = s1
                 else:
                     ### Normalize S1
@@ -2979,6 +3006,7 @@ class funct(FOC.FoCUS):
                 M2convPsi_dic = {}
 
             ###### S3
+            nside_j2=nside_j3
             for j2 in range(0, j3 + 1):  # j2 <= j3
                 if return_data:
                     if S4[j3] is None:
@@ -3013,6 +3041,13 @@ class funct(FOC.FoCUS):
                     if return_data:
                         if S3[j3] is None:
                             S3[j3] = {}
+                        if out_nside is not None and out_nside<nside_j2:
+                            s3 = self.backend.bk_reduce_mean(
+                                self.backend.bk_reshape(s3,[s3.shape[0],
+                                                            12*out_nside**2,
+                                                            (nside_j2//out_nside)**2,
+                                                            s3.shape[2],
+                                                            s3.shape[3]]),2)
                         S3[j3][j2] = s3
                     else:
                         ### Normalize S3 with S2_j [Nbatch, Nmask, Norient_j]
@@ -3095,6 +3130,19 @@ class funct(FOC.FoCUS):
                         if S3[j3] is None:
                             S3[j3] = {}
                             S3P[j3] = {}
+                        if out_nside is not None and out_nside<nside_j2:
+                            s3 = self.backend.bk_reduce_mean(
+                                self.backend.bk_reshape(s3,[s3.shape[0],
+                                                            12*out_nside**2,
+                                                            (nside_j2//out_nside)**2,
+                                                            s3.shape[2],
+                                                            s3.shape[3]]),2)
+                            s3p = self.backend.bk_reduce_mean(
+                                self.backend.bk_reshape(s3p,[s3.shape[0],
+                                                             12*out_nside**2,
+                                                             (nside_j2//out_nside)**2,
+                                                             s3.shape[2],
+                                                             s3.shape[3]]),2)
                         S3[j3][j2] = s3
                         S3P[j3][j2] = s3p
                     else:
@@ -3154,6 +3202,7 @@ class funct(FOC.FoCUS):
                                 )  # Add a dimension for NS3
 
                 ##### S4
+                nside_j1=nside_j2
                 for j1 in range(0, j2 + 1):  # j1 <= j2
                     ### S4_auto = <(|I1 * psi1| * psi3)(|I1 * psi2| * psi3)^*>
                     if not cross:
@@ -3179,6 +3228,14 @@ class funct(FOC.FoCUS):
                         if return_data:
                             if S4[j3][j2] is None:
                                 S4[j3][j2] = {}
+                            if out_nside is not None and out_nside<nside_j1:
+                                s4 = self.backend.bk_reduce_mean(
+                                    self.backend.bk_reshape(s4,[s4.shape[0],
+                                                                12*out_nside**2,
+                                                                (nside_j1//out_nside)**2,
+                                                                s4.shape[2],
+                                                                s4.shape[3],
+                                                                s4.shape[4]]),2)
                             S4[j3][j2][j1] = s4
                         else:
                             ### Normalize S4 with S2_j [Nbatch, Nmask, Norient_j]
@@ -3248,6 +3305,14 @@ class funct(FOC.FoCUS):
                         if return_data:
                             if S4[j3][j2] is None:
                                 S4[j3][j2] = {}
+                            if out_nside is not None and out_nside<nside_j1:
+                                s4 = self.backend.bk_reduce_mean(
+                                    self.backend.bk_reshape(s4,[s4.shape[0],
+                                                                12*out_nside**2,
+                                                                (nside_j1//out_nside)**2,
+                                                                s4.shape[2],
+                                                                s4.shape[3],
+                                                                s4.shape[4]]),2)
                             S4[j3][j2][j1] = s4
                         else:
                             ### Normalize S4 with S2_j [Nbatch, Nmask, Norient_j]
@@ -3292,7 +3357,9 @@ class funct(FOC.FoCUS):
                                         ],
                                         axis=2,
                                     )  # Add a dimension for NS4
-
+                            nside_j1=nside_j1 // 2
+                        nside_j2=nside_j2 // 2
+                        
             ###### Reshape for next iteration on j3
             ### Image I1,
             # downscale the I1 [Nbatch, Npix_j3]

{foscat-3.6.0 → foscat-3.6.1}/src/foscat/scat_cov_map.py

@@ -24,10 +24,10 @@ class funct(scat.funct):
         super().__init__(return_data=True, *args, **kwargs)
 
     def eval(
-        self, image1, image2=None, mask=None, norm=None, Auto=True, calc_var=False
+            self, image1, image2=None, mask=None, norm=None, Auto=True, calc_var=False,out_nside=None
     ):
         r = super().eval(
-            image1, image2=image2, mask=mask, norm=norm, Auto=Auto, calc_var=calc_var
+            image1, image2=image2, mask=mask, norm=norm, Auto=Auto, calc_var=calc_var,out_nside=out_nside
         )
         return scat_cov_map(
             r.S2, r.S0, r.S3, r.S4, S1=r.S1, S3P=r.S3P, backend=r.backend

{foscat-3.6.0 → foscat-3.6.1/src/foscat.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.1
 Name: foscat
-Version: 3.6.0
+Version: 3.6.1
 Summary: Generate synthetic Healpix or 2D data using Cross Scattering Transform
 Author-email: Jean-Marc DELOUIS <jean.marc.delouis@ifremer.fr>
 Maintainer-email: Theo Foulquier <theo.foulquier@ifremer.fr>
@@ -19,13 +19,6 @@ Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENCE
-Requires-Dist: imageio
-Requires-Dist: imagecodecs
-Requires-Dist: matplotlib
-Requires-Dist: numpy
-Requires-Dist: tensorflow
-Requires-Dist: healpy
-Requires-Dist: spherical
 
 # foscat