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

PaIRS_UniNa/parForWorkers.py

@@ -26,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
@@ -35,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
@@ -48,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: 
@@ -87,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=''
@@ -98,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
 
@@ -110,8 +110,10 @@ 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:
           
@@ -122,6 +124,7 @@ class MIN_ParFor_Worker(ParForWorker):
         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
@@ -172,13 +175,15 @@ 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
         
@@ -190,126 +195,52 @@ class PIV_ParFor_Worker(ParForWorker):
         self.data.mediaPIV.restoreSum()
         
         #args=(self.data,)
-        
-        
-        nPivOpt,nProcOpt=optimalPivCores(self.numUsedThreadsPIV,self.data.nimg,penCore=0.95)
-        #nProcOpt=floor(totCore/nPivOpt)#todo GP we should print the number of piv cores and processes in the  log
-        args=(self.data,nProcOpt)
-        self.data.NumThreads=nPivOpt   #numThreadsPiv
-        self.data.numUsedThreadsPIV=self.numUsedThreadsPIV# TODO GP now this is misleading we should change the name everywhere maybe numTotUsedThreads
-        #­args=(self.data,self.numUsedThreadsPIV)
-        #self.data.NumThreads=1 
-        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}  numProc={nProcOpt}  numPivProc={nPivOpt}')
+        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
-        parForFun= self.parForMul.parForExtPool if self.pfPool else self.parForMul.simpleFor
+        
+        
+        if self.pfPool:
+          self.parForMul.numUsedCores=numUsedProcs
+          parPool=self.pfPool.parPool
+          parForFun= self.parForMul.parForExtPool
+        else:
+          parPool=None
+          parForFun= self.parForMul.simpleFor
         try:
           if self.data.Step==StepTypes.piv:
-            (me,flagOut,VarOut,flagError)=parForFun(self.pfPool.parPool,procPIV,nImg,initTask=initPIV,finalTask=finalPIV, wrapUp=saveAndMean, callBack=myCallBack,*args,**kwargs)
+            (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(self.pfPool.parPool,procStereoPIV,nImg,initTask=initStereoPIV,finalTask=finalStereoPIV, wrapUp=saveAndMean, callBack=myCallBack,*args,**kwargs)
+            (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))
-          return
-        
-        try:
-          if me.cont:
-            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'
-        numCallBackTotOk+=sum(1 if x&FLAG_CALLBACK_INTERNAL else 0 for x in flagOut)            
-        
-        # Tbd 
-        '''
-        if flagDebugMem:
-          pri.Time.cyan(0,'Save results')
-          pr(f"Number of garbage element not collected before {gc.get_count()}",end='')   
-          gc.collect()
-          pr(f" after {gc.get_count()}")
-          pr(f"********************** End Fun Main -> {(memoryUsagePsutil()-m1)/ float(2 ** 20)}MByte")
-          pr(*gc.garbage)
-        '''
-        
-        
-        
-        #initTime=time()
-        self.data.flagParForCompleted=True
-        while self.numCallBackTotOk!=numCallBackTotOk :
-            pri.Process.blue (f'Error runPIVParFor self.numCallBackTotOk={self.numCallBackTotOk} numCallBackTotOk={numCallBackTotOk}    numProc={nProcOpt}  numPivProc={nPivOpt}')
-            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]}')
-    
-        #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}')
-        
-        self.data.mediaPIV=me
-        self.data.FlagFinished=self.data.nimg==numProcOrErrTot
-        self.signals.finished.emit(self.data,stringaErr)  
-
-class StereoPIV_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='SPIV_Worker',mainFun=self.runStereoPIVParFor)
-  
-  def runStereoPIVParFor(self):
-        stringaErr=''
-        global FlagStopWorkers
-        pri.Time.cyan(3,'runStereoPIVParFor')
-        FlagStopWorkers[0]=0
-        # TODEL
-        
-        flagDebugMem=False
-        if flagDebugMem:# TODEL?
-          m1=memoryUsagePsutil() 
         
