foscat 2025.5.0__py3-none-any.whl → 2025.6.1__py3-none-any.whl

foscat/scat_cov.py

@@ -2378,16 +2378,16 @@ class funct(FOC.FoCUS):
             # of cosine and sine contributions using all channels
             angles = self.backend.bk_cast(
                 (2 * np.pi * np.arange(self.NORIENT) / self.NORIENT).reshape(
-                    1, 1, self.NORIENT
+                    1, self.NORIENT, 1
                 )
             )  # shape: (NORIENT,)
 
             # we use cosines and sines as weights for sim
             weighted_cos = self.backend.bk_reduce_mean(
-                sim * self.backend.bk_cos(angles), axis=-1
+                sim * self.backend.bk_cos(angles), axis=-2
             )
             weighted_sin = self.backend.bk_reduce_mean(
-                sim * self.backend.bk_sin(angles), axis=-1
+                sim * self.backend.bk_sin(angles), axis=-2
             )
             # For simplicity, take first element of the batch
             cc = weighted_cos[0]
@@ -2423,43 +2423,46 @@ class funct(FOC.FoCUS):
             w1 = np.sin(delta * np.pi / 2) ** 2
 
             # build rotation matrix
-            mat = np.zeros([sim.shape[1], self.NORIENT * self.NORIENT])
-            lidx = np.arange(sim.shape[1])
+            mat = np.zeros([self.NORIENT * self.NORIENT, sim.shape[2]])
+            lidx = np.arange(sim.shape[2])
             for ell in range(self.NORIENT):
                 # Instead of simple linear weights, we use the cosine weights w0 and w1.
                 col0 = self.NORIENT * ((ell + iph) % self.NORIENT) + ell
                 col1 = self.NORIENT * ((ell + iph + 1) % self.NORIENT) + ell
-                mat[lidx, col0] = w0
-                mat[lidx, col1] = w1
 
-            cmat[k] = self.backend.bk_cast(mat.astype("complex64"))
+                mat[col0, lidx] = w0
+                mat[col1, lidx] = w1
+
+            cmat[k] = self.backend.bk_cast(mat[None, ...].astype("complex64"))
 
             # do same modifications for mat2
             mat2 = np.zeros(
-                [k + 1, sim.shape[1], self.NORIENT, self.NORIENT * self.NORIENT]
+                [k + 1, self.NORIENT * self.NORIENT, self.NORIENT, sim.shape[2]]
             )
 
             for k2 in range(k + 1):
-                tmp2 = self.backend.bk_repeat(sim, self.NORIENT, axis=-1)
+
+                tmp2 = self.backend.bk_repeat(sim, self.NORIENT, axis=1)
 
                 sim2 = self.backend.bk_reduce_sum(
                     self.backend.bk_reshape(
                         self.backend.bk_cast(
-                            mat.reshape(1, mat.shape[0], self.NORIENT * self.NORIENT)
+                            mat.reshape(1, self.NORIENT * self.NORIENT, mat.shape[1])
                         )
                         * tmp2,
-                        [sim.shape[0], cmat[k].shape[0], self.NORIENT, self.NORIENT],
+                        [sim.shape[0], self.NORIENT, self.NORIENT, mat.shape[1]],
                     ),
-                    2,
+                    1,
                 )
 
-                sim2 = self.backend.bk_abs(self.convol(sim2, axis=1))
+                sim2 = self.backend.bk_abs(self.convol(sim2, axis=-1))
 
+                angles = self.backend.bk_reshape(angles, [1, self.NORIENT, 1, 1])
                 weighted_cos2 = self.backend.bk_reduce_mean(
-                    sim2 * self.backend.bk_cos(angles), axis=-1
+                    sim2 * self.backend.bk_cos(angles), axis=1
                 )
                 weighted_sin2 = self.backend.bk_reduce_mean(
-                    sim2 * self.backend.bk_sin(angles), axis=-1
+                    sim2 * self.backend.bk_sin(angles), axis=1
                 )
 
                 cc2 = weighted_cos2[0]
@@ -2467,14 +2470,14 @@ class funct(FOC.FoCUS):
 
                 if smooth_scale > 0:
                     for m in range(smooth_scale):
