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

PaIRS_UniNa/Vis_Tab.py

@@ -25,6 +25,7 @@ spin_tips={
     'ymax' : 'Maximum y coordinate',
     'nclev':    'Number of color levels',
     'vecsize':  'Size of velocity vectors',
+    'vecwid':   'Width of velocity vectors',
     'vecspac':  'Spacing of velocity vectors',
     'streamdens':  'Density of streamlines',
     'img':      'Image number',
@@ -54,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',
@@ -101,6 +107,7 @@ class NamesPIV(TABpar):
         self.Step               = Step
    
         self.img='img'
+        self.dispMap='dispMap'
         self.X='X'
         self.Y='Y'
         self.Z='Z'
@@ -117,6 +124,7 @@ class NamesPIV(TABpar):
         self.uvp='uv'
         self.uwp='uw'
         self.vwp='vw'
+        self.ZVort='ZVort'
         self.dPar='dPar'
         self.dOrt='dOrt'
         self.sn='SN'
@@ -128,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',
@@ -135,10 +144,11 @@ class NamesPIV(TABpar):
                     self.w:   'W',
                     self.up:  "<u'u'>",
                     self.vp:  "<v'v'>",
-                    self.vwp:  "<w'w'>",
+                    self.wp:  "<w'w'>",
                     self.uvp:  "<u'v'>",
                     self.uwp:  "<u'w'>",
                     self.vwp:  "<v'w'>",
+                    self.ZVort: "z-vorticity",
                     self.dPar: "epipolar || disp.",
                     self.dOrt: "epipolar ⊥ disp.",
                     self.sn:   "S/N",
@@ -149,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",
@@ -160,6 +171,7 @@ class NamesPIV(TABpar):
                     self.uvp:  "xy tangential Reynolds stress",
                     self.uwp:  "xz tangential Reynolds stress",
                     self.vwp:  "yz tangential Reynolds stress",
+                    self.ZVort: "z-vorticity component",
                     self.dPar: "epipolar parallel displacement",
                     self.dOrt: "epipolar orthogonal displacement",
                     self.sn: "signal-to-noise ratio",
@@ -168,6 +180,7 @@ class NamesPIV(TABpar):
                     }
         self.titles_cb_dict={
                     self.img: '',
+                    self.dispMap: '',
                     self.Mod: "|Vel|",
                     self.z: "z",
                     self.u: "U",
@@ -181,6 +194,7 @@ class NamesPIV(TABpar):
                     self.vwp:  "<v'w'>",
                     self.dPar: "d par.",
                     self.dOrt: "d ort.",
+                    self.ZVort: "ωz",
                     self.sn: "S/N",
                     self.Info: "i",
                     self.FCl:   "CC"
@@ -201,14 +215,14 @@ class NamesPIV(TABpar):
             self.avgVel_plot=copy.deepcopy(self.instVel_plot)
         elif Step==StepTypes.spiv:
             self.instVel=[self.x,self.y,self.z,self.u,self.v,self.w,self.FCl,self.Info,self.sn]
-            self.instVel_plot=[self.Mod,self.u,self.v,self.w,self.FCl,self.Info,self.sn]
+            self.instVel_plot=[self.Mod,self.u,self.v,self.w,self.ZVort,self.FCl,self.Info,self.sn]
             self.avgVel=[self.x,self.y,self.z,self.u,self.v,self.w,self.up,self.vp,self.wp,self.uvp,self.uwp,self.vwp,self.FCl,self.Info,self.sn]
-            self.avgVel_plot=[self.Mod,self.u,self.v,self.w,self.up,self.vp,self.wp,self.uvp,self.uwp,self.vwp,self.FCl,self.Info,self.sn]
+            self.avgVel_plot=[self.Mod,self.u,self.v,self.w,self.up,self.vp,self.wp,self.uvp,self.uwp,self.vwp,self.ZVort,self.FCl,self.Info,self.sn]
         else: # for now should be StepTypes.piv
             self.instVel=[self.x,self.y,self.u,self.v,self.FCl,self.Info,self.sn]
-            self.instVel_plot=[self.Mod,self.u,self.v,self.FCl,self.Info,self.sn]
+            self.instVel_plot=[self.Mod,self.u,self.v,self.ZVort,self.FCl,self.Info,self.sn]
             self.avgVel=[self.x,self.y,self.u,self.v,self.up,self.vp,self.uvp,self.FCl,self.Info,self.sn]
-            self.avgVel_plot=[self.Mod,self.u,self.v,self.up,self.vp,self.uvp,self.FCl,self.Info,self.sn]
+            self.avgVel_plot=[self.Mod,self.u,self.v,self.up,self.vp,self.uvp,self.ZVort,self.FCl,self.Info,self.sn]
    
         self.instVelFields=[self.allFields[f] for f in self.instVel   ]
         self.instVel_plot_ind=[self.fields.index(f) for f in self.instVel_plot if f in self.fields]
@@ -220,8 +234,7 @@ class NamesPIV(TABpar):
     
 class VISpar(TABpar):
     FlagVis=True
-    FlagAutoLevels=True
-    FlagAutoSizes=True    
+
     class OUT(TABpar):
         def __init__(self):
             self.x     = 0                
@@ -238,6 +251,10 @@ class VISpar(TABpar):
             self.xres = 1
             self.pixAR = 1
 
+            self.zconst = 0.0
+            self.xterm  = 0.0
+            self.yterm  = 0.0
+
             super().__init__('VISpar.Out','Vis')
     
     class PRO(TABpar):
@@ -251,12 +268,12 @@ class VISpar(TABpar):
     def __init__(self,Process=ProcessTypes.null,Step=StepTypes.null):
         self.setup(Process,Step)
         super().__init__('VISpar','Vis')
-        self.unchecked_fields+=['FlagAutomaticLevels','FlagAutomaticSizes','setPage']
+        self.unchecked_fields+=['setPage']
+        self.uncopied_fields+=['graphics_fields']
 
     def setup(self,Process,Step):
         self.Process = Process
         self.Step    = Step
-        self.type     = 0
         self.FlagView = False
 
         self.img=-1
@@ -275,6 +292,8 @@ class VISpar(TABpar):
         self.result_file=''
         self.FlagResult=False
 
+        fields_noGraphics=[f for f,_ in self.__dict__.items()]
+        self.type      = 0
         self.FlagMIN   = False
         self.FlagTR    = False
         self.LaserType = 0
@@ -282,6 +301,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=''
@@ -293,25 +313,29 @@ class VISpar(TABpar):
         self.variableKey=''
         self.field_rep=0
 
+        self.FlagAutoLevels=True
+        self.FlagAutoSizes=True 
         self.FlagYInvert=[False,False]
         self.FlagResetLevels=True
         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
@@ -327,11 +351,14 @@ class VISpar(TABpar):
 
         self.nclev=30
         self.vecsize=1
+        self.vecwid=1
         self.vecspac=1
         self.streamdens=1
 
-        self.FlagContourf=False
+        self.FlagContourf=True
         
+        self.graphics_fields=[f for f,_ in self.__dict__.items() if f not in fields_noGraphics]
+
         self.Out=self.OUT()
         self.Pro=self.PRO()
 
@@ -339,13 +366,18 @@ class VISpar(TABpar):
         self.calList    = []
         self.calEx      = []
 
-        self.FlagDISP   = Step==StepTypes.disp
-        self.dispFile   = ''
+        #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:
@@ -368,6 +400,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):
@@ -386,8 +419,11 @@ class Vis_Tab(gPaIRS_Tab):
             setAppGuiPalette(self)
 
         #------------------------------------- Graphical interface: miscellanea
