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

PaIRS_UniNa/procTools.py

@@ -1,5 +1,6 @@
 ''' 2d PIV helper function for parfor   '''
 from  datetime import timedelta
+import os.path
 
 # In hex is easy 0606 both read and processed 01234156789abcdef 
 FLAG_READ_ERR = [1, 1<<8] #2, 256=                    0001    1   0001 0000 0000
@@ -19,87 +20,140 @@ FLAG_FINALIZED_OR_ERR = [ p|e for (p,e) in zip(FLAG_FINALIZED,FLAG_READ_ERR)]
 # per annullare un bit f=f& (~FLAG_CALLBACK)
 
 from .PaIRS_pypacks import*
-from .Import_Tab import INPpar as INPpar
-from .Export_Tab import OUTpar as OUTpar
-from .Export_Tab import outType_items
+from .Input_Tab import INPpar as INPpar
+from .Output_Tab import OUTpar as OUTpar
+from .Output_Tab import outType_dict
 from .Process_Tab import PROpar as PROpar
+from .Process_Tab_Min import PROpar_Min as PROpar_Min
+from .Process_Tab_Disp import PROpar_Disp as PROpar_Disp
 from .Vis_Tab import VISpar as VISpar
 from .Vis_Tab import NamesPIV
 from .TabTools import TABpar
+from .readcfg import readCalFile
 from .__init__ import __version__,__subversion__,__year__
 
+processData = {
+        ProcessTypes.min:  {'name': 'Pre-process', 'caption': 'Pre-process analysis of a set of images aimed at computing historical minimum background',
+         'class': 0, 'icon': 'min_proc.png', 
+         'children': {StepTypes.min:True}, 'mandatory': [StepTypes.min]},
+        ProcessTypes.piv:  {'name': 'PIV process', 'caption': 'Particle Image Velocimetry analysis for computation of the two-dimensional two-component velocity field',
+         'class': 0, 'icon': 'piv_proc.png', 
+         'children': {StepTypes.min:False,StepTypes.piv:True}, 'mandatory': [StepTypes.piv]},
+        ProcessTypes.cal: {'name': 'Calibration', 'caption': 'Accurate optical calibration of single and multiple camera bundles',
+         'class': 0, 'icon': 'cal_proc.png', 
+         'children': {StepTypes.cal:True}, 'mandatory': [StepTypes.cal]},   
+        ProcessTypes.spiv:  {'name': 'Stereo-PIV process', 'caption': 'Stereoscopic Particle Image Velocimetry analysis for computation of the two-dimensional three-component velocity field',
+         'class': 0, 'icon': 'spiv_proc.png', 
+         'children': {StepTypes.cal:True,StepTypes.min:False,StepTypes.disp:True,StepTypes.spiv:True},'mandatory': [StepTypes.cal]},
+        }
+for p in processData:
+    processData[p]['type']=p
+    
+stepData= {
+        StepTypes.cal: {'name': 'Camera calibration', 'caption': 'Select an appropriate camera model and estimate the parameters of the mapping functions based on calibration target images',
+         'class': 1, 'icon': 'cal_step.png', 'parents': [],
+         'tabs': ['Calibration','Input_CalVi','Process_CalVi','Vis_CalVi'], },    
+        StepTypes.min: {'name': 'Image pre-processing', 'caption': 'Select a set of particle images and compute the historical minimum background for subsets corresponding to the same laser light source',
+         'class': 1, 'icon': 'min_step.png', 'parents': [],
+         'tabs': ['Input','Output','Process_Min','Log','Vis'], },        
+        StepTypes.piv: {'name': 'PIV analysis', 'caption': 'Select a set of particle images, craft a custom iterative multi-grid method and compute the two-dimensional two-component displacement field',
+         'class': 1, 'icon': 'piv_step.png', 'parents': [],
+         'tabs': ['Input','Output','Process','Log','Vis'], },   
+        StepTypes.disp: {'name': 'Disparity correction', 'caption': 'Select a a set of particle images and compute the laser sheet position and orientation to adjust the camera disparities in the stereo-setup',
+         'class': 1, 'icon': 'disp_step.png', 'parents': [StepTypes.cal],
+         'tabs': ['Input','Output','Process_Disp','Log','Vis'], },   
+        StepTypes.spiv: {'name': 'Stereoscopic PIV analysis', 'caption': 'Select a set of particle images, craft a custom iterative multi-grid method and compute the two-dimensional three-component displacement field',
+         'class': 1, 'icon': 'piv_step.png', 'parents': [StepTypes.cal,StepTypes.disp],
+         'tabs': ['Input','Output','Process','Log','Vis'], },   
+         }
+for p in stepData:
+    stepData[p]['type']=p
 
 class dataTreePar(TABpar):
-    nTypeProc=3
-    typeNull=0
-    typeMIN=1
-    typePIV=2
-
-    def __init__(self,*args):
-        typeProc=0
-        flagRun=0
-        if len(args): typeProc=args[0]
-        if len(args)>1: flagRun=args[1]
-        self.setup(typeProc,flagRun)
-        super().__init__()
-        self.name='dataTreePar'
-        if typeProc==dataTreePar.typeMIN:
-            self.name+=':MINproc'
-        elif typeProc==dataTreePar.typePIV:
-            self.name+=':PIVproc'
+    def __init__(self,Process=ProcessTypes.null,Step=StepTypes.null):
+        self.setup(Process,Step)
+        super().__init__('dataTreePar','ITEpar')
+
+        self.setCompleteLog()
+        
         self.surname='itemTreePar.gPaIRS'
         self.unchecked_fields+=['name_fields']
+        self.uncopied_fields+=['ind']
 
-    def setup(self,typeProc,flagRun):
+    def setup(self,Process,Step):
         #typeProc, names, icon, log: item fields
-        self.typeProc=typeProc
+        self.Process=Process
+        self.Step=Step
+        self.namesPIV=NamesPIV(Step)
 
-        self.itemname=''
-        self.filename_proc = ['']*dataTreePar.nTypeProc
-        self.name_proc = ['']*dataTreePar.nTypeProc
-        self.icon_type=0
+        if Step:
+          self.itemname=stepData[Step]['name']
+        else: 
+          self.itemname=''
+        self.filename_proc = ''
+        self.name_proc = ''
 
         self.Log=''
-        self.subHeader=''
         self.procLog=['','','']  #LogProc, LogStat, LogErr
+        self.FlagErr=False
         self.warnings=['',''] #warnings once completed the process, warnings related to current state
 
-        self.item_fields=[f for f,_ in self.__dict__.items()]+['indTree','indItem','ind']
+        self.item_fields=[f for f,_ in self.__dict__.items()]+['ind']
 
-        #process
-        self.flagRun=flagRun  #0:not launched yet, 1:completed, -1:interrupted
-        #min data
+        #common data
         self.inpPath=''
+        self.outPath=''
         self.outPathRoot=''
-        self.inpExt=''
-        self.flag_TR=None
-        self.compMin:CompMin=CompMin()
-        #piv data
-        self.NumThreads=-1
         self.ndig=-1
         self.outExt=''
+        self.compMin:CompMin=CompMin()
+        self.mediaPIV:MediaPIV=MediaPIV(stepType=Step)
+        #if Step==StepTypes.min:
+        self.FlagTR = False
+        self.LaserType = False
+        self.SogliaNoise_Min = 0.0
+        self.SogliaStd_Min   = 100.0
+        
+        #elif Step in (StepTypes.piv, StepTypes.disp, StepTypes.spiv):
+          #common
+        self.FlagMIN=False
         self.Imin=[]
