foscat 3.0.19__tar.gz → 3.0.21__tar.gz

{foscat-3.0.19 → foscat-3.0.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foscat
-Version: 3.0.19
+Version: 3.0.21
 Summary: Generate synthetic Healpix or 2D data using Cross Scattering Transform
 Home-page: https://github.com/jmdelouis/FOSCAT
 Author: Jean-Marc DELOUIS
@@ -9,12 +9,6 @@ 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.19 → foscat-3.0.21}/setup.py

@@ -3,7 +3,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='foscat',
-    version='3.0.19',
+    version='3.0.21',
     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.21/src/foscat/CNN.py

@@ -0,0 +1,110 @@
+import numpy as np
+import pickle
+import foscat.scat_cov as sc
+  
+
+class CNN:
+        
+    def __init__(self,
+                 scat_operator=None,
+                 nparam=1,
+                 nscale=1,
+                 chanlist=[],
+                 in_nside=1,
+                 n_chan_in=1,
+                 nbatch=1,
+                 SEED=1234,
+                 filename=None):
+
+        if filename is not None:
+            outlist=pickle.load(open("%s.pkl"%(filename),"rb"))
+            self.scat_operator=sc.funct(KERNELSZ=outlist[3],all_type=outlist[7])
+            self.KERNELSZ= self.scat_operator.KERNELSZ
+            self.all_type= self.scat_operator.all_type
+            self.npar=outlist[2]
+            self.nscale=outlist[5]
+            self.chanlist=outlist[0]
+            self.in_nside=outlist[4] 
+            self.nbatch=outlist[1]
+            self.n_chan_in=outlist[8]
+            self.x=self.scat_operator.backend.bk_cast(outlist[6])
+            self.out_nside=self.in_nside//(2**self.nscale)
+        else:
+            self.nscale=nscale
+            self.nbatch=nbatch
+            self.npar=nparam
+            self.n_chan_in=n_chan_in
+            self.scat_operator=scat_operator
+            if len(chanlist)!=nscale+1:
+                print('len of chanlist (here %d) should of nscale+1 (here %d)'%(len(chanlist),nscale+1))
+                return None
+            
+            self.chanlist=chanlist
+            self.KERNELSZ= scat_operator.KERNELSZ
+            self.all_type= scat_operator.all_type
+            self.in_nside=in_nside
+            self.out_nside=self.in_nside//(2**self.nscale)
+
+            np.random.seed(SEED)
+            self.x=scat_operator.backend.bk_cast(np.random.randn(self.get_number_of_weights())/(self.KERNELSZ*self.KERNELSZ))
+            
+        
+
+    def save(self,filename):
+        
+        outlist=[self.chanlist, \
+                 self.nbatch, \
+                 self.npar, \
+                 self.KERNELSZ, \
+                 self.in_nside, \
+                 self.nscale, \
+                 self.get_weights().numpy(), \
+                 self.all_type, \
+                 self.n_chan_in]
+        
+        myout=open("%s.pkl"%(filename),"wb")
+        pickle.dump(outlist,myout)
+        myout.close()
+    
+    def get_number_of_weights(self):
+        totnchan=0
+        for i in range(self.nscale):
+            totnchan=totnchan+self.chanlist[i]*self.chanlist[i+1]
+        return self.npar*12*self.out_nside**2*self.chanlist[self.nscale] \
+            +totnchan*self.KERNELSZ*self.KERNELSZ+self.KERNELSZ*self.KERNELSZ*self.n_chan_in*self.chanlist[0]
+
+    def set_weights(self,x):
+        self.x=x
+        
+    def get_weights(self):
+        return self.x
+        
+    def eval(self,im):
+
+        x=self.x
+        ww=self.scat_operator.backend.bk_reshape(x[0:self.KERNELSZ*self.KERNELSZ*self.n_chan_in*self.chanlist[0]],
+                                                 [self.KERNELSZ*self.KERNELSZ,self.n_chan_in,self.chanlist[0]])
+        nn=self.KERNELSZ*self.KERNELSZ*self.n_chan_in*self.chanlist[0]
+
+        im=self.scat_operator.healpix_layer(im,ww)
+        im=self.scat_operator.backend.bk_relu(im)
+        
+        for k in range(self.nscale):
+            print(im.shape)
+            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)
+            im=self.scat_operator.backend.bk_relu(im)
+            im=self.scat_operator.ud_grade_2(im,axis=0)
+
+            
+        ww=self.scat_operator.backend.bk_reshape(x[nn:nn+self.npar*12*self.out_nside**2*self.chanlist[self.nscale]], \
+                                            [12*self.out_nside**2*self.chanlist[self.nscale],self.npar])
+        
+        im=self.scat_operator.backend.bk_matmul(self.scat_operator.backend.bk_reshape(im,[1,12*self.out_nside**2*self.chanlist[self.nscale]]),ww)
+        im=self.scat_operator.backend.bk_reshape(im,[self.npar])
+        im=self.scat_operator.backend.bk_relu(im)
+        
+        return im
+     

