PaIRS-UniNa 0.1.13__cp310-cp310-win_amd64.whl → 0.2.8__cp310-cp310-win_amd64.whl

PaIRS_UniNa/plt_util.py

@@ -1,141 +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)
+''' 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

@@ -1,150 +1,155 @@
-''' preProcParFor helper function for parfor '''
-
+''' 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()
-  
-  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,numUsedThreadsPIV,*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,'',[]]
-  
-  
-  nImgMolt=2 if data.flag_TR else 1
-  nImg=2
-  
-  
-  try:
-    for k in range(nImg):  
-      # tbd
-      #if i==2:1/0
-      ind=nImgMolt*nImg*i+k
-      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[k],data.PRO.SogliaNoise,data.PRO.SogliaStd ):
-              #flagOut=1 if k==0 else (2 if flagOut==-1 else 3)
-              compMin.minSum(I,k)
-              #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]+="The gray levels 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%numUsedThreadsPIV 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,numUsedThreadsPIV,*args,**kwargs):
-  #prLock(f'finalMIN  procId={procId}  {data.compMin.contab}')
-  return compMin
-
-def saveAndMin(procId,flagHasWorked,compMin:CompMin,data:dataTreePar,numUsedThreadsPIV,*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
-  
-
-
-
-  
-
+
+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
+  
+
+
+
+  
+