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

PaIRS_UniNa/parForMulti.py

@@ -167,15 +167,16 @@ class ParForMul():
     id is the id of the task should be a numeber between 1 and numUsedCores'''
     return ('finalTask',2)
 
-  def launchTask(self,task,initTask,finalTask,  *args,**kwargs):
+  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
+      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} ")
@@ -253,7 +254,7 @@ class ParForMul():
       com.q.put((-1,-1))
 
     for i  in range(self.numUsedCores):
-      _=parPool.apply_async(self.launchTask,(task, initTask,finalTask)+args,kwargs,callback=callWrapUp, error_callback=self.errorHandler)      
+      _=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
@@ -285,7 +286,7 @@ class ParForMul():
   
     return self.p,flagProcessed,strOutput,self.flagError  
 
-  def simpleFor(self,task,names,*args,initTask=None,finalTask=None,wrapUp=None,callBack=None,**kwargs):
+  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
@@ -314,7 +315,8 @@ class ParForMul():
     for _  in range(1):
       com.q.put((-1,-1))
     #with mp.Pool(self.numUsedCores) as pp:
-    var=self.launchTask(task, initTask,finalTask,*args,**kwargs)
+    procId=0
+    var=self.launchTask(procId,task, initTask,finalTask,*args,**kwargs)
     callWrapUp(var)
     nThreadEnd=0
     while True:

PaIRS_UniNa/parForWorkers.py

@@ -13,6 +13,7 @@ from .PaIRS_pypacks import *
 
 from .preProcParFor import *
 from .pivParFor import *
+from .stereoPivParFor import *
 
 prTime = PrintTA(PrintTA.yellow, PrintTA.faceStd,  PrintTAPriority.medium).prTime
 
@@ -25,7 +26,7 @@ class WorkerSignals(QObject):
     kill = Signal(int)
 
 class ParForWorker(QRunnable):
-    def __init__(self,data:dataTreePar,indWorker:int,indProc:int,numUsedThreadsPIV:int,pfPool:ParForPool,parForMul:ParForMul,nameWorker:str,mainFun:Callable):
+    def __init__(self,data:dataTreePar,indWorker:int,indProc:int,numMaxProcs:int,pfPool:ParForPool,parForMul:ParForMul,nameWorker:str,mainFun:Callable):
         #super(MIN_ParFor_Worker,self).__init__(data,indWorker,indProc,pfPool=ParForPool,parForMul=ParForMul)
         super().__init__()
         self.pfPool=pfPool
@@ -34,7 +35,7 @@ class ParForWorker(QRunnable):
         self.data=data.duplicate() #OPTIMIZE TA GP controllare se le modifiche fatte nel workers interferiscono con quelle fatte in progress_proc ed eventualmente evitare l'aggiornamento in resetProc e in store_proc
         self.indWorker = indWorker
         self.indProc = indProc
-        self.numUsedThreadsPIV=numUsedThreadsPIV
+        self.numMaxProcs=numMaxProcs
         self.signals=WorkerSignals()
         self.isKilled = False
         self.isStoreCompleted = False
@@ -47,7 +48,7 @@ class ParForWorker(QRunnable):
         if Flag_DEBUG_PARPOOL: debugpy.debug_this_thread()
         try:
             #pr(f'ParForWorker.run self.isKilled={self.isKilled}  self.indWorker={self.indWorker}  self.indProc={self.indProc}  ')
-            self.parForMul.numUsedCores=self.numUsedThreadsPIV
+            self.parForMul.numUsedCores=self.numMaxProcs
             while self.indWorker!=self.indProc:# and not self.isKilled:
                 timesleep(SleepTime_Workers) 
                 if self.isKilled: 
@@ -59,14 +60,11 @@ class ParForWorker(QRunnable):
             Message=printException('ParForWorker',flagMessage=True)
             self.signals.finished.emit(self.data,Message)
         #finally:#also after return eliminated
-        pri.Process.blue(f'End of ParForWorker {self.nameWorker} ({self.indWorker}, {self.numCallBackTotOk} )')
         while not self.isStoreCompleted:
            timesleep(SleepTime_Workers) 
         self.signals.completed.emit()
-        
-        
-        
-                    
+        pri.Process.blue(f'End of ParForWorker {self.nameWorker} ({self.indWorker}, {self.numCallBackTotOk} )')
+                      
     @Slot()
     def killOrReset(self,isKilled):
         #pr('\n***********************\n*************************    ParForWorker.die {isKilled}')
@@ -89,8 +87,8 @@ class ParForWorker(QRunnable):
        self.isStoreCompleted=True
 
 class MIN_ParFor_Worker(ParForWorker):
-  def __init__(self,data:dataTreePar,indWorker:int,indProc:int,numUsedThreadsPIV:int,pfPool:ParForPool,parForMul:ParForMul):
-    super().__init__(data,indWorker,indProc,numUsedThreadsPIV,pfPool,parForMul,nameWorker='calcMin_Worker',mainFun=self.calcmin)
+  def __init__(self,data:dataTreePar,indWorker:int,indProc:int,numMaxProcs:int,pfPool:ParForPool,parForMul:ParForMul):
+    super().__init__(data,indWorker,indProc,numMaxProcs,pfPool,parForMul,nameWorker='calcMin_Worker',mainFun=self.calcmin)
 
   def calcmin(self):
         stringaErr=''
@@ -100,10 +98,10 @@ class MIN_ParFor_Worker(ParForWorker):
         
         #pp=ParForMul()
         #pp.sleepTime=ParFor_sleepTime #time between calls of callBack
-        #pp.numCoresParPool=numUsedThreadsPIV
+        #pp.numCoresParPool=numMaxProcs
         
         self.data.compMin.restoreMin()
-        args=(self.data,self.numUsedThreadsPIV)
+        args=(self.data,self.numMaxProcs)
         kwargs={} 
         numCallBackTotOk=self.data.numFinalized  #su quelli non finalized ci ripassiamo quindi inizialmente il num di callback ok = num di finalized
 
@@ -112,14 +110,21 @@ class MIN_ParFor_Worker(ParForWorker):
         
         myCallBack=lambda a,b,c,d,e,f: callBackMin(a,b,c,d,e,f,self.signals.progress)
         #for ii,f in enumerate(self.data.list_pim):          pr(f'{ii}-{hex(f)}  ',end='')
-        pri.Process.blue(f'Init calcmin Contab={self.data.compMin.contab}   numCallBackTotOk={numCallBackTotOk}  numUsedThreadsPIV={self.numUsedThreadsPIV}')
+        pri.Process.blue(f'Init calcmin Contab={self.data.compMin.contab}   numCallBackTotOk={numCallBackTotOk}  numMaxProcs={self.numMaxProcs}')
         self.signals.initialized.emit()
+      
+        self.parForMul.numUsedCores=self.numMaxProcs
         #TBD TA all the exceptions should be managed inside parForExtPool therefore the try should be useless just in case I check
         try:
-          (mi,flagOut,VarOut,flagError)=self.parForMul.parForExtPool(self.pfPool.parPool,procMIN,nImg,initTask=initMIN,finalTask=finalMIN, wrapUp=saveAndMin, callBack=myCallBack,*args,**kwargs)
+          
+          if self.pfPool:
+            (mi,flagOut,VarOut,flagError)=self.parForMul.parForExtPool(self.pfPool.parPool,procMIN,nImg,initTask=initMIN,finalTask=finalMIN, wrapUp=saveAndMin, callBack=myCallBack,*args,**kwargs)
+          else:
+            (mi,flagOut,VarOut,flagError)=self.parForMul.simpleFor(procMIN,nImg,initTask=initMIN,finalTask=finalMIN, wrapUp=saveAndMin, callBack=myCallBack,*args,**kwargs)
         except Exception as e:  
           PrintTA().printEvidenced('Calcmin exception raised.\nThis should never happen.')
           raise (e)
+        
         if flagError: 
           self.signals.finished.emit(self.data,printException('calcmin',flagMessage=True,exception=self.parForMul.exception))
           return
@@ -170,55 +175,84 @@ class MIN_ParFor_Worker(ParForWorker):
         self.signals.finished.emit(self.data,stringaErr)
 
 class PIV_ParFor_Worker(ParForWorker):
-  def __init__(self,data:dataTreePar,indWorker:int,indProc:int,numUsedThreadsPIV:int,pfPool:ParForPool,parForMul:ParForMul):
-    super().__init__(data,indWorker,indProc,numUsedThreadsPIV,pfPool,parForMul,nameWorker='PIV_Worker',mainFun=self.runPIVParFor)
+  def __init__(self,data:dataTreePar,indWorker:int,indProc:int,numMaxProcs:int,pfPool:ParForPool,parForMul:ParForMul):
+    super().__init__(data,indWorker,indProc,numMaxProcs,pfPool,parForMul,nameWorker='PIV_Worker',mainFun=self.runPIVParFor)
   
-  def runPIVParFor(self):
+  def runPIVParFor(self):#unified function for piv and Stereo
         stringaErr=''
         global FlagStopWorkers
-        pri.Time.cyan(3,'runPIVParFor')
+
+        outString='runPIVParFor' if self.data.Step==StepTypes.piv else 'runStereoPIVParFor'
+        pri.Time.cyan(3,outString)
         FlagStopWorkers[0]=0
         # TODEL
         
         flagDebugMem=False
         if flagDebugMem:# TODEL?
           m1=memoryUsagePsutil() 
-        filename_preproc=self.data.filename_proc[dataTreePar.typeMIN]
+        filename_preproc=self.data.filename_proc[StepTypes.min]
 
         self.data.mediaPIV.restoreSum()
         
         #args=(self.data,)
-        args=(self.data,self.numUsedThreadsPIV)
-        kwargs={'finalPIVPIppo': self.data.nimg}#unused just for example
+        '''
+        if self.pfPool:#normal condition 
+          #todo GP we should print the number of piv cores and processes in the  log
+          numPivOmpCores,numUsedProcs=optimalPivCores(self.numMaxProcs,self.data.nimg,penCore=0.95)
+          self.data.numUsedProcs=numUsedProcs # self.data.numUsedProcs is used for output should be the number of parfor threads used 
+          self.data.numPivOmpCores=numPivOmpCores   
+        else:# serial par for used only for debugging  the c library
+          self.data.numUsedProcs=numUsedProcs=1 # self.data.numUsedProcs is used for output should be the number of parfor threads used 
+          self.data.numPivOmpCores=numPivOmpCores=self.numMaxProcs   
+        self.data.numUsedProcs=numUsedProcs=1 # self.data.numUsedProcs is used for output should be the number of parfor threads used 
+        self.data.numPivOmpCores=numPivOmpCores=2#self.numMaxProcs   '''
+        numPivOmpCores=self.data.numPivOmpCores
+        numUsedProcs=self.data.numUsedProcs
+        args=(self.data,numUsedProcs)
+        #kwargs={'finalPIVPIppo': self.data.nimg}#unused just for example
         kwargs={}
         numCallBackTotOk=self.data.numFinalized  #su quelli non finalized ci ripassiamo quindi inizialmente il num di callback ok = num di finalized
 
 
         nImg=range(self.data.nimg)
         myCallBack=lambda a,b,c,d,e,f: callBackPIV(a,b,c,d,e,f,self.signals.progress)