{foscat-3.0.19 → foscat-3.0.21}/src/foscat/FoCUS.py

@@ -32,7 +32,7 @@ class FoCUS:
                  mpi_size=1,
                  mpi_rank=0):
 
-        self.__version__ = '3.0.19'
+        self.__version__ = '3.0.21'
         # P00 coeff for normalization for scat_cov
         self.TMPFILE_VERSION=TMPFILE_VERSION
         self.P1_dic = None

{foscat-3.0.19 → foscat-3.0.21}/src/foscat/Synthesis.py

@@ -160,8 +160,7 @@ class Synthesis:
         self.l_log[self.mpi_rank*self.MAXNUMLOSS:(self.mpi_rank+1)*self.MAXNUMLOSS]=-1.0
         
         for istep in range(nstep):
-            
-        
+                    
             for k in range(self.number_of_loss):
                 if self.loss_class[k].batch is None:
                     l_batch=None

{foscat-3.0.19 → foscat-3.0.21}/src/foscat/backend.py

@@ -347,12 +347,10 @@ class foscat_backend:
             return self.bk_cast(self.backend.image.resize(x,shape, method='bilinear'))
         
         if self.BACKEND==self.TORCH:
-            print(x.shape)
             tmp=self.backend.nn.functional.interpolate(x,
                                                        size=shape,
                                                        mode='bilinear',
                                                        align_corners=False)
-            print(tmp.shape)
             return self.bk_cast(tmp)
         if self.BACKEND==self.NUMPY:
             return self.bk_cast(self.backend.image.resize(x,shape, method='bilinear'))

{foscat-3.0.19 → foscat-3.0.21}/src/foscat/scat.py

@@ -9,6 +9,7 @@ import sys
 tf_defined = 'tensorflow' in sys.modules
 
 if tf_defined:
+    import tensorflow as tf
     tf_function = tf.function  # Facultatif : si vous voulez utiliser TensorFlow dans ce script
 else:
     def tf_function(func):
@@ -64,44 +65,55 @@ class scat:
                     self.j1  , \
                     self.j2  ,backend=self.backend)
 
+        
     def domult(self,x,y):
-        if x.dtype==y.dtype:
+        try:
             return x*y
-        
-        if self.backend.bk_is_complex(x):
-            
-            return self.backend.bk_complex(self.backend.bk_real(x)*y,self.backend.bk_imag(x)*y)
-        else:
-            return self.backend.bk_complex(self.backend.bk_real(y)*x,self.backend.bk_imag(y)*x)
-        
+        except:
+            if x.dtype==y.dtype:
+                return x*y
+            if self.backend.bk_is_complex(x):
+
+                return self.backend.bk_complex(self.backend.bk_real(x)*y,self.backend.bk_imag(x)*y)
+            else:
+                return self.backend.bk_complex(self.backend.bk_real(y)*x,self.backend.bk_imag(y)*x)
+
     def dodiv(self,x,y):
-        if x.dtype==y.dtype:
+        try:
             return x/y
-        if self.backend.bk_is_complex(x):
+        except:
+            if x.dtype==y.dtype:
+                return x/y
+            if self.backend.bk_is_complex(x):
             
-            return self.backend.bk_complex(self.backend.bk_real(x)/y,self.backend.bk_imag(x)/y)
-        else:
-            return self.backend.bk_complex(x/self.backend.bk_real(y),x/self.backend.bk_imag(y))
+                return self.backend.bk_complex(self.backend.bk_real(x)/y,self.backend.bk_imag(x)/y)
+            else:
+                return self.backend.bk_complex(x/self.backend.bk_real(y),x/self.backend.bk_imag(y))
         
     def domin(self,x,y):