-                        if cc2.shape[0] > 12:
-                            cc2, _ = self.ud_grade_2(self.smooth(cc2))
-                            ss2, _ = self.ud_grade_2(self.smooth(ss2))
+                        if cc2.shape[1] > 12:
+                            cc2, _ = self.ud_grade_2(self.smooth(cc2, axis=1), axis=1)
+                            ss2, _ = self.ud_grade_2(self.smooth(ss2, axis=1), axis=1)
 
-                if cc2.shape[0] != sim.shape[1]:
-                    ll_nside = int(np.sqrt(sim.shape[1] // 12))
-                    cc2 = self.up_grade(cc2, ll_nside)
-                    ss2 = self.up_grade(ss2, ll_nside)
+                if cc2.shape[1] != sim.shape[2]:
+                    ll_nside = int(np.sqrt(sim.shape[2] // 12))
+                    cc2 = self.up_grade(cc2, ll_nside, axis=1)
+                    ss2 = self.up_grade(ss2, ll_nside, axis=1)
 
                 if self.BACKEND == "numpy":
                     phase2 = np.fmod(np.arctan2(ss2, cc2) + 2 * np.pi, 2 * np.pi)
@@ -2492,17 +2495,18 @@ class funct(FOC.FoCUS):
                 delta2 = phase2_scaled - iph2
                 w0_2 = np.cos(delta2 * np.pi / 2) ** 2
                 w1_2 = np.sin(delta2 * np.pi / 2) ** 2
-                lidx = np.arange(sim.shape[1])
+                lidx = np.arange(sim.shape[2])
 
                 for m in range(self.NORIENT):
                     for ell in range(self.NORIENT):
-                        col0 = self.NORIENT * ((ell + iph2[:, m]) % self.NORIENT) + ell
-                        col1 = (
-                            self.NORIENT * ((ell + iph2[:, m] + 1) % self.NORIENT) + ell
-                        )
-                        mat2[k2, lidx, m, col0] = w0_2[:, m]
-                        mat2[k2, lidx, m, col1] = w1_2[:, m]
-                cmat2[k] = self.backend.bk_cast(mat2.astype("complex64"))
+                        col0 = self.NORIENT * ((ell + iph2[m]) % self.NORIENT) + ell
+                        col1 = self.NORIENT * ((ell + iph2[m] + 1) % self.NORIENT) + ell
+                        mat2[k2, col0, m, lidx] = w0_2[m, lidx]
+                        mat2[k2, col1, m, lidx] = w1_2[m, lidx]
+
+                cmat2[k] = self.backend.bk_cast(
+                    mat2[0 : k + 1, None, ...].astype("complex64")
+                )
 
             if k < l_nside - 1:
                 tmp, _ = self.ud_grade_2(tmp, axis=1)
@@ -2620,6 +2624,9 @@ class funct(FOC.FoCUS):
                 x1 = im_shape[1]
                 x2 = im_shape[2]
             J = int(np.log(nside - self.KERNELSZ) / np.log(2))  # Number of j scales
+            if J == 0:
+                print("Use of too small 2D domain does not work J_max=", J)
+                return None
         elif self.use_1D:
             if len(image1.shape) == 2:
                 npix = int(im_shape[1])  # Number of pixels
@@ -2842,21 +2849,25 @@ class funct(FOC.FoCUS):
             ### Make the convolution I1 * Psi_j3
             conv1 = self.convol(
                 I1, axis=1, cell_ids=cell_ids_j3, nside=nside_j3
-            )  # [Nbatch, Npix_j3, Norient3]
+            )  # [Nbatch, Norient3 , Npix_j3]
+
             if cmat is not None:
-                tmp2 = self.backend.bk_repeat(conv1, self.NORIENT, axis=-1)
+
+                tmp2 = self.backend.bk_repeat(conv1, self.NORIENT, axis=-2)
+
                 conv1 = self.backend.bk_reduce_sum(
                     self.backend.bk_reshape(
                         cmat[j3] * tmp2,
-                        [tmp2.shape[0], cmat[j3].shape[0], self.NORIENT, self.NORIENT],
+                        [tmp2.shape[0], self.NORIENT, self.NORIENT, cmat[j3].shape[2]],
                     ),
-                    2,
+                    1,
                 )
 
             ### Take the module M1 = |I1 * Psi_j3|
             M1_square = conv1 * self.backend.bk_conjugate(
                 conv1
-            )  # [Nbatch, Npix_j3, Norient3]
+            )  # [Nbatch, Norient3, Npix_j3]
+
             M1 = self.backend.bk_L1(M1_square)  # [Nbatch, Npix_j3, Norient3]
             # Store M1_j3 in a dictionary
             M1_dic[j3] = M1
@@ -2871,10 +2882,10 @@ class funct(FOC.FoCUS):
                 else:
                     if calc_var:
                         s2, vs2 = self.masked_mean(
-                            M1_square, vmask, axis=1, rank=j3, calc_var=True
+                            M1_square, vmask, axis=2, rank=j3, calc_var=True
                         )
                     else:
-                        s2 = self.masked_mean(M1_square, vmask, axis=1, rank=j3)
+                        s2 = self.masked_mean(M1_square, vmask, axis=2, rank=j3)
 
                 if cond_init_P1_dic:
                     # We fill P1_dic with S2 for normalisation of S3 and S4
@@ -2890,9 +2901,9 @@ class funct(FOC.FoCUS):
                                 s2,
                                 [
                                     s2.shape[0],
+                                    s2.shape[2],
                                     12 * out_nside**2,
                                     (nside_j3 // out_nside) ** 2,
-                                    s2.shape[2],
                                 ],
                             ),
                             2,
@@ -2918,11 +2929,11 @@ class funct(FOC.FoCUS):
                 else:
                     if calc_var:
                         s1, vs1 = self.masked_mean(
-                            M1, vmask, axis=1, rank=j3, calc_var=True
+                            M1, vmask, axis=2, rank=j3, calc_var=True
                         )  # [Nbatch, Nmask, Norient3]
                     else:
                         s1 = self.masked_mean(
-                            M1, vmask, axis=1, rank=j3
+                            M1, vmask, axis=2, rank=j3
                         )  # [Nbatch, Nmask, Norient3]
 
                 if return_data:
@@ -2932,9 +2943,9 @@ class funct(FOC.FoCUS):
                                 s1,
                                 [
                                     s1.shape[0],
+                                    s1.shape[2],
                                     12 * out_nside**2,
                                     (nside_j3 // out_nside) ** 2,
-                                    s1.shape[2],
                                 ],
                             ),
                             2,
@@ -2956,21 +2967,21 @@ class funct(FOC.FoCUS):
             else:  # Cross
                 ### Make the convolution I2 * Psi_j3
                 conv2 = self.convol(
-                    I2, axis=1, cell_ids=cell_ids_j3, nside=nside_j3
+                    I2, axis=2, cell_ids=cell_ids_j3, nside=nside_j3
                 )  # [Nbatch, Npix_j3, Norient3]
                 if cmat is not None:
-                    tmp2 = self.backend.bk_repeat(conv2, self.NORIENT, axis=-1)
+                    tmp2 = self.backend.bk_repeat(conv2, self.NORIENT, axis=-2)
                     conv2 = self.backend.bk_reduce_sum(
                         self.backend.bk_reshape(
                             cmat[j3] * tmp2,
                             [
                                 tmp2.shape[0],
-                                cmat[j3].shape[0],
                                 self.NORIENT,
                                 self.NORIENT,
+                                cmat[j3].shape[2],
                             ],
                         ),
-                        2,
+                        1,
                     )
                 ### Take the module M2 = |I2 * Psi_j3|
                 M2_square = conv2 * self.backend.bk_conjugate(
@@ -2990,17 +3001,17 @@ class funct(FOC.FoCUS):
                     else:
                         if calc_var:
                             p1, vp1 = self.masked_mean(
-                                M1_square, vmask, axis=1, rank=j3, calc_var=True
+                                M1_square, vmask, axis=2, rank=j3, calc_var=True
                             )  # [Nbatch, Nmask, Norient3]
                             p2, vp2 = self.masked_mean(
-                                M2_square, vmask, axis=1, rank=j3, calc_var=True
+                                M2_square, vmask, axis=2, rank=j3, calc_var=True
                             )  # [Nbatch, Nmask, Norient3]
                         else:
                             p1 = self.masked_mean(
-                                M1_square, vmask, axis=1, rank=j3
+                                M1_square, vmask, axis=2, rank=j3
                             )  # [Nbatch, Nmask, Norient3]
                             p2 = self.masked_mean(
-                                M2_square, vmask, axis=1, rank=j3
+                                M2_square, vmask, axis=2, rank=j3
                             )  # [Nbatch, Nmask, Norient3]
                     # We fill P1_dic with S2 for normalisation of S3 and S4
                     P1_dic[j3] = self.backend.bk_real(p1)  # [Nbatch, Nmask, Norient3]
@@ -3016,10 +3027,10 @@ class funct(FOC.FoCUS):
                 else:
                     if calc_var:
                         s2, vs2 = self.masked_mean(
-                            s2, vmask, axis=1, rank=j3, calc_var=True
+                            s2, vmask, axis=2, rank=j3, calc_var=True
                         )
                     else:
-                        s2 = self.masked_mean(s2, vmask, axis=1, rank=j3)
+                        s2 = self.masked_mean(s2, vmask, axis=2, rank=j3)
 
                 if return_data:
                     if out_nside is not None and out_nside < nside_j3:
@@ -3028,9 +3039,9 @@ class funct(FOC.FoCUS):
                                 s2,
                                 [
                                     s2.shape[0],
+                                    s2.shape[2],
                                     12 * out_nside**2,
                                     (nside_j3 // out_nside) ** 2,
-                                    s2.shape[2],
                                 ],
                             ),
                             2,
@@ -3040,7 +3051,7 @@ class funct(FOC.FoCUS):
 
                     ### Store S2_cross as complex [Nbatch, Nmask, NS2, Norient3]
                     s2 = self.backend.bk_real(s2)
-                    
+
                     ### Normalize S2_cross
                     if norm == "auto":
                         s2 /= (P1_dic[j3] * P2_dic[j3]) ** 0.5
@@ -3061,11 +3072,11 @@ class funct(FOC.FoCUS):
                 else:
                     if calc_var:
                         s1, vs1 = self.masked_mean(
-                            MX, vmask, axis=1, rank=j3, calc_var=True
+                            MX, vmask, axis=2, rank=j3, calc_var=True
                         )  # [Nbatch, Nmask, Norient3]
                     else:
                         s1 = self.masked_mean(
-                            MX, vmask, axis=1, rank=j3
+                            MX, vmask, axis=2, rank=j3
                         )  # [Nbatch, Nmask, Norient3]
                 if return_data:
                     if out_nside is not None and out_nside < nside_j3:
@@ -3074,9 +3085,9 @@ class funct(FOC.FoCUS):
                                 s1,
                                 [
                                     s1.shape[0],
+                                    s1.shape[2],
                                     12 * out_nside**2,
                                     (nside_j3 // out_nside) ** 2,
-                                    s1.shape[2],
                                 ],
                             ),
                             2,
@@ -3487,19 +3498,19 @@ class funct(FOC.FoCUS):
                 for j2 in range(0, j3 + 1):  # j2 =< j3
                     ### Dictionary M1_dic[j2]
                     M1_smooth = self.smooth(
-                        M1_dic[j2], axis=1, cell_ids=cell_ids_j3, nside=nside_j3
+                        M1_dic[j2], axis=2, cell_ids=cell_ids_j3, nside=nside_j3
                     )  # [Nbatch, Npix_j3, Norient3]
                     M1_dic[j2], new_cell_ids_j2 = self.ud_grade_2(
-                        M1_smooth, axis=1, cell_ids=cell_ids_j3, nside=nside_j3
+                        M1_smooth, axis=2, cell_ids=cell_ids_j3, nside=nside_j3
                     )  # [Nbatch, Npix_j3, Norient3]
 
                     ### Dictionary M2_dic[j2]
                     if cross:
                         M2_smooth = self.smooth(
-                            M2_dic[j2], axis=1, cell_ids=cell_ids_j3, nside=nside_j3
+                            M2_dic[j2], axis=2, cell_ids=cell_ids_j3, nside=nside_j3
                         )  # [Nbatch, Npix_j3, Norient3]
                         M2_dic[j2], new_cell_ids_j2 = self.ud_grade_2(
-                            M2_smooth, axis=1, cell_ids=cell_ids_j3, nside=nside_j3
+                            M2_smooth, axis=2, cell_ids=cell_ids_j3, nside=nside_j3
                         )  # [Nbatch, Npix_j3, Norient3]
                 ### Mask
                 vmask, new_cell_ids_j3 = self.ud_grade_2(
@@ -3624,51 +3635,51 @@ class funct(FOC.FoCUS):
         cs3, ss3: real and imag parts of S3 coeff
         """
         ### Compute |I1 * Psi_j2| * Psi_j3 = M1_j2 * Psi_j3
-        # Warning: M1_dic[j2] is already at j3 resolution [Nbatch, Npix_j3, Norient3]
+        # Warning: M1_dic[j2] is already at j3 resolution [Nbatch, Norient3, Npix_j3]
         MconvPsi = self.convol(
-            M_dic[j2], axis=1, cell_ids=cell_ids, nside=nside_j2
-        )  # [Nbatch, Npix_j3, Norient3, Norient2]
+            M_dic[j2], axis=2, cell_ids=cell_ids, nside=nside_j2
+        )  # [Nbatch,   Norient3, Norient2, Npix_j3]
+
         if cmat2 is not None:
-            tmp2 = self.backend.bk_repeat(MconvPsi, self.NORIENT, axis=-1)
+            tmp2 = self.backend.bk_repeat(MconvPsi, self.NORIENT, axis=-3)
             MconvPsi = self.backend.bk_reduce_sum(
                 self.backend.bk_reshape(
                     cmat2[j3][j2] * tmp2,
                     [
                         tmp2.shape[0],
-                        cmat2[j3].shape[1],
                         self.NORIENT,
                         self.NORIENT,
                         self.NORIENT,
+                        cmat2[j3][j2].shape[3],
                     ],
                 ),
-                3,
+                1,
             )
 
         # Store it so we can use it in S4 computation
-        MconvPsi_dic[j2] = MconvPsi  # [Nbatch, Npix_j3, Norient3, Norient2]
+        MconvPsi_dic[j2] = MconvPsi  # [Nbatch, Norient3, Norient2, Npix_j3]
 
         ### Compute the product (I2 * Psi)_j3 x (M1_j2 * Psi_j3)^*
         # z_1 x z_2^* = (a1a2 + b1b2) + i(b1a2 - a1b2)
-        # cconv, sconv are [Nbatch, Npix_j3, Norient3]
+        # cconv, sconv are [Nbatch, Norient3, Npix_j3]
         if self.use_1D:
             s3 = conv * self.backend.bk_conjugate(MconvPsi)
         else:
-            s3 = self.backend.bk_expand_dims(conv, -1) * self.backend.bk_conjugate(
+            s3 = self.backend.bk_expand_dims(conv, -3) * self.backend.bk_conjugate(
                 MconvPsi
-            )  # [Nbatch, Npix_j3, Norient3, Norient2]
-
+            )  # [Nbatch, Norient3, Norient2, Npix_j3]
         ### Apply the mask [Nmask, Npix_j3] and sum over pixels
         if return_data:
             return s3
         else:
             if calc_var:
                 s3, vs3 = self.masked_mean(
-                    s3, vmask, axis=1, rank=j2, calc_var=True
+                    s3, vmask, axis=3, rank=j2, calc_var=True
                 )  # [Nbatch, Nmask, Norient3, Norient2]
                 return s3, vs3
             else:
                 s3 = self.masked_mean(
-                    s3, vmask, axis=1, rank=j2
+                    s3, vmask, axis=3, rank=j2
                 )  # [Nbatch, Nmask, Norient3, Norient2]
             return s3
 
@@ -3683,11 +3694,11 @@ class funct(FOC.FoCUS):
         return_data=False,
     ):
         #### Simplify notations
-        M1 = M1convPsi_dic[j1]  # [Nbatch, Npix_j3, Norient3, Norient1]
+        M1 = M1convPsi_dic[j1]  # [Nbatch, Norient3, Norient1, Npix_j3]
 
         # Auto or Cross coefficients
         if M2convPsi_dic is None:  # Auto
-            M2 = M1convPsi_dic[j2]  # [Nbatch, Npix_j3, Norient3, Norient2]
+            M2 = M1convPsi_dic[j2]  # [Nbatch, Norient3, Norient2, Npix_j3]
         else:  # Cross
             M2 = M2convPsi_dic[j2]
 
@@ -3696,9 +3707,9 @@ class funct(FOC.FoCUS):
         if self.use_1D:
             s4 = M1 * self.backend.bk_conjugate(M2)
         else:
-            s4 = self.backend.bk_expand_dims(M1, -2) * self.backend.bk_conjugate(
-                self.backend.bk_expand_dims(M2, -1)
-            )  # [Nbatch, Npix_j3, Norient3, Norient2, Norient1]
+            s4 = self.backend.bk_expand_dims(M1, -4) * self.backend.bk_conjugate(
+                self.backend.bk_expand_dims(M2, -3)
+            )  # [Nbatch,  Norient3, Norient2, Norient1,Npix_j3]
 
         ### Apply the mask and sum over pixels
         if return_data:
@@ -3706,12 +3717,12 @@ class funct(FOC.FoCUS):
         else:
             if calc_var:
                 s4, vs4 = self.masked_mean(
-                    s4, vmask, axis=1, rank=j2, calc_var=True
+                    s4, vmask, axis=4, rank=j2, calc_var=True
                 )  # [Nbatch, Nmask, Norient3, Norient2, Norient1]
                 return s4, vs4
             else:
                 s4 = self.masked_mean(
-                    s4, vmask, axis=1, rank=j2
+                    s4, vmask, axis=4, rank=j2
                 )  # [Nbatch, Nmask, Norient3, Norient2, Norient1]
                 return s4
 
@@ -6050,9 +6061,7 @@ class funct(FOC.FoCUS):
         cmat2=None,
     ):
 
-        res = self.eval(
-            image1, image2=image2, mask=mask, cmat=cmat, cmat2=cmat2
-        )
+        res = self.eval(image1, image2=image2, mask=mask, cmat=cmat, cmat2=cmat2)
         return res.S0, res.S2, res.S1, res.S3, res.S4, res.S3P
 
     def eval_fast(
@@ -6065,12 +6074,43 @@ class funct(FOC.FoCUS):
         cmat2=None,
     ):
         s0, s2, s1, s3, s4, s3p = self.eval_comp_fast(
-            image1, image2=image2, mask=mask,  cmat=cmat, cmat2=cmat2
+            image1, image2=image2, mask=mask, cmat=cmat, cmat2=cmat2
         )
         return scat_cov(
             s0, s2, s3, s4, s1=s1, s3p=s3p, backend=self.backend, use_1D=self.use_1D
         )
-
+    def calc_matrix_orientation(self,noise_map,image2=None):
+        # Décalage circulaire par matrice de permutation
+        def circ_shift_matrix(N,k):
+            return np.roll(np.eye(N), shift=-k, axis=1)
+        Norient = self.NORIENT
+        im=self.convol(noise_map)
+        if image2 is None:
+            mm=np.mean(abs(self.backend.to_numpy(im)),0)
+        else:
+            im2=self.convol(self.backend.bk_cast(image2))
+            mm=np.mean(self.backend.to_numpy(
+                self.backend.bk_L1(im*self.backend.bk_conjugate(im2))).real,0)
+        
+        Norient=mm.shape[0]
+        xx=np.cos(np.arange(Norient)/Norient*2*np.pi)
+        yy=np.sin(np.arange(Norient)/Norient*2*np.pi)
+
+        a=np.sum(mm*xx[:,None],0)
+        b=np.sum(mm*yy[:,None],0)
+        
+        o=np.fmod(Norient*np.arctan2(-b,a)/(2*np.pi)+Norient,Norient)
+        xx=np.arange(Norient)
+        alpha = o[None,:]-xx[:,None]
+        beta = np.fmod(1+o[None,:]-xx[:,None],Norient)
+        alpha=(1-alpha)*(alpha<1)*(alpha>0)+beta*(beta<1)*(beta>0)
+        
+        m=np.zeros([Norient,Norient,mm.shape[1]])
+        for k in range(Norient):
+            m[k,:,:]=np.roll(alpha,k,0)
+        #m=np.mean(m,0)
+        return self.backend.bk_cast(m)
+        
     def synthesis(
         self,
         image_target,
@@ -6104,12 +6144,12 @@ class funct(FOC.FoCUS):
         def The_loss_ref_image(u, scat_operator, args):
             input_image = args[0]
             mask = args[1]
-                
-            loss = 1E-3*scat_operator.backend.bk_reduce_mean(
-                scat_operator.backend.bk_square(mask*(input_image - u))
+
+            loss = 1e-3 * scat_operator.backend.bk_reduce_mean(
+                scat_operator.backend.bk_square(mask * (input_image - u))
             )
             return loss
-            
+
         def The_loss(u, scat_operator, args):
             ref = args[0]
             sref = args[1]
@@ -6346,14 +6386,17 @@ class funct(FOC.FoCUS):
                 loss = synthe.Loss(
                     The_lossX, self, ref, sref, use_variance, l_ref[k], l_jmax[k]
                 )
-                
+
             if input_image is not None:
                 # define a loss to minimize
-                loss_input = synthe.Loss(The_loss_ref_image, self, 
-                    self.backend.bk_cast(l_input_image[k]), 
-                    self.backend.bk_cast(l_in_mask[k]))
-                
-                sy = synthe.Synthesis([loss]) #,loss_input])
+                loss_input = synthe.Loss(
+                    The_loss_ref_image,
+                    self,
+                    self.backend.bk_cast(l_input_image[k]),
+                    self.backend.bk_cast(l_in_mask[k]),
+                )
+
+                sy = synthe.Synthesis([loss])  # ,loss_input])
             else:
                 sy = synthe.Synthesis([loss])
 

foscat/scat_cov_map2D.py

@@ -23,10 +23,10 @@ class funct(scat.funct):
         super().__init__(use_2D=True, 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, calc_var=False, Jmax=None
     ):
         r = super().eval(
-            image1, image2=image2, mask=mask, norm=norm, Auto=Auto, calc_var=calc_var
+            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

{foscat-2025.5.0.dist-info → foscat-2025.6.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: foscat
-Version: 2025.5.0
+Version: 2025.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>

{foscat-2025.5.0.dist-info → foscat-2025.6.1.dist-info}/RECORD

@@ -1,30 +1,31 @@
 foscat/BkBase.py,sha256=TEhfqUpIOh_bGBCyQfRCs0yjKdhgELjFpvq_QiouX5A,21514
 foscat/BkNumpy.py,sha256=zRldS_-L6A7y1zDzEPZXQntuw3Paw2zHZowhD43FHRs,10589
-foscat/BkTensorflow.py,sha256=N5TBacuyFB1-qGTi2kOc8zbgWzj5lVRRN47uZJpJJ10,15713
-foscat/BkTorch.py,sha256=011L9WCBtrRzV1jfGWCYOMSkt1IJ0PfEO82NnrIYbAc,16648
-foscat/CNN.py,sha256=j0F2a4Xf3LijhyD_WVZ6Eg_IjGuXw3ddH6Iudj1xVaw,4874
+foscat/BkTensorflow.py,sha256=K2s3xYVMHqLlTyApQpeKf9dc3hbRv8EqtCA_gE1bRQA,19958
+foscat/BkTorch.py,sha256=OUpa1ajRFxes9v_T6jK0gLlJXzn_DhQ3rlrf-yTSFcY,18126
+foscat/CNN.py,sha256=gQ9V76wmcowo2BaNp5sJYcSDCVOjc18TS9cE6-qEUso,5153
 foscat/CircSpline.py,sha256=CXi49FxF8ZoeZ17Ua8c1AZXe2B5ICEC9aCXb97atB3s,4028
-foscat/FoCUS.py,sha256=FeSkBmjBTELZQn529SONSOuzKlYxWqRLpyTM8j-Ql_Y,108768
-foscat/GCNN.py,sha256=5RV-FKuvqbD-k99TwiM4CttM2LMZE21WD0IK0j5Mkko,7599
-foscat/Softmax.py,sha256=aBLQauoG0q2SJYPotV6U-cxAhsJcspWHNRWdnA_nAiQ,2854
+foscat/FoCUS.py,sha256=Ke_h6g4Fqn62OpCkVxfr5zIDnT5hd-b1vvkm9aB3LhY,97364
+foscat/GCNN.py,sha256=q7yWHCMJpP7-m3WvR3OQnp5taeYWaMxIY2hQ6SIb9gs,4487
+foscat/Softmax.py,sha256=UDZGrTroYtmGEyokGUVpwNO_cgbICi9QVuRr8Yx52_k,2917
 foscat/Spline1D.py,sha256=rKzzenduaZZ-yBDJd35it6Gyrj1spqb7hoIaUgISPzY,2983
 foscat/Synthesis.py,sha256=tC5hvpam19QwDdvghVax7dA7gMgKA6ZtxQEcV9HjdC0,13824
 foscat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-foscat/alm.py,sha256=qZlsYj5HzV1EY9Fdzt0U8bemrZHZziaMOKZ55FU8foM,33806
+foscat/alm.py,sha256=XkK4rFVRoO-oJpr74iBffKt7hdS_iJkR016IlYm10gQ,33832
 foscat/backend.py,sha256=l3aMwDyXP6jURMIvratFMGWCTcQpaR68KnUuuGDezqE,45418
 foscat/backend_tens.py,sha256=9Dp136m9frkclkwifJQLLbIpl3ETI3_txdPUZcKfuMw,1618
+foscat/heal_NN.py,sha256=BXAqBEftvxVNOEtwo6xid6gFLrve8I-9jPQ1xI0HTl0,15648
 foscat/loss_backend_tens.py,sha256=dCOVN6faDtIpN3VO78HTmYP2i5fnFAf-Ddy5qVBlGrM,1783
 foscat/loss_backend_torch.py,sha256=k3z18Dj3SaLKK6ZIKcm7GO4U_YKYVP6LtHG1aIbxkYk,1627
 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=SMIhqspoe4vn6n_suNd1Npbs6eoXH7C45KupQta_h6M,258963
+foscat/scat_cov.py,sha256=bdlaDoMmIDHMAQ7ZdkbtrIKr4Y-3w2xWO9e2_ZTeelk,260445
 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=FqF45FBcoiQbvuVsrLWUIPRUc95GsKsrnH6fKzB3GlE,2841
-foscat-2025.5.0.dist-info/licenses/LICENSE,sha256=i0ukIr8ZUpkSY2sZaE9XZK-6vuSU5iG6IgX_3pjatP8,1505
-foscat-2025.5.0.dist-info/METADATA,sha256=lcHXnUQB5cZQUTHp8vgEUP0ZeG278dN5GIae_UqnQPs,7215
-foscat-2025.5.0.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
-foscat-2025.5.0.dist-info/top_level.txt,sha256=AGySXBBAlJgb8Tj8af6m_F-aiNg2zNTcybCUPVOKjAg,7
-foscat-2025.5.0.dist-info/RECORD,,
+foscat/scat_cov_map2D.py,sha256=1dS4P1KHqZYkYCLA1sYpPSZulJrCTd_2eL8HFOjlcz4,2841
+foscat-2025.6.1.dist-info/licenses/LICENSE,sha256=i0ukIr8ZUpkSY2sZaE9XZK-6vuSU5iG6IgX_3pjatP8,1505
+foscat-2025.6.1.dist-info/METADATA,sha256=0l5yu57MiVAHs7Q_Ar1I0CsksYBclfPs4Uq5me-4BnI,7215
+foscat-2025.6.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+foscat-2025.6.1.dist-info/top_level.txt,sha256=AGySXBBAlJgb8Tj8af6m_F-aiNg2zNTcybCUPVOKjAg,7
+foscat-2025.6.1.dist-info/RECORD,,

{foscat-2025.5.0.dist-info → foscat-2025.6.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.3.1)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any