-        pri.Process.blue(f'runPIVParFor   mediaPIV cont={self.data.mediaPIV.cont}  self.numCallBackTotOk={self.numCallBackTotOk}   self.data.nimg={self.data.nimg}')
+        pri.Process.blue(f'{outString}   mediaPIV cont={self.data.mediaPIV.cont}  self.numCallBackTotOk={self.numCallBackTotOk}   self.data.nimg={self.data.nimg}  numProc={numUsedProcs}  numPivProc={numPivOmpCores}')
 
         self.signals.initialized.emit()
         #TBD TA all the exceptions should be managed inside parForExtPool therefore the try should be useless just in case I check
+        
+        
+        if self.pfPool:
+          self.parForMul.numUsedCores=numUsedProcs
+          parPool=self.pfPool.parPool
+          parForFun= self.parForMul.parForExtPool
+        else:
+          parPool=None
+          parForFun= self.parForMul.simpleFor
         try:
-          (me,flagOut,VarOut,flagError)=self.parForMul.parForExtPool(self.pfPool.parPool,procPIV,nImg,initTask=initPIV,finalTask=finalPIV, wrapUp=saveAndMean, callBack=myCallBack,*args,**kwargs)
+          if self.data.Step==StepTypes.piv:
+            (me,flagOut,VarOut,flagError)=parForFun(parPool,procPIV,nImg,initTask=initPIV,finalTask=finalPIV, wrapUp=saveAndMean, callBack=myCallBack,*args,**kwargs)
+          elif self.data.Step==StepTypes.spiv:
+            (me,flagOut,VarOut,flagError)=parForFun(parPool,procStereoPIV,nImg,initTask=initStereoPIV,finalTask=finalStereoPIV, wrapUp=saveAndMean, callBack=myCallBack,*args,**kwargs)
+          
         except Exception as e:
-          PrintTA().printEvidenced('Calcmin exception raised\nThis should never happen ')
+          PrintTA().printEvidenced(f'{outString} exception raised\nThis should never happen ')
           raise (e)
+        
         if flagError: 
-          self.signals.finished.emit(self.data,printException('calcmin',flagMessage=True,exception=self.parForMul.exception))
+          self.signals.finished.emit(self.data,printException(outString,flagMessage=True,exception=self.parForMul.exception))
           return
         
         try:
           if me.cont:
-            me:mediaPIV
+            me:MediaPIV
             me.calcMedia()
             nameFields=me.namesPIV.avgVelFields
             Var=[getattr(me,f) for f in nameFields ]#me.x,me.y,me.u,me.v,me.up,me.vp,me.uvp,me.sn,me.Info]
             nameVar=me.namesPIV.avgVel  
             saveResults(self.data,-1,Var,nameVar)
         except:
-           stringaErr+=printException('calcmin',flagMessage=True,exception=self.parForMul.exception)+'\n'
+           stringaErr+=printException(outString,flagMessage=True,exception=self.parForMul.exception)+'\n'
         numCallBackTotOk+=sum(1 if x&FLAG_CALLBACK_INTERNAL else 0 for x in flagOut)            
         
         # Tbd 
@@ -237,18 +271,323 @@ class PIV_ParFor_Worker(ParForWorker):
         #initTime=time()
         self.data.flagParForCompleted=True
         while self.numCallBackTotOk!=numCallBackTotOk :