-        if x.dtype==y.dtype:
+        try:
             return x-y
-        
-        if self.backend.bk_is_complex(x):
-            
-            return self.backend.bk_complex(self.backend.bk_real(x)-y,self.backend.bk_imag(x)-y)
-        else:
-            return self.backend.bk_complex(x-self.backend.bk_real(y),x-self.backend.bk_imag(y))
+        except:
+            if x.dtype==y.dtype:
+                return x-y
+
+            if self.backend.bk_is_complex(x):
+
+                return self.backend.bk_complex(self.backend.bk_real(x)-y,self.backend.bk_imag(x)-y)
+            else:
+                return self.backend.bk_complex(x-self.backend.bk_real(y),x-self.backend.bk_imag(y))
         
     def doadd(self,x,y):
-        if x.dtype==y.dtype:
+        try:
             return x+y
-        
-        if self.backend.bk_is_complex(x):
-            
-            return self.backend.bk_complex(self.backend.bk_real(x)+y,self.backend.bk_imag(x)+y)
-        else:
-            return self.backend.bk_complex(x+self.backend.bk_real(y),x+self.backend.bk_imag(y))
+        except:
+            if x.dtype==y.dtype:
+                return x+y
+            if self.backend.bk_is_complex(x):
+
+                return self.backend.bk_complex(self.backend.bk_real(x)+y,self.backend.bk_imag(x)+y)
+            else:
+                return self.backend.bk_complex(x+self.backend.bk_real(y),x+self.backend.bk_imag(y))
         
     def relu(self):
         
@@ -337,7 +349,7 @@ class scat:
         if len(tmp.shape)==4:
             for k in range(tmp.shape[3]):
                 for i1 in range(tmp.shape[0]):
-                    for i2 in range(tmp.shape[0]):
+                    for i2 in range(tmp.shape[1]):
                         if test is None:
                             test=1
                             plt.plot(tmp[i1,i2,:,k],color=color, label=r'%s $P_{00}$' % (name), lw=lw)
@@ -1036,7 +1048,7 @@ class funct(FOC.FoCUS):
         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(image1.shape,mask.shape)
+                print('Image shape ',image1.shape,'Mask shape ',mask.shape)
                 exit(0)
         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')
@@ -1117,7 +1129,6 @@ class funct(FOC.FoCUS):
             else:
                 # if the kernel size is bigger than 3 increase the binning before smoothing
                 if self.use_2D:
-                    print(axis,image1.shape)
                     l_image1=self.up_grade(l_image1,I1.shape[axis]*4,axis=axis,nouty=I1.shape[axis+1]*4)
                     vmask=self.up_grade(vmask,I1.shape[axis]*4,axis=1,nouty=I1.shape[axis+1]*4)
                 else:

{foscat-3.0.19 → foscat-3.0.21}/src/foscat/scat1D.py

@@ -8,6 +8,7 @@ import sys
 tf_defined = 'tensorflow' in sys.modules
 
 if tf_defined:
+    import tensorflow as tf
     tf_function = tf.function  # Facultatif : si vous voulez utiliser TensorFlow dans ce script
 else:
     def tf_function(func):
@@ -28,7 +29,41 @@ class scat1D:
         self.j2=j2
         self.cross=cross
         self.backend=backend
+
+    # ---------------------------------------------−---------
+    def build_flat(self,table):
+        shape=table.shape
+        ndata=1
+        for k in range(1,len(table.shape)):
+            ndata=ndata*table.shape[k]
+        return self.backend.bk_reshape(table,[table.shape[0],ndata])
         
+    # ---------------------------------------------−---------
+    def flatten(self,S2L=False):
+        if not S2L:
+            if isinstance(self.P00,np.ndarray):
+                return np.concatenate([self.build_flat(lf.S0),
+                                       self.build_flat(lf.S1),
+                                       self.build_flat(lf.P00),
+                                       self.build_flat(lf.S2)],1)
+            else:
+                return self.backend.bk_concat([self.build_flat(self.S0),
+                                               self.build_flat(self.S1),
+                                               self.build_flat(self.P00),
+                                               self.build_flat(self.S2)],1)  
+        else:
+            if isinstance(self.P00,np.ndarray):
+                return np.concatenate([self.build_flat(lf.S0),
+                                       self.build_flat(lf.S1),
+                                       self.build_flat(lf.P00),
+                                       self.build_flat(lf.S2),
+                                       self.build_flat(lf.S2L)],1)
+            else:
+                return self.backend.bk_concat([self.build_flat(self.S0),
+                                               self.build_flat(self.S1),
+                                               self.build_flat(self.P00),
+                                               self.build_flat(self.S2),
+                                               self.build_flat(self.S2L)],1)        
     def get_j_idx(self):
         return self.j1,self.j2
     
@@ -62,6 +97,7 @@ class scat1D:
     def domult(self,x,y):
         if x.dtype==y.dtype:
             return x*y
+        
         if self.backend.bk_is_complex(x):
             
             return self.backend.bk_complex(self.backend.bk_real(x)*y,self.backend.bk_imag(x)*y)
@@ -80,6 +116,7 @@ class scat1D:
     def domin(self,x,y):
         if x.dtype==y.dtype:
             return x-y
+        
         if self.backend.bk_is_complex(x):
             
             return self.backend.bk_complex(self.backend.bk_real(x)-y,self.backend.bk_imag(x)-y)
@@ -89,6 +126,7 @@ class scat1D:
     def doadd(self,x,y):
         if x.dtype==y.dtype:
             return x+y
+        
         if self.backend.bk_is_complex(x):
             
             return self.backend.bk_complex(self.backend.bk_real(x)+y,self.backend.bk_imag(x)+y)
@@ -572,8 +610,6 @@ class scat1D:
             s2=self.S2.numpy()
             s2l=self.S2L.numpy()
 
-        print(s1.sum(),p0.sum(),s2.sum(),s2l.sum())
-
         if isinstance(threshold,scat1D):
             if isinstance(threshold.S1,np.ndarray):
                 s1th=threshold.S1
@@ -663,7 +699,6 @@ class scat1D:
                         s2l[:,i0]=s2l[:,i1]
                     else:
                         idx=np.where((s2[:,i2]>0)*(s2[:,i3]>0)*(s2[:,i2]<s2th[:,i2]))
-                        print(i0,i2)
                         if len(idx[0])>0:
                             s2[idx[0],i0,idx[1],idx[2]]=np.exp(3*np.log(s2[idx[0],i2,idx[1],idx[2]])-2*np.log(s2[idx[0],i3,idx[1],idx[2]]))
                         idx=np.where((s2[:,i1]>0)*(s2[:,i2]>0)*(s2[:,i1]<s2th[:,i1]))
@@ -681,7 +716,6 @@ class scat1D:
         p0[np.isnan(p0)]=0.0
         s2[np.isnan(s2)]=0.0
         s2l[np.isnan(s2l)]=0.0
-        print(s1.sum(),p0.sum(),s2.sum(),s2l.sum())
 
         return scat1D(self.backend.constant(p0),self.S0,
                     self.backend.constant(s1),
@@ -815,9 +849,14 @@ class funct(FOC.FoCUS):
     def eval(self, image1, image2=None,mask=None,Auto=True,s0_off=1E-6,Add_R45=False,axis=0):
         # Check input consistency
         if mask is not None:
-            if list(image1.shape)!=list(mask.shape)[1:]:
-                print('The mask should have the same size than the input timeline to eval Scattering')
-                exit(0)
+            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)
+            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)
             
         ### AUTO OR CROSS
         cross = False
@@ -830,7 +869,7 @@ class funct(FOC.FoCUS):
         # determine jmax and nside corresponding to the input map
         im_shape = image1.shape
 
-        nside=im_shape[axis]
+        nside=im_shape[len(image1.shape)-1]
         npix=nside
         
         jmax=int(np.log(nside)/np.log(2)) #-self.OSTEP
@@ -865,11 +904,19 @@ class funct(FOC.FoCUS):
             l_image1=I1
             if cross:
                 l_image2=I2
