PaIRS-UniNa 0.2.9__cp310-cp310-macosx_11_0_universal2.whl

PaIRS_UniNa/mtfPIV.py

@@ -0,0 +1,256 @@
+''' '''
+import numpy as np
+import matplotlib.pyplot as plt
+from math import factorial
+def winLoc(H, winType ):
+  '''
+  Returns the WW 
+  '''
+  datBlack = [    [0.42,	0.5,		0.08,		0.],
+                  [7938. / 18608,	9240. / 18608,	1430. / 18608,	0.0],
+                  [0.42323 ,		0.49755 ,		0.07922 ,		0.0],
+                  [0.44959,		0.49364 ,		0.05677 ,		0.0],
+                  [0.35875 ,		0.48829 ,		0.14128 ,		0.01168],
+                  [0.40217 ,		0.49703 ,		0.09392 ,		0.00183]]
+  nameBlack = ('Edged Blackman', 'Exact Blackman', 'Harris 3 term -67', 'Harris 3 term -61', 'Harris 4 term -92', 'Harris 4 term -74') 
+  sCutBlack = ('EBL', 'ExBL', 'HA67', 'HA61', 'HA92', 'HA74' ) 
+  # if needed insert the type   *************************
+  i=np.arange(0,H)
+
+  if winType==0: #no win
+    win=np.ones(H)
+    name='Top Hat'
+    sCut='TH'
+  elif winType==1: #Nogueira
+    WH = abs((H - 1) / 2.0 - i) / H
+    win= (4*WH*WH - 4*WH+1)
+    name='Nogueira 1999'
+    sCut='NOG'
+  elif winType==2: # Blackman ridotta
+    WH = (i+1) / (H+1)
+    win = (0.42 - 0.5*np.cos(2*np.pi*WH)+0.08*np.cos(4*np.pi*WH))
+    name='Blackman'
+    sCut='BL'
+  elif winType==3: # doppia finestra quadrata
+    lar = 0.25
+    WH = abs((H - 1) / 2.0 - i) / H
+    win =np.ones(H)      # if needed insert the type   *************************
+    win[WH > lar]= 0 
+    name='Double TH'
+    sCut='DTH'
+  elif winType==4: # doppia finestra quadrata bordo 1
+    win =np.ones(H)     # if needed insert the type   *************************
+    win[0]= 0
+    win[-1]= 0 
+    name='Edged TH'
+    sCut='ETH'
+  elif 5<=winType<=10: # Various Windows
+    ind = winType - 5
+    WH = i / (H - 1)
+    win = (datBlack[ind][0]-datBlack[ind][1]*np.cos(2*np.pi*WH)+datBlack[ind][2]*np.cos(4*np.pi*WH)-datBlack[ind][3]*np.cos(6*np.pi*WH))
+    name=nameBlack[ind] 
+    sCut=sCutBlack[ind]
+  elif winType==21: # Nogueira  new
+    WH = abs((H - 1) / 2.0 - i) / H
+    win = ((3*(4*WH*WH - 4*WH+1)+.15*np.cos(4*np.pi*WH)+.2*np.cos(6*np.pi*WH)+.1*np.cos(8*np.pi*WH)+.05*np.cos(10*np.pi*WH)) / 3.5)
+    name='Nogueira 2005'
+    sCut='NOG05'
+  elif winType==22: # Bartlett ridotta  diversa da triang di matlab
+      ii=np.arange(0,(H+2) / 2-1,dtype=int)
+      WH = 2*abs((ii+1) / (H+1))
+      win=np.ones(H)
+      win[H - ii-1] =WH
+      win[ii] = WH
+      name='Triangular'
+      sCut='TR'
+  elif winType==23: # Hann ridotta
+    WH = (i+1) / (H+1)
+    win = (0.5 - 0.5*np.cos(2*np.pi*WH))
+    name='Hann'
+    sCut='HA'
+  elif 101<=winType<=200: # Gaussian
+    alpha = ((winType - 100.0) / 10.0)
+    WH = (2*alpha*((H - 1) / 2.0 - i) / H)
+    win = np.exp(-0.5*WH*WH)
+    #as=sprintf(f'{alpha,"#.1f"}')
+    name='Gaussian '+f'{alpha:.1f}'
+    sCut='GA'+f'{alpha:.1f}'
+  return (win,name,sCut)
+
+def mtfSpline(o,n):
+  '''
+    n=order
+    see Frequency Domain Analysis of B-Spline  Interpolation 
+    by Zeljka MihajloviC*, Alan Goluban**, Mario Zagar**
+    doi:10.1109/ISIE.1999.801783
+    and of course Unser 1993 a and b
+    '''
+  k=np.arange(0,n+1)
+  fa=lambda k:np.array([factorial(v) for v in k ])
+
+  bSpline =lambda x: np.sum(( ((-1)**k)*(n+1)*((x+(n+1)/2-k)**n)*np.heaviside(x+(n+1)/2-k,1) )/(fa(k)*fa(n+1-k)))
+  aa=bSpline(0)
+  for kk in np.arange(1,n/2+1):
+    aa=aa+2*bSpline(kk)*np.cos(2*np.pi*kk*o)
+  mtf=np.sinc(o)**(n+1)/aa
+  return mtf
+
+def  mtfPIV1(Wa,FlagWindowing,hWb, FlagCalcVel,Wc, IntVel, oMaxC, WBase,nPointPlot,Niter,flagLambda):
+  '''
+  # Input **********************************
+  #Niter=[2 10 40 1000   inf]# Number of final iteration
+  #nPointPlot=1000
+  #WBase=16# scaltura plot
+  # A  correlation window
+  #Wa=32
+  #FlagWindowing=0  # Weighting window for the correlation map (0=TopHat 1= Nogueira 2=Blackman 3=top hat at 50#).
+  # B  weighted  average
+  #FlagCalcVel=0    # Weighting window for absolute velocity (0=TopHat, 1=Nogueira, 2=Blackman,...)
+  #hWb=4# Half-width of the filtering window (0=window dimension).
+  # C dense predictor 
+  #IntVel=1      # Type of interpolation of the velocity (1=bilinear, 52-70 Bspline)
+  #Wc=4 #Grid distance (overlap)
+  #oMax=0.5 # frequenza massima per c (legata all'overlap ov/lambda) non penso che abbia senso oltre 0,5 perchè 
+            # andremmo oltre Nyquist
+  # flagLambda se =1 allora equispazia lambda con un massimo di WBase*4 normalizza il grafico fra 
+  # same as done by PIV software
+  '''
+  if(np.mod(hWb,2)==1): #dispari
+    Wb=2*hWb-1
+  else:
+    if hWb==0:
+      Wb=Wa
+    else:
+      Wb=2*hWb
+   
+
+
+  # Windows 
+  [WinA,nameA,sCutA]=winLoc(Wa, FlagWindowing)
+  WinA=WinA/sum(WinA)
+  [WinB,nameB,sCutB]=winLoc(Wb, FlagCalcVel)
+  WinB=WinB/sum(WinB)
+
+  # omega W/lambda
+  if flagLambda:
+    lam=np.linspace(Wc/oMaxC,WBase*4,nPointPlot)
+    oC=Wc/lam
+  else:
+    oC=np.linspace(oMaxC/nPointPlot,oMaxC,nPointPlot)
+    lam=Wc/oC
+  oBase=oC*WBase/Wc
+  oA=oC*Wa/Wc
+  oB=oC*Wb/Wc
+  # Windows MTF *******
+  MTFWin=lambda Win,o,W: np.sum((np.tile(Win,(o.size,1))*np.cos(np.reshape(o, (-1, 1))*(2*np.pi*(np.arange(1,W+1)-W/2-0.5))/W)),1)
+  a=MTFWin(WinA,oA,Wa)
+  b=MTFWin(WinB,oB,Wb)
+
+
+
+  '''
+  for FlagWindowing=[0:10 21:23 101:10:200]
+    figure (1)clf
+    [WinA,nameA,sCutA]=winLoc(Wa, FlagWindowing)
+    plot(WinA)
+    title ([nameA,' -- ',sCutA])
+    pause
+  end
+  '''
+  # Interpolation MTF *******
+  if (IntVel==1):
+    c=(np.sin(np.pi*oC)/(Wc*np.sin(np.pi*oC/Wc)))**2
+    order=1
+  elif (52<=IntVel<=70):
+      c=mtfSpline(oC,IntVel-50)
+      order=IntVel-50
+  else:
+    c=1+0*oC
+    order=-1
+
+  # verify stability **********************
+  flagUnstable=0
+  if (np.sum(abs(c*(b-a))>1)!=0):
+    flagUnstable=1
+
+
+  # calc MTF **********************
+  MTF=np.zeros((Niter.size,oBase.size))
+  for j in range(Niter.size):
+    ii=Niter[j]
+    if(ii==np.inf):
+        MTF[j]=a/(1-(c*(b-a)))
+    else:
+        MTF[j]=a*(1-(c*(b-a))**ii)/(1-(c*(b-a)))
+
+  return (WinA,nameA,sCutA,Wa,WinB,nameB,sCutB,Wb, order,flagUnstable,  oBase,lam,MTF,a,b,c)
+
+
+def main():
+  ''' main '''
+  
+  
+  '''
+  FlagWindowing=2
+  Wa=15
+  for FlagWindowing in np.concatenate ((np.arange(0,11) ,[21,22,23], np.arange(101,200,10))):
+    (win,name,sCut)=winLoc(Wa,FlagWindowing ) 
+    plt.title (name+' -- '+sCut)
+    plt.plot(win,'.-')  # Plot some data on the axes.
+    plt.grid()
+    plt.show()
+  '''
+  Niter=np.array([1, 2, 3, np.inf])## Number of final iteration
+  nPointPlot=1000
+  WBase=16# scalatura plot
+
+  # A  correlation window
+  Wa=32
+  FlagWindowing=0 # Weighting window for the correlation map (0=TopHat 1= Nogueira 2=Blackman 3=top hat at 50#).
+  # B  weighted  average
+  FlagCalcVel=0  # Weighting window for absolute velocity (0=TopHat, 1=Nogueira, 2=Blackman,...)
+  hWb=8# Half-width of the filtering window (0=window dimension).
+  # C dense predictor 
+  IntVel=52  # Type of interpolation of the velocity (1=bilinear, 52-70 Bspline)
+  Wc=4#  Grid distance (overlap)
+  #   end input *********************************************
+
+  oMax=0.5 # frequenza massima per c (legata all'overlap ov/lambda) non penso che abbia senso oltre 0,5 perchè 
+          # andremmo oltre Nyquist
+    
+  WBase=2*Wa# scalatura plot the maximmum lambda is 4 *WBase in this case we are using a maximum of 8*Wa
+  flagLambda=1
+  
+  (WinA,nameA,sCutA,Wa,WinB,nameB,sCutB,Wb,order,flagUnstable,oBase,lam,MTF,a,b,c)= mtfPIV1(Wa,FlagWindowing,hWb, FlagCalcVel,Wc, IntVel, oMax, WBase,nPointPlot,Niter,flagLambda)
+
+
+  
+  fig, ax = plt.subplots()
+  ax.plot(oBase,a,'b')#plt.hold on grid on
+  ax.plot(oBase,b,'r')
+  ax.plot(oBase,c)
+  ax.grid()
+  fig2, ax2= plt.subplots()
+  ax2.plot(WinA)
+  ax2.plot(WinB)
+  ax2.grid()
+
+
+  fig4, ax4= plt.subplots()
+  ax4.grid()
+  ax4.plot(lam,MTF.T)
+  ax4.set(xlim=(1, max(lam)), ylim=(-.50, 1),)
+
+
+  fig3, ax3= plt.subplots()
+  ax3.grid()
+  ax3.plot(oBase,MTF.T)
+  ax3.set(xlim=(0, max(oBase)), ylim=(-.50, 1),)
+
+  plt.show()
+  
+
+
+if __name__ == "__main__":
+
+  main()