-        filename_preproc=self.data.filename_proc[StepTypes.min]# todo serve?
-
-        self.data.mediaPIV.restoreSum()#todo modificare in mediaStereoPIV
-        
-        #args=(self.data,)
-        args=(self.data,self.numUsedThreadsPIV)
-        #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'runStereoPIVParFor   mediaPIV cont={self.data.mediaPIV.cont}  self.numCallBackTotOk={self.numCallBackTotOk}   self.data.nimg={self.data.nimg}')
-
-        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
-        try:
-          if self.pfPool:
-            (me,flagOut,VarOut,flagError)=self.parForMul.parForExtPool(self.pfPool.parPool,procStereoPIV,nImg,initTask=initStereoPIV,finalTask=finalStereoPIV, wrapUp=saveAndMean, callBack=myCallBack,*args,**kwargs)
-          else:
-            (me,flagOut,VarOut,flagError)=self.parForMul.simpleFor(procStereoPIV,nImg,initTask=initStereoPIV,finalTask=finalStereoPIV, wrapUp=saveAndMean, callBack=myCallBack,*args,**kwargs)
-        except Exception as e:
-          PrintTA().printEvidenced('runStereoPIVParFor exception raised\nThis should never happen ')
-          raise (e)
         if flagError: 
-          self.signals.finished.emit(self.data,printException('runStereoPIVParFor',flagMessage=True,exception=self.parForMul.exception))
+          self.signals.finished.emit(self.data,printException(outString,flagMessage=True,exception=self.parForMul.exception))
           return
         
         try:
@@ -321,7 +252,7 @@ class StereoPIV_ParFor_Worker(ParForWorker):
             nameVar=me.namesPIV.avgVel  
             saveResults(self.data,-1,Var,nameVar)
         except:
-           stringaErr+=printException('runStereoPIVParFor',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 
@@ -340,17 +271,17 @@ class StereoPIV_ParFor_Worker(ParForWorker):
         #initTime=time()
         self.data.flagParForCompleted=True
         while self.numCallBackTotOk!=numCallBackTotOk :
-            pri.Process.blue (f'Error runStereoPIVParFor 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 runStereoPIVParFor **************  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
@@ -358,8 +289,8 @@ class StereoPIV_ParFor_Worker(ParForWorker):
 
 
 class StereoDisparity_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='Disp_Worker',mainFun=self.runDisparity)
+  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 
@@ -384,6 +315,11 @@ class StereoDisparity_ParFor_Worker(ParForWorker):
       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)
@@ -398,6 +334,7 @@ class StereoDisparity_ParFor_Worker(ParForWorker):
       else:
         FlagInitError=False
 