-
-        s0 = self.backend.bk_reduce_sum(l_image1*vmask,axis=axis+1)+s0_off
+        if len(image1.shape)==1:
+            s0 = self.backend.bk_reduce_sum(l_image1*vmask,axis=axis+1)
+            if cross and Auto==False:
+                s0 = self.backend.bk_concat([s0,self.backend.bk_reduce_sum(l_image2*vmask,axis=axis)])
+        else:
+            lmask=self.backend.bk_expand_dims(vmask,0)
+            lim=self.backend.bk_expand_dims(l_image1,1)
+            s0 = self.backend.bk_reduce_sum(lim*lmask,axis=axis+2)
+            if cross and Auto==False:
+                lim=self.backend.bk_expand_dims(l_image2,1)
+                s0 = self.backend.bk_concat([s0,self.backend.bk_reduce_sum(lim*lmask,axis=axis+2)])
+            
         
-        if cross and Auto==False:
-            s0 = self.backend.bk_concat([s0,self.backend.bk_reduce_sum(l_image2*vmask,axis=axis)+s0_off])
 
         s1=None
         s2=None

{foscat-3.0.19 → foscat-3.0.21}/src/foscat/scat_cov.py

@@ -9,6 +9,7 @@ import sys
 tf_defined = 'tensorflow' in sys.modules
 
 if tf_defined:
+    import tensorflow as tf
     tf_function = tf.function  # Facultatif : si vous voulez utiliser TensorFlow dans ce script
 else:
     def tf_function(func):
@@ -576,41 +577,53 @@ class scat_cov:
                             s1=s1, c10=c10,backend=self.backend)
         
     def domult(self,x,y):
-        if x.dtype==y.dtype:
+        try:
             return x*y
-        if self.backend.bk_is_complex(x):
-            
-            return self.backend.bk_complex(self.backend.bk_real(x)*y,self.backend.bk_imag(x)*y)
-        else:
-            return self.backend.bk_complex(self.backend.bk_real(y)*x,self.backend.bk_imag(y)*x)
+        except:
+            if x.dtype==y.dtype:
+                return x*y
+            if self.backend.bk_is_complex(x):
+
+                return self.backend.bk_complex(self.backend.bk_real(x)*y,self.backend.bk_imag(x)*y)
+            else:
+                return self.backend.bk_complex(self.backend.bk_real(y)*x,self.backend.bk_imag(y)*x)
 
     def dodiv(self,x,y):
-        if x.dtype==y.dtype:
+        try:
             return x/y
-        if self.backend.bk_is_complex(x):
+        except:
+            if x.dtype==y.dtype:
+                return x/y
+            if self.backend.bk_is_complex(x):
             
-            return self.backend.bk_complex(self.backend.bk_real(x)/y,self.backend.bk_imag(x)/y)
-        else:
-            return self.backend.bk_complex(x/self.backend.bk_real(y),x/self.backend.bk_imag(y))
+                return self.backend.bk_complex(self.backend.bk_real(x)/y,self.backend.bk_imag(x)/y)
+            else:
+                return self.backend.bk_complex(x/self.backend.bk_real(y),x/self.backend.bk_imag(y))
         
     def domin(self,x,y):
-        if x.dtype==y.dtype:
+        try:
             return x-y
-        
-        if self.backend.bk_is_complex(x):
-            
-            return self.backend.bk_complex(self.backend.bk_real(x)-y,self.backend.bk_imag(x)-y)
-        else:
-            return self.backend.bk_complex(x-self.backend.bk_real(y),x-self.backend.bk_imag(y))
+        except:
+            if x.dtype==y.dtype:
+                return x-y
+
+            if self.backend.bk_is_complex(x):
+
+                return self.backend.bk_complex(self.backend.bk_real(x)-y,self.backend.bk_imag(x)-y)
+            else:
+                return self.backend.bk_complex(x-self.backend.bk_real(y),x-self.backend.bk_imag(y))
         
     def doadd(self,x,y):
-        if x.dtype==y.dtype:
+        try:
             return x+y
-        if self.backend.bk_is_complex(x):
-            
-            return self.backend.bk_complex(self.backend.bk_real(x)+y,self.backend.bk_imag(x)+y)
-        else:
-            return self.backend.bk_complex(x+self.backend.bk_real(y),x+self.backend.bk_imag(y))
+        except:
+            if x.dtype==y.dtype:
+                return x+y
+            if self.backend.bk_is_complex(x):
+
+                return self.backend.bk_complex(self.backend.bk_real(x)+y,self.backend.bk_imag(x)+y)
+            else:
+                return self.backend.bk_complex(x+self.backend.bk_real(y),x+self.backend.bk_imag(y))
                 
             
     def __mul__(self, other):