PaIRS_UniNa/parForMulti.py

@@ -0,0 +1,435 @@
+'''  Parallel for for PIV '''
+#import os
+import traceback
+import queue
+import asyncio
+#import random
+import multiprocessing as mp
+from time import sleep, time
+from .tAVarie import PrintTA, PrintTAPriority
+from .__init__ import __version__,__year__,__mail__
+#import numpy as np
+#import scipy as sc
+
+prTime=PrintTA(PrintTA.blue, PrintTA.faceStd,  PrintTAPriority.medium).prTime
+pr=PrintTA(PrintTA.blue, PrintTA.faceStd,  PrintTAPriority.medium).prTime
+# pylint: disable=unused-argument
+lock=None
+def prLock( *args,**kwargs):
+  ''' print in parallel pool without overlap (slower)'''
+  try:
+    with lock:
+      PrintTA(PrintTA.blue, PrintTA.faceStd,  PrintTAPriority.medium).pr( *args,**kwargs)
+  except :
+    print(ParForMul.printExceptionPFM(flagMessage=True))
+
+def prTimeLock( *args,**kwargs):
+  ''' print in parallel pool without overlap (slower)'''
+  try:
+    with lock:
+      PrintTA(PrintTA.blue, PrintTA.faceStd,  PrintTAPriority.medium).prTime( *args,**kwargs)
+  except:
+    print(ParForMul.printExceptionPFM(flagMessage=True))
+
+def printExceptionMasterParFor(stringa='',flagMessage=False):  #timemilliseconds=-1 ***
+    ''' used to print when an exception is raised TA has decided that the printing function is a simple
+    print in this way we cannot have any problems when printing in non-compatible terminals
+    use with something like
+
+    try:
+        a=1/0
+    except :#non need to put a variable al the info are in traceback
+        printException()
+    * stringa is an additional string (to specify the point where the error comes from) 
+    * flagMessage is a flag, if true the error message is generated; default value is Flag_DEBUG
+    * flagDispDialog is a flag, if true a critical dialog appears after the exception
+    '''
+    #print(f'***** ParForMul Exception *****  Deltat={time()-PrintTA.startTime}\n{traceback.format_exc()}',*args,**kwargs)
+    #print(sys.exc_info()[2])
+    Message=""
+    if flagMessage:
+        Message+=f'Please, mail to: {__mail__}\n\n'
+        Message+=f'***** PaIRS Exception *****  time={time()-PrintTA.startTime}\n'+stringa
+        Message+=f'***** traceback.print_exc() *****  \n'
+        Message+=traceback.format_exc()
+        Message+=f'***** traceback.extract_stack() *****  \n'
+        # to print all the queue comment if not needed
+        for st in traceback.format_list(   traceback.extract_stack()):
+            if 'PAIRS_GUI' in st and 'printException'not in st:# limits to files that have  PAIRS_GUI in the path
+                Message+=st
+        Message+=f'***** PaIRS Exception -> End *****'
+    return Message
+
+  
+
+def fakePIV(iImg,procId, p, procTime, flagOutput=False, mes="fakePIV"):
+  ''' fakePIV'''
+  startTime = time()
+  #print(f'reading Img {iImg} pid={os.getpid()} pid={mp.current_process().pid}')
+  #print(f'reading Img {iImg}  pid={mp.current_process().pid} procId={procId}')
+  #sleep(0.5)
+  #print(f'Finished reading Img {iImg}')
+  
+  a=0
+  count=1*1000*1000#on my pc 10*1000*1000=1sec
+  nIt=1
+  while nIt<2000000: 
+    for _ in range(count):
+      a+=5#random.random()   
+    if time()-startTime>procTime: 
+      break
+    nIt+=1
+  if flagOutput:
+    print(f'fine proc Img {iImg} Nit={nIt} t={time()-startTime}   mes={mes}')
+  return (0,f'fine proc Img {iImg} Nit={nIt} t={time()-startTime}   mes={mes}')
+  
+  #return iImg
+
+class ParForCom():
+  ''' Comunication varibles used by ParFor'''
+  def __init__(self):
+    #prTime(0,'Dentro ParForCom Com')
+    manager=mp.Manager()#si potrebbe creare un lock al posto della variabile globale qui cercare su internet 
+    #prTime(0,'Dentro ParForCom dopo manager')
+    self.q = manager.Queue()
+    self.qOut= manager.Queue()
+    self.qProcessed= manager.Queue()
+    self.eventExit = manager.Event()
+  
+  def clearAll(self):
+    ''' Clears all the queues'''
+    self.clear(self.q)
+    self.clear(self.qOut)
+    self.clear(self.qProcessed)
+
+    
+    
+  def clear(self,q:queue):
+    '''clears a Queue'''
+    try:
+      while True:
+        q.get_nowait()
+    except queue.Empty:
+        pass
+
+
+
+class ParForMul():
+  ''' class Parallel for for PIV '''
+  printExceptionPFM=printExceptionMasterParFor #class variable
+  def __init__(self):
+    #prTime(0,'Dentro ParForMul inizio')
+    self.parForCom:ParForCom=ParForCom()
+    # valori impostabili dall'esterno
+    self.sleepTime=1. # waiting to do things
+    self.nonProcessed=0 # waiting to do things
+    #self.numUsedCores =psutil.cpu_count(logical=False)
+    ## numUsedCores is the number of cores used fo processing and can be different from numCoresParPool that is the number of cores used in the parPool
+    self.numCoresParPool=self.numUsedCores = mp.cpu_count()//2#da decidere per intel  /2 sono i processori reali 
+    #prTime(0,'Dentro ParForMul fine')
+    self.numCalledCallbacks=0 # identify the times that the callbacks have been called
+    self.p=None
+    self.flagError=False
+    self.exception=None
+
+
+  def initTask(self,eventExit,name,procId,*args,**kwargs):
+    ''' dummy InitTask sample 
+    id is the id of the task should be a numeber between 1 and numUsedCores
+    if needed initTask should call the main task with name
+    '''
+    
+    (flag,var)=fakePIV(name, procId,('initTask',2), *args,**kwargs)
+    return (flag,var,('initTask',2))
+
+  def wrapUp(self,procId,flagHasWorked,P,*args,**kwargs):
+    ''' Dummy wrapUp function '''
+    if flagHasWorked:#do something
+      pass
+    return P
+
+  def callBack(self,flag,perc,procId,flagOutFromTask, name,varOutFromTask):
+    ''' Dummy callBack function
+    perc=percentage of processed images
+    flag=true new data False just check exit
+    perc= precentage done
+    flagOutFromTasks,varOutFromTask Out variables from task  e.g.:
+      flagOutFromTasks= 0 success, 1 skipped, -1 error, -2 blocked from caller
+      varOutFromTask whatever for now string
+      name current element in names
+    to stop the process the return value should be True otherwise sleep  '''
+    if not flag:
+      return False  
+    return False
+
+  def finalTask(self,procId,*args,**kwargs):
+    ''' dummy final finalTask function 
+    id is the id of the task should be a numeber between 1 and numUsedCores'''
+    return ('finalTask',2)
+
+  def launchTask(self,procId,task,initTask,finalTask,  *args,**kwargs):
+    ''' the main parallel function first calls initTask (eventExit is an event that enables the safe exit)
+        then for all the element in the queue q calls task with the variable returned by initTask 
+        finally calls finalTask puts in the queue qOut the final result '''
+    # aggiunto try così almeno ci rendiamo conto se c'è un errore
+    '''
+    try: 
+      procId=mp.current_process()._identity[0]
+    except:
+      procId=0 # '''
+    #pid=mp.current_process().pid
+    flagHasWorked=False#if true the task has processed at least one element
+    #if  procId==2: prTimeLock(f"launchTask ||||||||||||  Inizio    procId={procId} flagHasWorked={flagHasWorked} ")
+    media=None
+    try:
+      i,n=self.parForCom.q.get()#  the first time task must be called by initTask
+      if i!=-1:
+        flagHasWorked=True
+        (flag,var,P)=initTask(self.parForCom.eventExit,n,procId,*args,**kwargs)
+        self.parForCom.qProcessed.put((procId,flag,i,var))
+        while True:
+          i,n=self.parForCom.q.get()
+          if i==-1:
+            break
+          (flag,var)=task(n,procId,P,*args,**kwargs)
+          self.parForCom.qProcessed.put((procId,flag,i,var))
+        media=finalTask(procId,P,*args,**kwargs)# media should be different from None
+    except Exception as e:
+      raise(e) # I do not really care to have a full report if in debug it may be important
+      #ParForMul.printExceptionPFM()
+    flagHasWorked=False if media is None else flagHasWorked #if true the task has processed at least one element and media should be different from None
+    return (procId,flagHasWorked,media)
+
+  def readQOutProcess(self,strOutput,flagProcessed,callBack,names,nElements):
+    ''' reads the qOut queue save the data and calls callback'''
+    com=self.parForCom 
+    while not com.qProcessed.empty():
+      (procId,flag,i,var)=com.qProcessed.get_nowait()
+      perc=1-(com.q.qsize()-self.numUsedCores)/nElements#
+      strOutput[i]=var
+      flagProcessed[i]=flag
+      
+      #prLock(f'callBack {i}  {perc} {com.q.qsize()}')
+      if callBack(True,perc,procId,flag,names[i],var):
+        com.eventExit.set()# in this case the process will stop
+      self.numCalledCallbacks+=1
+
+  def errorHandler(self,error):
+    ''' error function '''
+    #self.errorMessage=ParForMul.printExceptionPFM(flagMessage=True)
+    self.exception=error
+    self.flagError=True
+    self.parForCom.eventExit.set()# in this case the process will stop
+    #raise(error)
+  def parForExtPool(self,parPool,task,names,*args,initTask=None,finalTask=None,wrapUp=None,callBack=None,**kwargs):
+    ''' parallel for main function with external mp pool 
+    task is the main function that is called for each value in names. 
+    optionally initTask and finalTask are called only one time per worker
+    args and kwargs are passed to all the functions.add()
+    callBack is called frequently and can be used to stop the parFor
+    Finally the WrapUp function is called one time per worker to wrap things up
+     '''
+    #prTime(0,'Dentro parForExtPool')
+  
+    com=self.parForCom 
+    com.eventExit.clear()
+    initTask=self.initTask if initTask is None else initTask
+    finalTask=self.finalTask if finalTask is None else finalTask
+    wrapUp=self.wrapUp if wrapUp is None else wrapUp
+    callBack=self.callBack if callBack is None else callBack
+    self.flagError=False
+    self.numCalledCallbacks=0  # reset the number of called callbacks
+    nElements=len(names)
+    flagProcessed=[self.nonProcessed]*nElements #lista delle immagini processate inizialmente tutti -1 ma possiamo modificarla
+    strOutput = [None]*nElements #lista dei messaggi in output in realtà potrebbe essere di qualunque tipo
+    def callWrapUp(var): 
+      self.p=wrapUp(*var,*args,**kwargs)
+      self.parForCom.qOut.put((var[0:2])) #procid , flagHasWorked
+      #prTime(f"callWrapUp fine procid={var[0]} ")
+
+    # per ora -1 non processato, -2 errore ,numero positivo processato
+    for i,n  in enumerate(names):
+      com.q.put((i,n))
+    for _  in range(self.numUsedCores):
+      com.q.put((-1,-1))
+
+    for i  in range(self.numUsedCores):
+      _=parPool.apply_async(self.launchTask,(i,task, initTask,finalTask)+args,kwargs,callback=callWrapUp, error_callback=self.errorHandler)      
+      #_=parPool.apply_async(self.launchTask,(task, initTask,finalTask)+args,kwargs, error_callback=self.errorHandler)      
+    #prTime(0,'Dopo apply async in  parForExtPool ++++++++++++++++++++++++++++++++++')
+    nThreadEnd=0
+    while True:
+      try:
+        #(procId,flagHasWorked)=com.qOut.get_nowait()
+        (_,_)=com.qOut.get_nowait()
+        #p=wrapUp(procId,flagHasWorked,p,*args,**kwargs)
+        nThreadEnd+=1
+        #if nThreadEnd==1: prTime(f"fine nThreadEnd={nThreadEnd}  procId={procId}")
+        if nThreadEnd==self.numUsedCores: 
+          break
+      except queue.Empty :
+        #prTime('  except queue.Empty Prima  ')
+        if self.flagError  : break # in this case  a critical exception has been raised we should exit
+        if com.qProcessed.empty():
+          if callBack(False,None,None,None,None,None): 
+            com.eventExit.set()# in this case the process will be stopped
+            #print("com.eventExit.set()# in this case the process will be stopped")
+        else:
+          self.readQOutProcess(strOutput,flagProcessed,callBack,names,nElements)
+        #prTime('********************************\n******************************dopo  ')
+        sleep(self.sleepTime)
+
+    #prTime(f"fine parForExtPool")
+    # some of the processes may have  finished without saving the data
+    self.readQOutProcess(strOutput,flagProcessed,callBack,names,nElements)
+    com.clearAll()# just to be sure ideally only needed when self.flagError is True
+  
+    return self.p,flagProcessed,strOutput,self.flagError  
+
+  def simpleFor(self,parPool,task,names,*args,initTask=None,finalTask=None,wrapUp=None,callBack=None,**kwargs):
+    ''' parallel for main function 
+    task is the main function that is called for each value in names. 
+    optionally initTask and finalTask are called only one time per worker
+    args and kwargs are passed to all the functions.add()
+    Finally the WrapUp function is called one time per worker to wrap things up
+     '''
+    com=self.parForCom 
+    com.eventExit.clear()
+    initTask=self.initTask if initTask is None else initTask
+    finalTask=self.finalTask if finalTask is None else finalTask
+    wrapUp=self.wrapUp if wrapUp is None else wrapUp
+    callBack=self.callBack if callBack is None else callBack
+    self.flagError=False
+    self.numCalledCallbacks=0  # reset the number of called callbacks
+    nElements=len(names)
+    flagProcessed=[self.nonProcessed]*nElements #lista delle immagini processate inizialmente tutti -1 ma possiamo modificarla
+    strOutput = [None]*nElements #lista dei messaggi in output in realtà potrebbe essere di qualunque tipo
+    
+    def callWrapUp(var): 
+      self.p=wrapUp(*var,*args,**kwargs)
+      self.parForCom.qOut.put((var[0:2]))
+
+    # per ora -1 non processato, -2 errore ,numero positivo processato
+    for i,n  in enumerate(names):
+      com.q.put((i,n))
+    for _  in range(1):
+      com.q.put((-1,-1))
+    #with mp.Pool(self.numUsedCores) as pp:
+    procId=0
+    var=self.launchTask(procId,task, initTask,finalTask,*args,**kwargs)
+    callWrapUp(var)
+    nThreadEnd=0
+    while True:
+      try:
+        #(procId,flagHasWorked)=com.qOut.get_nowait()
+        (_,_)=com.qOut.get_nowait()
+        #p=wrapUp(procId,flagHasWorked,p,*args,**kwargs)
+        nThreadEnd+=1
+        #prTime(f"fine nThreadEnd={nThreadEnd}  procId={procId}  flagHasWorked={flagHasWorked}")
+        if nThreadEnd==1: 
+          break
+      except queue.Empty :
+        #prTime('********************************\n******************************Prima  ')
+        if self.flagError  : break # in this case  a critical exception has been raised we should exit
+        if com.qProcessed.empty():
+          if callBack(False,None,None,None,None,None): 
+            com.eventExit.set()# in this case the process will be stopped
+            #print("com.eventExit.set()# in this case the process will be stopped")
+        else:
+          self.readQOutProcess(strOutput,flagProcessed,callBack,names,nElements)
+        #prTime('********************************\n******************************dopo  ')
+        sleep(self.sleepTime)
+    # some of the processes may have  finished without saving the data
+    self.readQOutProcess(strOutput,flagProcessed,callBack,names,nElements)
+    return self.p,flagProcessed,strOutput  ,self.flagError    
+
+      
+  def parFor(self,task,names,*args,initTask=None,finalTask=None,wrapUp=None,callBack=None,**kwargs):
+    ''' parallel for main function 
+    task is the main function that is called for each value in names. 
+    optionally initTask and finalTask are called only one time per worker
+    args and kwargs are passed to all the functions.add()
+    callBack is called frequently and can be used to stop the parFor
+    Finally the WrapUp function is called one time per worker to wrap things up
+     '''
+    prTime(0,'Dentro parFor')
+    pfPool=ParForPool()
+    pfPool.startParPool(self.numUsedCores)
+    (p,flagProcessed,strOutput)=self.parForExtPool(pfPool.parPool,task,names,*args,initTask=initTask,finalTask=finalTask,wrapUp=wrapUp,callBack=callBack,**kwargs)
+    pfPool.closeParPool()
+    return p,flagProcessed,strOutput
+  
+
+    
+def initPoolProcesses(the_lock):
+    '''Initialize each process with a global variable lock.
+    '''
+    global lock
+    lock = the_lock  
+
+class ParForPool():
+  ''' Saves the pool '''
+  def __init__(self):
+    self.parPool=None
+    self.numCoresParPool = mp.cpu_count()//2#da decidere per intel sono /2 son i processori reali 
+  async def startParPoolAsync(self,numCoresParPool):
+    ''' dummy function to call startParPool in async'''
+    self.startParPool(numCoresParPool)
+  def startParPool(self,numCoresParPool):
+    ''' Starts the pool'''
+    the_lock = mp.Lock() # neded for prLock and the like
+    if self.parPool is None:
+      self.parPool=mp.Pool(numCoresParPool,initializer=initPoolProcesses, initargs=(the_lock,))  
+    elif self.numCoresParPool!=numCoresParPool:
+      self.parPool.close()# Si potrebbe usare terminate che ammazza tutti i processi in essere
+      self.parPool=mp.Pool(numCoresParPool)  
+    self.numCoresParPool=numCoresParPool
+  def closeParPool(self):
+    ''' Closes the pool'''
+    if self.parPool is not None:
+      self.parPool.close()# Si potrebbe usare terminate che ammazza tutti i processi in essere  
+
+async def initParForAsync(numCoresParPool):
+  ''' initialise the parPool'''
+  #prTime(0,'PIV_ParFor_Worker init')
+  pfPool=ParForPool()
+  t1=asyncio.create_task(pfPool.startParPoolAsync(numCoresParPool))
+  parForMul=ParForMul()
+  parForMul.numUsedCores=parForMul.numCoresParPool=numCoresParPool
+  await t1
+  #prTime(0,'PIV_ParFor_Worker Dopo ParForPool')
+  return (pfPool,parForMul)    
+
+
+def main():
+  ''' main '''
+  prTime(6,'start')
+  
+  pp=ParForMul()
+  #prTime(0,'Dopo ParForMul   ****************')
+  
+  pp.sleepTime=.1 # time between calls of callBack not used in this example
+  procTime=.02
+  nImg=  [x for x in range(20)]
+  #startTime = time()
+  args=(procTime,)
+  kwargs={"flagOutput":False, "mes":"fakePIV"}
+  #pp.initParPool()
+  #pp.parForCache(fakePIV,nImg,*args,**kwargs)
+  
+  pfPool=ParForPool()
+  pfPool.startParPool(pfPool.numCoresParPool)
+  #pp.simpleFor(fakePIV,nImg,*args,**kwargs)
+  pp.numUsedCores  =4
+  
+  #pp.parForExtPool(pfPool.parPool,fakePIV,nImg,*args,**kwargs)
+  pp.parForExtPool(pfPool.parPool,fakePIV,nImg,*args,**kwargs)
+  pfPool.closeParPool()
+  pp.parFor(fakePIV,nImg,*args,**kwargs)
+  #pp.parFor(fakePIV,nImg,*args,**kwargs)
+  prTime(0,'Fine')
+  
+    
+
+if __name__ == "__main__":
+  main()