-            pri.Process.blue (f'Error runPIVParFor self.numCallBackTotOk={self.numCallBackTotOk} numCallBackTotOk={numCallBackTotOk}    numUsedThreadsPIV={self.numUsedThreadsPIV}')
+            pri.Process.blue (f'Error {outString} self.numCallBackTotOk={self.numCallBackTotOk} numCallBackTotOk={numCallBackTotOk}    numUsedProcs={numUsedProcs}  numPivOmpCores={numPivOmpCores}')
             timesleep(SleepTime_Workers)
                
-        if me.cont:
-          pri.Time.cyan(f'u={me.u[5][4]} v={me.v[5][4]}  up={me.up[5][4]} vp={me.vp[5][4]} uvp={me.uvp[5][4]} sn={me.sn[5][4]} Info={me.Info[5][4]}')
+        #if me.cont:
+        #  pri.Time.cyan(f'u={me.u[5][4]} v={me.v[5][4]}  up={me.up[5][4]} vp={me.vp[5][4]} uvp={me.uvp[5][4]} sn={me.sn[5][4]} Info={me.Info[5][4]}')
     
         #self.numFinalized=sum(1 if f&FLAG_FINALIZED[0]  else 0 for f  in flagOut)   
         numProcOrErrTot=sum(1 if f else 0 for f  in flagOut)   
 
         #for ii,f in enumerate(flagOut):          pr(f'{ii}-{hex(f)}  ',end='')
