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

PaIRS_UniNa/Calibration_Tab.py

@@ -0,0 +1,331 @@
+from .ui_Calibration_Tab import*
+from .TabTools import*
+from .listLib import*
+
+spin_tips={
+    'ncam'  : 'Number of cameras',
+}
+check_tips={}
+radio_tips={}
+line_edit_tips={}
+button_tips={
+    'CalVi':            'Open/Close CalVi',
+    'import':           'Calibration file import',
+    'scan_list':        'Re-scan list',
+    'copy':             'Copy items',
+    'cut':              'Cut items',
+    'paste_below':      'Paste items below',
+    'paste_above':      'Paste items above',
+    'clean':            'Clean list',
+}
+combo_tips={}
+
+class CALpar(TABpar):
+    def __init__(self,Process=ProcessTypes.null,Step=StepTypes.null):
+        self.setup(Process,Step)
+        super().__init__('CALpar','Calibration')
+        self.OptionDone=0
+        self.unchecked_fields+=['row','calEx']
+
+    def setup(self,Process,Step):
+        self.Process        = Process
+        self.Step           = Step
+
+        self.FlagCalVi = False
+        self.ncam     = 2 if Process==ProcessTypes.spiv else 1
+        self.FlagCam  = False if Process==ProcessTypes.spiv else True
+        self.calList  = []
+        self.calEx    = []
+        self.row      = -1
+
+class Calibration_Tab(gPaIRS_Tab):
+    calibrationTreeButtons=['scan_list','-','import','|','copy','cut','paste_below','paste_above','|','clean']
+    class Process_Tab_Signals(gPaIRS_Tab.Tab_Signals):
+        pass
+    
+    def __init__(self,parent: QWidget =None, flagInit= __name__ == "__main__"):
+        super().__init__(parent,Ui_CalibrationTab,CALpar)
+        self.signals=self.Process_Tab_Signals(self)
+    
+        #------------------------------------- Graphical interface: widgets
+        self.TABname='Calibration'
+        self.ui: Ui_CalibrationTab
+
+        #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))
+        
+        if __name__ == "__main__": 
+            self.app=app
+            setAppGuiPalette(self)
+
+        #------------------------------------- Declaration of parameters 
+        self.CALpar_base=CALpar()
+        self.CALpar:CALpar=self.TABpar
+        self.CALpar_old:CALpar=self.TABpar_old
+
+        #------------------------------------- Callbacks 
+        self.defineWidgets()
+        self.setupWid()  #---------------- IMPORTANT
+
+        self.defineCallbacks()
+        self.connectCallbacks()
+        self.ui.calTree.itemSelectionChanged.connect(self.wrappedCallback('List selection',self.calibration_list_selection))
+        self.ui.calTree.signals.updateLists.connect(self.wrappedCallback('Re-ordering items',self.copyListsFromTree))
+
+        self.defineSettings()
+        
+        self.adjustTABpar=self.adjustCALpar
+        self.setTABlayout=self.setCALlayout
+        self.checkTABpar=self.checkCALpar
+        self.setTABwarn=self.setCALwarn
+
+        #------------------------------------- Initializing    
+        if flagInit:     
+            self.initialize()
+
+
+    def initialize(self):
+        pri.Info.yellow(f'{"*"*20}   PROCESS Disp initialization   {"*"*20}')
+        self.setTABpar(FlagAdjustPar=True,FlagBridge=False)
+        self.add_TABpar('initialization')
+        self.setFocus()
+
+#*************************************************** Adjusting parameters
+    def adjustCALpar(self):
+        if self.CALpar.Process==ProcessTypes.spiv:
+           self.CALpar.ncam=2
+           self.CALpar.FlagCam=False
+        self.ui.calTree.ncam=self.CALpar.ncam
+
+        self.checkCALpar()
+        return
+    
+    def checkCALpar(self,ind=None,FlagRescan=False):
+        if ind is None: CAL:CALpar=self.CALpar
+        else: CAL:CALpar=self.TABpar_at(ind)
+        if FlagRescan: self.scanCalList(ind)
+        CAL.OptionDone = 1 if all(CAL.calEx) and len(CAL.calList)==CAL.ncam else 0
+
+    def scanCalList(self,ind=None):
+        if ind is None: CAL:CALpar=self.CALpar
+        else: CAL:CALpar=self.TABpar_at(ind)
+        for c in range(len(CAL.calList)):  #CAL.ncam
+            CAL.calEx[c]=os.path.exists(CAL.calList[c])
+              
+#*************************************************** Layout
+    def setCALlayout(self):
+        self.ui.label_ncam.adjustSize()
+        self.ui.spin_ncam.setEnabled(self.CALpar.FlagCam)
+
+        self.calibration_list_set()
+
+        FlagFiles=self.ui.calTree.nimg>0
+        FlagSelected=len(self.ui.calTree.selectedItems())>0
+        FlagNCal=self.ui.calTree.nimg<self.ui.calTree.ncam
+        FlagCuttedItems=len(CalibrationTree.cutted_items)>0
+        self.ui.button_scan_list.setEnabled(FlagFiles)
+        self.ui.button_import.setEnabled(FlagNCal)
+        self.ui.button_cut.setEnabled(FlagSelected)
+        self.ui.button_copy.setEnabled(FlagSelected)
+        self.ui.button_paste_below.setEnabled(FlagNCal and FlagCuttedItems)
+        self.ui.button_paste_above.setEnabled(FlagNCal and FlagCuttedItems)
+        self.ui.button_clean.setEnabled(FlagFiles)
+
+        self.ui.button_CalVi.setVisible(self.CALpar.flagRun==0)
+
+        self.checkCALpar()
+        self.setCALwarn()
+        self.setTABWarnLabel()
+        return
+
+    def setCALwarn(self,ind=None):
+        if ind is None: CAL:CALpar=self.CALpar
+        else: CAL:CALpar=self.TABpar_at(ind)
+        if CAL.OptionDone==1:
+            CAL.warningMessage='Calibration files correctly identified!'
+        else:
+            warningMessage=''
+            nFiles=len(CAL.calList)
+            if nFiles<CAL.ncam:
+                warningMessage+=f'Number of calibration files ({nFiles}) lower than number of cameras specified ({CAL.ncam})!'
+            if not all(CAL.calEx):
+                n=sum([1 if not ex else 0 for ex in CAL.calEx])
+                if warningMessage: warningMessage='\n*  '
+                warningMessage+=f'{n} out of {CAL.ncam} calibration files missing!'
+            if '\n*  ' in warningMessage: warningMessage='*  '+warningMessage
+            CAL.warningMessage=warningMessage
+
+#*************************************************** Spin ncam
+#******************** Actions
+    def spin_ncam_action(self):
+        self.copyListsFromTree()
+
+#*************************************************** Buttons
+#******************** Actions
+    def button_CalVi_action(self):
+        self.CALpar.FlagCalVi=self.ui.button_CalVi.isChecked()
+
+    def button_scan_list_action(self):
+        self.ui.calTree.setLists()
+        self.CALpar.calEx=deep_duplicate(self.ui.calTree.calEx)
+
+    def button_import_action(self):
+        filenames, _ = QFileDialog.getOpenFileNames(self,\
+            "Select calibration files from the current directory", filter='*.cal',\
+                options=optionNativeDialog)
+        if filenames:
+            self.ui.calTree.hide()
+            self.ui.calTree.importLists(filenames)
+        self.copyListsFromTree()
+        self.ui.calTree.show()
+
+    def copyListsFromTree(self):
+        if self.ui.calTree.nimg>self.CALpar.ncam:
+            warningDialog(self,f'A number of files exceeding the specified number of cameras has been selected!\nOnly the first {self.CALpar.ncam} files will be retained in the list.')
+        self.CALpar.calList=deep_duplicate(self.ui.calTree.calList[:self.CALpar.ncam])
+        self.CALpar.calEx=deep_duplicate(self.ui.calTree.calEx[:self.CALpar.ncam])
+        self.calibration_list_selection()
+
+    def button_copy_cut_action(self, FlagCut=False):
+        self.ui.calTree.setVisible(False)
+        selectedItems,indexes=self.ui.calTree.selectTopLevel()
+        self.copy_cut_action(selectedItems,indexes,FlagCut)
+
+    def cutItems(self,items):
+        cutted_items=[None]*len(items)
+        for k,item in zip(range(len(items)),items): cutted_items[k]=self.ui.calTree.duplicateItem(item)
+        type(self.ui.calTree).cutted_items=cutted_items
+        return
+
+    def copy_cut_action(self,items,indexes,FlagCut):        
+        self.cutItems(items)
+
+        if FlagCut: 
+            for item in items:
+                self.ui.calTree.takeTopLevelItem(self.ui.calTree.indexOfTopLevelItem(item))
+            self.ui.calTree.cutLists(indexes)
+        else: 
+            self.ui.calTree.copyLists(indexes)
+
+        self.ui.calTree.setVisible(True)
+        self.ui.calTree.setFocus()
+
+        self.copyListsFromTree()
+    
+    def button_copy_action(self):
+        self.button_copy_cut_action(FlagCut=False)
+
+    def button_cut_action(self):
+        self.button_copy_cut_action(FlagCut=True)
+
+    def button_paste_above_below_action(self,FlagAbove=True): 
+        if not self.ui.calTree.cutted_items: return
+        self.ui.calTree.setVisible(False)
+        FlagResizeHeader=self.ui.calTree.topLevelItemCount()==0
+        selectedItems,indexes=self.ui.calTree.selectTopLevel()
+        #self.ui.calTree.clearSelection()
+        if FlagAbove:
+            if selectedItems: row=indexes[0]
+            else: row=0
+            firstItemToScroll=self.ui.calTree.cutted_items[0]
+            lastItemToScroll=self.ui.calTree.cutted_items[-1]
+        else:
+            if selectedItems: row=indexes[-1]+1
+            else: row=self.ui.calTree.topLevelItemCount()
+            firstItemToScroll=self.ui.calTree.cutted_items[-1]
+            lastItemToScroll=self.ui.calTree.cutted_items[0]
+        self.ui.calTree.insertItems2List(row,self.ui.calTree.cutted_items,True,FlagSignal=False)
+        if not self.ui.calTree.FlagCutted:
+            self.cutItems(self.ui.calTree.cutted_items)
+        self.ui.calTree.pasteLists(row)
+
+        self.ui.calTree.scrollToItem(firstItemToScroll)
+        self.ui.calTree.scrollToItem(lastItemToScroll)
+        if FlagResizeHeader: self.ui.calTree.resizeColumnToContents(0)
+        self.ui.calTree.setVisible(True)
+        self.ui.calTree.setFocus()
+        
+        self.copyListsFromTree()
+
+    def button_paste_above_action(self): 
+        self.button_paste_above_below_action(FlagAbove=True)
+
+    def button_paste_below_action(self): 
+        self.button_paste_above_below_action(FlagAbove=False)
+        
+    def button_clean_action(self):
+        self.ui.calTree.setVisible(False)
+        self.nullList()
+        self.ui.calTree.setVisible(True)
+
+    def nullList(self):
+        self.ui.calTree.nimg=0
+        self.ui.calTree.calList=[]
+        self.ui.calTree.calEx=[]
+        self.ui.calTree.itemList[0]=self.ui.calTree.calList
+        self.ui.calTree.itemList[1]=self.ui.calTree.calEx
+        self.ui.calTree.setLists()
+        
+        self.copyListsFromTree()
+
+#******************** Actions
+    def button_CalVi_set(self):
+        self.ui.button_CalVi.setChecked(self.CALpar.FlagCalVi)
+
+#*************************************************** Calibration List
+#******************** Actions
+    def calibration_list_selection(self):
+        selectedItems=self.ui.calTree.selectedItems()
+        self.CALpar.row=self.ui.calTree.indexOfTopLevelItem(selectedItems[-1]) if len(selectedItems) else -1
+        return 
+    
+#******************** Settings
+    def calibration_list_set(self):
+        if self.CALpar.isDifferentFrom(self.ui.calTree,fields=['calList','calEx']):
+            self.ui.calTree.itemList[0]=self.ui.calTree.calList=deep_duplicate(self.CALpar.calList)
+            self.ui.calTree.itemList[1]=self.ui.calTree.calEx=deep_duplicate(self.CALpar.calEx)
+            self.ui.calTree.setLists()
+            self.CALpar.calEx=deep_duplicate(self.ui.calTree.calEx)
+
+        if self.CALpar.row>-1 and self.CALpar.row<len(self.CALpar.calList):
+            self.ui.calTree.topLevelItem(self.CALpar.row).setSelected(True)
+
+#*************************************************** Context Menu
+    def contextMenuEvent(self, event):
+        menu=QMenu(self)
+        name=[]
+        act=[]
+        fun=[]
+        for nb in self.calibrationTreeButtons:
+            if '-' not in nb and '|' not in nb:
+                b:QPushButton=getattr(self.ui,'button_'+nb)
+                if b.isVisible() and b.isEnabled():
+                    if hasattr(self,'button_'+nb+'_callback'):
+                        name.append(nb)
+                        act.append(QAction(b.icon(),toPlainText(b.toolTip().split('.')[0]),self))
+                        menu.addAction(act[-1])
+                        callback=getattr(self,'button_'+nb+'_callback')
+                        fun.append(callback)
+            elif '|' in nb:
+                if len(act): menu.addSeparator()
+
+        if len(act):
+            action = menu.exec(self.mapToGlobal(event.pos()))
+            for nb,a,f in zip(name,act,fun):
+                if a==action: 
+                    TABpar.FlagSettingPar=False
+                    f()
+
+if __name__ == "__main__":
+    import sys
+    app=QApplication.instance()
+    if not app:app = QApplication(sys.argv)
+    app.setStyle('Fusion')
+    object = Calibration_Tab(None)
+    object.show()
+    app.exec()
+    app.quit()
+    app=None

