foscat 2025.7.3__py3-none-any.whl → 2025.8.4__py3-none-any.whl

foscat/UNET.py

@@ -0,0 +1,200 @@
+import numpy as np
+
+import foscat.scat_cov as sc
+import foscat.HOrientedConvol as hs
+
+class UNET:
+
+    def __init__(
+            self,
+            nparam=1,
+            KERNELSZ=3,
+            NORIENT=4,
+            chanlist=None,
+            in_nside=1,
+            n_chan_in=1,
+            n_chan_out=1,
+            cell_ids=None,
+            SEED=1234,
+            filename=None,
+    ):
+        self.f=sc.funct(KERNELSZ=KERNELSZ)
+        
+        if chanlist is None:
+            nlayer=int(np.log2(in_nside))
+            chanlist=[4*2**k for k in range(nlayer)]
+        else:
+            nlayer=len(chanlist)
+        print('N_layer ',nlayer)
+
+        n=0
+        wconv={}
+        hconv={}
+        l_cell_ids={}
+        self.KERNELSZ=KERNELSZ
+        kernelsz=self.KERNELSZ
+
+        # create the CNN part
+        l_nside=in_nside
+        l_cell_ids[0]=cell_ids.copy()
+        l_data=self.f.backend.bk_cast(np.ones([1,1,l_cell_ids[0].shape[0]]))
+        l_chan=n_chan_in
+        print('Initial chan %d Npix=%d'%(l_chan,l_data.shape[2]))
+        for l in range(nlayer):
+            print('Layer %d Npix=%d'%(l,l_data.shape[2]))
+            # init double convol weights
+            wconv[2*l]=n
+            nw=l_chan*chanlist[l]*kernelsz*kernelsz
+            print('Layer %d conv [%d,%d]'%(l,l_chan,chanlist[l]))
+            n+=nw
+            wconv[2*l+1]=n
+            nw=chanlist[l]*chanlist[l]*kernelsz*kernelsz
+            print('Layer %d conv [%d,%d]'%(l,chanlist[l],chanlist[l]))
+            n+=nw
+
+            hconvol=hs.HOrientedConvol(l_nside,3,cell_ids=l_cell_ids[l])
+            hconvol.make_idx_weights()
+            hconv[l]=hconvol
+            l_data,n_cell_ids=self.f.ud_grade_2(l_data,cell_ids=l_cell_ids[l],nside=l_nside)
+            l_cell_ids[l+1]=self.f.backend.to_numpy(n_cell_ids)
+            l_nside//=2
+            # plus one to add the input downgrade data
+            l_chan=chanlist[l]+n_chan_in
+
+        self.n_cnn=n
+        self.l_cell_ids=l_cell_ids
+        self.wconv=wconv
+        self.hconv=hconv
+
+        # create the transpose CNN part
+        m_cell_ids={}
+        m_cell_ids[0]=l_cell_ids[nlayer]
+        t_wconv={}
+        t_hconv={}
+        
+        for l in range(nlayer):
+            #upgrade data
+            l_chan+=n_chan_in
+            l_data=self.f.up_grade(l_data,l_nside*2,
+                                   cell_ids=l_cell_ids[nlayer-l],
+                                   o_cell_ids=l_cell_ids[nlayer-1-l],
+                                   nside=l_nside)
+            print('Transpose Layer %d Npix=%d'%(l,l_data.shape[2]))
+            
+            
+            m_cell_ids[l]=l_cell_ids[nlayer-1-l]
+            l_nside*=2
+            
+            # init double convol weights
+            t_wconv[2*l]=n
+            nw=l_chan*l_chan*kernelsz*kernelsz
+            print('Transpose Layer %d conv [%d,%d]'%(l,l_chan,l_chan))
+            n+=nw
+            t_wconv[2*l+1]=n
+            out_chan=n_chan_out
+            if nlayer-1-l>0:
+                out_chan+=chanlist[nlayer-1-l]
+            print('Transpose Layer %d conv [%d,%d]'%(l,l_chan,out_chan))
+            nw=l_chan*out_chan*kernelsz*kernelsz
+            n+=nw
+
+            hconvol=hs.HOrientedConvol(l_nside,3,cell_ids=m_cell_ids[l])
+            hconvol.make_idx_weights()
+            t_hconv[l]=hconvol
+
+            # plus one to add the input downgrade data
+            l_chan=out_chan
+        print('Final chan %d Npix=%d'%(out_chan,l_data.shape[2]))
+        self.n_cnn=n
+        self.m_cell_ids=l_cell_ids
+        self.t_wconv=t_wconv
+        self.t_hconv=t_hconv
+        self.x=self.f.backend.bk_cast((np.random.rand(n)-0.5)/self.KERNELSZ)
+        self.nside=in_nside
+        self.n_chan_in=n_chan_in
+        self.n_chan_out=n_chan_out
+        self.chanlist=chanlist
+
+    def get_param(self):
+        return self.x
+
+    def set_param(self,x):
+        self.x=self.f.backend.bk_cast(x)
+        
+    def eval(self,data):
+        # create the CNN part
+        l_nside=self.nside
+        l_chan=self.n_chan_in
+        l_data=data
+        m_data=data
+        nlayer=len(self.chanlist)
+        kernelsz=self.KERNELSZ
+        ud_data={}
+        
+        for l in range(nlayer):
+            # init double convol weights
+            nw=l_chan*self.chanlist[l]*kernelsz*kernelsz
+            ww=self.x[self.wconv[2*l]:self.wconv[2*l]+nw]
+            ww=self.f.backend.bk_reshape(ww,[l_chan,
+                                             self.chanlist[l],
+                                             kernelsz*kernelsz])
+            l_data = self.hconv[l].Convol_torch(l_data,ww)
+            
+            nw=self.chanlist[l]*self.chanlist[l]*kernelsz*kernelsz
+            ww=self.x[self.wconv[2*l+1]:self.wconv[2*l+1]+nw]
+            ww=self.f.backend.bk_reshape(ww,[self.chanlist[l],
+                                             self.chanlist[l],
+                                             kernelsz*kernelsz])
+            
+            l_data = self.hconv[l].Convol_torch(l_data,ww)
+            
+            l_data,_=self.f.ud_grade_2(l_data,
+                                       cell_ids=self.l_cell_ids[l],
+                                       nside=l_nside)
+
+            ud_data[l]=m_data
+            
+            m_data,_=self.f.ud_grade_2(m_data,
+                                       cell_ids=self.l_cell_ids[l],
+                                       nside=l_nside)
+
+            l_data = self.f.backend.bk_concat([m_data,l_data],1)
+            
+            l_nside//=2
+            # plus one to add the input downgrade data
+            l_chan=self.chanlist[l]+self.n_chan_in
+
+        for l in range(nlayer):
+            l_chan+=self.n_chan_in
+            l_data=self.f.up_grade(l_data,l_nside*2,
+                                   cell_ids=self.l_cell_ids[nlayer-l],
+                                   o_cell_ids=self.l_cell_ids[nlayer-1-l],
+                                   nside=l_nside)
+            
+
+            l_data = self.f.backend.bk_concat([ud_data[nlayer-1-l],l_data],1)
+            l_nside*=2
+            
+            # init double convol weights
+            out_chan=self.n_chan_out
+            if nlayer-1-l>0:
+                out_chan+=self.chanlist[nlayer-1-l]
+            nw=l_chan*l_chan*kernelsz*kernelsz
+            ww=self.x[self.t_wconv[2*l]:self.t_wconv[2*l]+nw]
+            ww=self.f.backend.bk_reshape(ww,[l_chan,
+                                             l_chan,
+                                             kernelsz*kernelsz])
+            
+            c_data = self.t_hconv[l].Convol_torch(l_data,ww)
+            
+            nw=l_chan*out_chan*kernelsz*kernelsz
+            ww=self.x[self.t_wconv[2*l+1]:self.t_wconv[2*l+1]+nw]
+            ww=self.f.backend.bk_reshape(ww,[l_chan,
+                                             out_chan,
+                                             kernelsz*kernelsz])
+            l_data = self.t_hconv[l].Convol_torch(c_data,ww)
+
+            # plus one to add the input downgrade data
+            l_chan=out_chan
+            
+        return l_data

foscat/scat_cov.py

@@ -33,7 +33,14 @@ testwarn = 0
 
 
 class scat_cov:
-    def __init__(self, s0, s2, s3, s4, s1=None, s3p=None, backend=None, use_1D=False):
+    def __init__(self,
+                 s0, s2, s3, s4,
+                 s1=None,
+                 s3p=None,
+                 backend=None,
+                 use_1D=False,
+                 return_data=False
+                 ):
         self.S0 = s0
         self.S2 = s2
         self.S3 = s3
@@ -44,12 +51,13 @@ class scat_cov:
         self.idx1 = None
         self.idx2 = None
         self.use_1D = use_1D
-        self.numel = self.backend.bk_len(s0)+ \
-            self.backend.bk_len(s1)+ \
-            self.backend.bk_len(s2)+ \
-            self.backend.bk_len(s3)+ \
-            self.backend.bk_len(s4)+ \
-            self.backend.bk_len(s3p)
+        if not return_data:
+            self.numel = self.backend.bk_len(s0)+ \
+                self.backend.bk_len(s1)+ \
+                self.backend.bk_len(s2)+ \
+                self.backend.bk_len(s3)+ \
+                self.backend.bk_len(s4)+ \
+                self.backend.bk_len(s3p)
 
     def numpy(self):
         if self.BACKEND == "numpy":
@@ -2755,34 +2763,6 @@ class funct(FOC.FoCUS):
 
                 nside = nside * 2
 
-            if self.KERNELSZ > 5 and not self.use_2D:
-                # if the kernel size is bigger than 3 increase the binning before smoothing
-                if self.use_2D:
-                    vmask = self.up_grade(
-                        vmask, I1.shape[-2] * 2, nouty=I1.shape[-1] * 2,axis=-2
-                    )
-                    I1 = self.up_grade(
-                        I1, I1.shape[-2] * 2, nouty=I1.shape[-1] * 2,axis=-2
-                    )
-                    if cross:
-                        I2 = self.up_grade(
-                            I2,
-                            I2.shape[-2] * 2,
-                            nouty=I2.shape[-1] * 2,axis=-2
-                        )
-                elif self.use_1D:
-                    vmask = self.up_grade(vmask, I1.shape[-1] * 2)
-                    I1 = self.up_grade(I1, I1.shape[-1] * 2)
-                    if cross:
-                        I2 = self.up_grade(I2, I2.shape[-1] * 2)
-                    nside = nside * 2
-                else:
-                    I1 = self.up_grade(I1, nside * 2)
-                    vmask = self.up_grade(vmask, nside * 2)
-                    if cross:
-                        I2 = self.up_grade(I2, nside * 2)
-                    nside = nside * 2
-
         # Normalize the masks because they have different pixel numbers
         # vmask /= self.backend.bk_reduce_sum(vmask, axis=1)[:, None]  # [Nmask, Npix]
 
@@ -2825,6 +2805,7 @@ class funct(FOC.FoCUS):
             P1_dic = {}
             if cross:
                 P2_dic = {}
+            
         elif (norm == "auto") and (self.P1_dic is not None):
             P1_dic = self.P1_dic
             if cross:
@@ -3647,7 +3628,9 @@ class funct(FOC.FoCUS):
         if calc_var:
             if not cross:
                 return scat_cov(
-                    s0, S2, S3, S4, s1=S1, backend=self.backend, use_1D=self.use_1D
+                    s0, S2, S3, S4, s1=S1, backend=self.backend,
+                    use_1D=self.use_1D,
+                    return_data=self.return_data
                 ), scat_cov(
                     vs0,
                     VS2,
@@ -3656,6 +3639,7 @@ class funct(FOC.FoCUS):
                     s1=VS1,
                     backend=self.backend,
                     use_1D=self.use_1D,
+                    return_data=self.return_data
                 )
             else:
                 return scat_cov(
@@ -3667,6 +3651,7 @@ class funct(FOC.FoCUS):
                     s3p=S3P,
                     backend=self.backend,
                     use_1D=self.use_1D,
+                    return_data=self.return_data
                 ), scat_cov(
                     vs0,
                     VS2,
@@ -3676,11 +3661,16 @@ class funct(FOC.FoCUS):
                     s3p=VS3P,
                     backend=self.backend,
                     use_1D=self.use_1D,
+                    return_data=self.return_data
                 )
         else:
             if not cross:
                 return scat_cov(
-                    s0, S2, S3, S4, s1=S1, backend=self.backend, use_1D=self.use_1D
+                    s0, S2, S3, S4,
+                    s1=S1,
+                    backend=self.backend,
+                    use_1D=self.use_1D,
+                    return_data=self.return_data
                 )
             else:
                 return scat_cov(
@@ -3692,6 +3682,7 @@ class funct(FOC.FoCUS):
                     s3p=S3P,
                     backend=self.backend,
                     use_1D=self.use_1D,
+                    return_data=self.return_data
                 )
 
     def clean_norm(self):
@@ -3769,8 +3760,12 @@ class funct(FOC.FoCUS):
         # cconv, sconv are [Nbatch, Norient3, Npix_j3]
         if self.use_1D:
             s3 = conv * self.backend.bk_conjugate(MconvPsi)
+        elif self.use_2D:
+            s3 = self.backend.bk_expand_dims(conv, -4)* self.backend.bk_conjugate(
+                MconvPsi
+            )  # [Nbatch, Norient3, Norient2, Npix_j3]
         else:
-            s3 = self.backend.bk_expand_dims(conv, -3) * self.backend.bk_conjugate(
+            s3 = self.backend.bk_expand_dims(conv, -3)* self.backend.bk_conjugate(
                 MconvPsi
             )  # [Nbatch, Norient3, Norient2, Npix_j3]
         ### Apply the mask [Nmask, Npix_j3] and sum over pixels
@@ -4100,6 +4095,7 @@ class funct(FOC.FoCUS):
             get_variance=False,
             ref_sigma=None,
             iso_ang=False,
+            return_table=False,
     ):
         """
         Calculates the scattering correlations for a batch of images, including:
@@ -4234,7 +4230,7 @@ class funct(FOC.FoCUS):
                 )
                 print("\n\n==========")
             J = Jmax  # Number of steps for the loop on scales
-
+            
         L = self.NORIENT
         norm_factor_S3 = 1.0
 
@@ -4803,6 +4799,12 @@ class funct(FOC.FoCUS):
             if data2 is None:
                 if iso_ang:
                     if ref_sigma is not None:
+                        if return_table:
+                            return (S1_iso / ref_sigma["S1_sigma"]), \
+                                (S2_iso / ref_sigma["S2_sigma"]) , \
+                                (S3_iso / ref_sigma["S3_sigma"]) , \
+                                (S4_iso / ref_sigma["S4_sigma"]) 
+                        
                         for_synthesis = self.backend.backend.cat(
                             (
                                 mean_data / ref_sigma["std_data"],
@@ -4829,6 +4831,9 @@ class funct(FOC.FoCUS):
                             dim=-1,
                         )
                     else:
+                        if return_table:
+                            return S1_iso,S2_iso,S3_iso,S4_iso
+                        
                         for_synthesis = self.backend.backend.cat(
                             (
                                 mean_data / std_data,
@@ -4844,6 +4849,12 @@ class funct(FOC.FoCUS):
                         )
                 else:
                     if ref_sigma is not None:
+                        if return_table:
+                            return (S1 / ref_sigma["S1_sigma"]), \
+                                (S2 / ref_sigma["S2_sigma"]), \
+                                (S3 / ref_sigma["S3_sigma"]), \
+                                (S4 / ref_sigma["S4_sigma"])
+                        
                         for_synthesis = self.backend.backend.cat(
                             (
                                 mean_data / ref_sigma["std_data"],
@@ -4870,6 +4881,9 @@ class funct(FOC.FoCUS):
                             dim=-1,
                         )
                     else:
+                        if return_table:
+                            return S1,S2,S3,S4
+                        
                         for_synthesis = self.backend.backend.cat(
                             (
                                 mean_data / std_data,
@@ -4886,6 +4900,12 @@ class funct(FOC.FoCUS):
             else:
                 if iso_ang:
                     if ref_sigma is not None:
+                        if return_table:
+                            return (S1_iso / ref_sigma["S1_sigma"]), \
+                                (S2_iso / ref_sigma["S2_sigma"]), \
+                                (S3_iso / ref_sigma["S3_sigma"]), \
+                                (S4_iso / ref_sigma["S4_sigma"])
+                        
                         for_synthesis = self.backend.backend.cat(
                             (
                                 mean_data / ref_sigma["std_data"],
@@ -4914,6 +4934,9 @@ class funct(FOC.FoCUS):
                             dim=-1,
                         )
                     else:
+                        if return_table:
+                            return S1_iso,S2_iso,S3_iso,S4_iso
+                        
                         for_synthesis = self.backend.backend.cat(
                             (
                                 mean_data / std_data,
@@ -4931,6 +4954,12 @@ class funct(FOC.FoCUS):
                         )
                 else:
                     if ref_sigma is not None:
+                        if return_table:
+                            return (S1 / ref_sigma["S1_sigma"]), \
+                                (S2 / ref_sigma["S2_sigma"]), \
+                                (S3 / ref_sigma["S3_sigma"]), \
+                                (S4 / ref_sigma["S4_sigma"])
+                        
                         for_synthesis = self.backend.backend.cat(
                             (
                                 mean_data / ref_sigma["std_data"],
@@ -4959,6 +4988,9 @@ class funct(FOC.FoCUS):
                             dim=-1,
                         )
                     else:
+                        if return_table:
+                            return S1,S2,S3,S4
+                        
                         for_synthesis = self.backend.backend.cat(
                             (
                                 mean_data / std_data,
@@ -5955,8 +5987,8 @@ class funct(FOC.FoCUS):
     def from_gaussian(self, x):
 
         x = self.backend.bk_clip_by_value(x,
-                                          self.val_min+1E-4*abs(self.val_min),
-                                          self.val_max-1E-4*abs(self.val_max))
+                                          self.val_min+1E-7*(self.val_max-self.val_min),
+                                          self.val_max-1E-7*(self.val_max-self.val_min))
         return self.f_gaussian(self.backend.to_numpy(x))
 
     def square(self, x):
@@ -6127,13 +6159,12 @@ class funct(FOC.FoCUS):
             return result
         else:
             if sigma is None:
-                tmp = x - y
+                tmp = self.diff_data(x,y)
             else:
-                tmp = (x - y) / sigma
+                tmp = self.diff_data(x,y,sigma=sigma)
+                
             # do abs in case of complex values
-            return self.backend.bk_abs(
-                self.backend.bk_reduce_mean(self.backend.bk_square(tmp))
-            )
+            return tmp/x.shape[0]
 
     def reduce_sum(self, x):
 
@@ -6295,7 +6326,7 @@ class funct(FOC.FoCUS):
         Jmax=None,
         edge=False,
         to_gaussian=True,
-        use_variance=False,
+        use_variance=True,
         synthesised_N=1,
         input_image=None,
         grd_mask=None,
@@ -6362,13 +6393,14 @@ class funct(FOC.FoCUS):
             use_v = args[2]
             ljmax = args[3]
 
-            learn = scat_operator.reduce_mean_batch(
-                scat_operator.eval(
-                    u,
-                    Jmax=ljmax,
-                    norm='self'
+            learn = scat_operator.eval(
+                u,
+                Jmax=ljmax,
+                norm='auto'
                 )
-            )
+            
+            if synthesised_N>1:
+                learn = scat_operator.reduce_mean_batch(learn)
             
             # compute scattering covariance of the current synthetised map called u
             if use_v:
@@ -6574,6 +6606,8 @@ class funct(FOC.FoCUS):
                     )
                     sref = ref
             else:
+                self.clean_norm()
+                
                 ref = self.eval(
                         tmp[k],
                         image2=l_ref[k],
@@ -6590,7 +6624,7 @@ class funct(FOC.FoCUS):
                         mask=l_in_mask[k],
                         Jmax=l_jmax[k],
                         calc_var=True,
-                        norm='self'
+                        norm='auto'
                     )
                 else:
                     ref = self.eval(
@@ -6598,7 +6632,7 @@ class funct(FOC.FoCUS):
                         image2=l_ref[k],
                         mask=l_in_mask[k],
                         Jmax=l_jmax[k],
-                        norm='self'
+                        norm='auto'
                     )
                     sref = ref
                     
@@ -6659,6 +6693,9 @@ class funct(FOC.FoCUS):
                 grd_mask=l_grd_mask[k],
             )
 
+        if not self.use_2D:
+            self.clean_norm()
+            
         t2 = time.time()
         print("Total computation %.2fs" % (t2 - t1))
 

foscat/scat_cov_map2D.py

@@ -29,7 +29,7 @@ class funct(scat.funct):
             image1, image2=image2, mask=mask, norm=norm, calc_var=calc_var, Jmax=Jmax
         )
         return scat_cov_map(
-            r.S2, r.S0, r.S3, r.S4, S1=r.S1, S3P=r.S3P, backend=r.backend
+            r.S2, r.S0, r.S3, r.S4, S1=r.S1, S3P=r.S3P, backend=r.backend,
         )
 
     def scat_coeffs_apply(

{foscat-2025.7.3.dist-info → foscat-2025.8.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: foscat
-Version: 2025.7.3
+Version: 2025.8.4
 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>

{foscat-2025.7.3.dist-info → foscat-2025.8.4.dist-info}/RECORD

@@ -2,14 +2,16 @@ foscat/BkBase.py,sha256=2buIR9RK6g7HLoHJbzVCYhi1PkjDW6SXlu7IlF7SfA4,21611
 foscat/BkNumpy.py,sha256=qvKxDoAPQD52Ui9qv_D_GZvWpXX2n9S9dOGlXz5uNdQ,10683
 foscat/BkTensorflow.py,sha256=iIdLx6VTOfOEocfZBOGyizQn5geDLTfdWWAwDeQr9YA,20056
 foscat/BkTorch.py,sha256=fWkNTrgK1MkpkS-bNVmC0ihJY_WlPs98ndperSh63i8,19593
-foscat/CNN.py,sha256=gQ9V76wmcowo2BaNp5sJYcSDCVOjc18TS9cE6-qEUso,5153
+foscat/CNN.py,sha256=4vky7jqTshL1aYLWsc-hQwf7gDjTVjL7I6HZiAsa6x4,5158
 foscat/CircSpline.py,sha256=CXi49FxF8ZoeZ17Ua8c1AZXe2B5ICEC9aCXb97atB3s,4028
-foscat/FoCUS.py,sha256=81LmzcWitLGS0CrqddoRmER95JlGxX3N0dQAi1M7i-g,103645
+foscat/FoCUS.py,sha256=iXcj6qcYaiREEcozd4xHfr983CwWFxNxvGIqEJw-JMI,114717
 foscat/GCNN.py,sha256=q7yWHCMJpP7-m3WvR3OQnp5taeYWaMxIY2hQ6SIb9gs,4487
-foscat/HealSpline.py,sha256=Y05LLtsAVdkzf_u6UZtQx8u1DwfBnmso9OzHAT35ZJM,7387
+foscat/HOrientedConvol.py,sha256=S4Ru4holHT0ux6oMttHrKrXtxF4kGeVvoWE8AQs-RhI,21619
+foscat/HealSpline.py,sha256=YRotJ1NQuXYFyFiM8fp6qkATIwRJ8lqIVo4vGXpHO-w,7472
 foscat/Softmax.py,sha256=UDZGrTroYtmGEyokGUVpwNO_cgbICi9QVuRr8Yx52_k,2917
 foscat/Spline1D.py,sha256=rKzzenduaZZ-yBDJd35it6Gyrj1spqb7hoIaUgISPzY,2983
-foscat/Synthesis.py,sha256=tC5hvpam19QwDdvghVax7dA7gMgKA6ZtxQEcV9HjdC0,13824
+foscat/Synthesis.py,sha256=ClrUkSKm2426ZX56dHoepoSQ2rJvwTXQnPPtlC2cESY,14174
+foscat/UNET.py,sha256=QIOv3ysz9lGKMFLmyfQarhzzh7gg833hk70Uo04u3-0,7027
 foscat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 foscat/alm.py,sha256=XkK4rFVRoO-oJpr74iBffKt7hdS_iJkR016IlYm10gQ,33832
 foscat/backend.py,sha256=l3aMwDyXP6jURMIvratFMGWCTcQpaR68KnUuuGDezqE,45418
@@ -20,13 +22,13 @@ foscat/loss_backend_torch.py,sha256=k3z18Dj3SaLKK6ZIKcm7GO4U_YKYVP6LtHG1aIbxkYk,
 foscat/scat.py,sha256=qGYiBIysPt65MdmF07WWA4piVlTfA9-lFDTaicnqC2w,72822
 foscat/scat1D.py,sha256=W5Uu6wdQ4ZsFKXpof0f1OBl-1wjJmW7ruvddRWxe7uM,53726
 foscat/scat2D.py,sha256=boKj0ASqMMSy7uQLK6hPniG87m3hZGJBYBiq5v8F9IQ,532
-foscat/scat_cov.py,sha256=TgYa78os4vbFI4DRK5hccnH-6bpRpXFEbN52Z2L2Xbs,270032
+foscat/scat_cov.py,sha256=QKPIjb5Tq00onp5uPX7qR6k5CoqUc_A1rrT3pDlnXyM,271522
 foscat/scat_cov1D.py,sha256=XOxsZZ5TYq8f34i2tUgIfzyaqaTDlICB3HzD2l_puro,531
 foscat/scat_cov2D.py,sha256=pAm0fKw8wyXram0TFbtw8tGcc8QPKuPXpQk0kh10r4U,7078
 foscat/scat_cov_map.py,sha256=9MzpwT2g9S3dmnjHEMK7PPLQ27oGQg2VFVsP_TDUU5E,2869
-foscat/scat_cov_map2D.py,sha256=1dS4P1KHqZYkYCLA1sYpPSZulJrCTd_2eL8HFOjlcz4,2841
-foscat-2025.7.3.dist-info/licenses/LICENSE,sha256=i0ukIr8ZUpkSY2sZaE9XZK-6vuSU5iG6IgX_3pjatP8,1505
-foscat-2025.7.3.dist-info/METADATA,sha256=uIMQ9XWdbP1sN8ftu_8flj1OgiNhRXHcn6Rw-tbLoWs,7215
-foscat-2025.7.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-foscat-2025.7.3.dist-info/top_level.txt,sha256=AGySXBBAlJgb8Tj8af6m_F-aiNg2zNTcybCUPVOKjAg,7
-foscat-2025.7.3.dist-info/RECORD,,
+foscat/scat_cov_map2D.py,sha256=zaIIYshXCqAeZ04I158GhD-Op4aoMlLnLEy7rxckVYY,2842
+foscat-2025.8.4.dist-info/licenses/LICENSE,sha256=i0ukIr8ZUpkSY2sZaE9XZK-6vuSU5iG6IgX_3pjatP8,1505
+foscat-2025.8.4.dist-info/METADATA,sha256=ur8T9ywlSsVA5J7Bb1WwkwizQhwwaT1ncuEr4ofLYUw,7215
+foscat-2025.8.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+foscat-2025.8.4.dist-info/top_level.txt,sha256=AGySXBBAlJgb8Tj8af6m_F-aiNg2zNTcybCUPVOKjAg,7
+foscat-2025.8.4.dist-info/RECORD,,