-        self.mediaPIV:mediaPIV=mediaPIV()
-        self.numUsedThreadsPIV=1
-
-        #common
-        self.INP=INPpar()
-        self.OUT=OUTpar()
-        self.PRO=PROpar('fast')
-        self.VIS=VISpar()
+        
+        self.dispFrames=0
+
+        self.numUsedProcs=1
+        self.numPivOmpCores=-1 # used by PIV_ParFor_Workerfor setting the correct number of threads
+
+        self.OUT_dict={}
+        self.PRO_dict={}
+        self.PRO_Disp_dict={}
+
+        self.Nit=0
         self.nimg=0
+        self.ncam=0
+        self.nframe=2
+        self.nsteps=0
         self.list_Image_Files=[]
         self.list_eim=[]
         self.list_pim=[]        
         self.list_print=[]
 
+        #if Step in (StepTypes.disp, StepTypes.spiv):
+        self.calList=[]
+        self.calEx=[]
+        self.res=0
+        self.laserConst=[0.0 for _ in range(3)]
+        
+        #if Step==StepTypes.spiv:
+        self.FlagDISP=False
+        #self.dispFile=''
+
         fields=[f for f,_ in self.__dict__.items()]
         self.numCallBackTotOk=0  #numero di callback ricevute= quelle con problema + finalized
         self.numFinalized=0   #numero di processi andati a buon fine
         self.numProcOrErrTot=0
         self.FlagFinished=False
         self.flagParForCompleted=False  # par for completed                
-                
 
         # processing time
         self.initProcTime=time()  #initial time qhen starting the process
@@ -110,55 +164,111 @@ class dataTreePar(TABpar):
         #interface
         self.freset_par=''
         self.procfields=[f for f,_ in self.__dict__.items() if f not in fields]+ ['compMin','mediaPIV']
-        self.setCompleteLog()
+
+        self.assignDataName()
         return
 
-    def setProc(self):
-        self.inpPath=self.INP.path
-        self.outPathRoot=myStandardRoot(self.OUT.path+self.OUT.subfold+self.OUT.root)
-        self.inpExt=self.INP.pinfo.ext
-        ind_in=self.INP.list_ind_items[0]
-        ind_fin=self.INP.list_ind_items[1]
-        self.list_Image_Files=self.INP.list_Image_Files[ind_in:ind_fin]
-        self.list_eim=self.INP.list_eim[ind_in:ind_fin]
-        self.flag_TR=self.INP.flag_TR
-        self.compMin.flag_TR=self.flag_TR
-
-        if self.typeProc==dataTreePar.typeMIN:
-            self.nimg=(len(self.list_Image_Files)//2+1)//2 if self.flag_TR else len(self.list_Image_Files)//2
-        elif self.typeProc==dataTreePar.typePIV:
-            self.nimg=int(len(self.list_Image_Files)/2)
-            self.ndig=self.INP.pinfo.ndig
-            self.outExt=list(outType_items)[self.OUT.outType]
-            self.numUsedThreadsPIV=self.numUsedThreadsPIV  #TODEL 
-
-        self.list_pim=[0]*self.nimg
-        self.VIS.Tre.list_pim=self.list_pim
-        self.list_print=['']*self.nimg
+    def resF(self,i,string=''):
+        if self.ndig<-1: return ''
+        if string=='dispMap':
+          fold=os.path.dirname(self.outPathRoot)
+          rad=os.path.splitext(os.path.basename(self.outPathRoot))[0]
+          if rad[-1]!='_': rad+='_'
+          return myStandardRoot(os.path.join(fold, f'dispMap_rot_{rad}{i}.png'))
+        else:
+          if type(i)==str:
+              return f"{self.outPathRoot}_{i}{self.outExt}"
+          elif type(i)==int:
+                return f"{self.outPathRoot}_{i:0{self.ndig:d}d}{self.outExt}"
+          else:
+              return ''
+
+    def setProc(self,INP:INPpar=INPpar(),OUT:OUTpar=OUTpar(),PRO:PROpar=PROpar(),PRO_Min:PROpar_Min=PROpar_Min(),PRO_Disp:PROpar_Disp=PROpar_Disp()):
+        if INP is None: return
+        self.inpPath=INP.path
+        self.outPath=myStandardRoot(OUT.path+OUT.subfold)
+        self.outPathRoot=myStandardRoot(OUT.path+OUT.subfold+OUT.root)
+        
+        if self.Step==StepTypes.disp:
+           self.list_Image_Files=INP.imList
+           self.list_eim=INP.imEx
+        else:
+          self.list_Image_Files=[]
+          self.list_eim=[]
+          for c in range(INP.ncam):
+            for k in range(INP.nimg):
+              for f in range(2):
+                  self.list_Image_Files.append(INP.imList[c][f][k])
+                  self.list_eim.append(INP.imEx[c][f][k])
+        self.ncam=len(INP.imList)
+        self.FlagTR=INP.FlagTR
+        self.LaserType=INP.LaserType
+        self.FlagMIN=INP.FlagMIN
+        self.Imin=INP.imListMin
+        
+        if self.Step==StepTypes.min:
+            self.compMin.outName   = self.outPathRoot+'_data'+outExt.min
+            self.compMin.name_proc = self.name_proc
+            self.compMin.flag_TR=self.FlagTR
+            self.compMin.LaserType=self.LaserType
+            self.compMin.setup(self.ncam,self.nframe)
+            self.nimg=(len(self.list_Image_Files)//(2*self.ncam)+1)//2 if self.FlagTR else len(self.list_Image_Files)//(2*self.ncam)
+        elif self.Step in (StepTypes.piv,StepTypes.disp,StepTypes.spiv):
+            if self.Step==StepTypes.piv:
+               self.mediaPIV.outName   = self.outPathRoot+'_data'+outExt.piv
+               self.mediaPIV.name_proc = self.name_proc
+            elif self.Step==StepTypes.spiv:
+               self.mediaPIV.outName   = self.outPathRoot+'_data'+outExt.spiv
+               self.mediaPIV.name_proc = self.name_proc
+            self.nimg=INP.nimg
+            self.ndig=len(str(self.nimg))
+            self.outExt=list(outType_dict)[OUT.outType]
+            self.numUsedProcs=self.numUsedProcs  #TODEL 
+        if self.Step in (StepTypes.disp,StepTypes.spiv):
+           self.calList=INP.calList
+           self.calEx  =INP.calEx
+        if self.Step==StepTypes.disp:
+           self.Nit = PRO_Disp.Nit
+           self.dispFrames = PRO_Disp.frames
+        #if self.Step==StepTypes.spiv:
+           #self.FlagDISP=INP.FlagDISP
+           #self.dispFile=INP.dispFile
+
+        self.nsteps=self.Nit if self.Step==StepTypes.disp else self.nimg
+        self.list_pim=[0]*self.nsteps
+        self.list_print=['']*self.nsteps
+
+        if PRO_Min:
+          self.SogliaNoise_Min=PRO_Min.SogliaNoise
+          self.SogliaStd_Min=PRO_Min.SogliaStd
+        
+        for f,v in OUT.duplicate().__dict__.items():
+          self.OUT_dict[f]=v
+        if self.Step in (StepTypes.piv,StepTypes.spiv):
+          for f,v in PRO.duplicate().__dict__.items():
+            self.PRO_dict[f]=v
+        if self.Step == StepTypes.disp:
+           for f,v in PRO_Disp.duplicate().__dict__.items():
+              self.PRO_Disp_dict[f]=v
+        #self.setPIV(OUT,PRO,flagSpiv)
     
     def assignDataName(self):
-        username=platform.system() +'-'+os.environ.get('USER', os.environ.get('USERNAME'))
-        date_time=QDate.currentDate().toString('yyyy/MM/dd')+'-'+\
-            QTime().currentTime().toString()
-        ppid=str(os.getppid())+'-'+str(os.getpid())
-        version_user_info='PaIRS-v'+__version__+'_'+username+'_'+date_time
-        id=ppid+'_'+str(uuid.uuid4())
-        for t in range(dataTreePar.nTypeProc):
-            self.name_proc[t]=version_user_info+'_proc'+str(t)+'_'+id
-
-        if self.typeProc==dataTreePar.typeMIN:
-            self.name='itemTREEpar:MinProc'
-            self.filename_proc[self.typeProc]=f"{self.outPathRoot}{outExt.min}"
-            self.itemname=f"Minimum computation ({self.filename_proc[self.typeProc]})"
-        elif self.typeProc==dataTreePar.typePIV:
-            self.name='itemTREEpar:PIVProc'
-            if self.INP.flag_min: 
-                self.filename_proc[dataTreePar.typeMIN]=f"{self.outPathRoot}{outExt.min}"
-            else:
-                self.filename_proc[dataTreePar.typeMIN]=''
-            self.filename_proc[self.typeProc]=f"{self.outPathRoot}{outExt.piv}"
-            self.itemname=f"PIV computation ({self.filename_proc[self.typeProc]})"
+        self.name_proc,_,_=identifierName(typeObject='proc')
+        
+        if self.Step!=StepTypes.null:
+          self.itemname=stepData[self.Step]['name']
+          for f,v in StepTypes.__dict__.items():
+            if v==self.Step: 
+              break
+          ext=getattr(outExt,f)
+          self.filename_proc=f"{self.outPathRoot}{ext}"
+        
+    def procOutName(self):
+      return procOutName(self)
     
+    def stepOutName(self):
+      return stepOutName(self)
+
     def resetTimeStat(self):        
         ''' reset all the TimeStat parameters should be called before starting a new process maybe it is useless ask GP'''
         self.procTime=0
@@ -188,7 +298,7 @@ class dataTreePar(TABpar):
     def calcTimeStat(self,actualTime,numDone):
         '''  Should be called when when the eta should be updated '''
         procTime=self.procTime+actualTime-self.initProcTime
-        numStilToProc=self.nimg-numDone
+        numStilToProc=self.nsteps-numDone
         
         if numDone==0:
            self.eta=0
@@ -200,25 +310,25 @@ class dataTreePar(TABpar):
         #pr(f'dt={procTime} ETA={self.eta} {self.deltaTime2String(self.eta)} dt+ETA={round(procTime+ self.eta)} timePerImage={self.timePerImage} numStilToProc={numStilToProc} numDone={numDone} ')
         return self.deltaTime2String(self.eta)
 
-    def setPIV(self):
-        self.PIV=data2PIV(self) 
+    def setPIV(self,flagSpiv=False):
+        self.PIV=data2PIV(self,flagSpiv) 
 
     def createLogHeader(self):
         header=PaIRS_Header
-        if self.typeProc==0: #minimum
+        if self.Step==StepTypes.null: #minimum
           name='Welcome to PaIRS!\nEnjoy it!\n\n'
           header=header+name
         else:
-          name=f'{self.itemname}\n'
-          name+=self.name_proc[self.typeProc]
+          name=f'{self.itemname} ({self.filename_proc})\n'
+          name+=self.name_proc
           date_time=QDate.currentDate().toString('yyyy/MM/dd')+' at '+\
               QTime().currentTime().toString()
           header+=f'{name}\n'+'Last modified date: '+date_time+'\n\n\n'
         return header
-
+      
     def setCompleteLog(self):
         warn1=self.headerSection('WARNINGS',self.warnings[1],'!')  
-        if self.flagRun:
+        if self.flagRun not in (0,-10):
             warn0=''
             self.createLogProc()
             LogProc = self.headerSection('OUTPUT',self.procLog[0])
@@ -228,7 +338,14 @@ class dataTreePar(TABpar):
             if self.warnings[0]: warn0='*Further information:\n'+self.warnings[0]+'\n'        
             self.Log=self.createLogHeader()+procLog+warn0+warn1
         else:
-            self.Log=self.createLogHeader()+warn1
+            if self.flagRun:
+              self.Log=self.createLogHeader() 
+            else:
+              self.Log=self.createLogHeader()+warn1
+
+    def createWarningLog(self,warning):
+        warn1=self.headerSection('WARNINGS',warning,'!')  
+        return self.createLogHeader()+warn1
 
     def headerSection(self,nameSection,Log,*args):
         if len(Log):
@@ -238,22 +355,67 @@ class dataTreePar(TABpar):
             if len(args)>1: n=args[1]
             ln=len(nameSection)
             ns=int((n-ln)/2)
-            Log=f'{f"{c}"*n}\n{" "*ns}{nameSection}{" "*ns}\n{f"{c}"*n}\n'+Log+'\n'
+            header=f'{f"{c}"*n}\n{" "*ns}{nameSection}{" "*ns}\n{f"{c}"*n}\n'
+            if Log!=' ': Log=header+Log+'\n'
+            else: Log=header
         return Log
     
+    def eyeHeaderSection(self, text:str, width:int=54, height:int=11, border:str='o', pad:int=0)->str:
+        """
+        Draw an eye-shaped frame with the given text centered on the middle row.
+        Works in monospace consoles or QTextEdit. Uses a smooth parametric eye curve.
+        """
+        width=max(width, len(text)+2*pad+2)
+        height=max(5, height|(1))  # make it odd
+        mid=height//2
+        # eye boundary: y = a*(1 - |x|^p)^b, mirrored top/bottom
+        import math
+        p,b=1.6,1.0   # shape controls (p: pointiness, b: roundness)
+        ax=width/2-1
+        ay=mid-1      # vertical semi-size (controls thickness of eye)
+        eps=0.6       # border thickness in "cells"
+
+        rows=[]
+        for r in range(height):
+            y=(r-mid)/ay  # -1..1
+            line=[]
+            for c in range(width):
+                x=(c- (width-1)/2)/ax  # -1..1
+                # target boundary (top curve positive y, bottom negative)
+                yb = (1 - abs(x)**p)
+                yb = (yb if yb>0 else 0)**b  # clamp
+                # distance to boundary (abs because top/bottom)
+                d=abs(abs(y)-yb)
+                ch=' '
+                if yb<=0 and abs(y)<eps/ay:           # very ends -> leave blank
+                    ch=' '
+                elif d*ay<=eps and yb>0:              # on border
+                    ch=border
+                line.append(ch)
+            rows.append(''.join(line))
+
+        # write text on middle row
+        body=list(rows[mid])
+        s=f' {text} '
+        start=(width-len(s))//2
+        body[start:start+len(s)]=list(s)
+        rows[mid]=''.join(body)
+
+        return '\n'.join(rows)
+
     def createLogProc(self):
         splitAs='\n   '#used to join the strings together tab or spaces may be use to indent the error
-        numImgTot=len(self.list_pim) if self.typeProc==2 else (2*len(self.list_pim))
+        numImgTot=len(self.list_pim) if self.Step!=StepTypes.min else (2*len(self.list_pim))
         LogProc=''
         LogErr=''
         cont=0
         contErr=0
         for i,p in enumerate(self.list_pim):
-            if not p: 
+            if not p or self.list_print[i]=='': 
               continue
-            if self.typeProc==1: #minimum
+            if self.Step==StepTypes.min: #minimum
                 cont+=2
-                flag=(p&FLAG_FINALIZED[0]) and (p&FLAG_FINALIZED[1]) 
+                #flag=(p&FLAG_FINALIZED[0]) and (p&FLAG_FINALIZED[1]) 
                 if (p&FLAG_FINALIZED[0]):
                     if (p&FLAG_FINALIZED[1]):
                       LogProc+=(self.list_print[i])
@@ -267,6 +429,7 @@ class dataTreePar(TABpar):
                       else:# la b nonè stata proprio letta
                           cont-=1
                           #pri.Process.magenta(f'LogProc wrong {i} {p}   {splitAs.join(sAppo[1:-1])} {hex(p)}  ')
+                    LogProc+='\n'
                 else:
                     sAppo=self.list_print[i].split('\n')
                     if (p&FLAG_FINALIZED[1]):
@@ -277,58 +440,98 @@ class dataTreePar(TABpar):
                       iDum=len(sAppo)//2
                       LogErr+=splitAs.join(sAppo[0:iDum])+'\n'+splitAs.join(sAppo[iDum:-1])+'\n'
                       contErr+=2
-            elif self.typeProc==2: #PIV process
+            elif self.Step in (StepTypes.piv,StepTypes.disp,StepTypes.spiv): #PIV process
                 cont+=1
                 if p&FLAG_FINALIZED[0]:
                   LogProc+=self.list_print[i]+"\n"
                   #pr(f'LogProc {i} {p}   {self.list_print[i]} {hex(p)}   =    {hex(FLAG_FINALIZED_AB)}\n')
                 else:
                   contErr+=1
-                  LogErr+=splitAs.join(self.list_print[i].split('\n')[0:-1])+'\n'
+                  errString=splitAs.join(self.list_print[i].split('\n')[0:-1])
+                  if errString: LogErr+=errString+'\n'
 
-        if not LogProc: LogProc='No output produced!\n\n'
+        if not LogProc: LogProc=self.nullLogProc()
         
-        if LogErr:
-          LogErr=f'There were {contErr}/{numImgTot} errors in the current process:\n\n'+LogErr
+        self.FlagErr=bool(LogErr) or 'CRITICAL ERROR' in self.warnings[0]
+        if self.Step in (StepTypes.piv,StepTypes.spiv):
+          errStr=f' ({contErr}/{numImgTot} images)'
+        else:
+          errStr=''
+        if 'CRITICAL ERROR' in self.warnings[0]:
+           errStr2='!!! Critical errors occured! Please, see further information reported below.\n\n'
         else:
-          LogErr=f'There were {contErr}/{numImgTot} errors in the current process!\n\n'
-        pProc=cont*100/numImgTot
+           errStr2=''
+        if self.FlagErr:
+          LogErr=f'There were errors in the current process{errStr}:\n\n{errStr2}'+LogErr
+        else:
+          LogErr=f'There were no errors in the current process!\n\n'
+        if numImgTot:
+          pProc=cont*100/numImgTot
+        else:
+           pProc=100
         pLeft=100-pProc
         if cont:
           pErr=contErr*100/cont
         else:
           pErr=0
         pCorr=100-pErr
+        item='pair' if self.Step!=StepTypes.disp else 'iteration'
+        sp=' '*6 if self.Step!=StepTypes.disp else ' ' 
+        Log_PIVCores='' if self.Step==StepTypes.min else f'          PIV cores:   {self.numPivOmpCores}\n'
         LogStat=\
-              f'Percentage of pairs\n'+\
+              f'Percentage of {item}s\n'+\
               f'          processed:   {pProc:.2f}%\n'+\
               f'          remaining:   {pLeft:.2f}%\n'+\
               f'     without errors:   {pCorr:.2f}%\n'+\
               f'        with errors:   {pErr:.2f}%\n\n'+\
               f'Time\n'+\
               f'     of the process:   {self.deltaTime2String(self.procTime,True)}\n'+\
-              f'          per image:   {self.deltaTime2String(self.timePerImage,True)}\n'+\
-              f'         to the end:   {self.deltaTime2String(self.eta,True)}\n'
+              f'    {sp} per {item}:   {self.deltaTime2String(self.timePerImage,True)}\n'+\
+              f'         to the end:   {self.deltaTime2String(self.eta,True)}\n\n'+\
+              f'Multi processing\n'+\
+              Log_PIVCores+\
+              f'   processing units:   {floor(self.numUsedProcs)}\n'
+              #5f'   processing units:   {floor(self.numUsedProcs/self.numPivOmpCores)}\n'
         self.procLog=[LogProc,LogStat,LogErr]
         return 
 
+    def nullLogProc(self):
+       return 'No output produced!\n\n'
+    
     def resetLog(self):
-       self.Log=self.createLogHeader()+self.procLog[0]
+      if self.procLog[0]!=self.nullLogProc():
+        self.Log=self.createLogHeader()+self.procLog[0]
+      else:
+        self.Log=self.createLogHeader()
+      return
 
-    def writeCfgProcPiv(self):
-        if self.outPathRoot=='':
-          outPathRoot=myStandardRoot(self.OUT.path+self.OUT.subfold+self.OUT.root)
-        else:
+    def writeCfgProcPiv(self,filename='',FlagWarningDialog=False):
+        flagSpiv=self.Step==StepTypes.spiv
+        if filename=='':
           outPathRoot=self.outPathRoot
-        foldOut=os.path.dirname(outPathRoot)
-        if not os.path.exists(foldOut):
-           os.mkdir(foldOut)
-        writeCfgProcPiv(self,f"{outPathRoot}.cfg")
+          foldOut=os.path.dirname(outPathRoot)
+          if not os.path.exists(foldOut):
+            try:
+              os.mkdir(foldOut)
+            except Exception as inst:
+              pri.Error.red(f'It was not possible to make the directory {foldOut}:\n{traceback.format_exc()}\n\n{inst}')
+          filename=f"{outPathRoot}.cfg"
+        try:
+          writeCfgProcPiv(self,filename,flagSpiv)
+        except Exception as inst:
+           warningMessage=f'Error while writing PIV configuration file to location "{filename}":\n{inst}'
+           if FlagWarningDialog: warningDialog(None,warningMessage)
+           pri.Error.red(f'{warningMessage}\n{traceback.format_exc()}\n')
 
-class mediaPIV():
+class MediaPIV():
   ''' helper class to perform the avearages '''
-  def __init__(self):
-    self.namesPIV=NamesPIV()
+  def __init__(self,stepType=StepTypes.piv):
+    self.outName=''
+    self.name_proc=''
+
+    self.stepType=stepType
+    self.namesPIV=NamesPIV(Step=self.stepType)
+        
     #self.avgVel=[self.x,self.y,self.u,self.v,self.up,self.vp,self.uvp,self.FCl,self.Info,self.sn]
     self.x=np.zeros(1)
     self.y=np.zeros(1)
@@ -340,6 +543,17 @@ class mediaPIV():
     self.sn=np.zeros(1)
     self.FCl=np.zeros(1)
     self.Info=np.zeros(1)
+    if self.stepType==StepTypes.disp:
+      self.z=np.zeros(1)
+      self.dPar=np.zeros(1)
+      self.dOrt=np.zeros(1)
+    if self.stepType==StepTypes.spiv:
+      self.z=np.zeros(1)
+      self.w=np.zeros(1)
+      self.wp=np.zeros(1)
+      self.uwp=np.zeros(1)
+      self.vwp=np.zeros(1)
+    self.indu=3 if self.stepType==StepTypes.spiv else 2
     
     # just for checking that the variables are the same 
     # I cannot do it automatically since variables are not recognized by vscode
@@ -349,6 +563,8 @@ class mediaPIV():
     self.cont=0
     self.nimg=0
 
+    self.fields=[f for f,_ in self.__dict__.items()]
+
   def sum(self,var):
     # should start with x, y ,u ,v
     infoSi=1
@@ -365,13 +581,20 @@ class mediaPIV():
     self.Info=self.Info+1*(var[5]==infoSi)  #piv.Info #verificare se sia il caso di sommare solo se =Infosi
     self.sn=self.sn+var[6] #piv.sn
     '''
-    self.up=self.up+var[2]*var[2] #piv.up
-    self.vp=self.vp+var[3]*var[3] #piv.up
-    self.uvp=self.uvp+var[2]*var[3] #piv.up
+    self.up=self.up+var[self.indu]*var[self.indu] #piv.up
+    self.vp=self.vp+var[self.indu+1]*var[self.indu+1] #piv.vp
+    self.uvp=self.uvp+var[self.indu]*var[self.indu+1] #piv.uvp
+    if self.stepType==StepTypes.spiv:
+      self.wp=self.wp+var[self.indu+2]*var[self.indu+2] #piv.wp
+      self.uwp=self.uwp+var[self.indu]*var[self.indu+2] #piv.uwp
+      self.vwp=self.vwp+var[self.indu+1]*var[self.indu+2] #piv.vwp
+    
     
     if self.x.size<=1:
       self.x=var[0]  #piv.x dovrebbero essere tutti uguali
       self.y=var[1]  #piv.y dovrebbero essere tutti uguali
+      if self.stepType==StepTypes.spiv:
+        self.z=var[2]  #piv.y dovrebbero essere tutti uguali
 
   def sumMedia(self,medToSum):
     self.cont=self.cont+medToSum.cont
@@ -383,46 +606,72 @@ class mediaPIV():
     self.vp=self.vp+medToSum.vp
     self.uvp=self.uvp+medToSum.uvp
     self.Info=self.Info+medToSum.Info
+    if self.stepType==StepTypes.spiv:
+      self.w=self.w+medToSum.w
+      self.wp=self.wp+medToSum.wp
+      self.uwp=self.uwp+medToSum.uwp
+      self.vwp=self.vwp+medToSum.vwp
     if self.x.size<=1:
       self.x=medToSum.x  #piv.x dovrebbero essere tutti uguali
       self.y=medToSum.y  #piv.y dovrebbero essere tutti uguali
+      if self.stepType==StepTypes.spiv:
+        self.z=medToSum.z  #piv.y dovrebbero essere tutti uguali
 
   def calcMedia(self):
     if self.cont>0:
 
       self.u/=self.cont
       self.v/=self.cont
+      
       self.sn/=self.cont
       self.FCl/=self.cont
       self.Info/=self.cont#percentuale di vettori buoni 1=100% 0 nememno un vettore buono
       self.up=(self.up/self.cont-self.u*self.u)#nan or inf is no good vector
       self.vp=(self.vp/self.cont-self.v*self.v)#nan or inf is no good vector
       self.uvp=(self.uvp/self.cont-self.u*self.v)#nan or inf is no good vector
-      
-  
+      if self.stepType==StepTypes.spiv:
+        self.w/=self.cont
+        self.wp=(self.wp/self.cont-self.w*self.w)#nan or inf is no good vector
+        self.uwp=(self.uwp/self.cont-self.u*self.w)#nan or inf is no good vector
+        self.vwp=(self.vwp/self.cont-self.w*self.v)#nan or inf is no good vector
   def restoreSum(self):
         
     #OPTIMIZE TA GP gestione delle statistiche ora si usano tutti i vettori anche quelli corretti forse si dovrebbe dare la possibiltà all'utente di scegliere?
     self.up=(self.up+self.u*self.u)*self.cont # inf is no good vector
     self.vp=(self.vp+self.v*self.v)*self.cont # inf is no good vector
     self.uvp=(self.uvp+self.u*self.v)*self.cont # inf is no good vector
+    if self.stepType==StepTypes.spiv:
+      self.wp=(self.wp+self.w*self.w)*self.cont # inf is no good vector
+      self.uwp=(self.uwp+self.u*self.w)*self.cont # inf is no good vector
+      self.vwp=(self.vwp+self.w*self.v)*self.cont # inf is no good vector
+      self.w=self.w*self.cont
 
     self.u=self.u*self.cont
     self.v=self.v*self.cont
     self.sn=self.sn*self.cont
     self.Info=self.Info*self.cont#percentuale di vettori buoni 1=100% 0 nememno un vettore buono
 
-  
 class CompMin():
   ''' helper class to compute minimum '''
-  def __init__(self):
-    self.Imin=[np.zeros(0),np.zeros(0)]
-    self.med=[np.zeros(1),np.zeros(1)]
-    self.contab=[0,0]
+  def __init__(self,ncam=1,nframe=2):
+    self.outName=''
+    self.name_proc=''
+    
+    self.setup(ncam,nframe)
     #self.cont=0
     #self.cont0=0
     
     self.flag_TR=None
+    self.LaserType=-1  #0 single, 1 double
+
+    self.fields=[f for f,_  in self.__dict__.items()]
+  
+  def setup(self,ncam,nframe):
+    self.ncam=ncam
+    self.nframe=nframe
+    self.Imin=[np.zeros(0) for _ in range(self.ncam*self.nframe)]
+    self.med=[np.zeros(1) for _ in range(self.ncam*self.nframe)]
+    self.contab=[0 for _ in range(ncam*2)]
   
   def minSum(self,I,k):
     ''' min '''   
@@ -439,9 +688,9 @@ class CompMin():
     #prLock(f"minSum   contab={self.contab[k]}")
   def checkImg(self,I,sogliaMedia,sogliaStd)->bool:
     ''' checkImg '''   
-    dum=1/I.size
-    media=I.ravel().sum()*dum#faster than mean
-    dev=np.square(I-media).ravel().sum()*dum
+    #dum=1/I.size
+    media=I.mean()   #I.ravel().sum()*dum     #faster than mean, but affected by overflow
+    dev=I.std()      #np.square(I-media).ravel().sum()*dum
     return media>sogliaMedia and dev >sogliaStd*sogliaStd 
     
   def calcMin(self,minMed):
@@ -449,9 +698,8 @@ class CompMin():
     #pri.Time.magenta(0,f"self.cont0={self.cont0}")
     #self.cont+=self.cont0
     #nImg=1 if self.flag_TR else 2
-    nImg=2
-    for k in range(nImg):
-    
+    #nImg=2
+    for k in range(len(self.Imin)):
       if minMed.contab[k]>0:
         if self.contab[k]==0:
           self.Imin[k]=minMed.Imin[k]
@@ -464,10 +712,22 @@ class CompMin():
     ''' calcMed and sum media  '''
     pri.Time.magenta(f"calcMed   contab={self.contab}  ")
     #nImg=1 if self.flag_TR else 2
-    nImg=2
-    for k in range(nImg):
-      if self.contab[k]>0:
+    if self.LaserType==0: # single laser
+      for cam in range(self.ncam):
+        k=self.nframe*cam
+        for j in range(1,self.nframe):
+          self.Imin[k]=np.minimum(self.Imin[k],self.Imin[k+j])
+          self.med[k]+=self.med[k+j]
+          self.contab[k]+=self.contab[k+j]
         self.med[k]/=self.contab[k]
+        for j in range(1,self.nframe):
+          self.Imin[k+j]=self.Imin[k].copy()   
+          self.med[k+j]=self.med[k].copy()   
+          self.contab[k+j]=self.contab[k]   #useless? I don't think so, important for restoreMin
+    else: 
+      for k in range(len(self.Imin)):
+        if self.contab[k]>0:
+          self.med[k]/=self.contab[k]
     pri.Time.magenta(f"calcMed   fine contab={self.contab}  ")
         
     
@@ -475,8 +735,7 @@ class CompMin():
   def restoreMin(self):
     #pr(f"restoreMin   contab={self.contab}    self.cont={self.cont} self.cont0={self.cont0}")
     #nImg=1 if self.flag_TR else 2
-    nImg=2
-    for k in range(nImg):
+    for k in range(len(self.Imin)):
       self.med[k]*=self.contab[k]
 
 def foList(li,formato):
@@ -487,9 +746,9 @@ def foList(li,formato):
     e.g. print(f'{a:<4d}') -> print(f'{foList([a a],"<4d")}') 
   '''
   return f"{''.join(f' {x:{formato}}' for x in li)}"
-# todo delete olf function
-def writeCfgProcPivOld(data,nomeFile):
-    PIV=data2PIV(data)
+# todo delete old function
+def writeCfgProcPivOld(data,nomeFile,flagSpiv=False):
+    PIV=data2PIV(data,flagSpiv)
     PIV.SetVect([v.astype(np.intc) for v in data.PRO.Vect])
     inp=PIV.Inp
     vect=data.PRO.Vect
@@ -544,8 +803,8 @@ def writeCfgProcPivOld(data,nomeFile):
         f.write(f'{1}, 			Value of info for an outlier\n')
         #   % Windowing parameters (Astarita, 			Exp Flu, 			2007) *************************
         f.write(f'% Windowing parameters (Astarita EiF 2007) *************************\n')
-        f.write(f'{inp.FlagCalcVel}, 			Weighting window for absolute velocity (0=TopHat, 1=Nogueira,	2=Blackmann,...) (26)\n')
-        f.write(f'{inp.FlagWindowing}, 			Weighting window for the correlation map (0=TopHat 1= Nogueira 2=Blackmann 3=top hat at 50%) (27)\n')  
+        f.write(f'{inp.FlagCalcVel}, 			Weighting window for absolute velocity (0=TopHat, 1=Nogueira,	2=Blackman,...) (26)\n')
+        f.write(f'{inp.FlagWindowing}, 			Weighting window for the correlation map (0=TopHat 1= Nogueira 2=Blackman 3=top hat at 50%) (27)\n')  
         f.write(f'{inp.SemiDimCalcVel}, 			Half-width of the filtering window (0=window dimension) (28)\n')
         #   % Adaptive PIV parameters (Astarita, 			Exp Flu, 			2009) *************************
         f.write(f'% Adaptive PIV parameters (Astarita EiF 2009) *************************\n')
@@ -625,8 +884,8 @@ def writeCfgProcPivOld(data,nomeFile):
                     
     
     #'''         
-def writeCfgProcPiv(data,nomeFile):
-    PIV=data2PIV(data)
+def writeCfgProcPiv(data,nomeFile,flagSpiv=False):
+    PIV=data2PIV(data,flagSpiv)
     inp=PIV.Inp
     vect=PIV.GetVect()
     vectWindowing=PIV.GetWindowingVect()
@@ -661,8 +920,8 @@ def writeCfgProcPiv(data,nomeFile):
         # % Windowing parameters (Astarita, Exp Flu, 2007) ***************************
         
         f.write(f'% Windowing parameters (Astarita, Exp Flu, 2007) ***************************\n')
-        f.write(f'[{foList(vectWindowing[1],"<3d")}],             WW for predictor  (0=TopHat; 2=Blackmann;...)                     (16)\n')
-        f.write(f'[{foList(vectWindowing[2],"<3d")}],             WW for the correlation map (0=TopHat;2=Blackmann 3=top hat at 50%)(17)\n')
+        f.write(f'[{foList(vectWindowing[1],"<3d")}],             WW for predictor  (0=TopHat; 2=Blackman;...)                     (16)\n')
+        f.write(f'[{foList(vectWindowing[2],"<3d")}],             WW for the correlation map (0=TopHat;2=Blackman 3=top hat at 50%)(17)\n')
         f.write(f'[{foList(vectWindowing[3],"<3d")}],             Half-width of the filtering window (0=window dimension)           (18)\n')
         f.write(f'[{foList(vectWindowing[4],"<3d")}],     Flag direct correlation (0=no 1=yes )                             (19)\n')
         f.write(f'[{foList(vectWindowing[0],"<3d")}],         Max displacement if <0  fraction of wa i.e. -4-> Wa/4             (20)\n')
@@ -804,8 +1063,6 @@ def PIV2Pro(piv:PaIRS_lib.PIV)-> PROpar:
   pro.FlagDirectCorr=piv.Inp.FlagDirectCorr
   pro.FlagBordo=piv.Inp.FlagBordo
 
-
-
   if piv.Inp.SemiDimCalcVel<0:
      pro.NItAdaptative=-piv.Inp.SemiDimCalcVel
      pro.NIterazioni=piv.Inp.NIterazioni-pro.NItAdaptative
@@ -817,15 +1074,24 @@ def PIV2Pro(piv:PaIRS_lib.PIV)-> PROpar:
 
   return pro
    
-def data2PIV(data):
-    PIV=PaIRS_lib.PIV()
+def data2PIV(data:dataTreePar,flagSpiv=False):
+    OUT=OUTpar()
+    OUT.copyfromdiz(data.OUT_dict)
+    PRO=PROpar()
+    PRO.copyfromdiz(data.PRO_dict)
+
+    if flagSpiv:
+      PIV=PaIRS_lib.Stereo()
+    else:
+      PIV=PaIRS_lib.PIV()
     
     PIV.DefaultValues()
-    OUT=data.OUT
-    PRO=data.PRO
+    PIV.Inp.FlagNumThreads=data.numPivOmpCores
+    #OUT=data.OUT
+    #PRO=data.PRO
 
     # % Windows dimensions position and iterations *******************************
-    PIV.SetVect([v.astype(np.intc) for v in data.PRO.Vect])
+    PIV.SetVect([np.array(v).astype(np.intc) for v in PRO.Vect])
     PIV.Inp.FlagBordo=PRO.FlagBordo
     PIV.Inp.NIterazioni=PRO.NIterazioni+PRO.NItAdaptative if PRO.FlagAdaptative else PRO.NIterazioni
     # % Process parameters - Interpolation ***********************************
@@ -864,7 +1130,7 @@ def data2PIV(data):
     PIV.Inp.InfoNo=0
     
     # % Windowing parameters (Astarita, Exp Flu, 2007) ***************************
-    PIV.Inp.numInitIt=max(len(v) for v in data.PRO.Vect)
+    PIV.Inp.numInitIt=max(len(v) for v in PRO.Vect)
     PIV.Inp.FlagWindowing=PRO.FlagWindowing
     """
     if (PIV.Inp.FlagWindowing >= 0) :
@@ -928,44 +1194,230 @@ def data2PIV(data):
     '''
     
 
+    return PIV
 
+def data2StereoPIV(data:dataTreePar):
+  StereoPIV=data2PIV(data,flagSpiv=True)
+  
+  OUT=OUTpar()
+  OUT.copyfromdiz(data.OUT_dict)
+  PRO=PROpar()
+  PRO.copyfromdiz(data.PRO_dict)
+
+  spiv=StereoPIV.SPIVIn
+  dP=StereoPIV.dataProc
+  inPiv=StereoPIV.Inp
+
+  # STEREO CFG file
+  # A €£ indicate that the feature is not enabled in the python wrapper
+  spiv.nomecal=''    # 		Root of calibration constants
+  #spiv.NomeCostPiano=data.dispFile[:-4]    # Root of disparity plane constants
+                      
+  spiv.percorsocal=''     # Path of calibration constants
+  spiv.FlagParallel=0          # Type of parallel process 0 horizontal 1 vertical (faster but with less information and mor RAM occupied)
+  dP.FlagInt=StereoPIV.Inp.IntFin    #			IS for image reconstruction (only used  when FlagRad==0)
+  inPiv.FlagRad=1     #			1 internal (in piv) or 0 external de-warping of the images (the latter €£)
+  dP.FlagCoordRad=0     #			when equal to 0 the de-warping is carried on with the larger resolution (pix/mm)
+                        #     when equal to 1 (2) the x (y) axis resolution is used 
+  spiv.salvarad=0			#    if true and FlagRad is equal to 0 then the dewarped images are saved (€£)
+
+
+  #                               %  ********************* Input/Output
+  spiv.FirstImg=0 # # of first img to be processed (€£)
+  spiv.LastImg=0   # # of first last to be processed (€£)
+  spiv.Digit=0     # number  of figures i.e. zeros (MAX 10)		 (€£)
+  spiv.ImgRoot=''   #		Root of the input Images (€£)
+  spiv.InDir=''     # Path of the images (€£)
+  spiv.InExt=''   #			Extension of the images (€£)
+  spiv.OutRoot =''      #	        Root of the output Files (€£)
+  spiv.OutDir =''      #                 Output path (€£)
+  spiv.OutExt =''      #                 Output extension (€£)
+  spiv.OutFlag = 0        # type of output file : 0 binary Tecplot 1 ascii tecplot (€£)
+  spiv.WrtFlag = 1        # 0 only mean values are saved 1 all the instantaneous images are written  (€£)
+
+  spiv.RigaPart=OUT.x 		# Starting row (€£)
+  spiv.ColPart=OUT.y			# Starting Col (€£)
+  dP.ImgH=OUT.H   # Ending row 
+  dP.ImgW=OUT.W	  # Starting Col
+  #                     % *********************** Process parameters
+  dP.FlagZonaCom=0   # 			Flag for common zone should be equal to 0
+  #           Volume ********************************
+  dP.xinfZC = OUT.x_min     #		  minimum x world coordinates
+  dP.yinfZC = OUT.y_min     #		  minimum y world coordinates
+  dP.xsupZC = OUT.x_max      #		  maximum x world coordinates
+  dP.ysupZC = OUT.y_max       #		  maximum y world coordinates
+  spiv.FlagRis=OUT.unit      #	    0 displacements in m/s 1 in pixels 
+  spiv.dt=OUT.dt        #	    time separation. If the displacements in mm are needed use 1000 (and 0 for the previous parameter)
+  spiv.Sfas=3         #	    in case of images in a single file the distance between images. Normally define the name (€£)
+                      #			1=a,b (after number); 2=_1,_2 (after number); 3=a,b (before number)
+  #                    % Output
+  spiv.FlagRotImg=0         #	    Rotation of the  img 0=no rot 1=90°, 2=180° 3= 270° clockwise	 (£€)
+  inPiv.FlagLog=9            #	    0=no 1=video 2=log 3=video e log 4=Log short  5=video e log short (£€)
+  spiv.StatFlag =0          #	    stat on: 1 all the vectors 0 only the good ones
+  spiv.nomecfgPiv =''          #	    name of the cfg file for PIV
+
+  # ******************************
+  flagReadCalConst=0# if true internal reading
+  if flagReadCalConst:
+    StereoPIV.readCalConst()
+  else:
+    c=0
+    cost=[]
+    for c in range(2):
+      fileName=data.calList[c]
+      flagCal,numCostCalib,costDum=readCalFile(fileName)
+      if c==0:
+        dP.FlagCal=flagCal
+        dP.NumCostCalib=numCostCalib
+      else:
+        if (dP.FlagCal!=flagCal):
+          raise('error the two calibration file are not compatible')
+      cost.append(costDum)
+    StereoPIV.setCalConst( flagCal, numCostCalib,cost)
     
+  StereoPIV.vect.PianoLaser[0]=np.float32(data.OUT_dict['zconst'])
+  StereoPIV.vect.PianoLaser[1]=np.float32(data.OUT_dict['xterm'])
+  StereoPIV.vect.PianoLaser[2]=np.float32(data.OUT_dict['yterm'])
+  """
+  flagReadPlaneConst=0# if true internal reading
+  if flagReadPlaneConst:
+    if StereoPIV.readPlaneConst()==0:
+      pri.Callback.green('Laser plane constants correclty read!')
+    else:
+      pri.Error.red('Error while reading the file containing the laser plane constants!')
+      data.laserConst=[const for const in StereoPIV.vect.PianoLaser]
+  else:
+    StereoPIV.vect.PianoLaser[0]=data.laserConst[0]
+    StereoPIV.vect.PianoLaser[1]=data.laserConst[1]
+    StereoPIV.vect.PianoLaser[2]=data.laserConst[2]
+  #piv *******************************************************************************
+  """
+  #StereoPIV.readCfgProc(spiv.nomecfgPiv)
+  return  StereoPIV
+
+def data2Disp(data:dataTreePar):
+    OUT=OUTpar()
+    OUT.copyfromdiz(data.OUT_dict)
+    PRO_Disp=PROpar_Disp()
+    PRO_Disp.copyfromdiz(data.PRO_Disp_dict)
+
+    Disp=PaIRS_lib.StereoDisp()
+    spiv=Disp.SPIVIn
+    dP=Disp.dataProc
+    dAC=Disp.dispAvCo
     
-    
-    
+    spiv.nomecal='' #os.path.splitext(os.path.basename(INP.calList[0]))    # 		Root of calibration constants				
+    spiv.percorsocal='' #os.path.dirname(INP.calList[0])     #Path of calibration constants
+    spiv.ImgRoot=''   #		Root input	Images
+    spiv.InExt=''   #			Extension of the images
+    spiv.InDir=''     #Path of the images
+    spiv.FirstImg=0 # # of first img to be processed
+    spiv.LastImg=0   # # of first last to be processed
+    spiv.Digit=0     # number  of figures i.e. zeros (MAX 10)		
 
-    return PIV
+    spiv.RigaPart=OUT.y 		# Starting row 
+    spiv.ColPart=OUT.x			# Starting column
+    dP.ImgH=OUT.h   # Ending row
+    dP.ImgW=OUT.w	  # Starting row
+    spiv.Sfas=1    #	Sfasamento sub-immagini (righe a partire dall'origine):			0 per singola img: 1=a,b (finali); 2=_1,_2 (finali); 3=a,b (prima del numero sequenziale			
+    spiv.FlagImgTau=data.dispFrames   #	Img da processare: 0-entrambe; 1-solo la prima; 2-solo la seconda;PARAMETRO IGNORATO SE SFAS=0					
+
+    #Output
+    spiv.OutRoot = OUT.root      #	        Root of output Files
+    spiv.OutDir = OUT.path+OUT.subfold      #                 Output path 
+    # Process parameters **********************
+    dP.FlagInt=PRO_Disp.IntIniz    #			Metodo di raddrizzamento: 0=veloce (simp.), 1=quad…….				
+    dP.FlagZonaCom=0   # 			Flag per la zona comune: 0=coordinate nel piano oggetto; 1=coord. nel piano img
+    spiv.Niter=PRO_Disp.Nit   #		Numero di iterazioni
+    """
+    if (spiv.Niter < 0) :
+      spiv.WrtFlag = 1
+      spiv.Niter = -spiv.Niter
+    else:
+      spiv.WrtFlag = 0
+    """
+
+    dAC.HCella=PRO_Disp.Vect[0]      #     Correlation window Height 
+    dAC.WCella=PRO_Disp.Vect[2]      #     Correlation window Width
+    dAC.HGrid=PRO_Disp.Vect[1]      #     Grid distance vertical
+    dAC.WGrid=PRO_Disp.Vect[3]      #     Grid distance horizontal
+    dAC.N_NormEpi=PRO_Disp.SemiWidth_Epipolar      #      Semiwidth in the direction normal to the epipolar line
+    dAC.RaggioFiltro=PRO_Disp.Filter_SemiWidth      #       Semiwidth of the filter for the detection of the maximum in the displacement map
+    dAC.SogliaCor = PRO_Disp.Threshold   #     Threshold for the determination of point used in the baricentric search of the maximum in the disp map
+    dAC.nIterMaxValid = PRO_Disp.Nit_OutDet
+    dAC.numStd = PRO_Disp.Std_Threshold
 
-def printPIVLog(PIV):
+    #%% Volume ********************************
+    dP.xinfZC = OUT.x_min    #		Coordinata x inferiore
+    dP.yinfZC = OUT.y_min    #		Coordinata y inferiore
+    dP.xsupZC = OUT.x_max    #28    #		Coordinata x superiore	
+    dP.ysupZC = OUT.y_max    #15    #		Coordinata y superiore
+    # ******************************
+    flagReadCalConst=0# if true internal reading
+    if flagReadCalConst:
+      Disp.readCalConst()
+    else:
+      c=0
+      cost=[]
+      for c in range(2):
+        fileName=data.calList[c]
+        flagCal,numCostCalib,costDum=readCalFile(fileName)
+        if c==0:
+          dP.FlagCal=flagCal
+          dP.NumCostCalib=numCostCalib
+        else:
+          if (dP.FlagCal!=flagCal):
+            raise('error the two calibration file are not compatible')
+        cost.append(costDum)
+      Disp.setCalConst( flagCal, numCostCalib,cost)
+      
+    flagReadPlaneConst=0# if true internal reading
+    if flagReadPlaneConst:
+      if Disp.readPlaneConst()==0:
+        pri.Callback.green('readPlaneConst ok')
+    else:
+      Disp.vect.PianoLaser[0]=0
+      Disp.vect.PianoLaser[1]=0
+      Disp.vect.PianoLaser[2]=0
+    return Disp
+    
+def printPIVLog(PD):
     stampa="It    IW      #IW        #Vect/#Tot      %       CC       CC(avg)   DC%\n"#  NR% Cap%\n"
-    for j in range(len(PIV.PD.It)):
+    for j in range(len(PD.It)):
         riga="%3d %3dx%-3d %4dx%-4d %7d/%-7d %5.1f  %8.7f  %8.7f  %4.1f\n" %\
-            (PIV.PD.It[j], PIV.PD.WCella[j], PIV.PD.HCella[j], PIV.PD.W[j], PIV.PD.H[j], PIV.PD.NVect[j],\
-            PIV.PD.W[j]*PIV.PD.H[j], 100.0*PIV.PD.NVect[j]/(PIV.PD.W[j]*PIV.PD.H[j]), PIV.PD.Fc[j],\
-                PIV.PD.FcMedia[j], 100.0*PIV.PD.ContErorreDc[j]/(PIV.PD.W[j]*PIV.PD.H[j]))#,\
+            (PD.It[j], PD.WCella[j], PD.HCella[j], PD.W[j], PD.H[j], PD.NVect[j],\
+            PD.W[j]*PD.H[j], 100.0*PD.NVect[j]/(PD.W[j]*PD.H[j]), PD.Fc[j],\
+                PD.FcMedia[j], 100.0*PD.ContErorreDc[j]/(PD.W[j]*PD.H[j]))#,\
                     #100.0*PIV.PD.ContRemNoise[j]/(PIV.Inp.ImgW*PIV.Inp.ImgH),\
                     #100.0*PIV.PD.ContCap[j]/(PIV.Inp.ImgW*PIV.Inp.ImgH))
         stampa=stampa+riga
     return stampa
 
+
 def saveMin(data:dataTreePar,Imin=list):
   pri.Time.magenta('saveMin Init ')
   frames='ab'
   #nImg=1 if self.flag_TR else 2
-  nImg=2
-  for j in range(nImg):
-    name_min=f"{data.outPathRoot}_{frames[j]}_min{data.inpExt}"
+  #nImg=2
+  for j in range(len(Imin)):
+    k=j%data.nframe
+    cam=j//data.nframe%data.ncam
+    name_min=f"{data.outPathRoot}_cam{cam+1}_{frames[k]}_min.png"
     im = Image.fromarray(Imin[j])
     im.save(name_min)
   pri.Time.magenta('saveMin End')
   
 def saveResults(data:dataTreePar,i,Var,nameVar):
     #pri.Time.magenta('saveResults Init')
-    if i<0:
-        nameFileOut=os.path.join(f"{data.outPathRoot}{data.outExt}")
-    else:
-        nameFileOut=os.path.join(f"{data.outPathRoot}_{i:0{data.ndig:d}d}{data.outExt}")
+    if type(i)==int:
+      if i<0:
+          nameFileOut=data.resF('*').replace('_*','')
+      else:
+          nameFileOut=data.resF(i)
+    elif type(i)==str:
+      nameFileOut=data.resF(i)
     #infoPrint.white(f'---> Saving field #{i}: {nameFileOut}')
+    
     if '.plt' in data.outExt:
         writePlt(nameFileOut,Var,f'PaIRS - 2D PIV',nameVar,nameFileOut)
     elif  '.mat' in data.outExt:
@@ -977,6 +1429,7 @@ def saveResults(data:dataTreePar,i,Var,nameVar):
         #timeit.timeit (lambda :'writePlt(nameFileOut,Var,"b16",nameVar,nameFileOut)')
         #timeit.timeit (lambda :'scipy.io.savemat(nameFileOut,dict_out)')
     #pri.Time.magenta('saveResults End')
+    return
 
 def memoryUsagePsutil():
     ''' return the memory usage in MB '''