PaIRS_UniNa/Changes.txt

@@ -1,10 +1,142 @@
-**********   Changes to version 0.1.12 (0.1.13 - 2024.02.07)  **********
+*********   Changes in version 0.2.8 (2025.11.14)  **********
+Bug fixes:
+- corrected a bug in the z-vorticity computation: velocity gradients were not properly converted to physical units, causing an error in the magnitude scales though not in the qualitative distributions;
+- corrected the display of maps of output variables and vector fields in Vis to ensure proper alignment across option changes;
+- fixed issues related to path handling in the batch-folder copy and other modules: paths are no longer relativized, avoiding inconsistent behavior across different operating systems or different.
+
+New features:
+- added new options in the batch folder-copy tool to automatically remove image pairs where one or more files are missing in the destination folders and to fully re-scan the destination folders for cases in which mismatches in the image sets may occur;
+- extended the existing functionality in Vis for loading and visualizing past results located under the specified output path and name root: when available, the corresponding saved log file is now automatically loaded and displayed in the Log tab.
+
+User-interface enhancements:
+- improved the naming logic for duplicated processes: copied processes are now assigned consistent incremental suffixes;
+- improved the example-image tree and the behavior of the step spin box in the Image Import Tool (minimum step is now 1); 
+- refined the behavior of the import button: it is now always enabled, and when no changes in the image list are detected upon importing, the user simply receives a warning message;
+- improved the behaviour of the list of path completers in the Input tabs; 
+- in Vis, resizing settings and automatic level-reset options are no longer global but apply individually per each step.
+
+
+*********   Changes in version 0.2.7 (2025.10.13)  **********
+Bug fixes:
+- resolved an issue related to visulazion of streamlines when the image is shown in pixel units and a custom resolution is specified (in previous versions, streamlines were always represented in physical units);
+- corrected the update of reprojection errors in CalVi when the control point grid is expanded after a calibration. Each new control point now has its error recalculated and plotted, providing a correct view of the extrapolation error;
+- fixed the automatic resize/reshape behavior specified in the Output tab: when an image transformation is assigned, it is now preserved even if the automatic reshape button is active.
+
+User-interface enhancements:
+- changed the behavior of the Vis button for restricting view on the interrogation window area: clicking it now opens a popup menu that allows users to select the desired interrogation-window size to focus on among all iterations of the process;
+- names of processes duplicated in the process tree are now automatically updated to avoid conflicts: if a name already exists, the new one is appended with an incremental suffix;
+- improved interaction with editable input fields: when hovering the highlighted style is displayed correctly, the text cursor now appears exactly where clicked and the background color is properly restored when leaving the field.
+
+
+
+*********   Changes in version 0.2.6 (2025.09.06)  **********
+Bug fixes:
+- fixed bugs related to process tree management.
+
+User-interface enhancements:
+- enhanced release check using SSL for reliable retrieval of the latest version.
+
+Distribution:
+- ready-to-use executables of PaIRS are now available!
+
+
+
+*********   Changes in version 0.2.5 (2025.07.28)  **********
+Bug fixes:
+- fixed bugs in launching PIV and stereoscopic PIV processes in special cases;
+- fixed tooltip crash introduced by PySide 6.9;
+- corrected package import errors and context menu bugs;
+- resolved multiple visual glitches in image tree selection and map visualization.
+
+New features:
+- implemented version control of required Python packages with automatic compatibility check and warning;
+- disparity maps are now automatically saved in the output folder and can be visualized in Vis;
+- added support for restricting view in Vis based on interrogation window size and shifting the view window interactively.
+
+User-interface enhancements:
+- redesigned the execution logic of internal workers for improved control and robustness;
+- improved formatting and display of coordinates and variable values when moving the cursor during map visualization;
+- updated button labels and layout for clarity and consistency.
+
+Distribution:
+- Support for Python 3.9 has been discontinued;
+- Python 3.13 builds have been successfully created and tested in Windows. 
+
+
+
+*********   Changes in version 0.2.4 (2024.12.01)  **********
+Bug fixes:
+- fixed critical bugs in process handling and calibration step (CalVi usage, closing PaIRS during CalVi operation, resetting steps while running);
+- resolved issues with velocity field visualization and stereo-PIV streamline representation;  
+- fixed undo/redo functionality, image tree selection issues, logging errors and focus-out signal handling.
+
+New features:
+- extended Vis features, including reference frame system plotting and vorticity field visualization;
+- introduced the ability to copy input and output information from other steps within the same process;
+- introduced functionality to interrupt processing before it starts if issues are detected.
+
+Performance improvements:
+- optimized thread usage and resource management for PIV and stereo-PIV;
+- streamlined process workflows, including faster and more reliable parameter updates.
+
+User-interface enhancements:
+- updated the CalVi Stop button to function as Save and improved its conditional display;
+- improved handling of project/process information and added better feedback for user actions.
+
+
+
+*********   Changes in version 0.2.3 (2024.11.06)  **********
+- Fixed bug in the functionality for replicating processes with changed input folders introduced in version v0.2.2.
+
+- Fixed bug in the compatibility check for the common region in disparity and stereoscopic PIV analysis steps.
+
+
+
+*********   Changes in version 0.2.2 (2024.10.15)  **********
+- [!!! Critical !!!] Fixed critical errors in the calculation of Reynolds stresses for stereoscopic PIV processes. Please consider reviewing the results from processes executed with version 0.2.1, as the w'w', u'w', and v'w' stresses were incorrectly calculated.
+
+- Introduced the "Laser Equation Plane" box in the Output tab to specify the initial attempt in the disparity step or to independently assign the constant values of the laser plane during the stereoscopic PIV step.
+
+- Introduced the "Copy process to loop over folders" button in the process tree. The latter allows the user to select multiple folders from the disk and replicate the process in the tree for each folder, automatically updating the input image path (specified in the Input tab) to match the path of each selected folder. This makes it extremely easy and fast to create a queue of processes for folders containing similar image sets.
+
+- Resolved various bugs related to the copy and link functions of steps within the process tree. Buttons have been relocated to the Explorer, and additional functionality has been added to the context menu of the process tree items.
+
+- Improved stability and interface performance.
+
+- The guide of PaIRS-UniNa v0.2 is now available. Discover all the information you need for advanced software usage at https://www.pairs.unina.it/web/PaIRS-UniNa-v020-Guide.pdf.
+
+
+
+*********   Changes in version 0.2.1 (2024.07.08)  **********
+- Fixed bugs for Python 3.11 and 3.12.
+
+- Fixed bugs related to use of historical minimum background image in disparity and image analysis steps.
+
+- Fixed minor bugs.
+
+
+
+**********   Changes in 0.2.0 (2024.07.03)  **********
+- The latest version of PaIRS marks a departure from its predecessors. PaIRS now boasts a completely redesigned interface aimed at quick, simple, and efficient usability. Users bid farewell to Past, Present, and Future trees in favor of a new, more intuitive process management system (the Explorer): processes are organized into groups called projects and each project or process can be queued for later execution. Processes within each project can be modified until they are launched, and if necessary, reset and restarted from scratch. Each project also features a tree of deleted processes, allowing retrieval of outdated or abandoned processes.
+
+- Currently, PaIRS includes four types of processes: preprocessing, PIV (Particle Image Velocimetry), calibration, and stereoscopic PIV. Each of these processes consists of one or more steps, which can be optional or mandatory. Similar to the first version of PaIRS, these steps are editable via PaIRS iconic tabs (Input, Output, Process, etc.). The process tree provides immediate visibility into the status of each step, further streamlining management.
+
+- The calibration process grants access to CalVi (Calibration Visualizer). It is no longer necessary to launch the PaIRS calibration tool separately; everything is conveniently available within a single interface.
+
+- The Input tab introduces a completely renewed image import list, offering users total freedom without the constraints of the past.
+
+- Additionally, the Vis tab introduces some exciting new features, such as the ability to modify colormaps and vector/streamline colors, along with improved handling of image/result loading.
+
+
+
+**********   Changes in version 0.1.13 (2024.02.07)  **********
 - Fixed bugs related to navigation across the Past, Present and Future trees in the Queue tab.
+
 - Minor changes in Vis.
 
 
 
-**********   Changes to version 0.1.11 (0.1.12 - 2024.02.02)  **********
+**********   Changes in version 0.1.12 (2024.02.02)  **********
 - PaIRS now includes the possibility to customize the windowing parameters for each iteration of a PIV process. The user can choose the windowing parameters for each iteration in the initial phase of the PIV process. This is possible by operating in the Windowing box at the bottom of the Process tab (visible only in the expert mode). A table widget has been added to this section, where the user can find all relevant information the windowing scheme for the PIV process and modify it iteration by iteration. By selecting the corresponding row of the table, the user can choose for the current iteration the type of weighting window to be used in the calculation of the absolute velocity and in the determination of the correlation map, if using the direct correlations or not and the maximum displacement allowed in the interrogation window. The latter parameter is an innovation of the present version itself and adds to the custom settings selectable by the user to build affordable validation strategies. In addition, in the table an indication about the stability of the windowing scheme for each iteration is reported. In conclusion, a larger degree of customization of the PIV process comes with the present modification of PaIRS.
  
 - CalVi now fully supports optical camera calibration for transparent cylindrical geometries. In the version 0.1.10 this camera model was available only in debug mode for beta testers and developers, now it is fully working. The calibration of this camera model is however a delicate task and the user is referred to the CalVi guide for reliable experimental procedures that could be used in this direction.