@@ -735,7 +748,7 @@ class scat_cov:
         return scat_cov(self.S0,self.backend.constant(p0),self.backend.constant(c01),
                         self.backend.constant(c11),s1=s1,c10=c10,backend=self.backend)
 
-    def plot(self, name=None, hold=True, color='blue', lw=1, legend=True):
+    def plot(self, name=None, hold=True, color='blue', lw=1, legend=True,norm=False):
 
         import matplotlib.pyplot as plt
 
@@ -754,7 +767,7 @@ class scat_cov:
             if len(tmp.shape)>3:
                 for k in range(tmp.shape[3]):
                     for i1 in range(tmp.shape[0]):
-                        for i2 in range(tmp.shape[0]):
+                        for i2 in range(tmp.shape[1]):
                             if test is None:
                                 test=1
                                 plt.plot(tmp[i1,i2,:,k],color=color, label=r'%s $S_1$' % (name), lw=lw)
@@ -762,7 +775,7 @@ class scat_cov:
                                 plt.plot(tmp[i1,i2,:,k],color=color, lw=lw)
             else:
                 for i1 in range(tmp.shape[0]):
-                    for i2 in range(tmp.shape[0]):
+                    for i2 in range(tmp.shape[1]):
                         if test is None:
                             test=1
                             plt.plot(tmp[i1,i2,:],color=color, label=r'%s $S_1$' % (name), lw=lw)
@@ -776,10 +789,11 @@ class scat_cov:
         test=None
         plt.subplot(2, 2, 2)
         tmp=abs(self.get_np(self.P00))
+        ntmp=np.sqrt(tmp)
         if len(tmp.shape)>3:
             for k in range(tmp.shape[3]):
                 for i1 in range(tmp.shape[0]):
-                    for i2 in range(tmp.shape[0]):
+                    for i2 in range(tmp.shape[1]):
                         if test is None:
                             test=1
                             plt.plot(tmp[i1,i2,:,k],color=color, label=r'%s $P_{00}$' % (name), lw=lw)
@@ -787,7 +801,7 @@ class scat_cov:
                             plt.plot(tmp[i1,i2,:,k],color=color, lw=lw)
         else:
             for i1 in range(tmp.shape[0]):
-                for i2 in range(tmp.shape[0]):
+                for i2 in range(tmp.shape[1]):
                     if test is None:
                         test=1
                         plt.plot(tmp[i1,i2,:],color=color, label=r'%s $P_{00}$' % (name), lw=lw)
@@ -819,15 +833,18 @@ class scat_cov:
                     for i2 in range(j1.max()+1):
                         for i3 in range(tmp.shape[3]):
                             for i4 in range(tmp.shape[4]):
+                                dtmp=tmp[i0,i1,j1==i2,i3,i4]
+                                if norm:
+                                    dtmp=dtmp/ntmp[i0,i1,i2,i3]
                                 if j2[j1==i2].shape[0]==1:
-                                    ax1.plot(j2[j1==i2]+n,tmp[i0,i1,j1==i2,i3,i4],'.', \
+                                    ax1.plot(j2[j1==i2]+n,dtmp,'.', \
                                                  color=color, lw=lw)
                                 else:
                                     if legend and test is None:
-                                        ax1.plot(j2[j1==i2]+n,tmp[i0,i1,j1==i2,i3,i4], \
+                                        ax1.plot(j2[j1==i2]+n,dtmp, \
                                                  color=color, label=lname, lw=lw)
                                         test=1
-                                    ax1.plot(j2[j1==i2]+n,tmp[i0,i1,j1==i2,i3,i4], \
+                                    ax1.plot(j2[j1==i2]+n,dtmp, \
                                              color=color, lw=lw)
                         tabnx=tabnx+[r'%d'%(k) for k in j2[j1==i2]]
                         tabx=tabx+[k+n for k in j2[j1==i2]]
@@ -840,15 +857,18 @@ class scat_cov:
                 for i1 in range(tmp.shape[1]):
                     for i2 in range(j1.max()+1):
                         for i3 in range(tmp.shape[3]):
+                            dtmp=tmp[i0,i1,j1==i2,i3]
+                            if norm:
+                                dtmp=dtmp/ntmp[i0,i1,i2]
                             if j2[j1==i2].shape[0]==1:
-                                ax1.plot(j2[j1==i2]+n,tmp[i0,i1,j1==i2,i3],'.', \
+                                ax1.plot(j2[j1==i2]+n,dtmp,'.', \
                                          color=color, lw=lw)
                             else:
                                 if legend and test is None:
-                                    ax1.plot(j2[j1==i2]+n,tmp[i0,i1,j1==i2,i3], \
+                                    ax1.plot(j2[j1==i2]+n,dtmp, \
                                              color=color, label=lname, lw=lw)
                                     test=1
-                                ax1.plot(j2[j1==i2]+n,tmp[i0,i1,j1==i2,i3], \
+                                ax1.plot(j2[j1==i2]+n,dtmp, \
                                          color=color, lw=lw)
                         tabnx=tabnx+[r'%d'%(k) for k in j2[j1==i2]]
                         tabx=tabx+[k+n for k in j2[j1==i2]]
@@ -894,6 +914,7 @@ class scat_cov:
         tabnx=[]
         tab2x=[]
         tab2nx=[]
+        ntmp=ntmp*ntmp
         if len(tmp.shape)>4:
             for i0 in range(tmp.shape[0]):
                 for i1 in range(tmp.shape[1]):
@@ -904,15 +925,18 @@ class scat_cov:
                             for i3 in range(tmp.shape[3]):
                                 for i4 in range(tmp.shape[4]):
                                     for i5 in range(tmp.shape[5]):
+                                        dtmp=tmp[i0,i1,idx,i3,i4,i5]
+                                        if norm:
+                                            dtmp=dtmp/ntmp[i0,i1,i2,i3]
                                         if len(idx)==1:
-                                            ax1.plot(np.arange(len(idx))+n,tmp[i0,i1,idx,i3,i4,i5],'.', \
+                                            ax1.plot(np.arange(len(idx))+n,dtmp,'.', \
                                                      color=color, lw=lw)
                                         else:
                                             if legend and test is None:
-                                                ax1.plot(np.arange(len(idx))+n,tmp[i0,i1,idx,i3,i4,i5], \
+                                                ax1.plot(np.arange(len(idx))+n,dtmp, \
                                                          color=color, label=lname, lw=lw)
                                                 test=1
-                                            ax1.plot(np.arange(len(idx))+n,tmp[i0,i1,idx,i3,i4,i5], \
+                                            ax1.plot(np.arange(len(idx))+n,dtmp, \
                                                      color=color, lw=lw)
                             tabnx=tabnx+[r'%d,%d'%(j2[k],j3[k]) for k in idx]
                             tabx=tabx+[k+n for k in range(len(idx))]
@@ -928,15 +952,18 @@ class scat_cov:
                         for i2b in range(j2[j1==i2].max()+1):
                             idx=np.where((j1==i2)*(j2==i2b))[0]
                             for i3 in range(tmp.shape[3]):
+                                dtmp=tmp[i0,i1,idx,i3]
+                                if norm:
+                                    dtmp=dtmp/ntmp[i0,i1,i2]
                                 if len(idx)==1:
-                                    ax1.plot(np.arange(len(idx))+n,tmp[i0,i1,idx,i3],'.', \
+                                    ax1.plot(np.arange(len(idx))+n,dtmp,'.', \
                                              color=color, lw=lw)
                                 else:
                                     if legend and test is None:
-                                        ax1.plot(np.arange(len(idx))+n,tmp[i0,i1,idx,i3], \
+                                        ax1.plot(np.arange(len(idx))+n,dtmp, \
                                                  color=color, label=lname, lw=lw)
                                         test=1
-                                    ax1.plot(np.arange(len(idx))+n,tmp[i0,i1,idx,i3], \
+                                    ax1.plot(np.arange(len(idx))+n,dtmp, \
                                              color=color, lw=lw)
                             tabnx=tabnx+[r'%d,%d'%(j2[k],j3[k]) for k in idx]
                             tabx=tabx+[k+n for k in range(len(idx))]

{foscat-3.0.19 → foscat-3.0.21}/src/foscat/scat_cov1D.py

@@ -10,6 +10,7 @@ import sys
 tf_defined = 'tensorflow' in sys.modules
 
 if tf_defined:
+    import tensorflow as tf
     tf_function = tf.function  # Facultatif : si vous voulez utiliser TensorFlow dans ce script
 else:
     def tf_function(func):
@@ -374,42 +375,54 @@ class scat_cov1D:
                             (self.C01 - other),
                             c11,
                             s1=s1, c10=c10,backend=self.backend)
-        
-    def domult(self,x,y):
-        if x.dtype==y.dtype:
+        def domult(self,x,y):
+        try:
             return x*y
-        
-        if self.backend.bk_is_complex(x):
-            return self.backend.bk_complex(self.backend.bk_real(x)*y,self.backend.bk_imag(x)*y)
-        else:
-            return self.backend.bk_complex(self.backend.bk_real(y)*x,self.backend.bk_imag(y)*x)
-        
+        except:
+            if x.dtype==y.dtype:
+                return x*y
+            if self.backend.bk_is_complex(x):
+
+                return self.backend.bk_complex(self.backend.bk_real(x)*y,self.backend.bk_imag(x)*y)
+            else:
+                return self.backend.bk_complex(self.backend.bk_real(y)*x,self.backend.bk_imag(y)*x)
+
     def dodiv(self,x,y):
-        if x.dtype==y.dtype:
+        try:
             return x/y
-        
-        if self.backend.bk_is_complex(x):
-            return self.backend.bk_complex(self.backend.bk_real(x)/y,self.backend.bk_imag(x)/y)
-        else:
-            return self.backend.bk_complex(x/self.backend.bk_real(y),x/self.backend.bk_imag(y))
+        except:
+            if x.dtype==y.dtype:
+                return x/y
+            if self.backend.bk_is_complex(x):
+            
+                return self.backend.bk_complex(self.backend.bk_real(x)/y,self.backend.bk_imag(x)/y)
+            else:
+                return self.backend.bk_complex(x/self.backend.bk_real(y),x/self.backend.bk_imag(y))
         
     def domin(self,x,y):
-        if x.dtype==y.dtype:
+        try:
             return x-y
-            
-        if self.backend.bk_is_complex(x):
-            return self.backend.bk_complex(self.backend.bk_real(x)-y,self.backend.bk_imag(x)-y)
-        else:
-            return self.backend.bk_complex(x-self.backend.bk_real(y),x-self.backend.bk_imag(y))
+        except:
+            if x.dtype==y.dtype:
+                return x-y
+
+            if self.backend.bk_is_complex(x):
+
+                return self.backend.bk_complex(self.backend.bk_real(x)-y,self.backend.bk_imag(x)-y)
+            else:
+                return self.backend.bk_complex(x-self.backend.bk_real(y),x-self.backend.bk_imag(y))
         
     def doadd(self,x,y):
-        if x.dtype==y.dtype:
+        try:
             return x+y
-            
-        if self.backend.bk_is_complex(x):
-            return self.backend.bk_complex(self.backend.bk_real(x)+y,self.backend.bk_imag(x)+y)
-        else:
-            return self.backend.bk_complex(x+self.backend.bk_real(y),x+self.backend.bk_imag(y))
+        except:
+            if x.dtype==y.dtype:
+                return x+y
+            if self.backend.bk_is_complex(x):
+
+                return self.backend.bk_complex(self.backend.bk_real(x)+y,self.backend.bk_imag(x)+y)
+            else:
+                return self.backend.bk_complex(x+self.backend.bk_real(y),x+self.backend.bk_imag(y))
                 
             
     def __mul__(self, other):

{foscat-3.0.19 → foscat-3.0.21}/src/foscat.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foscat
-Version: 3.0.19
+Version: 3.0.21
 Summary: Generate synthetic Healpix or 2D data using Cross Scattering Transform
 Home-page: https://github.com/jmdelouis/FOSCAT
 Author: Jean-Marc DELOUIS
@@ -9,12 +9,6 @@ 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.19 → foscat-3.0.21}/src/foscat.egg-info/SOURCES.txt

@@ -1,6 +1,7 @@
 README.md
 setup.cfg
 setup.py
+src/foscat/CNN.py
 src/foscat/CircSpline.py
 src/foscat/FoCUS.py
 src/foscat/GCNN.py