-        self.brush_cursor= QCursor(QPixmap(icons_path+"brush_cursor.png").scaled(24,24))
+        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
@@ -400,6 +436,7 @@ class Vis_Tab(gPaIRS_Tab):
         self.qui=None
         self.stream=None
         self.CR=None
+        self.RF=None
 
         self.namesPIV=NamesPIV()
 
@@ -451,7 +488,7 @@ class Vis_Tab(gPaIRS_Tab):
         self.setupWid()  #---------------- IMPORTANT
 
         FlagPreventAddPrev_Slider=False
-        for n in ('min','max','mean','range','nclev','vecsize','vecspac','streamdens'):
+        for n in ('min','max','mean','range','nclev','vecsize','vecwid','vecspac','streamdens'):
             def defineSliderCallbackSet(n):
                 spin:QSpinBox=getattr(self.ui,'spin_'+n)
                 slider:QSlider=getattr(self.ui,'slider_'+n)
@@ -460,7 +497,7 @@ class Vis_Tab(gPaIRS_Tab):
                     changingAction=lambda: self.sliderLevels_changing(spin,slider,FlagPreventAddPrev_Slider)
                     callback=self.wrappedCallback(spin_tips[n],changingAction)
                     action=lambda: self.spinLevels_action(spin)
-                elif n in ('nclev','vecsize','vecspac','streamdens'):
+                elif n in ('nclev','vecsize','vecwid','vecspac','streamdens'):
                     changingAction=lambda: self.sliderFieldRep_changing(spin,slider,FlagPreventAddPrev_Slider)
                     callback=self.wrappedCallback(spin_tips[n],changingAction)
                     action=lambda: self.spinFieldRep_action(spin)
@@ -514,8 +551,8 @@ class Vis_Tab(gPaIRS_Tab):
         self.setTABlayout=self.setVISlayout
 
         self.FlagReset=True
-        self.FlagResetLevels=True
-        self.FlagResetSizes =True
+        self.FlagResetLevels=False
+        self.FlagResetSizes =False
 
         self.image_file=''
         self.image_raw=None
@@ -523,6 +560,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
@@ -590,7 +630,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()
@@ -598,7 +638,7 @@ class Vis_Tab(gPaIRS_Tab):
         FlagNew=(not self.VISpar.type and FlagNewImage) or (self.VISpar.type==1 and FlagNewResult)
         FlagDiff=self.VISpar.isDifferentFrom(self.VISpar_old,fields=['img','cam','frame']) or FlagNew
 
-        if (VISpar.FlagAutoLevels and (FlagNewImage or FlagNewResult)):
+        if (self.VISpar.FlagAutoLevels and (FlagNewImage or FlagNewResult)):
             self.resetAllLevels()
             if FlagDiff or self.FlagResetLevels:
                 self.FlagResetLevels=False
@@ -607,7 +647,7 @@ class Vis_Tab(gPaIRS_Tab):
             self.FlagResetLevels=False
             self.resetLevels()
 
-        if (VISpar.FlagAutoSizes and (FlagNewImage or FlagNewResult)):
+        if (self.VISpar.FlagAutoSizes and (FlagNewImage or FlagNewResult)):
             self.resetAllXYLims()
             if FlagDiff or self.FlagResetSizes:
                 self.FlagResetSizes=False
@@ -615,21 +655,33 @@ class Vis_Tab(gPaIRS_Tab):
         elif self.FlagResetSizes: 
             self.FlagResetSizes=False
             self.resetXYLims()
+        
+        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
-        if self.VISpar.FlagMIN:
+        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)
+        if FlagMinimum:
             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
 
@@ -640,21 +692,7 @@ class Vis_Tab(gPaIRS_Tab):
             if (self.VISpar.Step==StepTypes.disp and self.VISpar.it==self.VISpar.Nit) or self.VISpar.Step!=StepTypes.disp:
                 self.VISpar.result_file=self.VISpar.result_file_Current
         else:
-            if self.VISpar.flagRun!=0: #and self.VISpar.isDifferentFrom(self.VISpar_old,fields=['outPathRoot']):
-                if not self.VISpar.FlagView and (self.VISpar.FlagView!=self.VISpar_old.FlagView or self.VISpar.ind[:-1]!=self.VISpar_old.ind[:-1]):
-                    self.VISpar.FlagResult=False
-                    filename=procOutName(self.VISpar)
-                    if os.path.exists(filename):
-                        try:
-                            from .Saving_tools import loadList
-                            data=loadList(filename)
-                            ind=list(data[0][0][0].children).index(self.VISpar.Step)+1
-                            self.VISpar.FlagResult=data[0][0][ind].procdata.name_proc==self.window().ui.Explorer.ITEpar.procdata.name_proc
-                        except:
-                            pri.Error.red(f'[VIS] Error while reading the file: {filename}.')
-                else: self.VISpar.FlagResult=True
-            else:
-                self.VISpar.FlagResult=self.VISpar.FlagView
+            self.VISpar.FlagResult=self.VISpar.Step!=StepTypes.min and (resultCheck(self,self.VISpar) or self.VISpar.FlagView)
             if self.VISpar.FlagResult:
                 if self.VISpar.Step==StepTypes.disp:
                     self.VISpar.result_file_Mean=self.VISpar.resF(f'it{self.VISpar.it}')
@@ -666,7 +704,13 @@ class Vis_Tab(gPaIRS_Tab):
                     else:
                         self.VISpar.result_file=self.VISpar.resF(self.VISpar.img)
                 elif self.VISpar.img==0:
-                    self.VISpar.result_file=self.VISpar.result_file_Mean               
+                    self.VISpar.result_file=self.VISpar.result_file_Mean   
+                if not self.VISpar.FlagView:
+                    ITE=self.gui.ui.Explorer.ITEfromInd(self.VISpar.ind)
+                    id=ITE.procdata.name_proc
+                    self.VISpar.FlagResult=fileIdenitifierCheck(id,self.VISpar.result_file)
+                    if not self.VISpar.FlagResult: self.VISpar.result_file=''
+
         
         FlagNewImage, FlagNewResult, _=self.importFiles()  
         return FlagNewImage, FlagNewResult
@@ -674,23 +718,28 @@ 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)
        
-        FlagNewImage=self.VISpar.image_file!=self.image_file
+        FlagNewImage=self.VISpar.image_file!=self.image_file or self.VISpar.ind[:-1]!=self.VISpar_old.ind[:-1]
         if FlagNewImage or self.FlagReset:
             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
+        FlagNewResult=self.VISpar.result_file!=self.result_file or self.VISpar.ind[:-1]!=self.VISpar_old.ind[:-1]
         if FlagNewResult or self.FlagReset:
             self.result_file=self.VISpar.result_file
             if self.VISpar.img==0:
@@ -702,7 +751,10 @@ class Vis_Tab(gPaIRS_Tab):
                 self.result_file,self.result=self.readResultFile(self.VISpar.result_file)
 
         if self.image_raw is not None:
-            self.image=transfIm(self.VISpar.Out,Images=[self.image_raw])[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
             self.getImageInfo()
         else:
             self.image=None
@@ -710,6 +762,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()
 
@@ -717,42 +773,81 @@ 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
     
+    def checkVISTab(self,ind=None):
+        if ind is None: VIS:VISpar=self.VISpar
+        else: VIS:VISpar=self.TABpar_at(ind)
+        VIS.OptionDone=1 if (VIS.flagRun>0 and resultCheck(self,VIS)) or VIS.flagRun<=0 else 0
+
+    def adjustFieldRep(self):
+        if self.VISpar_old.field_rep!=self.VISpar.field_rep and self.result:
+            if not self.VISpar.unit[self.VISpar.type]:
+                xres,yres=self.getXYRes(type=1)
+            else: xres=yres=1.0
+            if self.namesPIV.x in self.result and self.namesPIV.y in self.result:
+                X=self.result[self.namesPIV.x]*xres
+                Y=self.result[self.namesPIV.y]*yres
+            elif self.namesPIV.X in self.result and self.namesPIV.Y in self.result:
+                X=self.result[self.namesPIV.X]*xres
+                Y=self.result[self.namesPIV.Y]*yres
+            else: return
+            dX=np.sqrt((X[0,1]-X[0,0])**2+(Y[1,0]-Y[0,0])**2)   
+            dW=[X.max()-X.min(),Y.max()-Y.min()]     
+            size_pixels=self.ui.plot.fig.get_size_inches()*self.ui.plot.fig.get_dpi()*self.ui.plot.axes.get_position().bounds[2:]
+            spaPixels=dX*size_pixels/dW
+            fac_spa=np.max(nPixelsPerVector/spaPixels).astype(int).item()
+            self.VISpar.vecspac=max([1,fac_spa])
+            self.VISpar.vecsize=5
+            self.VISpar.vecwid=1
+
 #*************************************************** Layout
     def setVISlayout(self):
         _, _, comboItemsList=self.importFiles()
+        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"
             self.ui.button_ShowCR.setToolTip(tip)
             self.ui.button_ShowCR.setStatusTip(tip)
 
-        FlagMIN=self.VISpar.type==0 and self.image_Min is not None and self.VISpar.FlagMIN
+        FlagMIN=self.VISpar.type==0 and self.image_Min is not None and self.VISpar.img>0 #and self.VISpar.FlagMIN
         self.ui.button_SubMIN.setVisible(FlagMIN)
         if FlagMIN:
             tip=f"{'Add' if self.ui.button_SubMIN.isChecked() else 'Subtract'} historical minimum background"
@@ -776,27 +871,31 @@ class Vis_Tab(gPaIRS_Tab):
         self.ui.combo_map_var.clear()
         self.ui.combo_map_var.addItems(comboItemsList)
         
-        FlagResult=self.result is not None and "U" in self.result and "V" in self.result
+        FlagResult=self.result is not None and "U" in self.result and "V" in self.result and (self.VISpar.type>0 or self.VISpar.Step==StepTypes.piv)
         self.ui.button_cvec.setVisible(FlagResult and self.VISpar.field_rep!=0)
         self.ui.label_field_rep.setVisible(FlagResult)
         self.ui.combo_field_rep.setVisible(FlagResult)
         
         i=self.VISpar.setPage
-        c=self.ui.image_levels.count()-1-int(not FlagResult) #or (not self.VISpar.FlagContourf and not self.VISpar.field_rep))
+        c=self.ui.image_levels.count()-1-int(not FlagResult or (self.VISpar.type==0 and self.VISpar.field_rep==0)) #or (not self.VISpar.FlagContourf and not self.VISpar.field_rep))
         if i>c: i=0
         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)
@@ -805,6 +904,9 @@ class Vis_Tab(gPaIRS_Tab):
         self.ui.label_vecsize.setVisible(self.VISpar.field_rep==1)
         self.ui.slider_vecsize.setVisible(self.VISpar.field_rep==1)
         self.ui.spin_vecsize.setVisible(self.VISpar.field_rep==1)
+        self.ui.label_vecwid.setVisible(self.VISpar.field_rep==1)
+        self.ui.slider_vecwid.setVisible(self.VISpar.field_rep==1)
+        self.ui.spin_vecwid.setVisible(self.VISpar.field_rep==1)
         self.ui.spin_vecspac.setMaximum(self.VISpar.size_default[1][-1])
         self.ui.label_streamdens.setVisible(self.VISpar.field_rep==2)
         self.ui.slider_streamdens.setVisible(self.VISpar.field_rep==2)
@@ -817,12 +919,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)
@@ -841,8 +943,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'))
@@ -856,35 +960,52 @@ class Vis_Tab(gPaIRS_Tab):
         self.VISpar.xmax=self.VISpar.size[self.VISpar.type][1]*self.xres
         self.VISpar.ymin=self.VISpar.size[self.VISpar.type][2]*self.yres
         self.VISpar.ymax=self.VISpar.size[self.VISpar.type][3]*self.yres   
+
+        self.checkVISTab()
+        self.setVISwarn()
         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
+        else: VIS:VISpar=self.TABpar_at(ind)
+        for field in ('min','max','mean','range'):
+            v=getattr(VIS,'v'+field)
+            w=getattr(VIS,'v'+field+'_default')
+            for f in list(w):
+                v[f]=w[f]
+        #self.setLevels()
 
-    def resetAllLevels(self):
+    def checkResVariables(self):
         for field in ('min','max','mean','range'):
             v=getattr(self.VISpar,'v'+field)
             w=getattr(self.VISpar,'v'+field+'_default')
             for f in list(w):
-                v[f]=w[f]
-        self.setLevels()
+                if f not in list(v):
+                    v[f]=w[f]
     
     def resetXYLims(self):
         self.VISpar.size[self.VISpar.type][::]=self.VISpar.size_default[self.VISpar.type][::]
     
-    def resetAllXYLims(self):
+    def resetAllXYLims(self, ind=None):
+        if ind is None: VIS:VISpar=self.VISpar
+        else: VIS:VISpar=self.TABpar_at(ind)
         for t in (0,1):
-            self.VISpar.size[t][::]=self.VISpar.size_default[t][::]
+            VIS.size[t][::]=self.VISpar.size_default[t][::]
 
     def readImageFile(self,filename):
         I=None
@@ -897,25 +1018,42 @@ class Vis_Tab(gPaIRS_Tab):
                 self.nbits=img.getextrema()[1].bit_length()
                 #I=transfIm(self.VISpar.Out,Images=[I])[0]
         except Exception as inst:
-            pri.Error.red(f'Error opening image file: {filename}\n{traceback.print_exc()}\n{inst}')
+            pri.Error.red(f'Error opening image file: {filename}\n{traceback.format_exc()}\n{inst}')
             I=None
         return filename, I
     
-    def getImageInfo(self):
-        I=self.image
-        mean=np.mean(I).item()
-        std=np.std(I).item()
-        #self.VISpar.vLim[self.namesPIV.img]=2**self.nbits
-        self.VISpar.vLim[self.namesPIV.img]=min([2*I.max().item(),2**(self.nbits+1)])
-        self.VISpar.vmin_default[self.namesPIV.img]=np.round(max([mean-2*std,0])).item()
-        self.VISpar.vmax_default[self.namesPIV.img]=np.round(min([mean+2*std,self.VISpar.vLim[self.namesPIV.img]])).item()
-        self.VISpar.vmean_default[self.namesPIV.img]=0.5*(self.VISpar.vmin_default[self.namesPIV.img]+self.VISpar.vmax_default[self.namesPIV.img])
-        self.VISpar.vrange_default[self.namesPIV.img]=self.VISpar.vmax_default[self.namesPIV.img]-self.VISpar.vmin_default[self.namesPIV.img]
-        self.VISpar.size_default[0]=[0,np.size(I,1),0,np.size(I,0),1]
-        if self.namesPIV.img not in self.VISpar.vcolorMap:
-            self.VISpar.vcolorMap[self.namesPIV.img]='gray'
-        if self.namesPIV.img not in self.VISpar.vvectorColor:
-            self.VISpar.vvectorColor[self.namesPIV.img]='green'
+    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)
+        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 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
@@ -931,42 +1069,71 @@ class Vis_Tab(gPaIRS_Tab):
                     res={}                                
                     for j, n in enumerate(tres[1]):
                         res[n]=tres[0][:,:,j]
-                if "U" in res and "V" in res:
-                    if "W" in res:
-                        res["Mod"]=np.sqrt(res["U"]**2+res["V"]**2++res["W"]**2)
-                    else:
-                        res["Mod"]=np.sqrt(res["U"]**2+res["V"]**2)
+                if self.namesPIV.u in res and self.namesPIV.v in res:
+                    res=self.calcMagnitude(res)
+                    FlagUnit=self.VISpar.Out.xres!=1.0 or self.VISpar.Out.pixAR!=1.0
+                    res=self.calcZVorticity(res,FlagUnit)
                 for f in list(res):
                     if not f in self.namesPIV.allFields: del res[f]
         except Exception as inst:
-            pri.Error.red(f'Error opening image file: {filename}\n{traceback.print_exc()}\n{inst}')
+            pri.Error.red(f'Error opening image file: {filename}\n{traceback.format_exc()}\n{inst}')
             res=None
         return filename, res
 
-    def getResultInfo(self):
-        res=self.result
-        for i in list(self.VISpar.vmin_default):
-            if i!=self.namesPIV.img:
-                del self.VISpar.vmin_default[i]
-                del self.VISpar.vmax_default[i]
-                del self.VISpar.vmean_default[i]
-                del self.VISpar.vrange_default[i]
-                del self.VISpar.vLim[i]
+    def calcMagnitude(self,res):
+        if self.namesPIV.u in res and self.namesPIV.v in res:
+            if self.namesPIV.w in res:
+                res[self.namesPIV.Mod]=np.sqrt(res[self.namesPIV.u]**2+res[self.namesPIV.v]**2+res[self.namesPIV.w]**2)
+            else:
+                res[self.namesPIV.Mod]=np.sqrt(res[self.namesPIV.u]**2+res[self.namesPIV.v]**2)
+        return res
+
+    def calcZVorticity(self,res,FlagUnit=False):
+        if self.namesPIV.x in res and self.namesPIV.y in res and self.namesPIV.u in res and self.namesPIV.v in res:
+            if FlagUnit: xres=yres=1/1000
+            else: xres=yres=1.0
+            try:
+                du_dy, _=np.gradient(res[self.namesPIV.u],res[self.namesPIV.y][:,0]*yres,res[self.namesPIV.x][0,:]*xres)  # Derivate di u rispetto a y e x
+                _, dv_dx=np.gradient(res[self.namesPIV.v],res[self.namesPIV.y][:,0]*yres,res[self.namesPIV.x][0,:]*xres)  # Derivate di v rispetto a y e x
+                res[self.namesPIV.ZVort]=dv_dx-du_dy
+            except:
+                pri.Error.red(f'Error while computing vorticity field:\n{traceback.format_exc()}\n\n')
+        return res
+    
+    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 not in (self.namesPIV.img,self.namesPIV.dispMap):
+                del VIS.vmin_default[i]
+                del VIS.vmax_default[i]
+                del VIS.vmean_default[i]
+                del VIS.vrange_default[i]
+                del VIS.vLim[i]
 
         for f in list(res):
-            V:np=res[f]
-            m=np.mean(V).item()
-            r=np.std(V).item()
-            self.VISpar.vLim[f]=max([m+5*r,abs(m-5*r)])
-            if self.VISpar.vLim[f]<0.1: self.VISpar.vLim[f]=1
-            self.VISpar.vmin_default[f]=np.round(m-2*r).item()
-            self.VISpar.vmax_default[f]=np.round(m+2*r).item()
-            self.VISpar.vmean_default[f]=0.5*(self.VISpar.vmin_default[f]+self.VISpar.vmax_default[f])
-            self.VISpar.vrange_default[f]=self.VISpar.vmax_default[f]-self.VISpar.vmin_default[f]
-            if f not in self.VISpar.vcolorMap:
-                self.VISpar.vcolorMap[f]='jet'
-            if f not in self.VISpar.vvectorColor:
-                self.VISpar.vvectorColor[f]='black'
+            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)])
+            amax=np.max(np.abs(V))*5.0
+            m=np.mean(V)
+            r=(np.max(V)-np.min(V))*2.50
+            rmax=np.abs(m+r)
+            rmin=np.abs(m-r)
+            VIS.vLim[f]=float(max([amax,rmax,rmin]))
+            if VIS.vLim[f]<0.1: VIS.vLim[f]=1
+            VIS.vmin_default[f]=float(np.percentile(V,1)) #np.round(m-2*r).item()
+            VIS.vmax_default[f]=float(np.percentile(V,99)) #np.round(m+2*r).item()
+            VIS.vmean_default[f]=0.5*(VIS.vmin_default[f]+VIS.vmax_default[f])
+            VIS.vrange_default[f]=VIS.vmax_default[f]-VIS.vmin_default[f]
+            if f not in VIS.vcolorMap:
+                VIS.vcolorMap[f]='jet'
+            if f not in VIS.vvectorColor:
+                VIS.vvectorColor[f]='black'
             pass
             
         FlagSize=False
@@ -980,11 +1147,15 @@ class Vis_Tab(gPaIRS_Tab):
             FlagSize=True
         if FlagSize:
             if np.size(X) and np.size(Y):
-                self.VISpar.size_default[1]=[X.min().item(),X.max().item(),Y.min().item(),Y.max().item(),int(max([np.size(X,0),np.size(X,1)])/4)]
+                VIS.size_default[1]=[X.min().item(),X.max().item(),Y.min().item(),Y.max().item(),int(max([np.size(X,0),np.size(X,1)])/4)]
         else:
-            self.VISpar.size_default[1]=[0,1,0,1,1]
+            VIS.size_default[1]=[0,1,0,1,1]
        
-        
+    def setVISwarn(self,ind=None):
+        if ind is None: VIS:VISpar=self.VISpar
+        else: VIS:VISpar=self.TABpar_at(ind)
+        VIS.warningMessage='Result files correctly identified!' if VIS.OptionDone==1 else 'Result files corresponding to the current step appear to be missing from the specified output path.'
+
 #*************************************************** Plot tools
 #******************** Actions
     def button_view_action(self):
@@ -992,7 +1163,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()
@@ -1021,11 +1192,21 @@ class Vis_Tab(gPaIRS_Tab):
         self.setLevels()
     
     def button_automatic_levels_action(self):
-        VISpar.FlagAutoLevels=self.ui.button_automatic_levels.isChecked()
+        self.VISpar.FlagAutoLevels=self.ui.button_automatic_levels.isChecked()
         return True
     
     def button_automatic_sizes_action(self):
-        VISpar.FlagAutoSizes=self.ui.button_automatic_sizes.isChecked()
+        self.VISpar.FlagAutoSizes=self.ui.button_automatic_sizes.isChecked()
+        if self.VISpar.FlagAutoSizes is False and self.VISpar.Process==ProcessTypes.piv:
+            type2=0 if self.VISpar.type==1 else 1
+            if self.VISpar.unit[self.VISpar.type]!=self.VISpar.unit[type2]:
+                xres,yres=self.getXYRes(type=self.VISpar.unit[self.VISpar.type])
+            else: xres=yres=1.0
+            if (type2==0 and self.VISpar.unit[type2]) or (type2==1 and not self.VISpar.unit[type2]):
+                xres2,yres2=self.getXYRes(type=type2)
+            else: xres2=yres2=1.0
+            self.VISpar.size[type2][0:2]=[s*xres/xres2 for s in [self.VISpar.xmin, self.VISpar.xmax]]
+            self.VISpar.size[type2][2:4]=[s*yres/yres2 for s in [self.VISpar.ymin, self.VISpar.ymax]]
         return True
     
     def button_restore_action(self):
@@ -1128,7 +1309,86 @@ 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):
+        """
+        Show a popup menu with options 'H x W' and return the selected index (int) or None.
+        Labels are formatted as f"{Vect[2][i]} x {Vect[0][i]}".
+        """
+        FlagDisp=self.VISpar.variableKey is self.namesPIV.dispMap
+        if FlagDisp: it=-1
+        else:
+            # Ensure consistent length between lists 0 (width values) and 2 (height values)
+            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]
+            n = min(len(Vect[0]), len(Vect[2]))
+            if n == 0:
+                return None
+
+            # Create a context menu and populate it with the available sizes
+            menu = QMenu(self)
+            for i in range(n):
+                label = f"{Vect[2][i]} x {Vect[0][i]}"
+                act = menu.addAction(label)
+                act.setData(i)
+
+            # Display the menu at the current cursor position and wait for user selection
+            chosen = menu.exec(QCursor.pos())
+            it = None if chosen is None else chosen.data()
+        if it is not None: self.FocusIW_it(it)
+
+    def FocusIW_it(self,it=-1):
+        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][it]
+        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][it]
+            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][it] 
+            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][it]
+            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)
@@ -1149,10 +1409,10 @@ class Vis_Tab(gPaIRS_Tab):
         self.ui.button_Contourf.setChecked(self.VISpar.FlagContourf)
     
     def button_automatic_levels_set(self):
-        self.ui.button_automatic_levels.setChecked(VISpar.FlagAutoLevels)
+        self.ui.button_automatic_levels.setChecked(self.VISpar.FlagAutoLevels)
 
     def button_automatic_sizes_set(self):
-        self.ui.button_automatic_sizes.setChecked(VISpar.FlagAutoSizes)
+        self.ui.button_automatic_sizes.setChecked(self.VISpar.FlagAutoSizes)
 
     def button_invert_y_set(self):
         self.ui.button_invert_y.setChecked(self.VISpar.FlagYInvert[self.VISpar.type])
@@ -1183,14 +1443,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')
@@ -1199,7 +1463,7 @@ class Vis_Tab(gPaIRS_Tab):
             if self.VISpar.type==0:
                 fields=['image_file','variable','unit','FlagSubMIN','Out','colorMap']
                 img=self.image
-                if self.VISpar.img and self.VISpar.FlagSubMIN and self.image_Min is not None:
+                if img is not None and self.VISpar.img>0 and self.VISpar.FlagSubMIN and self.image_Min is not None:
                     img=img-self.image_Min
                 self.img=img
                 FlagDraw=self.showImg(fields)
@@ -1207,34 +1471,48 @@ 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 and self.VISpar.variableKey!=self.namesPIV.dispMap:
+                    self.showCommonRegion()
+                    FlagDraw=FlagDraw or self.CR is not None
+                else: 
+                    self.cleanCommonRegion()
             else:
                 if self.orect: self.cleanRect()
+                self.cleanCommonRegion()
                 fields=['result_file','variable','unit','min','max','nclev','FlagContourf','colorMap']
-                if not self.VISpar.FlagContourf:    
-                    self.img=self.calcMap(self.result[self.VISpar.variableKey])
-                    FlagDraw=self.showImg(fields)
+                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:
-                    FlagDraw=self.showMap(fields)
+                    self.img,Ximg,Yimg,FlagInterp,size=self.calcMap(V)
+                    if FlagInterp:
+                        FlagDraw=self.showImg(fields,size)
+                    else:
+                        FlagDraw=self.showMap(fields)
+                        if self.contour is None:
+                            FlagDraw=self.showImg(fields,size)
             fields=['result_file','variable','FlagContourf','field_rep','unit','vectorColor']
-            if self.VISpar.field_rep==1: fields+=['vecsize','vecspac']
+            if self.VISpar.field_rep==1: fields+=['vecsize','vecwid','vecspac']
             elif self.VISpar.field_rep==2: fields+=['streamdens']
+            if self.VISpar.Step!=StepTypes.piv: fields+=['type']
             FlagVecField=self.VISpar.isDifferentFrom(self.VISpar_old,fields=fields)
             if FlagVecField and self.result: 
                 self.showVecField()
+            elif self.result is None: self.cleanVecField()
             FlagDraw=FlagDraw or FlagVecField
             
-            if self.image is not None and self.VISpar.FlagShowCR:
-                self.showCommonRegion()
-                FlagDraw=FlagDraw or self.CR is not None
             if FlagDraw: 
                 #self.ui.plot.draw()  
                 self.ui.plot.draw_idle() 
         except:
+            pri.Error.red(f'Error while generating plot:\n{traceback.format_exc()}\n\n')
             printException()
         #self.exitVISerr(False)  
         pri.PlotTime.magenta(f'{"%"*25} Plotting image - end')
 
-    def showImg(self,fields):
+    def showImg(self,fields,size:list=None):
         img=self.img
         if img is None: 
             self.cleanAxes(FlagAxis=False)
@@ -1252,16 +1530,18 @@ 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(), origin='lower', vmin=self.VISpar.min,vmax=self.VISpar.max,zorder=0)
+                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)
                 cax = divider.append_axes("right", size="5%", pad=0.05) 
                 self.cb=self.ui.plot.fig.colorbar(self.imgshow,cax=cax) 
                 self.setTitleLabels()
+                FlagXLim=True
             else: 
                 self.imgshow.set_data(img)
-                extent=self.imgExtent()
+                extent=self.imgExtent(size)
                 if extent!=self.imgshow.get_extent():
                     self.imgshow.set_extent(extent)
                     FlagExtent=True
@@ -1301,7 +1581,7 @@ class Vis_Tab(gPaIRS_Tab):
         return cmap, levs
     
     def getXYRes(self,type=None):
-        if not type: type=self.VISpar.type
+        if type is None: type=self.VISpar.type
         xres=yres=1.0 
         if self.VISpar.Process==ProcessTypes.piv and not self.VISpar.Out.FlagNone:
             if type==0: #mm/pixels
@@ -1312,8 +1592,8 @@ class Vis_Tab(gPaIRS_Tab):
                 yres=self.VISpar.Out.xres*self.VISpar.Out.pixAR
         return xres, yres
     
-    def imgExtent(self):
-        size=self.VISpar.size_default[self.VISpar.type]
+    def imgExtent(self,size=None):
+        if size is None: size=self.VISpar.size_default[self.VISpar.type]
         return [k*self.xres for k in size[:2]]+[k*self.yres for k in size[2:4]]
     
     def setAxisLim(self):
@@ -1342,45 +1622,48 @@ class Vis_Tab(gPaIRS_Tab):
         FlagCMap=self.VISpar_old.colorMap!=self.VISpar.colorMap
         FlagCLim=self.VISpar.isDifferentFrom(self.VISpar_old,fields=['min','max'])
 
-        if FlagNewPlot or self.VISpar_old.nclev!=self.VISpar.nclev:
+        if FlagNewPlot or self.VISpar_old.FlagContourf!=self.VISpar.FlagContourf or self.VISpar_old.nclev!=self.VISpar.nclev:
+            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()
-            self.contour=self.ui.plot.axes.contourf(X, Y, V, levs, \
-                cmap=cmap, origin='lower', extend='both', zorder=0)
+            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
     
-    def calcMap(self,V):
+    def calcMap(self,V,size_pixels=[1000]*2):
         #size_pixels=self.ui.plot.fig.get_size_inches()*self.ui.plot.fig.get_dpi()
         #size_pixels=np.minimum(np.round(0.5*size_pixels).astype(int),1000)
-        size_pixels=[1000]*2
         FlagSize=False
         if "X" in list(self.result) and "Y" in list(self.result):
             X=self.result["X"]
@@ -1394,17 +1677,59 @@ class Vis_Tab(gPaIRS_Tab):
             xmin,xmax,ymin,ymax=[X.min(),X.max(),Y.min(),Y.max()]
         else:
             xmin,xmax,ymin,ymax=[0,np.size(V,1),0,np.size(V,0)]
-        x = np.linspace(xmin,xmax, np.size(V,1))  
-        y = np.linspace(ymin,ymax, np.size(V,0))
-        if np.size(V,1)<size_pixels[1] or np.size(V,0)<size_pixels[0]:
-            f = scipy.interpolate.RectBivariateSpline(y, x, V)
-            x_new = np.linspace(xmin,xmax, size_pixels[0]) 
-            y_new = np.linspace(ymin,ymax, size_pixels[1])
-            V = f(y_new, x_new)
-        return V
+        xstep_half=(xmax-xmin)/(np.size(V,1)-1)*0.5
+        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=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_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_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_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
@@ -1414,7 +1739,7 @@ class Vis_Tab(gPaIRS_Tab):
                 if isinstance(ax, mpl.patches.FancyArrowPatch):
                     ax.remove()      
             self.stream=None 
-        if ind in (1,2):
+        if ind in (1,2) and (self.VISpar.type>0 or self.VISpar.Step==StepTypes.piv):
             if not self.VISpar.unit[self.VISpar.type]:
                 xres,yres=self.getXYRes(type=1)
             else: xres=yres=1.0
@@ -1429,45 +1754,73 @@ class Vis_Tab(gPaIRS_Tab):
             Mod=np.sqrt(U**2+V**2)
             if ind==1:
                 dX=np.sqrt((X[0,1]-X[0,0])**2+(Y[1,0]-Y[0,0])**2)   
-                dW=[X.max()-X.min(),Y.max()-Y.min()]          
-                if self.VISpar_old.field_rep!=self.VISpar.field_rep:
-                    size_pixels=self.ui.plot.fig.get_size_inches()*self.ui.plot.fig.get_dpi()*self.ui.plot.axes.get_position().bounds[2:]
-                    spaPixels=dX*size_pixels/dW
-                    fac_spa=np.max(nPixelsPerVector/spaPixels).astype(int).item()
-                    spa=self.VISpar.vecspac=max([1,fac_spa])
-                    vecsize=self.VISpar.vecsize=1.5
-                    self.ui.spin_vecspac.setValue(spa)
-                    self.ui.spin_vecsize.setValue(vecsize)
-                else:           
-                    spa=self.VISpar.vecspac
-                    vecsize=self.VISpar.vecsize
+                spa=self.VISpar.vecspac
+                vecsize=self.VISpar.vecsize
                 fac=dX*vecsize*spa
                 Modq= Mod[::spa,::spa]
                 Uq=np.divide(U[::spa,::spa], Modq, where=Modq!=0)*fac
                 Vq=np.divide(V[::spa,::spa], Modq, where=Modq!=0)*fac
                 w=0.15*fac
-                wmax=0.02*min([X.max()-X.min(),Y.max()-Y.min()])
-                qwidth=min([w,wmax])
+                n=3
+                wmax=min([X.max()-X.min(),Y.max()-Y.min()])*0.001
+                qwidth=min([w,wmax])*self.VISpar.vecwid**2
                 hwidth=4 if vecsize<4 else vecsize
                 self.qui=self.ui.plot.axes.quiver(
                     X[::spa,::spa],Y[::spa,::spa],Uq,Vq, color=VIS_VectorColors[self.VISpar.vectorColor], clip_on=True,
                     angles='xy',scale_units='xy',scale=1.0,
                     units='xy',width=qwidth,headwidth=hwidth,headlength=1.25*hwidth,headaxislength=0.75*hwidth,zorder=10)
             elif ind==2:
-                self.stream=self.ui.plot.axes.streamplot(X,Y,U,V,color=VIS_VectorColors[self.VISpar.vectorColor],density=self.VISpar.streamdens,zorder=10)
+                size_pixels=np.shape(U)
+                Up,_,_,_,_=self.calcMap(U,size_pixels=size_pixels)
+                Vp,Xp,Yp,_,_=self.calcMap(V,size_pixels=size_pixels)
+                Xp=Xp*xres
+                Yp=Yp*yres
+                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: 
@@ -1551,34 +1904,42 @@ 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())
-
-    def showCommonRegion(self):
+        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:
             self.CR.remove()
             self.CR=None
+            self.ui.plot.draw_idle() 
+        self.cleanReferenceFrame()
 
+    def showCommonRegion(self):
+        self.cleanCommonRegion()
         try:
             mapFun=PaIRS_lib.MappingFunction() 
             mapFun.readCal(self.VISpar.calList)
-            if self.VISpar.Step==StepTypes.spiv:
-                planeConst=self.readLaserPlaneConst(self.VISpar.dispFile)
-            else:
-                planeConst=[0.0,0.0,0.0]
+
+            #if self.VISpar.Step==StepTypes.spiv:
+            #    planeConst=self.readLaserPlaneConst(self.VISpar.dispFile)
+            #else:
+            #    planeConst=[0.0,0.0,0.0]
+            planeConst=[self.VISpar.Out.zconst,self.VISpar.Out.xterm,self.VISpar.Out.yterm]
+
             o=self.VISpar.Out
             points=[ [o.x_min, o.y_min], [o.x_max, o.y_min], [o.x_max, o.y_max], [o.x_min, o.y_max]]
             zLaser=lambda xy: self.zLaser(xy[0],xy[1],planeConst)
@@ -1590,30 +1951,68 @@ class Vis_Tab(gPaIRS_Tab):
             x_values = [Xp[0] for Xp in X]+[X[0][0]]
             y_values = [Xp[1] for Xp in X]+[X[0][1]]
             self.CR,=self.ui.plot.axes.plot(x_values, y_values, 'b-',clip_on=False)
+            self.showReferenceFrame(mapFun=mapFun)
         except Exception as exc:
             pri.Error.red(f"[VIS] Error while plotting common zone!\n{traceback.format_exc()}\n")
         return
 
     def zLaser(self,x,y,planeConst):
         return planeConst[0]+planeConst[1]*x+planeConst[2]*y
-    
-    def readLaserPlaneConst(self, filename: str):
+
+    def cleanReferenceFrame(self):
+        if self.RF:
+            for p in self.RF:
+                p.remove()
+            self.RF=None
+            self.ui.plot.draw_idle() 
+
+    def showReferenceFrame(self,mapFun=None):
+        self.cleanReferenceFrame()
         try:
-            with open(filename, "r") as cfg:
-                lines = cfg.readlines()
-                if len(lines) < 6:
-                    raise ValueError("Il file non contiene abbastanza righe per essere valido")
-                planeConst = [
-                    float(lines[3].strip().rstrip(',')),
-                    float(lines[4].strip().rstrip(',')),
-                    float(lines[5].strip().rstrip(','))
-                ]
-                return planeConst
-        
-        except Exception as inst:
-            errorPrint = f"\n!!!!!!!!!! Error while reading the file:\n{str(inst)}\n"
-            return [0.0,0.0,0.0]
-        
+            if mapFun is None:
+                mapFun=PaIRS_lib.MappingFunction() 
+                mapFun.readCal(self.VISpar.calList)
+
+            labels=['O','x','y','z']
+            unit=1
+
+            points=[ [0, 0, 0], [unit, 0, 0], [0, unit, 0], [0, 0, unit]]
+            points_array=np.array(points,dtype=np.float64,order='C')
+            cam=self.VISpar.cam-1
+            X=mapFun.worldToImg(points_array,cam,None)# In output X1 is equal to X if correctly allocated
+            
+            self.RF=[]
+            origin=X[0]
+            hp,=self.ui.plot.axes.plot(origin[0], origin[1], 'o', color='darkblue')  # 'ko' indica un pallino nero
+            self.RF.append(hp)
+            length=0.25*min([q for q in self.image.shape])
+            qwidth=length/25
+            hwidth=4
+            vnorm = np.linalg.norm(X[2]-origin)
+            #colors=['darkred','darkgreen','darkmagenta']
+            for k in range(1,len(X)-1): #-1 exclude z
+                P=X[k]
+                v=P-origin
+                if vnorm!=0: v=v/vnorm*length
+                hp=self.ui.plot.axes.quiver(origin[0], origin[1], v[0], v[1], 
+                                            color='darkblue',#color=colors[k-1], 
+                                            angles='xy',scale_units='xy',scale=1.0,
+                                            units='xy',width=qwidth,headwidth=hwidth,headlength=1.25*hwidth,headaxislength=0.75*hwidth,zorder=10)
+                self.RF.append(hp)
+                T=origin+v*1.2
+                ha=self.ui.plot.axes.text(T[0], T[1], f'{labels[k]}', color='darkblue', fontsize=fontPixelSize)
+                self.RF.append(ha)
+            """
+                X[k]=T
+            T=0.5*(X[1]+X[2])
+            T=origin-0.1*(T-origin)
+            ha=self.ui.plot.axes.text(T[0], T[1], f'{labels[0]}', color='darkblue', fontsize=fontPixelSize)
+            self.RF.append(ha)
+            """
+        except Exception as exc:
+            pri.Error.red(f"[VIS] Error while plotting reference frame!\n{traceback.format_exc()}\n")
+        return
+
     """
     def getZonaCom(self,c:int):
         return (min (self.disp.vect.Xinf[c],self.disp.vect.Xsup[c]),
@@ -1626,19 +2025,26 @@ class Vis_Tab(gPaIRS_Tab):
     def contextMenuEvent(self, event):   
         contextMenu = QMenu(self)
         copy2clipboard = contextMenu.addAction("Copy to clipboard ("+self.QS_copy2clipboard.key().toString(QKeySequence.NativeText)+")")
+        copy2clipboard.setIcon(self.ui.plot.copyIcon)
         copy2newfig = contextMenu.addAction("Open in new figure ("+self.QS_copy2newfig.key().toString(QKeySequence.NativeText)+")")
+        copy2newfig.setIcon(self.ui.plot.openNewWindowIcon)
         contextMenu.addSeparator()
-        if len(self.ui.plot.fig2)>1:
+        if len(self.ui.plot.fig2)>0:
             showAll = contextMenu.addAction("Show all")
-            closeAll = contextMenu.addAction("Close all")
+            showAll.setIcon(self.ui.plot.showAllIcon)
             alignAll = contextMenu.addAction("Align all")
+            alignAll.setIcon(self.ui.plot.alignAllIcon)
+            closeAll = contextMenu.addAction("Close all")
+            closeAll.setIcon(self.ui.plot.closeAllIcon)
             contextMenu.addSeparator()
         else:
             showAll = None 
             closeAll= None
             alignAll= None
         loadImg = contextMenu.addAction("Load image")
+        loadImg.setIcon(self.ui.plot.loadImageIcon)
         loadRes = contextMenu.addAction("Load result")
+        loadRes.setIcon(self.ui.plot.loadResultIcon)
 
         action = contextMenu.exec(self.mapToGlobal(event.pos()))
         if action == copy2clipboard:
@@ -1669,6 +2075,7 @@ class Vis_Tab(gPaIRS_Tab):
             self.image=None
 
             self.ui.spin_img.setMinimum(-1)
+            self.VISpar.image_file=''
             self.VISpar.img=-1
             self.VISpar.type=0
             self.VISpar.variable=self.namesPIV.combo_dict[self.namesPIV.img]
@@ -1685,6 +2092,7 @@ class Vis_Tab(gPaIRS_Tab):
             self.result_file_Load=filename
             self.result=None
             self.ui.spin_img.setMinimum(-1)
+            self.VISpar.result_file=''
             self.VISpar.img=-1
             self.VISpar.variable=self.namesPIV.combo_dict[self.namesPIV.Mod]
             self.VISpar.variableKey=self.namesPIV.combo_dict_keys[self.VISpar.variable]