-        pri.Process.blue (f'Fine runPIVParFor **************  numCallBackTotOk={numCallBackTotOk}  numProcOrErrTot={numProcOrErrTot} numFinalized={self.data.numFinalized}')
+        pri.Process.blue (f'Fine {outString} **************  numCallBackTotOk={numCallBackTotOk}  numProcOrErrTot={numProcOrErrTot} numFinalized={self.data.numFinalized}')
         
         self.data.mediaPIV=me
         self.data.FlagFinished=self.data.nimg==numProcOrErrTot
         self.signals.finished.emit(self.data,stringaErr)  
+
+
+class StereoDisparity_ParFor_Worker(ParForWorker):
+  def __init__(self,data:dataTreePar,indWorker:int,indProc:int,numMaxProcs:int,pfPool:ParForPool,parForMul:ParForMul):
+    super().__init__(data,indWorker,indProc,numMaxProcs,pfPool,parForMul,nameWorker='Disp_Worker',mainFun=self.runDisparity)
+
+  def runDisparity(self):
+      ''' 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
+      '''
+      self.signals.initialized.emit()
+      data=self.data
+      
+      it=0
+      Var=[]
+      procID=-1
+
+      flagOut=flagOutIter=0
+      kConst=0
+      self.disp=data2Disp(data)
+      spivIn=self.disp.SPIVIn
+      dP=self.disp.dataProc
+      dAC=self.disp.dispAvCo
+      ve=self.disp.vect
+      ve.PianoLaser[0]=np.float32(data.OUT_dict['zconst'])
+      ve.PianoLaser[1]=np.float32(data.OUT_dict['xterm'])
+      ve.PianoLaser[2]=np.float32(data.OUT_dict['yterm'])
+
+      stringaErr=''
+      if self.isKilled: return self.stopDisparity(it,flagOut,flagOutIter)
+      try:
+        #1/0  #***************** delete
+        self.disp.evalCommonZone()
+      except Exception as inst: #ValueError as exc:
+        FlagInitError=True
+        stringaErr=f'\n!!!!!!!!!! Error while evaluating common region:\n{inst}\n'
+        pri.Error.red(stringaErr)
+        flagOut|=FLAG_READ_ERR[kConst]
+      else:
+        FlagInitError=False
+
+      """
+      if self.isKilled: return self.stopDisparity(it,flagOut,flagOutIter)
+      if not FlagInitError:
+        self.imgs=[]
+        ind=np.ix_(np.arange(spivIn.RigaPart,spivIn.RigaPart+dP.ImgH),np.arange(spivIn.ColPart,spivIn.ColPart+dP.ImgW))
+        #data.list_Image_Files[c][f][k]
+        imList=data.list_Image_Files
+        for p in range(len(imList[0][0])):
+          if self.isKilled: return self.stopDisparity(it,flagOut,flagOutIter)
+          ic=[]
+          #print(f'reading {p}')
+          try:
+            for cam in range(len(imList[0])):
+              da=db=None
+              if spivIn.FlagImgTau in (0,1):
+                if self.isKilled: return self.stopDisparity(it,flagOut,flagOutIter)
+                nomeImg=data.inpPath+imList[cam][0][p]
+                da=np.ascontiguousarray(np.array(Image.open(nomeImg),dtype=float)[ind],dtype= np.uint16)
+              if spivIn.FlagImgTau in (0,2):
+                if self.isKilled: return self.stopDisparity(it,flagOut,flagOutIter)
+                nomeImg=data.inpPath+imList[cam][1][p]
+                db=np.ascontiguousarray(np.array(Image.open(nomeImg),dtype=float)[ind],dtype= np.uint16)
+             
+              ic.append([da,db])
+          except Exception as inst: #ValueError as exc:
+            FlagInitError=True
+            stringaErr=f"\n!!!!!!!!!! Error while reading the image {nomeImg}:\n{inst}\n" 
+            pri.Error.red(stringaErr)
+            flagOut|=FLAG_READ_ERR[kConst]
+            break
+          else:
+            self.imgs.append(ic)
+            #self.imgs.append(np.ascontiguousarray(da[spivIn.RigaPart:spivIn.RigaPart+dP.ImgH,spivIn.ColPart:spivIn.ColPart+dP.ImgW],dtype= np.uint16))
+      """
+
+      imList=data.list_Image_Files
+      indim=np.ix_(np.arange(spivIn.RigaPart,spivIn.RigaPart+dP.ImgH),np.arange(spivIn.ColPart,spivIn.ColPart+dP.ImgW))
+      if data.FlagMIN:
+        data.compMin.Imin=[[np.zeros(1) for _ in range(data.nframe)] for _ in range(data.ncam)]
+        for c,Iminc in enumerate(data.Imin):
+          for k,filename in enumerate(Iminc):
+            try:
+              data.compMin.Imin[c][k]=np.ascontiguousarray(np.array(Image.open(filename),dtype=float)[indim],dtype= np.uint16)
+            except Exception as inst:  
+                FlagInitError=True
+                stringaErr=f'\n!!!!!!!!!! Error while reading background image {filename}:\n{inst}\n'
+                pri.Error.red(stringaErr)
+                flagOut|=FLAG_READ_ERR[kConst]
+                break
+            
+      if not FlagInitError:
+        if self.isKilled: return self.stopDisparity(it,flagOut,flagOutIter)
+        try:
+          self.disp.initAllocDisp()
+          self.disp.dispAvCo.NImg=2*len(imList[0][0]) if spivIn.FlagImgTau==0 else len(imList[0][0])
+        except Exception as inst: #ValueError as exc:
+          FlagInitError=True
+          stringaErr=f'\n!!!!!!!!!! Error during disparity process initialization:\n{inst}\n'
+          pri.Error.red(stringaErr)
+          flagOut|=FLAG_READ_ERR[kConst]
+
+      #print(f'Esempio risoluzione utilizzata {self.disp.dataProc.RisxRadd} {1/self.disp.dataProc.RisxRadd}')
+      #sleepTimeWorkers=0.2 #for multithreading and other stuff
+      #if FlagInitError: flagOut|=FLAG_FINALIZED[kConst]|FLAG_CALLBACK_INTERNAL
+      flagOutIter=FLAG_READ[kConst]
+      for it in range(spivIn.Niter):
+        if FlagInitError:
+           if data.list_pim[it]&FLAG_READ_ERR[kConst]: ind=-1# no log already written
+           if it==0: stampa=stringaErr
+           else: stampa=''
+           data.list_print[it]=stampa
+           data.list_pim[it]=flagOut
+           self.signals.progress.emit(procID,-1,flagOut,Var,stringaErr)
+           continue
+        if data.list_pim[it]&FLAG_FINALIZED[kConst]:
+          flagOut=FLAG_READ[kConst]|FLAG_PROC[kConst]|FLAG_FINALIZED[kConst]  # It has been already processed. Exit without calling the callback  core 
+          stampa=''
+          ind=-1
+          self.signals.progress.emit(procID,ind,flagOut,Var,stampa)
+          continue
+        flagOut=flagOutIter
+        Var=[]
+        stampa=f"Iteration {it+1}\n"
+        ind=it
+        if self.isKilled: return self.stopDisparity(it,flagOut,flagOutIter)
+        try:
+          errorType='evaluating viewing angles'
+          self.disp.evaldXdY()  
+          if self.isKilled: return self.stopDisparity(it,flagOut,flagOutIter)
+          for p in range(len(imList[0][0])):
+            if self.isKilled: return self.stopDisparity(it,flagOut,flagOutIter)
+            ic=[]
+            #print(f'reading {p}')
+            for cam in range(len(imList[0])):
+              da=db=None
+              if spivIn.FlagImgTau in (0,1):
+                if self.isKilled: return self.stopDisparity(it,flagOut,flagOutIter)
+                nomeImg=data.inpPath+imList[cam][0][p]
+                errorType=f'reading the image {nomeImg}'
+                da=np.ascontiguousarray(np.array(Image.open(nomeImg),dtype=float)[indim],dtype= np.uint16)
+                if data.FlagMIN:
+                  if data.FlagTR and p%2:
+                    da=da-data.compMin.Imin[cam][1]
+                  else:
+                    da=da-data.compMin.Imin[cam][0]
+                  da=np.ascontiguousarray(da,dtype= np.uint16)
+              if spivIn.FlagImgTau in (0,2):
+                if self.isKilled: return self.stopDisparity(it,flagOut,flagOutIter)
+                nomeImg=data.inpPath+imList[cam][1][p]
+                errorType=f'reading the image {nomeImg}'
+                db=np.ascontiguousarray(np.array(Image.open(nomeImg),dtype=float)[indim],dtype= np.uint16)
+                if data.FlagMIN:
+                  if data.FlagTR and p%2:
+                    db=db-data.compMin.Imin[cam][0]
+                  else:
+                    db=db-data.compMin.Imin[cam][1]
+                  db=np.ascontiguousarray(db,dtype= np.uint16)
+            
+              ic.append([da,db])
+            
+            errorType=f'dewarping and computing disparity ({imList[0][0][p]},...,{imList[1][1][p]})'
+            self.disp.deWarpAndCalcCC(ic)
+            #while self.disp.flagWorking==2:# and not self.isKilled:            sleep (sleepTimeWorkers) 
+            if self.isKilled: return self.stopDisparity(it,flagOut,flagOutIter)
+          
+          errorType=f'computing the laser plane constants'
+          self.disp.calcDisparity()
+          if self.isKilled: return self.stopDisparity(it,flagOut,flagOutIter)
+          #while self.disp.flagWorking==2:# and not self.isKilled:          sleep (sleepTimeWorkers) 
+        except Exception as inst:
+          if (data.list_pim[it]&FLAG_READ[kConst]): ind=-1# no log already written
+          #dum=str(inst.__cause__).split('\n')[3] #solved
+          dum=str(inst.args[0])
+          #varOut[1]+=f"\n!!!!!!!!!! Error while processing the above image pair: {dum}"  
+          errorPrint=f"!!!!!!!!!! Error while {errorType}:\n{dum}\n"  
+          stampa+=errorPrint  
+          stringaErr+=stampa
+          pri.Error.red(stringaErr)
+        else:
+          flagOut|=FLAG_PROC[kConst]# per completezza aggiungo anche processato
+          stampa+=f"   Laser plane eq. :  z (mm) = {ve.PianoLaser[0]:.4g} + {ve.PianoLaser[1]:.4g} * x + {ve.PianoLaser[2]:.4g} * y\n   Residual calib. err. ort. = {dAC.dOrtMean:.4g} pixels\n   Residual calib. err. par. = {dAC.dParMean:.4g} pixels\n   Estimated laser thick.    = {dAC.DeltaZ:.4g} pixels (approx. {dAC.DeltaZ * dP.RisxRadd / abs(dAC.ta0Mean - dAC.ta1Mean):.4g} mm)\n   Outliers %                = {dAC.percOutlier*100:g} \n"
+          data.OUT_dict['zconst']=float(ve.PianoLaser[0])
+          data.OUT_dict['xterm']=float(ve.PianoLaser[1])
+          data.OUT_dict['yterm']=float(ve.PianoLaser[2])
+          try:
+            nameVar=data.namesPIV.instVel 
+            Var=[getattr(self.disp.vect,f) for f in nameVar ]
+            #if it==spivIn.Niter-1:
+            #  saveResults(data,-1,Var,nameVar)
+            #else:
+            saveResults(data,f'it{it+1}',Var,nameVar)
+            CC_rot=self.create_CC_image(self.disp.vect.CCrot)
+            nameFileOut=data.resF(f'it{it+1}',string='dispMap')
+            self.save_CC_image(CC_rot,nameFileOut)
+            pass
+          except Exception as inst:
+            errorPrint=f"\n!!!!!!!!!! Error while saving the results:\n{str(inst)}\n"
+            stampa+=errorPrint
+            stringaErr+=stampa
+            pri.Error.red(stringaErr)
+            FlagFinalized=False
+          else:
+            FlagFinalized=True
+            if it==spivIn.Niter-1:
+              errorPrint=self.writeLaserPlaneConst(filename=data.outPathRoot+'.clz',planeConst=ve.PianoLaser,resolution=self.disp.dataProc.RisxRadd)
+              if errorPrint:
+                stampa+=errorPrint
+                stringaErr+=stampa
+                pri.Error.red(stringaErr)
+                FlagFinalized=False
+              else:
+                 data.res=1./self.disp.dataProc.RisxRadd
+                 data.laserConst=[float(const) for const in ve.PianoLaser]
+          if FlagFinalized:
+            flagOut|=FLAG_FINALIZED[kConst]|FLAG_CALLBACK_INTERNAL
+       
+        data.list_print[it]=stampa
+        data.list_pim[it]=flagOut
+        self.signals.progress.emit(procID,ind,flagOut,Var,stampa)
+        if stringaErr: break
+        timesleep(3)
+      
+      for j in range(it+1,spivIn.Niter):
+        data.list_print[j]=''
+        data.list_pim[j]=flagOut
+        self.signals.progress.emit(procID,j,flagOut,[],'')
+
+      self.data.FlagFinished=True
+      self.signals.finished.emit(data,stringaErr)  
+
+  def writeLaserPlaneConst(self,filename:str, planeConst:list, resolution:float):
+      try:
+        with open(filename, "w") as cfg:
+            cfg.write(f"%SP00007\n")
+            cfg.write(f"% Used resolution={1 / resolution:.6g}pix/mm\n")
+            cfg.write(f"% Laser plane constants\n")
+            cfg.write(f"{planeConst[0]:.14e},\n")
+            cfg.write(f"{planeConst[1]:.14e},\n")
+            cfg.write(f"{planeConst[2]:.14e},\n")
+      except Exception as inst:
+        errorPrint=f"\n!!!!!!!!!! Error while saving the results:\n{str(inst)}\n"
+          #pri.Error.red(f'Error while saving the laser plane constants!\n{traceback.format_exc()}\n')
+      else:
+        errorPrint=''
+      return errorPrint
+  
+  def stopDisparity(self,it,flagOut,flagOutIter):
+     procID=-1
+     ind=-1
+     data=self.data
+     spivIn=self.disp.SPIVIn
+     for j in range(it,spivIn.Niter):
+        data.list_print[j]=''
+        data.list_pim[j]=flagOut if j==it else flagOutIter
+        self.signals.progress.emit(procID,ind,flagOutIter,[],'')
+     self.signals.finished.emit(data,'')  
+
+
+  def create_CC_image(self,CC):
+    # Get the dimensions of the input matrix
+    n, m, h, w = CC.shape
+
+    # Normalize the matrix values to the range [0, 65535]
+    CC_min = CC.min()
+    CC_max = CC.max()
+    CC_mean = 0.5*(CC_min+CC_max)
+    CC_mean_normalized = (CC_mean + 1.0)/2.0 * 65535
+
+    CC_normalized = (CC + 1.0)/2.0 * 65535
+    CC_normalized = CC_normalized.astype(np.uint16)  # Convert to 16-bit integers
+
+    # Initialize the final image grid with the correct size
+    h=2*self.disp.dispAvCo.N_NormEpi+1
+    grid_height = h * n
+    grid_width  = w * m
+    CC_rot = np.zeros((grid_height, grid_width), dtype=np.uint16)
+
+    # Populate the grid with submatrices
+    try:
+      for i in range(n):
+          for j in range(m):
+              # Copy the submatrix (w x h) into the appropriate position in the grid
+              CC_rot[i*h:(i+1)*h, j*w:(j+1)*w] = CC_normalized[i, j, :h, :]
+              CC_rot[i*h, j*w:(j+1)*w] = CC_mean_normalized
+              CC_rot[i*h:(i+1)*h, j*w] = CC_mean_normalized
+              CC_rot[(i+1)*h-1, j*w:(j+1)*w] = CC_mean_normalized
+              CC_rot[i*h:(i+1)*h, (j+1)*w-1] = CC_mean_normalized
+    except:
+       pri.Error.red(f'Error while generating disparity map image:\n{traceback.format_exc()}\n\n')
+       pass
+
+    return CC_rot
+  
+  def save_CC_image(self,CC,file_path):
+    image = Image.fromarray(CC)
+    image.save(file_path)
+    return