PaIRS-UniNa 0.2.4__cp311-cp311-win_amd64.whl → 0.2.6__cp311-cp311-win_amd64.whl

PaIRS_UniNa/Vis_Tab.py

@@ -55,6 +55,11 @@ button_tips={
     'cvec': 'Color of vectors/streamlines',
     'view': 'Inspect pre-existing results',
     'ShowCR': 'Show common region',
+    'dx_left': 'View zone moved to left',
+    'dx_right': 'View zone moved to right',
+    'dy_down': 'View zone moved down',
+    'dy_up': 'View zone moved up',
+    'FocusIW': 'Resize to interrogation window size',
 }
 combo_tips={
     'map_var':      'Map variable',
@@ -102,6 +107,7 @@ class NamesPIV(TABpar):
         self.Step               = Step
    
         self.img='img'
+        self.dispMap='dispMap'
         self.X='X'
         self.Y='Y'
         self.Z='Z'
@@ -130,6 +136,7 @@ class NamesPIV(TABpar):
         self.allFields=allFields
         self.combo_dict={
                     self.img: 'image intesity',
+                    self.dispMap: 'disparity maps',
                     self.Mod: 'magnitude',
                     self.z:   'z',
                     self.u:   'U',
@@ -152,6 +159,7 @@ class NamesPIV(TABpar):
         for k,v in self.combo_dict.items(): self.combo_dict_keys[v]=k
         self.titles_dict={
                     self.img: 'intensity',
+                    self.dispMap: 'disparity maps',
                     self.Mod: "velocity magnitude",
                     self.z: "z coordinate",
                     self.u: "x-velocity component",
@@ -172,6 +180,7 @@ class NamesPIV(TABpar):
                     }
         self.titles_cb_dict={
                     self.img: '',
+                    self.dispMap: '',
                     self.Mod: "|Vel|",
                     self.z: "z",
                     self.u: "U",
@@ -293,6 +302,7 @@ class VISpar(TABpar):
         self.imListMin=[[[],[]]*self.ncam]
 
         self.image_file_Min=''
+        self.image_file_Disp=''
         self.result_file_Mean=''
         self.image_file_Current=''
         self.result_file_Current=''
@@ -309,20 +319,22 @@ class VISpar(TABpar):
         self.FlagResetSizes=True
         self.setPage=0
 
-        img=NamesPIV().img
-        self.vcolorMap={img: 'gray'}
+        namesPIV=NamesPIV()
+        img=namesPIV.img
+        dispMap=namesPIV.dispMap
+        self.vcolorMap={img: 'gray', dispMap: 'gray'}
         self.colorMap='gray'
-        self.vvectorColor={img: 'green'}
+        self.vvectorColor={img: 'green', dispMap: 'green'}
         self.vectorColor='green'
-        self.vLim={img: 1}
-        self.vmin_default={img: 0}
-        self.vmax_default={img: 1}
-        self.vmean_default={img: 0.5}
-        self.vrange_default={img: 1}
-        self.vmin={img: 0}
-        self.vmax={img: 1}
-        self.vmean={img: 0.5}
-        self.vrange={img: 1}
+        self.vLim={img: 1, dispMap: 1}
+        self.vmin_default={img: 0, dispMap: 0}
+        self.vmax_default={img: 1, dispMap: 0}
+        self.vmean_default={img: 0.5, dispMap: 0.5}
+        self.vrange_default={img: 1, dispMap: 1}
+        self.vmin={img: 0, dispMap: 0}
+        self.vmax={img: 1, dispMap: 1}
+        self.vmean={img: 0.5, dispMap: 0.5}
+        self.vrange={img: 1, dispMap: 1}
         self.min=0
         self.max=1
         self.mean=0.5
@@ -356,10 +368,15 @@ class VISpar(TABpar):
         #self.FlagDISP   = Step==StepTypes.disp
         #self.dispFile   = ''
     
-    def resF(self,i):
+    def resF(self,i,string=''):
         fres=self.fres
         if not fres: return ''
         outPathRoot=fres[0]
+        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'))
         ndig=fres[1]
         outExt=fres[2]
         if type(i)==str:
@@ -382,6 +399,7 @@ class Vis_Tab(gPaIRS_Tab):
         self.ui: Ui_VisTab
         self.Ptoolbar=None
         self.addPlotToolBar()
+        self.ui.plot.axes.format_coord=lambda x,y: self.custom_format_coord(x,y)
 
         self.ui.sliders=self.findChildren(QSlider)
         for slider in (self.ui.slider_min,self.ui.slider_max,self.ui.slider_mean,self.ui.slider_range):
@@ -402,6 +420,9 @@ class Vis_Tab(gPaIRS_Tab):
         #------------------------------------- Graphical interface: miscellanea
         self.brush_cursor= QCursor(QPixmap(icons_path+"brush_cursor.png").scaled(24,24,mode=Qt.TransformationMode.SmoothTransformation))
         self.FlagNormalCursor=True
+        self.CursorTimer = QTimer(self)
+        self.CursorTimer.setSingleShot(True)
+        self.CursorTimer.timeout.connect(self.forceRestoreArrowCursor)
 
         self.img=None
         self.imgshow=None
@@ -538,6 +559,9 @@ class Vis_Tab(gPaIRS_Tab):
         self.image_file_Min=''
         self.image_Min_raw=None
         self.image_Min=None
+        self.image_file_Disp=''
+        self.image_Disp_raw=None
+        self.image_Disp=None
         self.nbits=0
         self.result_file=''
         self.result=None
@@ -605,7 +629,7 @@ class Vis_Tab(gPaIRS_Tab):
         if self.VISpar.ncam and not self.VISpar.cam: self.VISpar.cam=1
         self.VISpar.nimg=len(self.VISpar.imList[0][0]) if len(self.VISpar.imList[0]) else 0 if self.VISpar.ncam else 0
         if not self.VISpar.nimg and self.VISpar.img:
-            FlagResults=self.image_file_Min!='' or self.result_file_Mean!=''
+            FlagResults=self.image_file_Min!='' or self.result_file_Mean!='' or self.image_file_Disp!=''
             self.VISpar.img=0 if FlagResults else -1
 
         FlagNewImage, FlagNewResult = self.adjustImport()
@@ -634,10 +658,17 @@ class Vis_Tab(gPaIRS_Tab):
         self.adjustFieldRep()
 
     def adjustImport(self):
-        self.VISpar.image_file=self.VISpar.image_file_Min=''
+        self.VISpar.image_file=self.VISpar.image_file_Min=self.VISpar.image_file_Disp=''
         if self.VISpar.img%2==0 and self.VISpar.FlagTR and not self.VISpar.LaserType:
             f=[1,0][self.VISpar.frame-1]
         else: f=self.VISpar.frame-1
+        self.VISpar.image_file_Disp=''
+        FlagDisparity=self.VISpar.Step==StepTypes.disp and (resultCheck(self,self.VISpar,ind=self.VISpar.ind) or self.VISpar.FlagView)
+        if FlagDisparity:
+            dispMap_filename=self.VISpar.resF(f'it{self.VISpar.it}',string='dispMap')
+            if os.path.exists(dispMap_filename):
+                self.VISpar.image_file_Disp=dispMap_filename
+        self.VISpar.image_file_Min=''
         ITEs=self.gui.ui.Explorer.ITEsfromInd(self.VISpar.ind)
         ind_min=list(ITEs[0].children).index(StepTypes.min)
         FlagMinimum=(self.VISpar.FlagMIN or self.VISpar.Step==StepTypes.min) and (resultCheck(self,self.VISpar,ind=ITEs[ind_min+1].ind) or self.VISpar.FlagView)
@@ -645,11 +676,10 @@ class Vis_Tab(gPaIRS_Tab):
             if 0<=self.VISpar.cam-1<self.VISpar.ncam:
                 if 0<=f<len(self.VISpar.imListMin[self.VISpar.cam-1]):
                     self.VISpar.image_file_Min=self.VISpar.imListMin[self.VISpar.cam-1][f]
-        else: self.VISpar.image_file_Min=''
         if self.VISpar.img>0:
             self.VISpar.image_file=self.VISpar.path+self.VISpar.imList[self.VISpar.cam-1][self.VISpar.frame-1][self.VISpar.img-1] if len(self.VISpar.imList[self.VISpar.cam-1][self.VISpar.frame-1]) else ''
         elif self.VISpar.img==0:
-            self.VISpar.image_file=self.VISpar.image_file_Current if self.VISpar.flagRun==-2 else self.VISpar.image_file_Min
+            self.VISpar.image_file=self.VISpar.image_file_Current if self.VISpar.flagRun==-2 and self.VISpar.variableKey!=self.namesPIV.dispMap else self.VISpar.image_file_Disp if self.VISpar.variableKey==self.namesPIV.dispMap else self.VISpar.image_file_Min 
         else:
             self.VISpar.image_file=self.image_file_Load
 
@@ -680,6 +710,8 @@ class Vis_Tab(gPaIRS_Tab):
     def importFiles(self):
         if self.VISpar.image_file_Min!=self.image_file_Min or self.VISpar.FlagMIN!=self.VISpar_old.FlagMIN or self.FlagReset:
             self.image_file_Min,self.image_Min_raw=self.readImageFile(self.VISpar.image_file_Min)
+        if self.VISpar.image_file_Disp!=self.image_file_Disp or self.FlagReset:
+            self.image_file_Disp,self.image_Disp_raw=self.readImageFile(self.VISpar.image_file_Disp)
         if self.VISpar.result_file_Mean!=self.result_file_Mean or self.VISpar.FlagResult!=self.VISpar_old.FlagResult or self.FlagReset:
             self.result_file_Mean,self.result_Mean=self.readResultFile(self.VISpar.result_file_Mean)
        
@@ -688,13 +720,16 @@ class Vis_Tab(gPaIRS_Tab):
             self.image_file=self.VISpar.image_file
             if self.VISpar.img==0:
                 if self.VISpar.flagRun==-2:
-                    self.image_raw=self.image_Current_raw[self.VISpar.frame] if self.image_Current_raw else None
+                    self.image_raw=self.image_Disp_raw if self.VISpar.variableKey==self.namesPIV.dispMap else self.image_Current_raw[self.VISpar.frame] if self.image_Current_raw else None
                 else:
-                    self.image_raw=self.image_Min_raw
+                    self.image_raw=self.image_Disp_raw if self.VISpar.variableKey==self.namesPIV.dispMap else self.image_Min_raw
             else:
                 self.image_file,self.image_raw=self.readImageFile(self.VISpar.image_file)
-        if self.image_raw is None and self.VISpar.img==0: mapVariableList=[]
-        else: mapVariableList=[self.namesPIV.img]
+        mapVariableList=[]
+        #if self.image_raw is None and self.VISpar.img==0: mapVariableList=[]
+        #else: 
+        if self.image_Disp_raw is not None and self.VISpar.img==0: mapVariableList+=[self.namesPIV.dispMap]
+        if (self.image_Min_raw is not None and self.VISpar.img==0) or self.VISpar.img!=0: mapVariableList+=[self.namesPIV.img]
 
         FlagNewResult=self.VISpar.result_file!=self.result_file or self.VISpar.ind[:-1]!=self.VISpar_old.ind[:-1]
         if FlagNewResult or self.FlagReset:
@@ -708,7 +743,7 @@ class Vis_Tab(gPaIRS_Tab):
                 self.result_file,self.result=self.readResultFile(self.VISpar.result_file)
 
         if self.image_raw is not None:
-            if self.VISpar.img>=0:
+            if self.VISpar.img>=0 and self.VISpar.variableKey!=self.namesPIV.dispMap:
                 self.image=transfIm(self.VISpar.Out,Images=[self.image_raw])[0]
             else:
                 self.image=self.image_raw
@@ -719,6 +754,10 @@ class Vis_Tab(gPaIRS_Tab):
             self.image_Min=transfIm(self.VISpar.Out,Images=[self.image_Min_raw])[0]
         else:
             self.image_Min=None
+        if self.image_Disp_raw is not None:
+            self.image_Disp=self.image_Disp_raw #transfIm(self.VISpar.Out,Images=[self.image_Disp_raw])[0]
+        else:
+            self.image_Disp=None
         if self.result is not None: 
             self.getResultInfo()
 
@@ -726,15 +765,26 @@ class Vis_Tab(gPaIRS_Tab):
             [mapVariableList.append(r) for r in list(self.result)]
         self.FlagReset=False
 
-        if self.namesPIV.img in mapVariableList: comboItemsList=[self.namesPIV.combo_dict[self.namesPIV.img]]
-        else: comboItemsList=[]
-        for f in list(self.namesPIV.combo_dict)[1:]:
+        comboItemsList=[]
+        if self.namesPIV.img in mapVariableList: comboItemsList+=[self.namesPIV.combo_dict[self.namesPIV.img]]
+        if self.namesPIV.dispMap in mapVariableList: comboItemsList+=[self.namesPIV.combo_dict[self.namesPIV.dispMap]]
+        for f in list(self.namesPIV.combo_dict)[2:]:
             if f in mapVariableList: comboItemsList.append(self.namesPIV.combo_dict[f])
         if len(comboItemsList)==0: comboItemsList=[self.namesPIV.combo_dict[self.namesPIV.img]]
         if self.VISpar.variable not in comboItemsList:
             self.VISpar.variable=comboItemsList[0]
         self.VISpar.variableKey=self.namesPIV.combo_dict_keys[self.VISpar.variable]
-        self.VISpar.type=int(self.VISpar.variableKey!=self.namesPIV.img)
+        if self.VISpar.variableKey==self.namesPIV.img and self.VISpar.img==0: 
+            if self.VISpar.image_file!=self.VISpar.image_file_Min:
+                self.VISpar.image_file=self.VISpar.image_file_Min
+                self.image=self.image_Min
+                self.getImageInfo()
+        elif self.VISpar.variableKey==self.namesPIV.dispMap and self.VISpar.img==0: 
+            if self.VISpar.image_file!=self.VISpar.image_file_Disp:
+                self.VISpar.image_file=self.VISpar.image_file_Disp
+                self.image=self.image_Disp
+                self.getImageInfo()
+        self.VISpar.type=int(self.VISpar.variableKey not in (self.namesPIV.img, self.namesPIV.dispMap) )
 
         return FlagNewImage, FlagNewResult, comboItemsList
     
@@ -770,18 +820,19 @@ class Vis_Tab(gPaIRS_Tab):
         self.checkResVariables()
 
         FlagLoad=self.image_file_Load!='' or self.result_file_Load!=''
-        FlagResults=self.image_file_Min!='' or self.result_file_Mean!=''
+        FlagResults=self.image_file_Min!='' or self.result_file_Mean!='' or self.image_file_Disp!=''
         FlagSpinsEnabled=self.VISpar.nimg or FlagLoad
+        FlagDispMap=self.VISpar.variableKey==self.namesPIV.dispMap
         #self.ui.Plot_tools.setEnabled(FlagSpinsEnabled)
 
-        FlagIW=self.VISpar.type==0 and self.VISpar.Step in (StepTypes.piv,StepTypes.disp,StepTypes.spiv)
+        FlagIW=self.VISpar.type==0 and self.VISpar.Step in (StepTypes.piv,StepTypes.disp,StepTypes.spiv) and not FlagDispMap
         self.ui.button_ShowIW.setVisible(FlagIW)
         if FlagIW:
             tip=f"{'Hide' if self.ui.button_ShowIW.isChecked() else 'Show'} Interrogation Window scheme"
             self.ui.button_ShowIW.setToolTip(tip)
             self.ui.button_ShowIW.setStatusTip(tip)
 
-        FlagCR=self.VISpar.type==0 and self.VISpar.Step in (StepTypes.disp,StepTypes.spiv)
+        FlagCR=self.VISpar.type==0 and self.VISpar.Step in (StepTypes.disp,StepTypes.spiv) and not FlagDispMap
         self.ui.button_ShowCR.setVisible(FlagCR)
         if FlagCR:
             tip=f"{'Hide' if self.ui.button_ShowCR.isChecked() else 'Show'} common region"
@@ -823,16 +874,20 @@ class Vis_Tab(gPaIRS_Tab):
         self.ui.image_levels.setCurrentIndex(i)
         self.ui.label_title.setText(f"Settings ({i+1}/{c+1})")
 
-        Lim=self.VISpar.vLim[self.VISpar.variableKey]
+        if self.VISpar.variableKey in self.VISpar.vLim:
+            Lim=self.VISpar.vLim[self.VISpar.variableKey]
+        else:
+            Lim=1.0
         step=Lim/nStepsSlider
-        self.ui.spin_min.setMinimum(-Lim if self.VISpar.type else 0)
+        FlagLim= self.VISpar.type or FlagDispMap
+        self.ui.spin_min.setMinimum(-Lim if FlagLim else 0)
         self.ui.spin_min.setMaximum(Lim-2*step)
-        self.ui.spin_max.setMinimum(-Lim+2*step if self.VISpar.type else 2*step)
+        self.ui.spin_max.setMinimum(-Lim+2*step if FlagLim else 2*step)
         self.ui.spin_max.setMaximum(Lim)
-        self.ui.spin_mean.setMinimum(-Lim+step if self.VISpar.type else step)
+        self.ui.spin_mean.setMinimum(-Lim+step if FlagLim else step)
         self.ui.spin_mean.setMaximum(Lim-step)
         self.ui.spin_range.setMinimum(2*step)
-        self.ui.spin_range.setMaximum(2*Lim if self.VISpar.type else step)
+        self.ui.spin_range.setMaximum(2*Lim if FlagLim else step)
         self.ui.spin_vecspac.setMaximum(self.VISpar.size[1][4])
 
         self.ui.label_vecspac.setVisible(self.VISpar.field_rep==1)
@@ -856,12 +911,12 @@ class Vis_Tab(gPaIRS_Tab):
         self.ui.spin_cam.setMaximum(self.VISpar.ncam)
         self.ui.spin_cam.setEnabled(FlagSpinsEnabled and self.VISpar.ncam>1)
 
-        FlagCamFrame=self.VISpar.img>-1 and self.VISpar.type==0
+        FlagCamFrame=self.VISpar.img>-1 and self.VISpar.type==0 and not FlagDispMap
         self.ui.label_frame.setVisible(FlagCamFrame)
         self.ui.spin_frame.setVisible(FlagCamFrame)
         self.ui.label_cam.setVisible(FlagCamFrame)
         self.ui.spin_cam.setVisible(FlagCamFrame)
-        FlagDispResult=self.VISpar.img==0 and self.VISpar.Step==StepTypes.disp and self.VISpar.type==1
+        FlagDispResult=self.VISpar.img==0 and self.VISpar.Step==StepTypes.disp #and self.VISpar.variableKey is not self.namesPIV.img #and self.VISpar.type==1
         self.ui.label_it.setVisible(FlagDispResult)
         self.ui.spin_it.setVisible(FlagDispResult)
         self.ui.spin_it.setMinimum(1)
@@ -880,8 +935,10 @@ class Vis_Tab(gPaIRS_Tab):
         self.ui.name_var.setToolTip(f'{dataType} file: {dataName}')
         self.ui.name_var.setStatusTip(self.ui.name_var.toolTip()) 
         
-        self.VISpar.colorMap=self.VISpar.vcolorMap[self.VISpar.variableKey]
-        self.VISpar.vectorColor=self.VISpar.vvectorColor[self.VISpar.variableKey]
+        if self.VISpar.variableKey in self.VISpar.vcolorMap:
+            self.VISpar.colorMap=self.VISpar.vcolorMap[self.VISpar.variableKey]
+        if self.VISpar.variableKey in self.VISpar.vvectorColor:
+            self.VISpar.vectorColor=self.VISpar.vvectorColor[self.VISpar.variableKey]
 
         self.ui.button_cmap.setIcon(QIcon(icons_path+'colormaps/'+self.VISpar.colorMap+'.png'))
         self.ui.button_cvec.setIcon(QIcon(icons_path+'colormaps/'+self.VISpar.vectorColor+'Vector.png'))
@@ -901,17 +958,19 @@ class Vis_Tab(gPaIRS_Tab):
         return
     
     def setLevels(self):
-        self.VISpar.min=self.VISpar.vmin[self.VISpar.variableKey]
-        self.VISpar.max=self.VISpar.vmax[self.VISpar.variableKey]
-        self.VISpar.mean=self.VISpar.vmean[self.VISpar.variableKey]
-        self.VISpar.range=self.VISpar.vrange[self.VISpar.variableKey]
+        if self.VISpar.variableKey in self.VISpar.vmin:
+            self.VISpar.min=self.VISpar.vmin[self.VISpar.variableKey]
+            self.VISpar.max=self.VISpar.vmax[self.VISpar.variableKey]
+            self.VISpar.mean=self.VISpar.vmean[self.VISpar.variableKey]
+            self.VISpar.range=self.VISpar.vrange[self.VISpar.variableKey]
             
     def resetLevels(self):
-        self.VISpar.vmin[self.VISpar.variableKey]=self.VISpar.vmin_default[self.VISpar.variableKey]
-        self.VISpar.vmax[self.VISpar.variableKey]=self.VISpar.vmax_default[self.VISpar.variableKey]
-        self.VISpar.vmean[self.VISpar.variableKey]=self.VISpar.vmean_default[self.VISpar.variableKey]
-        self.VISpar.vrange[self.VISpar.variableKey]=self.VISpar.vrange_default[self.VISpar.variableKey]
-        #self.setLevels()
+        if self.VISpar.variableKey in self.VISpar.vmin_default:
+            self.VISpar.vmin[self.VISpar.variableKey]=self.VISpar.vmin_default[self.VISpar.variableKey]
+            self.VISpar.vmax[self.VISpar.variableKey]=self.VISpar.vmax_default[self.VISpar.variableKey]
+            self.VISpar.vmean[self.VISpar.variableKey]=self.VISpar.vmean_default[self.VISpar.variableKey]
+            self.VISpar.vrange[self.VISpar.variableKey]=self.VISpar.vrange_default[self.VISpar.variableKey]
+            #self.setLevels()
 
     def resetAllLevels(self, ind=None):
         if ind is None: VIS:VISpar=self.VISpar
@@ -958,22 +1017,35 @@ class Vis_Tab(gPaIRS_Tab):
     def getImageInfo(self,image=None,ind=None):
         if image is None: I=self.image
         else: I=image
+        if I is None: return
         if ind is None: VIS:VISpar=self.VISpar
         else: VIS:VISpar=self.TABpar_at(ind)
-
-        mean=np.mean(I).item()
-        std=np.std(I).item()
-        #self.VISpar.vLim[self.namesPIV.img]=2**self.nbits
-        VIS.vLim[self.namesPIV.img]=min([2*I.max().item(),2**(self.nbits+1)])
-        VIS.vmin_default[self.namesPIV.img]=np.round(max([mean-2*std,0])).item()
-        VIS.vmax_default[self.namesPIV.img]=np.round(min([mean+2*std,VIS.vLim[self.namesPIV.img]])).item()
-        VIS.vmean_default[self.namesPIV.img]=0.5*(VIS.vmin_default[self.namesPIV.img]+VIS.vmax_default[self.namesPIV.img])
-        VIS.vrange_default[self.namesPIV.img]=VIS.vmax_default[self.namesPIV.img]-VIS.vmin_default[self.namesPIV.img]
+        variableKey=self.VISpar.variableKey
+        if variableKey is self.namesPIV.dispMap:
+            variableKey=self.namesPIV.dispMap
+            if image is None:
+                CC_16bit=self.image.astype(np.float64)  # Convert back to float
+                I=(CC_16bit / 65535.0) * 2.0 - 1.0  # Reverse the normalization     
+                self.image=I 
+            mean=np.mean(I).item()
+            std=np.std(I).item()
+            VIS.vLim[variableKey]=1.0
+            VIS.vmin_default[variableKey]=max([mean-2*std,-1.0])
+            VIS.vmax_default[variableKey]=min([mean+2*std,1.0])
+        else:
+            mean=np.mean(I).item()
+            std=np.std(I).item()
+            VIS.vLim[variableKey]=min([2*I.max().item(),2**(self.nbits+1)])
+            VIS.vmin_default[variableKey]=np.round(max([mean-2*std,0])).item()
+            VIS.vmax_default[variableKey]=np.round(min([mean+2*std,VIS.vLim[variableKey]])).item()
+
+        VIS.vmean_default[variableKey]=0.5*(VIS.vmin_default[variableKey]+VIS.vmax_default[variableKey])
+        VIS.vrange_default[variableKey]=VIS.vmax_default[variableKey]-VIS.vmin_default[variableKey]
         VIS.size_default[0]=[0,np.size(I,1),0,np.size(I,0),1]
-        if self.namesPIV.img not in VIS.vcolorMap:
-            VIS.vcolorMap[self.namesPIV.img]='gray'
-        if self.namesPIV.img not in VIS.vvectorColor:
-            VIS.vvectorColor[self.namesPIV.img]='green'
+        if variableKey not in VIS.vcolorMap:
+            VIS.vcolorMap[variableKey]='gray' if variableKey in ('img','dispMap') else 'jet'
+        if variableKey not in VIS.vvectorColor:
+            VIS.vvectorColor[variableKey]='green' if variableKey in ('img','dispMap') else 'black'
 
     def readResultFile(self,filename):
         res=None
@@ -1021,10 +1093,11 @@ class Vis_Tab(gPaIRS_Tab):
     def getResultInfo(self,result=None,ind=None):
         if result is None: res=self.result
         else: res=result
+        if res is None: return
         if ind is None: VIS:VISpar=self.VISpar
         else: VIS:VISpar=self.TABpar_at(ind)
         for i in list(VIS.vmin_default):
-            if i!=self.namesPIV.img:
+            if i not in (self.namesPIV.img,self.namesPIV.dispMap):
                 del VIS.vmin_default[i]
                 del VIS.vmax_default[i]
                 del VIS.vmean_default[i]
@@ -1032,7 +1105,7 @@ class Vis_Tab(gPaIRS_Tab):
                 del VIS.vLim[i]
 
         for f in list(res):
-            V:np=res[f]
+            V:np=res[f][~np.isnan(res[f])]
             #m=np.mean(V).item()
             #r=np.std(V).item()
             #VIS.vLim[f]=max([m+5*r,abs(m-5*r)])
@@ -1080,7 +1153,7 @@ class Vis_Tab(gPaIRS_Tab):
 
     def button_ShowIW_action(self):
         self.VISpar.FlagShowIW=self.ui.button_ShowIW.isChecked()
-        self.resetXYLims()
+        #if self.VISpar.FlagShowIW: self.resetXYLims()
     
     def button_SubMIN_action(self):
         self.VISpar.FlagSubMIN=self.ui.button_SubMIN.isChecked()
@@ -1216,7 +1289,59 @@ class Vis_Tab(gPaIRS_Tab):
         spin_value=getattr(self.VISpar,n)
         res=self.xres if k<2 else self.yres
         self.VISpar.size[self.VISpar.type][k]=spin_value/res
-        
+
+    def button_dx_left_action(self):
+        dx=(self.VISpar.xmax-self.VISpar.xmin)/self.xres
+        self.VISpar.size[self.VISpar.type][0]-=dx
+        self.VISpar.size[self.VISpar.type][1]-=dx
+
+    def button_dx_right_action(self):
+        dx=(self.VISpar.xmax-self.VISpar.xmin)/self.xres
+        self.VISpar.size[self.VISpar.type][0]+=dx
+        self.VISpar.size[self.VISpar.type][1]+=dx
+
+    def button_dy_down_action(self):
+        dy=(self.VISpar.ymax-self.VISpar.ymin)/self.yres
+        self.VISpar.size[self.VISpar.type][2]-=dy
+        self.VISpar.size[self.VISpar.type][3]-=dy
+
+    def button_dy_up_action(self):
+        dy=(self.VISpar.ymax-self.VISpar.ymin)/self.yres
+        self.VISpar.size[self.VISpar.type][2]+=dy
+        self.VISpar.size[self.VISpar.type][3]+=dy
+
+    def button_FocusIW_action(self):
+        ve=self.VISpar.Pro.Vect if isinstance(self.VISpar.Pro.Vect[0],list) else [[v] for v in self.VISpar.Pro.Vect] 
+        Vect = [[val for val in v] for v  in ve]
+        if self.VISpar.unit[self.VISpar.type] and self.VISpar.type!=0:
+            yres=self.VISpar.Out.xres*self.VISpar.Out.pixAR
+            for k in range(2): Vect[k]=[val/self.VISpar.Out.xres for val in Vect[k]]
+            for k in range(2,4): Vect[k]=[val/yres for val in Vect[k]]
+        else: yres=1.0
+        W=Vect[2][-1]
+        FlagDisp=self.VISpar.variableKey is self.namesPIV.dispMap
+        if FlagDisp:
+            H=self.gui.w_Process_Disp.PROpar.SemiWidth_Epipolar*2+1
+            H/=yres
+            FlagBordo=False
+        else:
+            H=Vect[0][-1]
+            FlagBordo=self.VISpar.Pro.FlagBordo
+        if abs(self.VISpar.size[self.VISpar.type][1]-self.VISpar.size[self.VISpar.type][0]-W)<1 and abs(self.VISpar.size[self.VISpar.type][3]-self.VISpar.size[self.VISpar.type][2]-H)<1:
+            dW=W if FlagDisp else Vect[3][-1] 
+            boundDist=W/2 if not FlagBordo else dW
+            x0=int((self.VISpar.size[self.VISpar.type][0]-boundDist+W/2)/dW)*dW+boundDist-W/2 if self.VISpar.size[self.VISpar.type][0]>boundDist else boundDist-W/2
+            dH=H if FlagDisp else Vect[1][-1]
+            boundDist=H/2 if not FlagBordo else dH
+            y0=int((self.VISpar.size[self.VISpar.type][2]-boundDist+H/2)/dH)*dH+boundDist-H/2 if self.VISpar.size[self.VISpar.type][2]>boundDist else boundDist-H/2
+            self.VISpar.size[self.VISpar.type][0]=x0
+            self.VISpar.size[self.VISpar.type][2]=y0
+            self.VISpar.size[self.VISpar.type][1]=x0+W
+            self.VISpar.size[self.VISpar.type][3]=y0+H
+        else:
+            self.VISpar.size[self.VISpar.type][1]=self.VISpar.size[self.VISpar.type][0]+W
+            self.VISpar.size[self.VISpar.type][3]=self.VISpar.size[self.VISpar.type][2]+H
+
  #******************** Settings
     def button_view_set(self):
         self.ui.button_view.setChecked(self.VISpar.FlagView)
@@ -1271,14 +1396,18 @@ class Vis_Tab(gPaIRS_Tab):
         self.VISpar.size[self.VISpar.type][:2]=[xmin/self.xres,xmax/self.xres]
         self.VISpar.size[self.VISpar.type][2:4]=[ymin/self.yres,ymax/self.yres]
         
+    def forceRestoreArrowCursor(self):
+        if self.CursorTimer.isActive():
+            self.CursorTimer.stop()
+        while QApplication.overrideCursor() is not None:
+            QApplication.restoreOverrideCursor()
+        self.FlagNormalCursor = True
+
     def brushCursor(self):
-        if self.FlagNormalCursor:
-            self.FlagNormalCursor=False
-            QApplication.setOverrideCursor(self.brush_cursor) 
-            def restoreCursor():
-                QApplication.restoreOverrideCursor()
-                self.FlagNormalCursor=True
-            QTimer.singleShot(250,lambda: restoreCursor())
+        self.forceRestoreArrowCursor()
+        self.FlagNormalCursor=False
+        QApplication.setOverrideCursor(self.brush_cursor) 
+        self.CursorTimer.start(250)
 
     def setMapVar(self):    
         pri.PlotTime.magenta(f'{"/"*25} Plotting image - start')
@@ -1295,7 +1424,7 @@ class Vis_Tab(gPaIRS_Tab):
                 FlagIW=self.VISpar.isDifferentFrom(self.VISpar_old,fields=['FlagShowIW','Pro'])
                 if FlagIW or FlagDraw: self.showRect()
                 FlagDraw=FlagDraw or FlagIW
-                if self.image is not None and self.VISpar.FlagShowCR:
+                if self.image is not None and self.VISpar.FlagShowCR and self.VISpar.variableKey!=self.namesPIV.dispMap:
                     self.showCommonRegion()
                     FlagDraw=FlagDraw or self.CR is not None
                 else: 
@@ -1304,12 +1433,13 @@ class Vis_Tab(gPaIRS_Tab):
                 if self.orect: self.cleanRect()
                 self.cleanCommonRegion()
                 fields=['result_file','variable','unit','min','max','nclev','FlagContourf','colorMap']
+                if self.VISpar.variableKey not in self.result: raise('Variable not found in result structure!')
                 V=self.result[self.VISpar.variableKey]
                 if not self.VISpar.FlagContourf:   
                     self.img,Ximg,Yimg,FlagInterp,size=self.calcMap(V,size_pixels=[np.size(V,0), np.size(V,1)])
                     FlagDraw=self.showImg(fields,size)
                 else:
-                    self.img,Ximg,Yimg,FlagInterp,size=self.calcMap(self.result[self.VISpar.variableKey])
+                    self.img,Ximg,Yimg,FlagInterp,size=self.calcMap(V)
                     if FlagInterp:
                         FlagDraw=self.showImg(fields,size)
                     else:
@@ -1353,6 +1483,7 @@ class Vis_Tab(gPaIRS_Tab):
             if self.imgshow is None or self.VISpar_old.FlagContourf!=self.VISpar.FlagContourf or FlagOut:
                 self.cleanAxes()
                 self.imgshow=self.ui.plot.axes.imshow(img,extent=self.imgExtent(size), origin='lower', vmin=self.VISpar.min,vmax=self.VISpar.max,zorder=0)
+                self.imgshow.format_cursor_data=lambda v: self.custom_format_cursor_data(v)
                 cmap,_=self.colorMap()
                 self.imgshow.set_cmap(cmap)
                 divider = make_axes_locatable(self.ui.plot.axes)
@@ -1444,44 +1575,40 @@ class Vis_Tab(gPaIRS_Tab):
         FlagCLim=self.VISpar.isDifferentFrom(self.VISpar_old,fields=['min','max'])
 
         if FlagNewPlot or self.VISpar_old.FlagContourf!=self.VISpar.FlagContourf or self.VISpar_old.nclev!=self.VISpar.nclev:
-            if self.imgshow:
-                self.imgshow.remove()
-                self.imgshow=None
+            self.cleanAxes()
             if not self.VISpar.unit[self.VISpar.type]:
                 xres,yres=self.getXYRes(type=1)
             else: xres=yres=1.0
             X=result[self.namesPIV.x]*xres
             Y=result[self.namesPIV.y]*yres
+            if self.VISpar.variableKey not in self.result: raise('Variable not found in result structure!')
             V=result[self.VISpar.variableKey]
-            self.map=V
-           
-            
-            if self.contour: 
-                for coll in self.contour.collections:
-                    coll.remove()
+            self.map=[X,Y,V]
+
             cmap,levs=self.colorMap()
             try:
                 self.contour=self.ui.plot.axes.contourf(X, Y, V, levs, \
                     cmap=cmap, origin='lower', extend='both', zorder=0)
+                self.contour.format_cursor_data=lambda v: self.custom_format_cursor_data(v)
             except:
                 pri.Error.red(f'Error while generating contour lines:\n{traceback.format_exc()}\n\n')
                 self.contour=None
                 return
             self.contour.set_clim(levs[0],levs[-1])
-            if self.cb is None:
-                divider = make_axes_locatable(self.ui.plot.axes)
-                cax = divider.append_axes("right", size="5%", pad=0.05) 
-                self.cb=self.ui.plot.fig.colorbar(self.contour,cax=cax) 
+            divider = make_axes_locatable(self.ui.plot.axes)
+            cax = divider.append_axes("right", size="5%", pad=0.05) 
+            self.cb=self.ui.plot.fig.colorbar(self.contour,cax=cax) 
             self.setTitleLabels()
+            FlagXLim=True
         else:
             if FlagCMap:
                 cmap,_=self.colorMap()
                 self.contour.set_cmap(cmap)
             if FlagCLim:
                 self.contour.set_clim(self.VISpar.min,self.VISpar.max)
-            if FlagXLim:
-                self.setAxisLim()
-            self.Ptoolbar.update()
+        if FlagXLim:
+            self.setAxisLim()
+        self.Ptoolbar.update()
 
         FlagDraw=FlagNewPlot or FlagXLim or FlagCMap or FlagCLim
         return FlagDraw
@@ -1506,37 +1633,55 @@ class Vis_Tab(gPaIRS_Tab):
         x = self.mylinspace(xmin,xmax, np.size(V,1))  
         ystep_half=(ymax-ymin)/(np.size(V,0)-1)*0.5
         y = self.mylinspace(ymin,ymax, np.size(V,0))
-        FlagInterp=True
-        if np.size(V,1)<size_pixels[1] or np.size(V,0)<size_pixels[0]:
+        FlagInterp=False
+        if (np.size(V,1)<size_pixels[1] or np.size(V,0)<size_pixels[0]) and not bool(np.any(np.isnan(V))):
             x_new = self.mylinspace(xmin, xmax, size_pixels[0]) 
             y_new = self.mylinspace(ymin, ymax, size_pixels[1])
             try:
                 f = scipy.interpolate.RectBivariateSpline(y, x, V)
-                V = f(y_new, x_new)
+                V_new = f(y_new, x_new)
+                FlagInterp=True
             except:
                 try:
                     x_flat, y_flat = np.meshgrid(x, y)  # Griglia 2D
                     points = np.column_stack((x_flat.ravel(), y_flat.ravel()))  # Punti 2D
                     X_new, Y_new = np.meshgrid(x_new, y_new)
-                    V = scipy.interpolate.griddata(points, V.ravel(), (X_new, Y_new), method='cubic') #'nearest', 'linear', 'cubic'
+                    V_new = scipy.interpolate.griddata(points, V.ravel(), (X_new, Y_new), method='cubic') #'nearest', 'linear', 'cubic'
+                    FlagInterp=True
+                    pass
                 except:
                     pri.Error.red(f'Error while interpolating map variable field for contour representation:\n{traceback.format_exc()}\n\n')
                     x_new=x
                     y_new=y
+                    V_new=V
                     FlagInterp=False
                     pass
         else:
             x_new=x
             y_new=y
+            V_new=V
+            FlagInterp=not bool(np.any(np.isnan(V)))
         X_new, Y_new = np.meshgrid(x_new, y_new)
-        return V, X_new, Y_new, FlagInterp, (xmin-xstep_half,xmax+ystep_half,ymin-ystep_half,ymax+ystep_half)
+        return V_new, X_new, Y_new, FlagInterp, (xmin-xstep_half,xmax+ystep_half,ymin-ystep_half,ymax+ystep_half)
 
     def mylinspace(self,xmin,xmax,N):
         step=(xmax-xmin)/(N-1)
         return xmin+np.arange(0,N,1)*step
     
+    def cleanVecField(self):
+        if self.qui!=None:
+            self.qui.remove()  
+            self.qui=None
+        if self.stream is not None:
+            self.stream.lines.remove()
+            for ax in self.ui.plot.axes.get_children():
+                if isinstance(ax, mpl.patches.FancyArrowPatch):
+                    ax.remove()      
+            self.stream=None 
+
     def showVecField(self):
         ind=self.VISpar.field_rep
+        self.cleanVecField()
         if self.qui!=None:
             self.qui.remove()  
             self.qui=None
@@ -1583,17 +1728,49 @@ class Vis_Tab(gPaIRS_Tab):
                 self.stream=self.ui.plot.axes.streamplot(Xp,Yp,Up,Vp,color=VIS_VectorColors[self.VISpar.vectorColor],density=self.VISpar.streamdens,zorder=10)
 
     def cleanAxes(self,FlagAxis=True):
-        self.imgshow=self.contour=None 
-        self.ui.plot.axes.cla()
+        self.imgshow=self.contour=self.CR=self.RF=None 
+        self.orect=[]
+        self.qui=self.stream=None
+        """
+        self.cleanCommonRegion()
+        self.cleanReferenceFrame()
+        self.cleanRect()
+        self.cleanVecField()
+        if self.contour: 
+            for coll in self.contour.collections:
+                coll.remove()
+        """
         if self.cb: 
-            try:
-                self.cb.remove()
-            except:
-                pass
+            self.cb.remove()
             self.cb=None
+        self.ui.plot.axes.cla()
         self.ui.plot.axes.axis('on' if FlagAxis else 'off')
         #self.ui.Plot_tools.setEnabled(FlagAxis)
 
+    def custom_format_coord(self,x,y):
+        if self.contour is not None:
+            X=self.map[0]
+            Y=self.map[1]
+            
+            if X.min() <= x <= X.max() and Y.min() <= y <= Y.max():
+                # Trova l'indice più vicino nella matrice
+                col = np.searchsorted(X[0,:],x) - 1
+                row = np.searchsorted(Y[:,0],y) - 1
+                Z=self.map[2]
+
+                # Estrai il valore dal dato Z
+                if 0 <= row < Z.shape[0] and 0 <= col < Z.shape[1]:
+                    value = Z[row, col]
+                    formatted_value = f"{value:.4f}".rstrip('0').rstrip('.')
+                    return f"(x, y)=({x:.2f}, {y:.2f})\n[{formatted_value}]" 
+            return f"(x, y)=({x:.2f}, {y:.2f})" 
+        else:
+            return f"(x, y)=({x:.2f}, {y:.2f})"
+
+    def custom_format_cursor_data(self,value):
+        formatted_value = f"{value:.4f}".rstrip('0').rstrip('.')
+        return f"[{formatted_value}]"
+
     def cleanRect(self):
         if len(self.orect):
             for r in self.orect: 
@@ -1677,21 +1854,22 @@ class Vis_Tab(gPaIRS_Tab):
             else:
                 yin0=0
                 xin0=xmax
-        xlim=self.ui.plot.axes.get_xlim()
-        xlim_min=min([xlim[0],xlim_min])
-        xlim_max=max([xlim[1],xlim_max])
-        self.ui.plot.axes.set_xlim(xlim_min,xlim_max)
-        if self.VISpar.FlagYInvert[self.VISpar.type]: 
-            ylim=self.ui.plot.axes.get_ylim()
-            ylim_max=min([ylim[1],ylim_min])
-            ylim_min=max([ylim[0],ylim_max])
-        else:
-            ylim=self.ui.plot.axes.get_ylim()
-            ylim_min=min([ylim[0],ylim_min])
-            ylim_max=max([ylim[1],ylim_max])
-        self.ui.plot.axes.set_ylim(ylim_min,ylim_max)
-        self.VISpar.xmin,self.VISpar.xmax=list(self.ui.plot.axes.get_xlim())
-        self.VISpar.ymin,self.VISpar.ymax=list(self.ui.plot.axes.get_ylim())
+        if self.VISpar.FlagShowIW and self.VISpar.isDifferentFrom(self.VISpar_old,fields=['FlagShowIW']):
+            xlim=self.ui.plot.axes.get_xlim()
+            xlim_min=min([xlim[0],xlim_min])
+            xlim_max=max([xlim[1],xlim_max])
+            self.ui.plot.axes.set_xlim(xlim_min,xlim_max)
+            if self.VISpar.FlagYInvert[self.VISpar.type]: 
+                ylim=self.ui.plot.axes.get_ylim()
+                ylim_max=min([ylim[1],ylim_min])
+                ylim_min=max([ylim[0],ylim_max])
+            else:
+                ylim=self.ui.plot.axes.get_ylim()
+                ylim_min=min([ylim[0],ylim_min])
+                ylim_max=max([ylim[1],ylim_max])
+            self.ui.plot.axes.set_ylim(ylim_min,ylim_max)
+            self.VISpar.xmin,self.VISpar.xmax=list(self.ui.plot.axes.get_xlim())
+            self.VISpar.ymin,self.VISpar.ymax=list(self.ui.plot.axes.get_ylim())
 
     def cleanCommonRegion(self):
         if self.CR: