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

PaIRS_UniNa/Vis_Tab_CalVi.py

@@ -2,7 +2,7 @@ from .ui_Vis_Tab_CalVi import*
 from .TabTools import*
 from .calib import Calib, CalibTasks, calibTasksText, CalibFunctions, calibFunctionsText
 from .calibView import CalibView
-from .Import_Tab_CalVi import INPpar_CalVi
+from .Input_Tab_CalVi import INPpar_CalVi
 from .Process_Tab_CalVi import PROpar_CalVi
 
 
@@ -10,51 +10,92 @@ bufferSizeLimit=2000*1e6  #bytes
 if __name__ == "__main__":
     cfgName='../../img/calib/NewCam0.cfg'
     cfgName='../../img/calib/NewCam0_Mod.cfg'
-    FlagRun=True
+    FlagRunning=True
 else:
     cfgName=''
-    FlagRun=False
+    FlagRunning=False
+
+spin_tips={
+    'plane'     :  'Plane number',
+    'cam'       :  'Camera number',
+    'LMin'      :  'Minimum intensity level',
+    'LMax'      :  'Maximum intensity level',
+    'yOriOff'   :  'Origin y shift',
+    'xOriOff'   :  'Origin x shift',
+    'yp'        :  'Maximum y limit',
+    'ym'        :  'Minimum y limit',
+    'xp'        :  'Maximum x limit',
+    'xm'        :  'Minimum x limit',
+}
+check_tips={}
+radio_tips={
+    'ShowMask' : 'Show mask', 
+}
+line_edit_tips={}
+button_tips={
+    'findAll'   :  'Find points in all planes',
+    'find'      :  'Find points in current plane',
+    'copyGrid'  :  'Copy grid limits to all planes',
+    'saveCoord' :  'Save point coordinates',
+    'calibrate' :  'Calibration',
+    'focusErr'  :  'Focus on max. error point',
+    'deleteErr' :  'Deletion of max. error point',
+    'zoom_minus':  'Zoom out',
+    'zoom_equal':  'Reset zoom',
+    'zoom_plus' :  'Zoom in',
+    'restore'   :  'Restore intensity levels',
+    'PlotMask'  :  'Plot mask',
+}
+combo_tips={}
 
 class VISpar_CalVi(TABpar):
     FlagVis=True
 
-    def __init__(self):
-        self.setup()
-        super().__init__()
-        self.name='VISpar'
-        self.surname='VIS_Tab'
+    def __init__(self,Process=ProcessTypes.null,Step=StepTypes.null):
+        self.setup(Process,Step)
+        super().__init__('VISpar_CalVi','Vis_CalVi')
         self.unchecked_fields+=[]
 
-    def setup(self):
-        self.cfgName=cfgName
-        self.FlagRun=FlagRun
-
-        self.nPlane=0
-        self.plane=0
-        self.nCam=0
-        self.cam=0
-        self.scaleFactor=1.0
-        self.LLim=0
-        self.LMin=0
-        self.LMax=0
-
-        self.MaskType=0
-        self.FlagShowMask=1
-        self.FlagPlotMask=0
-
-        self.xOriOff=0
-        self.yOriOff=0
-        self.xm=0
-        self.xp=0
-        self.ym=0
-        self.yp=0
-
-        self.orPosAndShift=[]
-        self.angAndMask=[]
-        self.spotDistAndRemoval=[]
+    def setup(self,Process,Step):
+        self.Process = Process
+        self.Step = Step
+
+        self.cfgName = cfgName
+        self.FlagRunning = FlagRunning
+
+        self.nPlane         = 0
+        self.plane          = 1
+        self.nCam           = 0
+        self.cam            = 1
+        self.defaultScaleFactor = 1.0
+        self.scaleFactor    = 1.0
+        self.scrollBarValues = [0,0]
+        self.LLim           = 0
+        self.LMin           = 0
+        self.LMax           = 1
+
+        self.MaskType       = 0
+        self.DotDiam        = 0
+        self.FlagShowMask   = True
+        self.FlagPlotMask   = False
+
+        #self.xOriOff        = 0
+        #self.yOriOff        = 0
+        #self.xm             = 0
+        #self.xp             = 0
+        #self.ym             = 0
+        #self.yp             = 0
+
+        self.orPosAndShift  = []
+        self.angAndMask     = []
+        self.spotDistAndRemoval = []
         
-        self.list_Image_Files=[]
-        self.list_eim=[]
+        self.imList = []
+        self.imEx   = []
+        self.splitterSizes   = [ ]
+
+        self.FlagResetLevels = True
+        self.FlagResetZoom   = True
 
         self.errorMessage=''
 
@@ -62,6 +103,17 @@ class Vis_Tab_CalVi(gPaIRS_Tab):
     class VIS_Tab_Signals(gPaIRS_Tab.Tab_Signals):
         run=Signal(bool)
         pass
+    
+    def showEvent(self, event: QShowEvent) -> None:
+        super().showEvent(event)
+        if not self.FlagInitVIS:
+            self.FlagInitVIS=True
+            S=self.scrollArea.size()
+            s=self.calibView.pixmap().size()
+            self.VISpar.scaleFactor = self.calibView.scaleFactor =min([S.width()/s.width() if s.width() else S.width(), S.height()/s.height() if s.height() else S.height()])
+            self.calibView.resize(self.VISpar.scaleFactor * self.calibView.pixmap().size())
+        return 
+    
     def closeEvent(self,event):
         ''' called when closing 
         I had to add this to be sure that calib was destroyed'''
@@ -74,111 +126,134 @@ class Vis_Tab_CalVi(gPaIRS_Tab):
         super().resizeEvent(event)
         self.setZoom()
 
-    def __init__(self,*args):
-        parent=None
-        self.flagInit=True
-        if len(args): parent=args[0]
-        if len(args)>1: self.flagInit=args[1]
+    def __init__(self,parent: QWidget =None, flagInit= __name__ == "__main__"):
         super().__init__(parent,Ui_VisTab_CalVi,VISpar_CalVi)
         self.signals=self.VIS_Tab_Signals(self)
 
         #------------------------------------- Graphical interface: widgets
+        self.TABname='Vis_CalVi'
         self.ui: Ui_VisTab_CalVi
-        ui=self.ui
 
-        self.setupWid()  #---------------- IMPORTANT
+        #necessary to change the name and the order of the items
+        for g in list(globals()):
+            if '_items' in g or '_ord' in g or '_tips' in g:
+                #pri.Info.blue(f'Adding {g} to {self.name_tab}')
+                setattr(self,g,eval(g))
+
+        
         #introducing CalibView
         self.scrollArea = QtWidgets.QScrollArea(self)
+        self.scrollArea.setObjectName('scroll_area_Vis_CalVi')
         self.scrollArea.setBackgroundRole(QtGui.QPalette.Dark)
         self.calibView=CalibView(self.scrollArea,self.outFromCalibView,self.outToStatusBarFromCalibView,self.textFromCalib,self.workerCompleted)
         self.scrollArea.setWidget(self.calibView)
-        self.ui.splitter.insertWidget(0,self.scrollArea)
+        self.ui.Vis_CalVi_splitter.insertWidget(0,self.scrollArea)
+        if __name__ == "__main__": 
+            self.app=app
+            setAppGuiPalette(self)
 
         #------------------------------------- Graphical interface: miscellanea
         self.ui.status_L.setText('')
         self.ui.status_R.setText('')
         self.FlagFirstShow=False
-        self.FlagSettingNewCalib=False
         self.setLogFont(fontPixelSize-dfontLog)
 
         #------------------------------------- Declaration of parameters 
         self.VISpar_base=VISpar_CalVi()
         self.VISpar:VISpar_CalVi=self.TABpar
-        self.VISpar_old:VISpar_CalVi=self.TABpar_old
-        self.defineSetTABpar(self.setVISpar)
-        
+        self.VISpar_old:VISpar_CalVi=self.TABpar_old        
         
         #------------------------------------- Callbacks 
-        self.setupCallbacks()
-        self.FlagSettingPar=False
+        self.FlagInitVIS=False
+        self.defineWidgets()
+        self.setupWid()  #---------------- IMPORTANT
+
+        self.defineCallbacks()
+        self.spins_valueChanged=[self.ui.spin_plane,self.ui.spin_cam,
+                                 self.ui.spin_xOriOff,self.ui.spin_yOriOff,
+                                 self.ui.spin_ym,self.ui.spin_yp,
+                                 self.ui.spin_xm,self.ui.spin_xp]
+        self.connectCallbacks()
+        self.defineFurtherCallbacks()
+    
+        self.defineSettings()
+
+        self.adjustTABpar=self.adjustVISpar
+        self.setTABlayout=self.setVISlayout
+        
         self.FlagAddPrev=False
-        self.updateGCalVi= lambda: None
-        self.calibView.flagCurrentTask=CalibTasks.stop#todo GP per me si deve cancellare è stato già fatto nell'init di CalibView
+        
+        self.calibView.flagCurrentTask=CalibTasks.stop #todo GP per me si deve cancellare è stato già fatto nell'init di CalibView
+        
         self.bufferImg={}
         self.bufferSize=[]
         self.setRunButtonText=lambda: None
 
+        self.FlagResume=0
+        self.FlagInitData=False
+
         #------------------------------------- Initializing       
-        if self.flagInit:
+        if flagInit:
             self.initialize()
 
     def initialize(self):
         pri.Info.yellow(f'{"*"*20}   VIS initialization   {"*"*20}')
-        self.defaultSplitterSize()
 
         if self.VISpar.cfgName:
-            #self.VISpar.FlagRun=True
+            self.calibView.calib.cfgName=self.VISpar.cfgName
             flagOp=self.calibView.calib.readCfg()
             self.calibView.calib.readImgs() #todo verificare eventuali errori e dimensioni delle immagini in questo momento non da errore e l'img viene tagliata
             
-            self.calib2VIS()
-            self.setVISpar()
-            
-            #self.signals.run.emit(not flagOp)
+            self.nullCallback('CalVi process')
+            #self.adjustTABparInd()        
             self.runCalVi('_Mod' in self.VISpar.cfgName)
-        #self.ui.plot.show() 
-        #self.setTABpar(True)  #with bridge
     
-    def defaultSplitterSize(self):
-        self.ui.splitter.setSizes([self.width()-self.ui.w_Commands.minimumWidth(),self.ui.w_Commands.minimumWidth()])
-
     @Slot(bool)
     def runCalVi(self,flagMod=False):
+        self.FlagBridge=False
         self.calibView.flagFirstTask=CalibTasks.findPlanesFromOrigin if flagMod else CalibTasks.findAllPlanes
-        self.VISpar.plane=self.VISpar.cam=0
-        self.setVISpar()
+        self.VISpar.plane=self.VISpar.cam=1
+        self.VISpar.FlagPlotMask=False
         if flagMod: self.ui.log.setText('')
+        self.setTABlayout()
         if self.calibView.executeCalibTask(self.calibView.flagFirstTask):
             self.setTaskButtonsText()
-            self.resetScaleFactor()
+            #self.resetScaleFactor()
 
     def stopCalVi(self):
         self.calibView.executeCalibTask(CalibTasks.stop)
         self.setTaskButtonsText()
-        self.plotPlane()
+        self.gui.ui.button_Run_CalVi.setVisible(True)
+        self.setTABlayout()
+        self.FlagBridge=True  
+        self.adjustTABparInd()      
 
     def show(self):
         super().show()
         if not self.FlagFirstShow:
             self.FlagFirstShow=True
             self.resetScaleFactor()
+            self.setVISlayout()
 
-    def setupCallbacks(self):
-        self.ui.button_zoom_minus.clicked.connect(self.addParWrapper(lambda:self.zoom(0.8),'Zoom'))
-        self.ui.button_zoom_equal.clicked.connect(self.addParWrapper(self.resetScaleFactor,'Zoom'))
-        self.ui.button_zoom_plus.clicked.connect(self.addParWrapper(lambda:self.zoom(1.25),'Zoom'))
-        self.ui.splitter.addfuncout['setScrollAreaWidth']=self.setZoom
-        
+    def defineFurtherCallbacks(self):
+        self.ui.Vis_CalVi_splitter.addfuncout['setScrollAreaWidth']=self.wrappedCallback('Splitter sizes',self.splitterMoved)
 
         self.taskButtons=[self.ui.button_findAll,
                           self.ui.button_find,
                           self.ui.button_calibrate,
                           self.ui.button_saveCoord,
                           ]
-        self.taskButton_callbacks=[]
+        self.taskButtons_actions=[]
+        def create_taskButton_action(ind,k):
+            def taskButton_action(ind,k):
+                FlagSettingPar=TABpar.FlagSettingPar
+                TABpar.FlagSettingPar=True
+                self.taskButtonPressed(CalibTasks(ind),k!=3)
+                TABpar.FlagSettingPar=FlagSettingPar
+            return self.wrappedCallback('CalVi task',lambda: taskButton_action(ind,k))
         for k,ind in enumerate([f.value for f in CalibTasks if f.value>0]):
-            self.taskButton_callbacks.append(lambda dum=ind, flag=k!=3,ff=self.taskButtonPressed: ff(CalibTasks(dum),flag))
-            self.taskButtons[k].clicked.connect(self.taskButton_callbacks[k])
+            self.taskButtons_actions.append(create_taskButton_action(ind,k))
+            self.taskButtons[k].clicked.connect(self.taskButtons_actions[k])
 
         self.buttonsToDisableNotCalibrated=[] #used to gray buttons if not calibrated
         self.functionButtons=[
@@ -186,18 +261,24 @@ class Vis_Tab_CalVi(gPaIRS_Tab):
                               self.ui.button_focusErr,
                               self.ui.button_copyGrid,
                               ]
-        self.functionButtons_callbacks=[]
+        self.functionButtons_actions=[]
+        def create_functionButton_action(ind):
+            def functionButton_action(ind):
+                FlagSettingPar=TABpar.FlagSettingPar
+                TABpar.FlagSettingPar=True
+                self.functionButtonPressed(CalibFunctions(ind),True)
+                TABpar.FlagSettingPar=FlagSettingPar
+            return self.wrappedCallback('CalVi function',lambda: functionButton_action(ind))
         for k,ind in  enumerate([f.value for f in CalibFunctions if f.value>0]):
-            self.functionButtons_callbacks.append(lambda dum=ind, flag=True,ff=self.functionButtonPressed: ff(CalibFunctions(dum),flag))
-            self.functionButtons[k].clicked.connect(self.functionButtons_callbacks[k])
+            self.functionButtons_actions.append(create_functionButton_action(ind))
+            self.functionButtons[k].clicked.connect(self.functionButtons_actions[k])
             self.buttonsToDisableNotCalibrated.append(self.functionButtons[k])
 
-        
         functionButtons_insert=[0,0,0]
         for k,ind in  enumerate([f.value for f in CalibFunctions]):
-            action=QAction(self.functionButtons[k].icon(),calibFunctionsText[abs(ind)],self)
+            action=QAction(self.functionButtons[k].icn,calibFunctionsText[abs(ind)],self)
             self.calibView.contextMenuActions.insert(functionButtons_insert[k],action)
-            action.triggered.connect(lambda dum=ind, flag=True,ff=self.functionButtonPressed: ff(CalibFunctions(dum),flag))
+            action.triggered.connect(create_functionButton_action(ind))
             if ind>0:
                 self.buttonsToDisableNotCalibrated.append(action)
 
@@ -208,53 +289,6 @@ class Vis_Tab_CalVi(gPaIRS_Tab):
                               self.originOffbox,
                               self.remPoinsBox,
                              ] #used to gray buttons when calibrating
-        
-        self.spin_plane_callback=self.addParWrapper(self.spinImgChanged,'Plane changed')
-        self.ui.spin_plane.valueChanged.connect(self.spin_plane_callback)
-        self.spin_cam_callback=self.spinImgChanged
-        self.spin_xOriOff_callback=lambda off: self.spin_OriOff_callback(off,self.ui.spin_xOriOff,True)
-        self.spin_yOriOff_callback=lambda off: self.spin_OriOff_callback(off,self.ui.spin_yOriOff,False)
-
-        self.spin_yp_callback=lambda off: self.spin_remPoi_callback(off, self.ui.spin_yp,False,True)
-        self.spin_ym_callback=lambda off: self.spin_remPoi_callback(off, self.ui.spin_ym,False,False)
-        self.spin_xp_callback=lambda off: self.spin_remPoi_callback(off, self.ui.spin_xp,True,True)
-        self.spin_xm_callback=lambda off: self.spin_remPoi_callback(off, self.ui.spin_xm,True,False)
-        self.ui.button_copyGrid.clicked.connect(self.copyRemPoints)
-        
-        spin_names=['cam',
-                    'LMin',
-                    'LMax',
-                    'yOriOff',
-                    'xOriOff',
-                    'yp',
-                    'ym',
-                    'xp',
-                    'xm',
-                    ]
-        spin_tips=['Camera number  (from 1 to number of cameras)',
-                   'Minimum value of the image intensity',
-                   'Maximum value of the image intensity',
-                   'Shift the origin along y with respect to the first selected point in current target image',
-                   'Shift the origin along x with respect to the first selected point in current target image',
-                   'Maximum y limit for the point grid',
-                   'Minimum y limit for the point grid',
-                   'Maximum x limit for the point grid',
-                   'Minimum x limit for the point grid',
-                   ]
-        self.setSpinCallbacks(spin_names,spin_tips)
-
-
-        self.button_restore_callback=self.addParWrapper(self.restoreLevels,'Restore image levels')
-        self.ui.button_restore.clicked.connect(self.button_restore_callback)
-
-        self.radio_showMask_callback=self.addParWrapper(self.showMask,'Show/hide correlation mask')
-        self.ui.radio_showMask.clicked.connect(self.radio_showMask_callback)
-
-        self.tool_plotMask_callback=self.addParWrapper(self.plotMask,'Plot correlation mask')
-        self.ui.tool_plotMask.clicked.connect(self.tool_plotMask_callback)
-
-        self.signals.run.connect(self.runCalVi)
-        return
     
     def setLogFont(self,fPixSize):
         logfont=self.ui.log.font()
@@ -262,93 +296,134 @@ class Vis_Tab_CalVi(gPaIRS_Tab):
         logfont.setPixelSize(fPixSize)
         self.ui.log.setFont(logfont)
 
-#********************************************* Setting parameters
-    def setVISpar(self):
-        FlagImg=bool(len(self.calibView.calib.imgs))
-        FlagMask=self.VISpar.MaskType not in (2,3) and bool(len(self.calibView.calib.ccMask))
-        if FlagImg:
-            self.ui.g_Image.setEnabled(True)
-            self.ui.spin_plane.setEnabled(self.VISpar.nPlane>1)
-            self.ui.spin_cam.setEnabled(self.VISpar.nCam>1)
+#********************************************* Adjusting parameters
+    def adjustVISpar(self):
+        self.calibView.hide()
+        
+        FlagNewRun=self.VISpar.isDifferentFrom(self.VISpar_old,fields=['FlagRunning'])
+        if FlagNewRun: 
+            self.defaultSplitterSize()
+
+        FlagNewSet=False
+        INP_CalVi:INPpar_CalVi = self.gui.w_Input_CalVi.TABpar
+        PRO_CalVi:PROpar_CalVi = self.gui.w_Process_CalVi.TABpar
+        if PRO_CalVi.isDifferentFrom(self.gui.w_Process_CalVi.PROpar_old,exceptions=['ind']) or INP_CalVi.isDifferentFrom(self.gui.w_Input_CalVi.INPpar_old,exceptions=['ind']) or not self.FlagInitData: 
+            FlagNewSet=True
+            self.gui.initDataAndSetImgFromGui(INP_CalVi,PRO_CalVi)
+
+        #***Data
+        c=self.calibView.calib
+        self.VISpar.nPlane=c.nPlanesPerCam
+        self.VISpar.nCam=c.nCams
+        if self.VISpar.plane and not self.VISpar.nPlane: self.VISpar.plane=0
+        elif not self.VISpar.plane and self.VISpar.nPlane: self.VISpar.plane=self.VISpar.nPlane
+        if self.VISpar.cam and not self.VISpar.nCam: self.VISpar.cam=0
+        elif not self.VISpar.cam and self.VISpar.nCam: self.VISpar.cam=self.VISpar.nCam
+
+        self.VISpar.MaskType=abs(self.calibView.calib.cal.data.FlagPos)
+        if self.VISpar.MaskType in (2,3):
+            #self.VISpar.FlagShowMask=False
+            self.VISpar.FlagPlotMask=False
+        #if not self.VISpar.FlagShowMask: self.VISpar.FlagPlotMask=False
+        self.VISpar.DotDiam=abs(self.calibView.calib.cal.data.raggioInizialeRicerca)
+        self.calibView.calib.flagShowMask=self.VISpar.FlagShowMask
+        self.calibView.calib.flagPlotMask=self.VISpar.FlagPlotMask
+
+        #***Levels
+        FlagPlot=False
+        FlagPlotMask=self.VISpar.isDifferentFrom(self.VISpar_old,fields=['FlagPlotMask'])
+        if FlagPlotMask: 
+            FlagPlot=True
+            self.plotPlane()
+        if self.VISpar.FlagResetLevels or FlagNewRun or FlagNewSet: #or FlagPlotMask:
+            if not FlagPlot: 
+                FlagPlot=True
+                self.plotPlane()
+            self.restoreLevels()
+            #self.VISpar.FlagResetLevels=False            
+        self.VISpar.LLim=c.LLim
+        if self.VISpar.FlagResetLevels: 
+            self.VISpar.LMin=c.LMin
+            self.VISpar.LMax=c.LMax
         else:
-            self.ui.g_Image.setEnabled(False)     
+            self.VISpar.LMax=c.LMax if self.VISpar.LMax>c.LLim else self.VISpar.LMax
+            self.VISpar.LMin=self.VISpar.LMax-1 if self.VISpar.LMin >self.VISpar.LMax-1 else self.VISpar.LMin
+        self.calibView.calib.LMin=self.VISpar.LMin
+        self.calibView.calib.LMax=self.VISpar.LMax
+        self.VISpar.FlagResetLevels=False
+        
+        #***Zoom
+        if self.VISpar.FlagResetZoom or FlagNewRun or FlagPlotMask or FlagNewSet:
+            if not FlagPlot: 
+                FlagPlot=True
+                self.plotPlane()
+            self.resetScaleFactor()
+        self.calibView.scaleFactor=self.VISpar.scaleFactor
+        self.VISpar.FlagResetZoom=False
+        
+    def defaultSplitterSize(self):
+        self.VISpar.splitterSizes=[self.width()-self.ui.w_Commands.minimumWidth(),self.ui.w_Commands.minimumWidth()]
+        
+#********************************************* Layout
+    def setVISlayout(self):
+        self.calibView.hide()
+
+        FlagImg=len(self.calibView.calib.imgs)>0
+        self.ui.g_Image.setEnabled(FlagImg)
+        self.ui.spin_plane.setEnabled(FlagImg and self.VISpar.nPlane>1)
+        self.ui.spin_cam.setEnabled(FlagImg and self.VISpar.nCam>1)
+
+        FlagMask=self.VISpar.MaskType not in (2,3) and len(self.calibView.calib.ccMask)>0
+        self.ui.g_Mask.setVisible(FlagMask)
 
         FlagZoomLevels=FlagImg or FlagMask
         self.ui.g_Zoom.setEnabled(FlagZoomLevels)
         self.ui.g_Levels.setEnabled(FlagZoomLevels)
         
-        self.ui.g_Mask.setVisible(FlagMask)
-        self.ui.radio_showMask.setChecked(self.VISpar.FlagShowMask)
-        self.ui.tool_plotMask.setEnabled(self.VISpar.FlagShowMask)
-        self.ui.tool_plotMask.setChecked(self.VISpar.FlagPlotMask and self.VISpar.FlagShowMask)
+        self.ui.button_PlotMask.setEnabled(self.VISpar.MaskType not in (2,3))
         
-        self.ui.w_Commands.setVisible(self.VISpar.FlagRun)
-        flagNewRun=self.VISpar.isDifferentFrom(self.VISpar_old,[],['FlagRun'],True)
-        if flagNewRun: self.defaultSplitterSize()
-        if self.VISpar.FlagRun:
-            self.calibView.contextMenu =QtWidgets.QMenu(self)
+        self.ui.w_Commands.setVisible(self.VISpar.FlagRunning)
+        if self.VISpar.FlagRunning:
+            self.calibView.contextMenu = QtWidgets.QMenu(self)
             for a in self.calibView.contextMenuActions:
                 self.calibView.contextMenu.addAction(a)
             self.calibView.contextMenu.insertSeparator(self.calibView.contextMenuActions[1])
         else:
             self.calibView.contextMenu =None
             
-        self.setRunButtonText()
-
-        self.ui.status_L.setText('')
-        self.ui.status_R.setText('')
-        self.setSpinMaxMinLimValues()
-        if not self.FlagSettingNewCalib: self.calibView.scaleFactor=self.VISpar.scaleFactor
-        self.setZoom()
-        self.plotPlane()
-        flagPlotMask=self.VISpar.isDifferentFrom(self.VISpar_old,[],['FlagPlotMask'],True)
-        if  flagPlotMask or flagNewRun or self.FlagSettingNewCalib:
-            self.FlagSettingNewCalib=False
-            if flagPlotMask:
-                self.restoreLevels()
-                self.setSpinMaxMinLimValues()
-
-            self.resetScaleFactor()
+        self.setSpinMaxMin()
+        self.ui.Vis_CalVi_splitter.setSizes(self.VISpar.splitterSizes)
+        
+        self.calibView.scaleFactor=self.VISpar.scaleFactor
+        self.calibView.calib.LMin=self.VISpar.LMin
+        self.calibView.calib.LMax=self.VISpar.LMax
+        self.calibView.calib.flagShowMask=self.VISpar.FlagShowMask
+        self.calibView.calib.flagPlotMask=self.VISpar.FlagPlotMask
+        
+        FlagNoImage=True
+        if self.VISpar.cam>0 and self.VISpar.plane>0:
+            if self.VISpar.nCam==len(self.VISpar.imEx):
+                TargetType=self.gui.w_Process_CalVi.PROpar.TargetType
+                nPlane=self.VISpar.nPlane/(1+TargetType)
+                if nPlane==len(self.VISpar.imEx[0]):
+                    plane=int( (self.VISpar.plane+TargetType)/(1+TargetType) )
+                    if self.VISpar.imEx[self.VISpar.cam-1][plane-1]:
+                        FlagNoImage=False
+        if FlagNoImage:
+            self.ui.status_R.setText('')
+            self.ui.status_L.setText('')
+            self.calibView.hide()
+        else:   
+            if self.VISpar_old.FlagRunning!=self.VISpar.FlagRunning or (self.VISpar.nPlane>0 and self.VISpar_old.nPlane==0):
+                self.plotPlane()
+                self.button_zoom_equal_action()
             self.setZoom()
             self.plotPlane()
+            self.calibView.show()
+            if not self.VISpar.FlagInit:
+                self.button_zoom_equal_action()
+        self.setRunButtonText()
         return
-    
-    def calib2VIS(self,flagResetLevels=True,flagResetZoom=True):
-        c=self.calibView.calib
-        self.VISpar.nPlane=c.nPlanesPerCam
-        self.VISpar.nCam=c.nCams
-        """
-        if flagReset:
-            self.VISpar.plane=0
-            self.VISpar.cam=0
-        else:
-            self.VISpar.plane=c.nPlanesPerCam if self.VISpar.plane>c.nPlanesPerCam else self.VISpar.plane
-            self.VISpar.cam=c.nCams if self.VISpar.cam>c.nCams else self.VISpar.cam
-        """
-        
-        c.setLMinMax()
-        self.VISpar.LLim=c.LLim
-        if flagResetLevels: 
-            self.VISpar.LMin=c.LMin
-            self.VISpar.LMax=c.LMax
-        else:
-            self.VISpar.LMax=c.LMax if self.VISpar.LMax>c.LLim else self.VISpar.LMax
-            self.VISpar.LMin=self.VISpar.LMax-1 if self.VISpar.LMin >self.VISpar.LMax-1 else self.VISpar.LMin
-
-        self.VISpar.MaskType=abs(self.calibView.calib.cal.data.FlagPos)
-        if self.VISpar.MaskType in (2,3):
-            self.VISpar.FlagShowMask=0
-            self.VISpar.FlagPlotMask=0
-        self.FlagSettingNewCalib=flagResetZoom
-        #self.setVISpar()
-
-    def setSpinMaxMinLimValues(self):
-        spins=['plane','cam','LMin','LMax']
-        vals=[]
-        for s in spins: vals.append(getattr(self.VISpar,s))
-        self.setSpinMaxMin()
-        for s,v in zip(spins,vals): setattr(self.VISpar,s,v)
-        self.setSpinValues()
 
     def setSpinMaxMin(self):
         self.ui.spin_plane.setMinimum(1*bool(self.VISpar.nPlane))
@@ -361,110 +436,126 @@ class Vis_Tab_CalVi(gPaIRS_Tab):
         self.ui.spin_LMax.setMinimum(self.VISpar.LMin+1)
         self.ui.spin_LMax.setMaximum(self.VISpar.LLim)
 
-    def setSpinValues(self):
-        spin_p1=['plane','cam']
-        spins=self.findChildren(MyQSpin)+self.findChildren(MyQDoubleSpin)
-        for s in spins:
-            s:MyQSpin
-            nameSpin=s.objectName().split('spin_')[-1]
-            if nameSpin in spin_p1: d=1
-            else: d=0
-            s.setValue(getattr(self.VISpar,nameSpin)+d)
-        self.calibView.calib.LMax=self.VISpar.LMax
-        self.calibView.calib.LMin=self.VISpar.LMin
+#********************************************* Zoom
+#******************** Actions
+    def button_zoom_minus_action(self):
+        self.zoom(0.8)
+        return
+    
+    def button_zoom_equal_action(self):
+        self.resetScaleFactor()
+        self.zoom(1.0)
+        return
+    
+    def button_zoom_plus_action(self):
+        self.zoom(1.25)
+        return
 
-    def spin_LMin_callback(self):
-        self.VISpar.LMin=self.ui.spin_LMin.value()
-        if self.ui.spin_LMin.hasFocus():
-            self.ui.spin_LMax.setMinimum(self.VISpar.LMin+1)
-            #self.plotPlane()
+    def zoom(self,zoom):
+        ''' zooms f a factor zoom if negative reset to no zoom '''
+        if zoom<=0:
+            zoom = self.calibView.scaleFactor = 1.0
+        self.zoomImage(zoom)
+  
+    def zoomImage(self, zoom):
+        ''' zooms the image of self.CalibView.scaleFactor times a factor zoom
+        adjust also the scrollBars'''
+        self.calibView.scaleFactor *= zoom
+        self.VISpar.scaleFactor=self.calibView.scaleFactor
+        self.VISpar.scrollBarValues[0]=self.adjustedScrollBarValue(self.scrollArea.horizontalScrollBar(), zoom)
+        self.VISpar.scrollBarValues[1]=self.adjustedScrollBarValue(self.scrollArea.verticalScrollBar(), zoom)
+    
+    def adjustedScrollBarValue(self, scrollBar:QScrollBar, factor):
+        ''' adjust the position when zooming in or out ''' 
+        return int(factor * scrollBar.value() + ((factor - 1) * scrollBar.pageStep()/2))
+    
+    def splitterMoved(self):
+        self.calibView.resetScaleFactor(self.scrollArea.size())
+        self.VISpar.defaultScaleFactor=self.calibView.scaleFactor
+        self.VISpar.splitterSizes=self.ui.Vis_CalVi_splitter.sizes()
 
-    def spin_LMax_callback(self):
-        self.VISpar.LMax=self.ui.spin_LMax.value()
-        if self.ui.spin_LMax.hasFocus():
-            self.ui.spin_LMin.setMaximum(self.VISpar.LMax-1)
-            #self.plotPlane()
+#******************** Settings
+    def setZoom(self):
+        #self.calibView.show()
+        self.calibView.resize(self.VISpar.scaleFactor * self.calibView.pixmap().size())
+        self.scrollArea.horizontalScrollBar().setValue(self.VISpar.scrollBarValues[0])
+        self.scrollArea.verticalScrollBar().setValue(self.VISpar.scrollBarValues[1])
 
+#******************** Adjusting
+    def resetScaleFactor(self):
+        ''' reset the scale factor so that the image perfectly feet the window'''
+        self.calibView.resetScaleFactor(self.scrollArea.size())
+        self.VISpar.defaultScaleFactor=self.VISpar.scaleFactor=self.calibView.scaleFactor
+        self.VISpar.scrollBarValues=[0,0]
+
+#********************************************* Levels
+#******************** Actions
+    def button_restore_action(self):
+        self.VISpar.FlagResetLevels=True
+        
+#******************** Adjusting
     def restoreLevels(self):
-        pc=self.VISpar.plane
-        c=self.VISpar.cam
+        pc=self.VISpar.plane-1
+        c=self.VISpar.cam-1
         p=pc+c*self.calibView.calib.nPlanesPerCam
         c=self.calibView.calib
         c.setLMinMax(p)
-        self.VISpar.LLim=c.LLim
-        self.VISpar.LMin=c.LMin
-        self.VISpar.LMax=c.LMax
 
+#********************************************* Mask
+#******************** Actions
+    def button_PlotMask_action(self):
+        self.VISpar.FlagPlotMask=self.ui.button_PlotMask.isChecked()
+        
+#******************** Settings
+    def button_PlotMask_set(self):
+        self.ui.button_PlotMask.setChecked(self.VISpar.FlagPlotMask)
+        
+#********************************************* Plot
+#******************** Layout
     def plotPlane(self):
-        if not self.calibView.calib.cal.data.Numpiani: 
-            self.calibView.hide()
-            return
-        else:
-            self.calibView.show()
-        pc=self.VISpar.plane
-        c=self.VISpar.cam
+        pc=self.VISpar.plane-1
+        c=self.VISpar.cam-1
         p=pc+c*self.calibView.calib.nPlanesPerCam
         self.calibView.plotPlane(p)
 
-    def spin_OriOff_callback(self,Off,spin:QSpinBox,flagX):
-        self.focusOnTarget(False)
-        nameSpin=spin.objectName().split('spin_')[-1]
-        setattr(self.VISpar,nameSpin,spin.value())
+#********************************************* Parameters
+#******************** Actions
+    def spin_OriOff_action(self,spin:QSpinBox,flagX):
+        self.focusOnTarget()
+        Off=spin.value()
         if spin.hasFocus():
-            self.calibView.spinOriginChanged(Off, spin,flagX)
+            self.calibView.spinOriginChanged(Off,spin,flagX,flagPlot=False)
+
+    def spin_xOriOff_action(self):
+        self.spin_OriOff_action(self.ui.spin_xOriOff,True)
+
+    def spin_yOriOff_action(self):
+        self.spin_OriOff_action(self.ui.spin_yOriOff,False)
 
-    def spin_remPoi_callback(self,Off,spin:QSpinBox,flagX,flagPos):
-        self.focusOnTarget(False)
-        nameSpin=spin.objectName().split('spin_')[-1]
-        setattr(self.VISpar,nameSpin,spin.value())
+    def spin_remPoi_action(self,spin:QSpinBox,flagX,flagPos):
+        self.focusOnTarget()
+        Off=spin.value()
         if spin.hasFocus():
             self.calibView.spinRemPoints(Off,spin,flagX,flagPos)
     
-    def copyRemPoints(self):
-        self.focusOnTarget(False)
-        self.calibView.copyRemPoints()
-
-    def showMask(self):
-        self.VISpar.FlagShowMask=self.ui.radio_showMask.isChecked()
-        if not self.VISpar.FlagShowMask: self.VISpar.FlagPlotMask=False
-        self.calibView.calib.flagShowMask=self.VISpar.FlagShowMask
-        self.calibView.calib.flagPlotMask=self.VISpar.FlagPlotMask
+    def spin_ym_action(self):
+        self.spin_remPoi_action(self.ui.spin_ym,flagX=False,flagPos=False)
     
-    def plotMask(self):
-        self.VISpar.FlagPlotMask=self.ui.tool_plotMask.isChecked()
-        self.calibView.calib.flagPlotMask=self.VISpar.FlagPlotMask
-        #self.restoreLevels()
+    def spin_yp_action(self):
+        self.spin_remPoi_action(self.ui.spin_yp,flagX=False,flagPos=True)
 
-#********************************************* Zoom functions
-    def resetScaleFactor(self):
-        ''' reset the scale factor so that the image perfectly feet the window'''
-        self.calibView.resetScaleFactor(self.scrollArea.size())
-        self.VISpar.scaleFactor=self.calibView.scaleFactor
-        self.zoomImage(1)
+    def spin_xm_action(self):
+        self.spin_remPoi_action(self.ui.spin_xm,flagX=True,flagPos=False)
 
-    def zoom(self,zoom):
-        ''' zooms f a factor zoom if negative reset to no zoom '''
-        if zoom<=0:
-            zoom =self.calibView.scaleFactor = 1.0
-        self.zoomImage(zoom)
-  
-    def zoomImage(self, zoom):
-        ''' zooms the image of self.CalibView.scaleFactor times a factor zoom
-        adjust also the scrollBars'''
-        self.calibView.scaleFactor *= zoom
-        self.VISpar.scaleFactor=self.calibView.scaleFactor
-        self.setZoom()
-        self.adjustScrollBar(self.scrollArea.horizontalScrollBar(), zoom)
-        self.adjustScrollBar(self.scrollArea.verticalScrollBar(), zoom)
-        
-    def setZoom(self):
-        self.calibView.resize(self.calibView.scaleFactor * self.calibView.pixmap().size())
-        
-    def adjustScrollBar(self, scrollBar:QScrollBar, factor):
-        ''' adjust the position when zooming in or out 
-        # TBS copied and possibly modified wrongly'''  
-        scrollBar.setValue(int(factor * scrollBar.value()+ ((factor - 1) * scrollBar.pageStep()/2)))
+    def spin_xp_action(self):
+        self.spin_remPoi_action(self.ui.spin_xp,flagX=True,flagPos=True)
 
+    def button_copyGrid_action(self):
+        self.focusOnTarget()
+        self.calibView.copyRemPoints()
+    
+    def focusOnTarget(self):
+        self.VISpar.FlagPlotMask=False
 
 #********************************************* CalibView function
     def outFromCalibView(self,out:str):
@@ -475,8 +566,10 @@ class Vis_Tab_CalVi(gPaIRS_Tab):
         c=int(p/calib.nPlanesPerCam)
         pc=p-c*calib.nPlanesPerCam
         
-        self.VISpar.plane=pc
-        self.VISpar.cam=c
+        FlagSettingPar=TABpar.FlagSettingPar
+        TABpar.FlagSettingPar=True
+        self.VISpar.plane=pc+1
+        self.VISpar.cam=c+1
         self.ui.spin_cam.setValue(c+1)
         self.ui.spin_plane.setValue(pc+1)
         
@@ -487,6 +580,7 @@ class Vis_Tab_CalVi(gPaIRS_Tab):
         self.ui.spin_xp.setValue(da.remPointsRi[p])
         self.ui.spin_ym.setValue(da.remPointsDo[p])
         self.ui.spin_yp.setValue(da.remPointsUp[p])
+        TABpar.FlagSettingPar=FlagSettingPar
 
         if self.VISpar.FlagPlotMask:
             out2=' [CC mask]'
@@ -507,9 +601,6 @@ class Vis_Tab_CalVi(gPaIRS_Tab):
         #print(f'textFromCalib  {out}')
         self.ui.log.setText(out)
 
-        
-        
-
     def workerCompleted(self,flagError):
         ''' called when worker has completed '''
         if flagError:
@@ -521,7 +612,6 @@ class Vis_Tab_CalVi(gPaIRS_Tab):
     def setTaskButtonsText(self):
         ''' set all the button texts and enable/disable them '''
         flagEnab=True if (self.calibView.flagCurrentTask==CalibTasks.stop) else False
-        self.updateGCalVi()
         for f in  [f for f in CalibTasks if f.value>0]:
             if flagEnab:  # stop the process -> enable all buttons and restore text
                 self.taskButtons [f.value-1].setText(calibTasksText[f.value])
@@ -535,6 +625,7 @@ class Vis_Tab_CalVi(gPaIRS_Tab):
             b.setEnabled(flagEnab)
         for b  in  self.buttonsToDisableNotCalibrated:      
             b.setEnabled(self.calibView.calib.cal.flagCalibrated)    
+        self.setRunCalViButtonLayout()
         #for b in self.functionButtons:      b.setEnabled(flagEnab)
         #pri.Callback.green('-----abcde----- TaskButtonsText -----abcde-----')
    
@@ -550,23 +641,8 @@ class Vis_Tab_CalVi(gPaIRS_Tab):
         if flagFocus: self.focusOnTarget()
         self.calibView.executeCalibFunction(flag)  
         #pri.Callback.green('-----|||||----- functionButtonPressed -----|||||-----')
-   
-    def focusOnTarget(self,flagCallback=True):
-        if self.VISpar.FlagPlotMask:
-            self.ui.tool_plotMask.setChecked(False)
-            self.tool_plotMask_callback()
-
 
 #********************************************* Spin callbacks
-    def spinImgChanged(self):
-        ''' changes the plotted image'''
-        pc=self.ui.spin_plane.value()-1
-        self.VISpar.plane=pc
-        c=self.ui.spin_cam.value()-1
-        self.VISpar.cam=c
-        if self.ui.spin_plane.hasFocus() or self.ui.spin_cam.hasFocus():
-            self.plotPlane()
-
     def setImgFromGui(self):
         inddel=[]
         calib=self.calibView.calib    
@@ -574,39 +650,58 @@ class Vis_Tab_CalVi(gPaIRS_Tab):
         calib.ccMask=[]
         flagFirstImage=True
         npType=np.uint16
-        if self.list_Image_Files: #only used to read the first image and fix the img dimensions
-            for j in range(len(self.list_Image_Files[0])):
-                for k,fp in enumerate(self.list_Image_Files):
-                    f=fp[j]
-                    if self.list_eim[k][j]:
+
+        data=calib.cal.data
+        Him=data.ImgH
+        Wim=data.ImgW
+        if self.VISpar.imList: #only used to read the first image and fix the img dimensions
+            for imListc,imExc in zip(self.VISpar.imList,self.VISpar.imEx):
+                for k,f in enumerate(imListc):
+                    ex=imExc[k]=os.path.exists(f)
+                    if ex:
                         if f not in self.bufferImg:
-                            im=Image.open(f)
-                            #da=
-                            self.bufferImg[f]=da=np.array(im,dtype=npType)
+                            try:
+                                im=Image.open(f)
+                                da=np.array(im,dtype=npType)
+                                if len(da.shape)!=2:
+                                    self.bufferImg[f]=da=None
+                                    raise(f'Error: the image file: {f} seems not to be grayscale!')
+                                else:
+                                    self.bufferImg[f]=da
+                            except:
+                                pri.Error.red(f'Error while opening the image file: {f}.\n{traceback.format_exc()}\n')
+                                self.bufferImg[f]=da=None
                         else:
                             da=self.bufferImg[f]
-                        if flagFirstImage:
+                        if flagFirstImage and da is not None:
                             Him,Wim=da.shape
                             flagFirstImage=False
                             break
-                if not flagFirstImage: break
-        data=calib.cal.data
-        if flagFirstImage:
-            Him=data.ImgH
-            Wim=data.ImgW
-        if self.list_Image_Files: #reading the images 
-            for j in range(len(self.list_Image_Files[0])):
-                for k,fp in enumerate(self.list_Image_Files):
-                    f=fp[j]
+                if not flagFirstImage: break        
+        if self.VISpar.imList: #reading the images 
+             for imListc,imExc in zip(self.VISpar.imList,self.VISpar.imEx):
+                k=-1
+                for f,ex in zip(imListc,imExc):
+                    k+=1
                     if f not in self.bufferImg:
-                        if self.list_eim[k][j]:
-                            im=Image.open(f)
-                            da=np.array(im,dtype=npType)
+                        if ex:
+                            try:
+                                im=Image.open(f)
+                                da=np.array(im,dtype=npType)
+                                if len(da.shape)!=2:
+                                    da=None
+                                    raise(f'Error: the image file: {f} seems not to be grayscale!')
+                            except:
+                                pri.Error.red(f'Error while opening the image file: {f}.\n{traceback.format_exc()}\n')
+                                da=None
                         else:
                             da=np.zeros((Him,Wim),dtype=npType)
                         self.bufferImg[f]=da
                     else:
                         da=self.bufferImg[f]
+                    if da is None:
+                        inddel.append(k)
+                        continue
                     h,w=da.shape
                     if (Wim,Him)!=(w,h):
                         inddel.append(k)
@@ -617,17 +712,18 @@ class Vis_Tab_CalVi(gPaIRS_Tab):
                 
         self.bufferSize=0
         for f in self.bufferImg:#deleting buffer if to big
-                a:np.ndarray=self.bufferImg[f]
+            a:np.ndarray=self.bufferImg[f]
+            if a is not None:
                 self.bufferSize+=a.size*a.itemsize
         if self.bufferSize>bufferSizeLimit:
-                imgList=list(self.bufferImg)
-                while self.bufferSize>bufferSizeLimit and len(imgList) and imgList[0] not in self.list_Image_Files:
-                        k=0
-                        f=imgList[k]
-                        a=self.bufferImg[f]
-                        self.bufferSize-=a.size*a.itemsize
-                        self.bufferImg.pop(f)
-                        imgList.pop(k)
+            imgList=list(self.bufferImg)
+            k=0
+            while self.bufferSize>bufferSizeLimit and len(imgList) and imgList[k] not in self.VISpar.imList: 
+                f=imgList[k]
+                a=self.bufferImg[f]
+                self.bufferSize-=a.size*a.itemsize
+                self.bufferImg.pop(f)
+                imgList.pop(k)
 
         if calib.imgs:        
             calib.cal.setImgs(calib.imgs)
@@ -636,16 +732,19 @@ class Vis_Tab_CalVi(gPaIRS_Tab):
         return inddel
 
     def initDataFromGui(self,INP:INPpar_CalVi,PRO:PROpar_CalVi):
+        #FlagNewImages=self.VISpar.imList!=INP.imList or self.VISpar.imEx!=INP.imEx
+        #if not FlagNewImages: return FlagNewImages
+        self.VISpar.imList=copy.deepcopy(INP.imList)
+        self.VISpar.imEx=copy.deepcopy(INP.imEx)
         calib=self.calibView.calib
         calib.cal.DefaultValues()
         calib.FlagCalibration=False
-        self.list_Image_Files=INP.list_Image_Files
-        self.list_eim=INP.list_eim
+        
         self.FlagResume=0
         #-------------------------------------- %
         #            Not in cfg             %
         # --------------------------------------%
-        
+
         data=calib.cal.data
         calVect=calib.cal.vect
         data.PercErrMax = 0.1                # 0.10 Percentuale massima per errore in posizioneTom da modificare 
@@ -656,28 +755,37 @@ class Vis_Tab_CalVi(gPaIRS_Tab):
         # --------------------------------------%
         data.percorso = INP.path     #percorso file di input
         data.EstensioneIn = INP.ext #estensione in (b16 o tif)
-        data.FlagCam=0 if len(INP.cams) else 1    
-        data.percorsoOut = INP.pathout # percorso file di output
-        data.NomeFileOut = INP.radout # nome file di output
+        data.FlagCam=0 if INP.FlagCam else 1    
+        data.percorsoOut = INP.path_out # percorso file di output
+        data.NomeFileOut = INP.root_out # nome file di output
 
         camString=''
         cams=INP.cams
-        if cams:
+        if INP.FlagCam:
             if len(cams)==1: camString=f'_cam{cams[0]}'
         else:
             cams=[-1]
         calib.cfgName=f'{data.percorsoOut}{data.NomeFileOut}{camString}.cfg'
-        data.NCam = len(cams) # Numero di elementi nel vettore cam (numero di camere da calibrare)
-
-        varName=f'{data.percorsoOut}{data.NomeFileOut}{camString}{outExt.cal}'
-        #var=[INP,self.w_Process.PROpar,VIS]
-        if os.path.exists(varName):
-            with open(varName, 'rb') as file:
-                var=pickle.load(file)
-                self.FlagResume=1 if INP.isEqualTo(var[0],[],['cams','filenames','x','y','w','h','W','H']) else -1
-                INP.printDifferences(var[0])
-                if self.FlagResume>0:
-                    self.VISpar.copyfrom(var[2],TABpar().fields+['FlagRun'])
+        data.NCam = len(cams) if INP.FlagCam else 1 # Numero di elementi nel vettore cam (numero di camere da calibrare)
+
+        if self.VISpar.FlagRunning:
+            varName=f'{data.percorsoOut}{data.NomeFileOut}{camString}{outExt.calvi}'
+            if os.path.exists(varName):
+                try:
+                    with open(varName, 'rb') as file:
+                        try:
+                            var=pickle.load(file)
+                        except:
+                            self.FlagResume=-1
+                        else:
+                            self.FlagResume=1 if INP.isEqualTo(var[0],exceptions=TABpar().fields,fields=['cams','filenames','x','y','w','h','W','H']) else -1
+                            INP.printDifferences(var[0])
+                            #PRO.printDifferences(var[1])
+                            if self.FlagResume>0:
+                                self.VISpar.copyfrom(var[2],TABpar().fields+['FlagRunning'])
+                except:
+                    self.FlagResume=-1
+                    pri.Error.red(f'Error while restoring the previous calibration process file: {varName}.\n{traceback.format_exc()}\n')
 
         #-------------------------------------- %
         #            Distance between spots                     %
@@ -721,6 +829,12 @@ class Vis_Tab_CalVi(gPaIRS_Tab):
         data.Numpiani = data.NCam * data.Numpiani_PerCam
 
         if len(INP.filenames) <1 : #when initializing the filenames are not known
+            calib.nCams=0
+            calib.cams=[]
+            calib.nPlanes=0
+            calib.nPlanesPerCam=0
+            self.VISpar.nPlane=calib.nPlanesPerCam
+            self.VISpar.nCam=calib.nCams
             return
 
         CamModType=[1,2,3,10,30][PRO.CamMod]
@@ -839,10 +953,24 @@ class Vis_Tab_CalVi(gPaIRS_Tab):
         calib.nCams=calib.cal.data.NCam
         calib.cams=calib.cal.getCams()
         calib.nPlanes=calib.cal.data.Numpiani
+
         calib.nPlanesPerCam=calib.cal.data.Numpiani_PerCam
+        self.VISpar.nPlane=calib.nPlanesPerCam
+        self.VISpar.nCam=calib.nCams
+        self.FlagInitData=True
+        return
+    
+    def setRunCalViButtonLayout(self):
+        if self.gui:
+            FlagVisible=True
+            calib=self.calibView.calib
+            calVect=calib.cal.vect
+            FlagVisible=all([not bool(p) for p in calVect.flagPlane[:-1]])
+            self.gui.ui.button_Run_CalVi.setVisible(FlagVisible)
+
+        
+    
 
-        return 
-  
 if __name__ == "__main__":
     import sys
     app=QApplication.instance()