+      """
       if self.isKilled: return self.stopDisparity(it,flagOut,flagOutIter)
       if not FlagInitError:
         self.imgs=[]
@@ -430,10 +367,28 @@ class StereoDisparity_ParFor_Worker(ParForWorker):
           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'
@@ -441,10 +396,8 @@ class StereoDisparity_ParFor_Worker(ParForWorker):
           flagOut|=FLAG_READ_ERR[kConst]
 
       #print(f'Esempio risoluzione utilizzata {self.disp.dataProc.RisxRadd} {1/self.disp.dataProc.RisxRadd}')
-      dAC=self.disp.dispAvCo
-      ve=self.disp.vect
-      sleepTimeWorkers=0.2 #for multithreading and other stuff
-      if FlagInitError: flagOut|=FLAG_FINALIZED[kConst]|FLAG_CALLBACK_INTERNAL
+      #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:
@@ -453,7 +406,7 @@ class StereoDisparity_ParFor_Worker(ParForWorker):
            else: stampa=''
            data.list_print[it]=stampa
            data.list_pim[it]=flagOut
-           self.signals.progress.emit(procID,it,flagOut,Var,stampa)
+           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 
@@ -467,13 +420,46 @@ class StereoDisparity_ParFor_Worker(ParForWorker):
         ind=it
         if self.isKilled: return self.stopDisparity(it,flagOut,flagOutIter)
         try:
-          #if it==2: 1/0  #***************** delete
+          errorType='evaluating viewing angles'
           self.disp.evaldXdY()  
           if self.isKilled: return self.stopDisparity(it,flagOut,flagOutIter)
-          for i in range( len(self.imgs) ):
-            self.disp.deWarpAndCalcCC(self.imgs[i])
+          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) 
@@ -482,13 +468,16 @@ class StereoDisparity_ParFor_Worker(ParForWorker):
           #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 processing data:\n{dum}\n"  
+          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. error    = {dAC.dOrtMean:.4g} pixels\n   Estimated laser thick.   = {dAC.DeltaZ:.4g} pixels (approx. {dAC.DeltaZ * dP.RisxRadd / abs(dAC.ta0Mean - dAC.ta1Mean):.4g} mm)\n"
+          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 ]
@@ -496,6 +485,10 @@ class StereoDisparity_ParFor_Worker(ParForWorker):
             #  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
@@ -513,15 +506,15 @@ class StereoDisparity_ParFor_Worker(ParForWorker):
                 FlagFinalized=False
               else:
                  data.res=1./self.disp.dataProc.RisxRadd
-                 data.laserConst=[const for const in ve.PianoLaser]
+                 data.laserConst=[float(const) for const in ve.PianoLaser]
           if FlagFinalized:
             flagOut|=FLAG_FINALIZED[kConst]|FLAG_CALLBACK_INTERNAL
-        finally:
-          data.list_print[it]=stampa
-          data.list_pim[it]=flagOut
-          self.signals.progress.emit(procID,ind,flagOut,Var,stampa)
-          if stringaErr: break
-          timesleep(3)
+       
+        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]=''
@@ -556,4 +549,45 @@ class StereoDisparity_ParFor_Worker(ParForWorker):
         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,'Stopped by user')  
+     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 

PaIRS_UniNa/pivParFor.py

@@ -38,16 +38,14 @@ def initPIV(eventFerma,iImg,procId,data:dataTreePar,*args,**kwargs):
   #PIV.SetVect([v.astype(np.intc) for v in data.PRO.Vect])
   if data.FlagMIN:
     data.compMin.Imin=[np.zeros(1),np.zeros(1)]
-    filename=data.filename_proc[StepTypes.min]
-    if filename:
+    for k,filename in enumerate(data.Imin[0]):
       try:
-          with open(filename, 'rb') as file:
-              data_min:dataTreePar = pickle.load(file)
-          data.copyfromfields(data_min,['compMin'])
+        data.compMin.Imin[k]=np.ascontiguousarray(Image.open(filename))
       except Exception as inst:  
-          raise (inst)
-          #data.INP.flag_min=False        
-        
+          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
@@ -59,7 +57,7 @@ def exitNoLog(flagOut,varOut):
   ''' exit without printing the log '''
   varOut[0]=-1
   return (flagOut,varOut)
-def procPIV(i,procId ,PIV,data:dataTreePar,numUsedThreadsPIV,*args,**kwargs):
+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:
@@ -80,7 +78,7 @@ def procPIV(i,procId ,PIV,data:dataTreePar,numUsedThreadsPIV,*args,**kwargs):
     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\'
+    pa='C:\\desk\\dl\\apairs\\jetcross\\'
     no='zR2jet0_0004a'
     I =imread([pa no '.png']);
     I=I*0+1;
@@ -182,7 +180,7 @@ def procPIV(i,procId ,PIV,data:dataTreePar,numUsedThreadsPIV,*args,**kwargs):
   
   # to del  ma il resto dove va
   #varOut=[i,stampa,[]] if flagOut&FLAG_FINALIZING_PROC_OK[0] else [-1,stampa,[]]
-  if (not procId%numUsedThreadsPIV) and flagOut&FLAG_FINALIZED[0]: # copiare l'img nella coda è un operazione onerosa. TA ha deciso che si copia solo quando serve
+  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]
   

PaIRS_UniNa/preProcParFor.py

@@ -19,7 +19,7 @@ def initMIN(eventFerma,iImg,procId,data:dataTreePar,*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):
+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:
@@ -98,15 +98,15 @@ def procMIN(i,procId,compMin:CompMin,data:dataTreePar,numUsedThreadsPIV,*args,**
     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
+  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,numUsedThreadsPIV,*args,**kwargs):
+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,numUsedThreadsPIV,*args,**kwargs):
+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: