PaIRS-UniNa 0.2.10__cp313-cp313-macosx_11_0_universal2.whl

PaIRS_UniNa/pivParFor.py

@@ -0,0 +1,235 @@
+from .PaIRS_pypacks import *
+from .procTools import *
+
+def image2Float(a): 
+  ''' converts image to float '''
+  return lambda I: np.ascontiguousarray(I,dtype= a)
+Image2PIV_Float=image2Float( np.float64 if PaIRS_lib.SizeOfReal()==8 else np.float32)   
+
+class WrapperOutFromPIV(PaIRS_lib.PyFunOutPIV):
+   ''' Wrapper class for FunOut 
+   FunOut is called periodically from the PaIRS_lib lib and if FunOut returns a value different from 
+   zero the processing is stopped
+   '''
+   def __init__(self,flagFerma,eventExit) :
+      PaIRS_lib.PyFunOutPIV.__init__(self)
+      self.flagFerma=flagFerma
+      self.eventExit=eventExit
+   def FunOut(self, a, b, o) :
+      if self.eventExit.is_set():
+        self.flagFerma=-1
+        return -1
+      #print(f'flag ferma {self.flagFerma[0]} id={id(self.flagFerma)}  {os.getpid()} ')
+      return  0
+
+def initPIV(eventFerma,iImg,procId,data:dataTreePar,*args,**kwargs):  
+  ''' this  function is called once per processor before the main function 
+  eventferma is passed to the function called by PIV in order to stop the processing ''' 
+  #prTimeLock(0,f"  initPIV")
+  
+  PIV=data2PIV(data,flagSpiv=False)
+  data.OUT=OUTpar(data.Process,data.Step)
+  data.OUT.copyfromdiz(data.OUT_dict)
+  
+  PIV.Inp.FlagLog=0
+  #vect=[]
+  #for v in data.PRO.Vect:      vect.append(v.astype(np.intc))
+      
+  #PIV.SetVect([v.astype(np.intc) for v in data.PRO.Vect])
+  if data.FlagMIN:
+    data.compMin.Imin=[np.zeros(1),np.zeros(1)]
+    for k,filename in enumerate(data.Imin[0]):
+      try:
+        data.compMin.Imin[k]=np.ascontiguousarray(Image.open(filename))
+      except Exception as inst:  
+          errorMessage=f'Error while opening historical minimum background image file: {filename}. PIV process will not be executed!'
+          pri.Error.red(errorMessage+f"\n\nError details:\n{inst}\n")
+          raise (errorMessage)  
+          #raise (inst)        
+
+
+  PIV.Media=MediaPIV()#data.mediaPIV
+  PIV.WraOut =WrapperOutFromPIV(0,eventExit=eventFerma)
+  PIV.fun=PaIRS_lib.GetPyFunction(PIV.WraOut) 
+  (flagOut,VarOut)  =procPIV(iImg,procId ,PIV,data,*args,**kwargs)
+  return (flagOut,VarOut,PIV)
+def exitNoLog(flagOut,varOut):
+  ''' exit without printing the log '''
+  varOut[0]=-1
+  return (flagOut,varOut)
+def procPIV(i,procId ,PIV,data:dataTreePar,numUsedProcs,*args,**kwargs):
+  ''' main proc function called for all the images one time per processor 
+    k=0 always
+    In output flagOut and varOut[0] can be:
+      Already processed:      varOut[0]=-1 flagOut=FLAG_PROC[k]|FLAG_READ[k]|FLAG_FINALIZED[k]
+      Error reading:          varOut[0]=i  flagOut=FLAG_READ_ERR[k]
+      Error processing:       varOut[0]=i  flagOut=FLAG_READ[k]
+      Process stoped by user: varOut[0]=-1 flagOut=FLAG_READ[k]
+      Error saving:           varOut[0]=i  flagOut=FLAG_PROC[k]|FLAG_READ[k]
+      Read and processed:     varOut[0]=i  flagOut=FLAG_PROC[k]|FLAG_READ[k]|FLAG_FINALIZED[k]|FLAG_CALLBACK_INTERNAL
+    Use:
+    numCallBackTotOk+=sum(1 if x&FLAG_CALLBACK_INTERNAL else 0 for x in flagOut) 
+        to evaluate the number of total internal callbacks
+    numProcOrErrTot=sum(1 if f else 0 for f  in flagOut)   
+        to evaluate the number of total images processed (after a possible pause)
+    numFinalized=sum(1 if f&FLAG_FINALIZED[0]  else 0 for f  in flagOut)   
+        to evaluate the number of total images correctly  processed   
+
+    where FLAG_FINALIZED_OR_ERR = [ p|e for (p,e) in zip(FLAG_FINALIZED,FLAG_READ_ERR)]
+    numProcOrErrTot=sum(1 if (f&FLAG_FINALIZED_OR_ERR[0])or(not f&FLAG_PROC[0])  else 0 for f  in flagOut)    
+    to delete images 
+    pa='C:\\desk\\dl\\apairs\\jetcross\\'
+    no='zR2jet0_0004a'
+    I =imread([pa no '.png']);
+    I=I*0+1;
+    imwrite(I,[pa no 'black.png']);
+  '''
+  
+  flagOut=0#data.list_pim[i] #0 to be processed, -1 error, 1 correctly processed
+  
+  varOut=[i,'',[]] # The log will be written unless exitNoLog. If FLAG_CALLBACK_INTERNAL will be set then also the internal part will be called. 
+  
+  #if PIV.WraOut.flagFerma!=0: return (flagOut,VarOut)
+  j=i*2
+  kConst=0#useless. In preProc the flags are different for the first and second image in this case we only use the first (i.e. k=0)
+  try:
+    varOut[1]+=f'{data.list_Image_Files[j]}-{data.list_Image_Files[j+1]}'
+    if data.list_eim[j] and data.list_eim[j+1]:  
+      if  data.list_pim[i]&FLAG_FINALIZED[kConst]:
+        flagOut=FLAG_READ[kConst]|FLAG_PROC[kConst]|FLAG_FINALIZED[kConst]  # It has been already processed. Exit without calling the callback  core part
+        #☻prTimeLock(0,f"{i} --> {data.list_Image_Files[j]}   {data.list_Image_Files[j+1]}  {hex(flagOut)}")
+        return exitNoLog(flagOut,varOut)
+      else:
+        if PIV.WraOut.eventExit.is_set():    return exitNoLog(flagOut,varOut)# non si può mettere prima
+        # reading images and transforming 
+        #prTimeLock(0,f"{i} --> {data.list_Image_Files[j]}   {data.list_Image_Files[j+1]}")
+        I1=[None]*2 
+        # tbd
+        #if i==2:1/0
+        try:
+          for k in range(2):
+            if PIV.WraOut.eventExit.is_set(): return exitNoLog(flagOut,varOut)
+            nameImg=data.inpPath+data.list_Image_Files[j+k]
+            I1[k]=np.ascontiguousarray(Image.open(nameImg))
+            if data.FlagMIN:
+              if data.FlagTR and i%2:
+                I1[k]=I1[k]-data.compMin.Imin[[1,0][k]]
+              else:
+                I1[k]=I1[k]-data.compMin.Imin[k]
+          iProc=transfIm(data.OUT,flagTransf=0,Images=I1)
+        except Exception as inst:
+          flagOut|=FLAG_READ_ERR[kConst]
+          if data.list_pim[i]&FLAG_READ_ERR[kConst]:varOut[0]=-1# no log already written
+          varOut[1]+=f"\n!!!!!!!!!! Error while reading the image {data.list_Image_Files[j+k]}:\n{inst}\n" 
+          prLock(f'{varOut[1]}')
+          return (flagOut,varOut) #we can exit directly! Not calling the internal part of the callback in case of error
+        
+        # no exception reading images and transforming running the process 
+        flagOut|=FLAG_READ[kConst]
+        #infoPrint.white(os.getpid())
+        try:
+          PIV.SetImg([Image2PIV_Float(I) for I in iProc]) #inside try but should not happen
+          if PIV.WraOut.eventExit.is_set(): return (flagOut,varOut)
+          err=PIV.PIV_Run(PIV.fun)
+        except Exception as inst:
+          #raise (inst)
+          if ( data.list_pim[i] &FLAG_READ[kConst]):varOut[0]=-1# no log already written
+          #dum=str(inst.__cause__).split('\n')[3] #solved
+          dum='\n'.join(str(inst.args[0]).split('\n')[3:])
+          #varOut[1]+=f"\n!!!!!!!!!! Error while processing the above image pair: {dum}"  
+          varOut[1]+=f"\n!!!!!!!!!! Error while processing data:\n{dum}\n"  
+          #prLock(f'{varOut[1]}')
+          return (flagOut,varOut) #we can exit directly! Not calling the internal part of the callback in case of error
+        try:# no exception running the process 
+          if err==-1000: #interrotto 
+              return exitNoLog(flagOut,varOut) #we can exit directly no log ! 
+          else:
+            # Finalizing the process (means  transformations and saving data)
+            flagOut|=FLAG_PROC[kConst]# per completezza aggiungo anche processato
+            x,y,u,v=transfVect(data.OUT,PIV) 
+            nameFields=PIV.Media.namesPIV.instVelFields
+            otherVars=[getattr(PIV,f) for f in nameFields[4:] ]
+            campoVel=[x,y,u,v] +transfIm(data.OUT,flagTransf=1,Images=otherVars,flagRot=1)
+            nameVar=PIV.Media.namesPIV.instVel
+            PIV.Media.sum(campoVel)  
+            try:
+              saveResults(data,i+1,campoVel,nameVar)
+            except Exception as inst:   
+              varOut[1]+=f"\n!!!!!!!!!! Error while saving the results:\n{str(inst)}\n"   
+              #prLock(f'{varOut[1]}')
+              varOut[0]=i# In any case the log will be written. If FLAG_CALLBACK_INTERNAL will be set then also the internal part will be called. 
+              return (flagOut,varOut) #we can exit directly! Not calling the internal part of the callback in case of error
+            varOut[1]+="\n"+printPIVLog(PIV.PD)
+            flagOut|=FLAG_FINALIZED[kConst]
+            varOut[0]=i# In any case the log will be written. If FLAG_CALLBACK_INTERNAL will be set then also the internal part will be called. 
+            flagOut|=FLAG_CALLBACK_INTERNAL# Verrà chiamata la callback
+        except Exception as inst:
+          varOut[1]+=f"\n!!!!!!!!!! Error while finalizing the PIV process:\n{str(inst)}\n"  
+          #prLock(f'{varOut[1]}')
+          return (flagOut,varOut)
+    else:#if data.list_eim[j] and data.list_eim[j+1]:  
+      flagOut|=FLAG_READ_ERR[kConst]
+      if  data.list_pim[i]&FLAG_READ_ERR[kConst]:varOut[0]=-1# no log already written
+      jj=j+1 if data.list_eim[j] else j
+      varOut[1]+=f"\n!!!!!!!!!! Error while reading the image {data.list_Image_Files[jj]}:\nThe image file is missing!\n"
+      #prLock(f'{varOut[1]}')
+  except :
+    flagOut|=FLAG_GENERIC_ERROR
+    varOut[0]=i# In any case the log will be written. If FLAG_CALLBACK_INTERNAL will be set then also the internal part will be called. 
+    varOut[1]+=printException(flagMessage=True)
+  
+  # to del  ma il resto dove va
+  #varOut=[i,stampa,[]] if flagOut&FLAG_FINALIZING_PROC_OK[0] else [-1,stampa,[]]
+  if (not procId%numUsedProcs) and flagOut&FLAG_FINALIZED[0]: # copiare l'img nella coda è un operazione onerosa. TA ha deciso che si copia solo quando serve
+    #prLock(f'procMIN Main proc i={i}')
+    varOut[2]=campoVel#VarOut=[i,stampa,Var]
+  
+
+  
+  return (flagOut,varOut)
+
+def finalPIV(procId, PIV,data,*args,finalPIVPIppo=4 ,**kwargs):
+  #prLock(f'finalPIV  procId={procId}')
+  return PIV.Media
+
+def saveAndMean(procId,flagHasWorked,med,data,*args,**kwargs):
+  ''' saveAndMean is the wrapUp function called once per processor  '''
+  if flagHasWorked:
+    data.mediaPIV.sumMedia(med)
+  return data.mediaPIV
+
+def callBackPIV(flag,perc,procId,flagOut,name,VarOut,signal_res):
+  ''' 
+    flag=true new data False just check exit
+    perc= precentage done
+    flagOutFromTasks,varOutFromTask Out varibles from task  e.g.:
+      flagOut=1 #0 to be processed, -1 error, 1 correctly processed
+      varOutFromTask whatever for now a string
+      name current element in names
+    to stop the process the return value should be True otherwise sleep  
+  '''
+  global FlagStopWorkers
+  
+  if flag:
+    i=VarOut[0]
+    stampa=VarOut[1]
+    Var=VarOut[2]
+    #pr(f'Callback {i}         getpid {os.getpid()}      {len(Var)}')
+    #prLock(f'Callback {i}         getpid {os.getpid()}   ')
+    signal_res.emit(procId,i,flagOut,Var,stampa)
+    VarOut[2]=[]#altrimenti salvo le img 
+    '''
+    if i==0:
+      callBackPIV.flagStop=True
+    if(callBackPIV.flagStop):
+      if i>=2:
+        callBackPIV.flagStop=False
+        FlagStopWorkers[0]=True
+        return True
+    #''' 
+  if FlagStopWorkers[0]:
+    return True
+  else:
+    return False     
+callBackPIV.flagStop=True
+

PaIRS_UniNa/plt_util.py

@@ -0,0 +1,141 @@
+''' plt utilities '''
+from typing import List#, Set, Dict, Tuple, Optional
+from  struct import unpack
+import numpy as np
+
+
+
+def writePlt(outFileName:str,mat,title:str,varNames:List[str],zoneTitle:str)->None :
+  ''' write tecplot binary files'''
+  nVar=len(mat)
+  h,w=mat[0].shape
+  tecIntest=b'#!TDV71 '
+
+  def writeLong(l):
+    f.write(np.int32(l))
+  def writeFloat32(fl):
+    f.write(np.float32(fl))
+  def writeString(s):
+    for c in str.encode(s):
+      f.write(np.int32(c))
+    f.write(np.int32(0))
+    return
+  #apertura file binario di output .plt
+  f=open(outFileName,"wb")
+
+  #scrittura nel file di output del TEST
+  f.write(tecIntest)
+    #scrittura nel file di output di 1 (ordine dei bytes BO???)
+  writeLong(1)
+  #scrittura del titolo
+  writeString(title)
+
+  #scrittura numero e nome delle variabili
+  writeLong(nVar)
+  for s in varNames:
+    writeString(s)
+  writeFloat32(299.0)
+  #ZONE NAME
+  writeString(zoneTitle)
+  #scrittura del BLOCK POINT
+  writeLong(1)
+  #scrittura del COLORE
+  writeLong(-1)
+  #scrittura nel file di output della larghezza e altezza img W e H
+  writeLong(w)
+  writeLong(h)
+  #scrittura nel file di output della dimensione Z
+  writeLong(1)
+  #scrittura nel file di output di 357.0 (bo????)
+  writeFloat32(357.0)
+  #scrittura nel file di output di 299.0 (bo????)
+  writeFloat32(299.0)
+  #scrittura nel file di output di 0 (bo????)
+  writeLong(0)
+  #sizeof variabili
+  for _ in range (0,nVar):
+    writeLong(1)
+
+  #scrittura nel file di output delle matrici x,y,u,v,up,vp (variabili)
+  writeFloat32(np.ascontiguousarray(np.transpose(mat,(1,2,0))))
+
+  f.flush()
+  f.close()
+
+  return
+def readPlt(inFileName):
+  ''' read tecplot binary files 
+  returns a 3d array [w,h,nVar]
+  '''
+  #nVar=len(Mat)
+  #h,w=Mat[0].shape
+  tecIntest=b'#!TDV71 '
+
+
+  def readFloat32():
+    return unpack('f',f.read(4))[0]
+
+  def readLong():
+    return unpack('i',f.read(4))[0]
+  def readString():
+    s=''
+    while True:
+      ic=unpack('i',f.read(4))[0]
+      if ic==0: 
+        break
+      s+=chr(ic)
+    return s
+   
+
+  #apertura file binario di output .plt
+  f=open(inFileName,"rb")
+
+  #scrittura nel file di output del TEST
+  tecIntest=f.read(8)
+  if tecIntest!=b'#!TDV71 ':
+    print("ERrore")
+  if readLong()!=1:
+    print("ERrore")
+  #Lettura del titolo
+  _=readString()
+
+  #lettura numero e nome delle variabili
+  nVar=readLong()
+  varNames=[]
+  for _ in range(nVar):
+    varNames.append(readString())
+  if readFloat32()!=299:
+    print("ERrore")
+  #ZONE NAME
+  _=readString()
+  #scrittura del BLOCK POINT
+  readLong()
+  #scrittura del COLORE
+  readLong()
+  #scrittura nel file di output della larghezza e altezza img W e H
+  w=readLong()
+  h=readLong()
+  #scrittura nel file di output della dimensione Z
+  if readLong()!=1:
+    print("ERrore")#3d nonprevisto
+  if readFloat32()!=357:
+    print("ERrore")
+  if readFloat32()!=299:
+    print("ERrore")  
+  readLong()
+  for _ in range(nVar):
+    dimVar=readLong()   
+  ty=np.float32 if dimVar==1 else np.float64
+  aa=np.reshape(np.fromfile(f, ty,count=w*h*nVar),[h,w,nVar])
+
+  f.close()
+  return  aa,varNames
+
+
+
+
+
+if __name__ == "__main__":
+   i=0
+   nomeFileOut= f"{'test'}{i:0{4:d}d}.plt"
+   readPlt(nomeFileOut)

PaIRS_UniNa/preProcParFor.py

@@ -0,0 +1,155 @@
+''' preProcParFor helper function for parfor '''
+
+from .PaIRS_pypacks import * #OPTIMIZE TAGP rimuovere tutti gli import e mettere solo quelli necessari
+from .procTools import *
+
+prTime = PrintTA(PrintTA.cyan, PrintTA.faceStd,  PrintTAPriority.medium).prTime
+
+def initMIN(eventFerma,iImg,procId,data:dataTreePar,*args,**kwargs):   
+  ''' this  function is called once per processor before the main function 
+  eventferma is passed to the function called by PIV in order to stop the processing ''' 
+  #prLock(0,f"  initMIN procId={procId}")
+  compMin=CompMin(data.ncam)
+  
+  compMin.eventExit=eventFerma
+  # initially I thought that it was easier to initialize the minimum without calling procMIN but this is not possible because
+  # if an error occurs (e.g. reading) while processing the first image it is not possible to overcome this error
+  #if  procId==2:    prTimeLock(f"initMIN  rima compmin   procId={procId} ")
+  (flagOut,VarOut)=procMIN(iImg,procId,compMin,data,*args,**kwargs)
+  #if  procId==2:    prTimeLock(f"fine initMIN    procId={procId} ")
+  return  (flagOut,VarOut,compMin)
+
+def procMIN(i,procId,compMin:CompMin,data:dataTreePar,numMaxProcs,*args,**kwargs):
+  ''' main proc function called for all the images one time per processor 
+    k=0 or 1 for the first and second image
+    In output flagOut and varOut[0] can be:
+      Already processed:  varOut[0]=-1 flagOut=FLAG_PROC[k]|FLAG_READ[k]|FLAG_FINALIZED[k]
+      Error reading:      varOut[0]=i  flagOut=FLAG_READ_ERR[k]
+      Read and processed: varOut[0]=i  flagOut=FLAG_PROC[k]|FLAG_READ[k]|FLAG_FINALIZED[k]|FLAG_CALLBACK_INTERNAL
+    Use:
+    numCallBackTotOk+=sum(1 if x&FLAG_CALLBACK_INTERNAL else 0 for x in flagOut) 
+        to evaluate the number of total internal callbacks
+    numProcOrErrTot=sum(1 if (f&FLAG_FINALIZED_OR_ERR[0])and (f&FLAG_FINALIZED_OR_ERR[1]) else 0 for f  in flagOut)   
+    numProcOrErrTot=sum(1 if f else 0 for f  in flagOut)   
+        to evaluate the number of total images processed (after a possible pause)
+    numFinalized=sum(1 if (f&FLAG_FINALIZED[0]) and (f&FLAG_FINALIZED[1])  else 0 for f  in flagOut)   
+        to evaluate the number of total images correctly  processed 
+    where FLAG_FINALIZED_OR_ERR = [ p|e for (p,e) in zip(FLAG_FINALIZED,FLAG_READ_ERR)]
+  '''
+  flagOut=0 
+
+  varOut=[-1,'',[]]
+  
+  ncam=data.ncam
+  nframe=data.nframe
+  nImgMin=nframe*ncam
+  nImgMolt=2 if data.FlagTR else 1
+  
+  try:
+    for j in range(nImgMin):  
+      # tbd
+      k=j%nframe
+      cam=j//nframe%ncam
+      ind=nImgMolt*nframe*i + k + data.nimg*nframe*cam
+      #if i==2:1/0
+      
+      #i=0 ind=0 (0)-> a ind=1 (1)->b
+      #i=1 ind=4 (2)-> a ind=5 (3)->b
+      varOut[1]+=data.list_Image_Files[ind]+"\n"
+      if data.list_eim[ind]:
+        if data.list_pim[i]&FLAG_PROC[k]:
+          flagOut|=FLAG_PROC[k]|FLAG_READ[k]|FLAG_FINALIZED[k] # It has been already processed. Exit without calling the callback  core part
+          if k: return (flagOut,varOut) #second img
+          #flagOut=flagOut& ~FLAG_CALLBACK# nel caso sia stata chiamata in precedenza ed ora non venga chiamata
+        else:  
+          if compMin.eventExit.is_set(): return (flagOut,varOut)
+          nameImg=data.inpPath+data.list_Image_Files[ind]
+          #if k==0:          prLock(f'{i}    {data.list_Image_Files[ind]} --- {data.list_Image_Files[ind+1]}  ')
+          try:
+            if compMin.eventExit.is_set():             return (flagOut,varOut)
+            I=np.array(Image.open(nameImg))
+          except Exception as inst:
+            flagOut|=FLAG_READ_ERR[k]
+            #if data.list_pim[i]&FLAG_READ_ERR[k]: varOut[0]=-1# no log already written
+            varOut[1]+=f"!!!!!!!!!! Error reading {data.list_Image_Files[ind]}:\n{inst}\n"# no internal callback  {str(inst.__cause__)}
+            prLock(f'{varOut[1]}',end='')
+            varOut[0]=i# In any case the log will be written. If FLAG_CALLBACK_INTERNAL will be set then also the internal part will be called. 
+          else:# no exception
+            
+            flagOut|=FLAG_READ[k]
+            if compMin.checkImg(I,data.SogliaNoise_Min,data.SogliaStd_Min ):
+              #flagOut=1 if k==0 else (2 if flagOut==-1 else 3)
+              compMin.minSum(I,j)
+              #prLock(f"procMIN  {i}--{procId} {nameIm}  flagOut={flagOut}  list_pim[i]={data.list_pim[i]}  ")
+              flagOut|=FLAG_PROC[k]|FLAG_FINALIZED[k]# in this case both processed and finalized
+            else:
+              varOut[1]+=f"The gray levels in {data.list_Image_Files[ind]} are too small! Please, check the image or change the minimum allowed value and standard deviation thresholds in the Validation box!\n" 
+              flagOut|=FLAG_PROC[k] # in this case both processed and finalized
+            varOut[0]=i# In any case the log will be written. If FLAG_CALLBACK_INTERNAL will be set then also the internal part will be called. 
+            flagOut|=FLAG_CALLBACK_INTERNAL# Verrà chiamata la callback
+      else:
+        #if data.list_pim[i]&FLAG_READ_ERR[k]: varOut[0]=-1# no log already written
+        varOut[0]=i# In any case the log will be written. If FLAG_CALLBACK_INTERNAL will be set then also the internal part will be called. 
+        flagOut|=FLAG_READ_ERR[k]
+        varOut[1]+=f"!!!!!!!!!! The file {data.list_Image_Files[ind]} is missing!\n"
+  except :
+    flagOut|=FLAG_GENERIC_ERROR
+    varOut[0]=i# In any case the log will be written. If FLAG_CALLBACK_INTERNAL will be set then also the internal part will be called. 
+    varOut[1]+=printException(flagMessage=True)
+
+
+  if not procId%numMaxProcs and flagOut&FLAG_PROC_AB: # copying in the queue is time consuming. This is done only when needed
+    varOut[2]=compMin.Imin#VarOut=[i,stampa,Var]
+  return (flagOut,varOut)
+            
+def finalMIN( procId,compMin:CompMin,data:dataTreePar,numMaxProcs,*args,**kwargs):
+  #prLock(f'finalMIN  procId={procId}  {data.compMin.contab}')
+  return compMin
+
+def saveAndMin(procId,flagHasWorked,compMin:CompMin,data:dataTreePar,numMaxProcs,*args,**kwargs):
+  ''' saveAndMean is the wrapUp function called once per processor  '''
+  #prTimeLock(f'saveAndMin  procId={procId}  {data.compMin.contab}')
+  if flagHasWorked:
+    data.compMin.calcMin(compMin)
+  #prTimeLock(f'saveAndMin  fine procId={procId}  {data.compMin.contab}')
+  return data.compMin
+
+
+def callBackMin(flag,perc,procId,flagOut,name,VarOut,signal_res):
+  ''' 
+    flag=true new data False just check exit
+    perc= precentage done
+    flagOutFromTasks,varOutFromTask Out varibles from task  e.g.:
+      flagOut=1 #0 to be processed, -1 error, 1 correctly processed
+      varOutFromTask whatever for now a string
+      name current element in names
+    to stop the process the return value should be True otherwise sleep  
+  '''
+  global FlagStopWorkers
+  if flag:
+    i=VarOut[0]
+    stampa=VarOut[1]
+    Var=VarOut[2]
+    #prLock(f'Callback {i}  {perc}       getpid {os.getpid()}      {len(Var)}')
+    signal_res.emit(procId,i,flagOut,Var,stampa)
+    VarOut[2]=[]#altrimenti salvo le img 
+    '''
+    if i==0:
+      callBackMin.flagStop=True
+    if(callBackMin.flagStop):
+      if i>=2:
+        callBackMin.flagStop=False
+        FlagStopWorkers[0]=True
+        return True
+    #'''    
+  if FlagStopWorkers[0]:
+    return True
+  else:
+    return False     
+callBackMin.flagStop=True
+  
+
+
+
+  
+