PaIRS-UniNa 0.2.7__cp312-cp312-win_amd64.whl → 0.2.9__cp312-cp312-win_amd64.whl

PaIRS_UniNa/Calibration_Tab.py

@@ -1,6 +1,7 @@
 from .ui_Calibration_Tab import*
 from .TabTools import*
 from .listLib import*
+from .SPIVCalHelp import showSPIVCalHelp
 
 spin_tips={
     'ncam'  : 'Number of cameras',
@@ -21,6 +22,7 @@ button_tips={
 combo_tips={}
 
 class CALpar(TABpar):
+    FlagSPIVCal = True
     def __init__(self,Process=ProcessTypes.null,Step=StepTypes.null):
         self.setup(Process,Step)
         super().__init__('CALpar','Calibration')
@@ -61,6 +63,8 @@ class Calibration_Tab(gPaIRS_Tab):
             self.app=app
             setAppGuiPalette(self)
 
+        self.ui.button_info.setStyleSheet("border: none;")
+
         #------------------------------------- Declaration of parameters 
         self.CALpar_base=CALpar()
         self.CALpar:CALpar=self.TABpar
@@ -133,6 +137,7 @@ class Calibration_Tab(gPaIRS_Tab):
         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_info.setVisible(self.CALpar.Process==ProcessTypes.spiv)
 
         self.ui.button_CalVi.setVisible(self.CALpar.flagRun==0)
 
@@ -166,13 +171,23 @@ class Calibration_Tab(gPaIRS_Tab):
 #*************************************************** Buttons
 #******************** Actions
     def button_CalVi_action(self):
+        if self.CALpar.FlagSPIVCal and self.ui.button_info.isVisible() and self.ui.button_CalVi.isChecked():
+            showSPIVCalHelp(self,self.dontShowAgainSPIVCalHelp)
         self.CALpar.FlagCalVi=self.ui.button_CalVi.isChecked()
 
+    def dontShowAgainSPIVCalHelp(self):
+        self.CALpar.FlagSPIVCal = False
+
+    def button_info_action(self):
+        showSPIVCalHelp(self)
+
     def button_scan_list_action(self):
         self.ui.calTree.setLists()
         self.CALpar.calEx=deep_duplicate(self.ui.calTree.calEx)
 
     def button_import_action(self):
+        if self.CALpar.FlagSPIVCal and self.ui.button_info.isVisible():
+            showSPIVCalHelp(self,self.dontShowAgainSPIVCalHelp)
         filenames, _ = QFileDialog.getOpenFileNames(self,\
             "Select calibration files from the current directory", filter='*.cal',\
                 options=optionNativeDialog)

PaIRS_UniNa/Changes.txt

@@ -1,3 +1,30 @@
+*********   Changes in version 0.2.9 (2025.12.12)  **********
+Bug fixes:
+- fixed a bug in the batch folder-copy tool enabling automatic removal of incomplete image pairs and a full re-scan of destination folders to detect and resolve any image-set mismatches.
+
+New features:
+- a new help dialog has been introduced to assist users during the stereoscopic PIV calibration process. The dialog provides a detailed explanation of the required coordinate convention (plate defining the x–y plane, z-axis normal to the plate and x-axis aligned with the stereoscopic baseline) and displays example images illustrating correct and incorrect configurations.
+
+
+
+*********   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);

PaIRS_UniNa/Explorer.py

@@ -1452,8 +1452,8 @@ class ProcessTree(PaIRSTree):
             ITE.FlagQueue=self.TREpar.FlagQueue
             ITE.ind=[self.TREpar.project,int(self.FlagBin),ind,0,0]
             
+            processNames=[item[0].name for item in self.itemList[0]]+[item[0].name for item in self.restoreTree.itemList[0]]
             if name is None:
-                processNames=[item[0].name for item in self.itemList[0]]+[item[0].name for item in self.restoreTree.itemList[0]]
                 nameInd=1
                 ITE.name=f'{ITE.basename} {nameInd}'
                 while ITE.name in processNames:
@@ -1461,6 +1461,10 @@ class ProcessTree(PaIRSTree):
                     ITE.name=f'{ITE.basename} {nameInd}'
             else:
                 ITE.name=name
+                nameInd=1
+                while ITE.name in processNames:
+                    nameInd+=1
+                    ITE.name=f'{name} ({nameInd})'
             self.createParPrevs(ITE)
             self.itemList[0].insert(ind,[ITE])
         else:
@@ -1917,12 +1921,12 @@ class ProcessTree(PaIRSTree):
                 pixmap_list.append(icons_path+ITE.icon)
                 name_list.append(ITE.name)
                 flag_list.append(ITE.Step!=StepTypes.cal)
-            func=lambda i, opts: self.process_loop(paths,processType,ind,ITEs[0].name,i,opts)
+            func=lambda i, opts, cleanup_flag, rescan_flag: self.process_loop(paths,processType,ind,ITEs[0].name,i,opts,cleanup_flag,rescan_flag)
             dialog = FolderLoopDialog(pixmap_list, name_list, flag_list, parent=self, paths=paths, func=func, process_name=ITEs[0].name)
             dialog.exec()
         return
     
-    def process_loop(self,paths,processType,ind,name0,i,opts):
+    def process_loop(self,paths,processType,ind,name0,i,opts,cleanup_flag,rescan_flag):
         nProcess=self.topLevelItemCount()
         path=paths[i]
         name=name0+f" (.../{os.path.basename(path)}/)"
@@ -1933,6 +1937,7 @@ class ProcessTree(PaIRSTree):
         ind_slave[2]=nProcess
         ind_slave[-1]=0
         
+        FlagWarning=False
         for j in range(len(opts)):
             ind_master[3]=j
             ind_slave[3]=j
@@ -1944,10 +1949,17 @@ class ProcessTree(PaIRSTree):
                 if opts[j]==2:
                     INP: INPpar=self.gui.w_Input.TABpar_at(ind_new)
                     INP.path=myStandardPath(path)
-                    self.gui.w_Input.scanImList(ind_new)
+                    if rescan_flag: 
+                        flagWarning=self.rescanInputPath(ind_master,ind_new,cleanup_flag)
+                    else: 
+                        flagWarning=self.gui.w_Input.scanImList(ind_new)
+                    if cleanup_flag: self.gui.w_Input.purgeImList(ind_new)
+                    INP.nimg=0
+                    if len(INP.imList[0]):
+                        if len(INP.imList[0][0]):
+                            INP.nimg=len(INP.imList[0][0])
                     self.gui.w_Input.checkINPpar(ind_new)
                     self.gui.w_Input.setINPwarn(ind_new)
-                    self.Explorer.setITElayout(ITE)
 
                     TABname=self.gui.w_Input.TABname
                     self.gui.bridge(TABname,ind_new)
@@ -1966,12 +1978,54 @@ class ProcessTree(PaIRSTree):
                                 w.TABpar.copyfrom(currpar)
                                 self.gui.bridge(w.TABname,ind_new)
                     TABpar.FlagSettingPar=FlagSettingPar
+                    self.Explorer.setITElayout(ITE)
+                    FlagWarning=FlagWarning or flagWarning or ITE.OptionDone==0
+
                     #item_child=item.child(j)
                     #item_child.setSelected(True)
                     #self.setCurrentItem(item_child)
             else:
                 self.gui.link_pars(ind_slave,ind_master,FlagSet=False)
-        return
+        return FlagWarning
+
+    def rescanInputPath(self, ind_master, ind_new, FlagNoWarning):
+        """Rescan input on slave using master patterns, then rebuild imList/imEx."""
+        INP: INPpar  = self.gui.w_Input.TABpar_at(ind_new)     # slave
+        INPm: INPpar = self.gui.w_Input.TABpar_at(ind_master)  # master
+
+        # Build A (for frame_1) and B (for frame_2) from master's pattern at master's frames
+        patm = getattr(INPm.imSet, "pattern", [])
+        ncam = INP.inp_ncam
+        def _pat_list(frames,ind0=0):
+            out=[]; 
+            for k in range(ncam):
+                f = frames[k]-ind0 if k < len(frames) else -1
+                out.append(patm[f] if isinstance(f,int) and 0 <= f < len(patm) else None)
+            return out
+        A = _pat_list(INPm.frame_1)
+        B = _pat_list(INPm.frame_2,1)
+
+        # Rescan slave input path with patterns=A,B (maps patterns -> frame indices on slave)
+        self.gui.w_Input.scanInputPath(ind_new, patterns=[A, B], FlagNoWarning=FlagNoWarning)
+
+        # Rebuild imList/imEx from frames computed on slave
+        INP.imList, INP.imEx = INP.imSet.genListsFromFrame(
+            INP.frame_1, INP.frame_2, INP.ind_in, INP.npairs, INP.step, INP.FlagTR_Import
+        )
+        # Compare slave vs master lists
+        def _lists_differ(a, b):
+            if len(a) != len(b): return True
+            for x, y in zip(a, b):
+                if x != y: return True
+            return False
+
+        FlagWarning = (
+            _lists_differ(INP.imList, INPm.imList) or
+            _lists_differ(INP.imEx,   INPm.imEx)
+        )
+
+        return FlagWarning
+
 
     def button_delete_action(self):
         self.blockSignals(True)
@@ -2957,9 +3011,16 @@ class StartingPage(QFrame):
         for n, process in processes.items():
             # Layout orizzontale per ogni processo
             widget=QWidget()
+            widget.setObjectName("process_item")
+            widget.setStyleSheet("""
+            QWidget#process_item:hover {
+                background-color: rgba(64, 64, 255, 33); 
+                border-radius: 10px;
+            }
+            """)
             process_layout = QHBoxLayout(widget)
             process_layout.setSpacing(self.LAYOUT_SPACING)
-            process_layout.setContentsMargins(0, 0, 0, 0)
+            process_layout.setContentsMargins(10, 10, 10, 0)
 
             # Pulsante con icona
             button_layout = QHBoxLayout()
@@ -3007,13 +3068,15 @@ class StartingPage(QFrame):
             caption_text_edit.setFont(caption_font)
             caption_text_edit.setAlignment(Qt.AlignmentFlag.AlignJustify)
             caption_text_edit.setReadOnly(True)
+            caption_text_edit.setTextInteractionFlags(Qt.NoTextInteraction)
+            caption_text_edit.viewport().setCursor(Qt.PointingHandCursor)
             caption_text_edit.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
             caption_text_edit.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
             caption_text_edit.setFrameStyle(QFrame.NoFrame)
             #caption_text_edit.setFixedWidth(self.CAPTION_WIDTH)
             caption_text_edit.setStyleSheet("background: transparent;")
             caption_text_edit.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
-
+            
             # Adjust height to content
             caption_text_edit.document().setTextWidth(caption_text_edit.viewport().width())
             caption_text_edit.setFixedHeight(CAPTION_HEIGHT)#caption_text_edit.document().size().height())
@@ -3029,6 +3092,25 @@ class StartingPage(QFrame):
             # Aggiungi il layout orizzontale al layout principale
             self.main_layout.addWidget(widget)
 
+            # --- Make the whole row clickable (icon + labels + background) ---
+            if buttonBar:
+
+                def make_clickable(w, callback):
+                    w.setCursor(Qt.PointingHandCursor)
+
+                    def mouseReleaseEvent(event, cb=callback, ww=w):
+                        if event.button() == Qt.LeftButton:
+                            cb()
+                        # call base implementation to keep default behaviour
+                        QWidget.mouseReleaseEvent(ww, event)
+
+                    w.mouseReleaseEvent = mouseReleaseEvent
+
+                # entire row + title + caption all trigger the same action
+                make_clickable(widget, action(n))
+                #make_clickable(name_label, click_callback)
+                #make_clickable(caption_text_edit, click_callback)
+            
             self.items[n]=widget
 
         self.main_layout.addItem(QSpacerItem(0, 0, QSizePolicy.Expanding, QSizePolicy.Expanding))

PaIRS_UniNa/FolderLoop.py

@@ -1,6 +1,6 @@
 import sys
 from PySide6.QtWidgets import (
-    QApplication, QDialog, QVBoxLayout, QLabel, QHBoxLayout, QWidget, QSpacerItem,
+    QApplication, QDialog, QVBoxLayout, QLabel, QHBoxLayout, QWidget, QSpacerItem, QTreeWidget, QTreeWidgetItem,
     QPushButton, QProgressBar, QSizePolicy,
     QFileDialog, QListView, QAbstractItemView, QTreeView,  QFileSystemModel
 )
@@ -83,14 +83,18 @@ class FolderLoopDialog(QDialog):
         self.tooltips = {
             "copy": "Copy the item",
             "link": "Link the item",
-            "change_folder": "Change the folder"
+            "change_folder": "Change the folder",
+            "auto_purge": "Auto-remove missing-image pairs",
+            "rescan": "Re-scan destination paths"
         }
 
         # Icons for the buttons
         self.icons = {
             "copy": [QIcon(icons_path + "copy_process.png"), QIcon(icons_path + "copy_process_off.png")],
             "link": [QIcon(icons_path + "link.png"), QIcon(icons_path + "unlink.png")],
-            "change_folder": [QIcon(icons_path + "change_folder.png"), QIcon(icons_path + "change_folder_off.png")]
+            "change_folder": [QIcon(icons_path + "change_folder.png"), QIcon(icons_path + "change_folder_off.png")],
+            "auto_purge": [QIcon(icons_path + "folder_loop_cleanup.png"), QIcon(icons_path + "folder_loop_cleanup_off.png")],
+            "rescan": [QIcon(icons_path + "scan_path_loop.png"), QIcon(icons_path + "scan_path_loop_off.png")],
         }
         self.options_list=list(self.icons)
 
@@ -109,7 +113,8 @@ class FolderLoopDialog(QDialog):
         self.header_icon.setFixedSize(self.icon_size)
         header_layout.addWidget(self.header_icon)
 
-        self.header_label = QLabel(process_name)
+        header_text=process_name[:48]+f"{'...' if len(process_name)>50 else ''}"
+        self.header_label = QLabel(header_text)
         self.header_label.setFont(self.title_font)
         self.header_label.setAlignment(Qt.AlignmentFlag.AlignLeft|Qt.AlignmentFlag.AlignVCenter)
         self.header_label.setFixedHeight(self.title_height)
@@ -191,6 +196,82 @@ class FolderLoopDialog(QDialog):
 
             layout.addWidget(widget)
 
+        # --- Cleanup row ---
+        cleanup_spacing = 5
+        self.cleanup_widget = QWidget()
+        cw_layout = QHBoxLayout(self.cleanup_widget)
+        cw_layout.setContentsMargins(0, cleanup_spacing, 0, cleanup_spacing)
+        cw_layout.setSpacing(5)
+
+        self.cleanup_button = QPushButton(self)
+        self.cleanup_button.setCheckable(True)
+        self.cleanup_button.setChecked(False)
+        self.cleanup_button.setIcon(self.icons["auto_purge"][1])
+        self.cleanup_button.setFixedSize(self.button_size)
+        self.cleanup_button.setStyleSheet("QPushButton{border: none;}")
+        self.cleanup_button.setCursor(QCursor(Qt.PointingHandCursor))
+        self.cleanup_button.setToolTip(self.tooltips["auto_purge"])
+        self.cleanup_button.setIconSize(self.icon_size_off)
+
+        self.cleanup_label = QLabel("", self)
+        self.cleanup_label_font = parent.font()
+        self.cleanup_label_font.setPixelSize(fontPixelSize)
+        self.cleanup_label_font.setItalic(True)
+        self.cleanup_label.setFont(self.cleanup_label_font)
+        self.cleanup_label.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
+
+        self.cleanup_button.toggled.connect(self.on_cleanup_toggled)
+        cw_layout.addItem(QSpacerItem(10, 0, QSizePolicy.Expanding, QSizePolicy.Minimum))
+        cw_layout.addWidget(self.cleanup_label)
+        cw_layout.addWidget(self.cleanup_button)
+
+
+        # --- Rescan row ---
+        rescan_spacing = 5
+        self.rescan_widget = QWidget()
+        rw_layout = QHBoxLayout(self.rescan_widget)
+        rw_layout.setContentsMargins(0, rescan_spacing, 0, rescan_spacing)
+        rw_layout.setSpacing(5)
+
+        self.rescan_button = QPushButton(self)
+        self.rescan_button.setCheckable(True)
+        self.rescan_button.setChecked(False)
+        self.rescan_button.setIcon(self.icons["rescan"][1])
+        self.rescan_button.setFixedSize(self.button_size)
+        self.rescan_button.setStyleSheet("QPushButton{border: none;}")
+        self.rescan_button.setCursor(QCursor(Qt.PointingHandCursor))
+        self.rescan_button.setToolTip(self.tooltips["rescan"])
+        self.rescan_button.setIconSize(self.icon_size_off)
+
+        self.rescan_label = QLabel("", self)
+        self.rescan_label_font = parent.font()
+        self.rescan_label_font.setPixelSize(fontPixelSize)
+        self.rescan_label_font.setItalic(True)
+        self.rescan_label.setFont(self.rescan_label_font)
+        self.rescan_label.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
+
+        self.rescan_button.toggled.connect(self.on_rescan_toggled)
+        rw_layout.addItem(QSpacerItem(10, 0, QSizePolicy.Expanding, QSizePolicy.Minimum))
+        rw_layout.addWidget(self.rescan_label)
+        rw_layout.addWidget(self.rescan_button)
+
+        # --- Container for both rows ---
+        self.extra_opts_widget = QWidget()
+        eo_layout = QVBoxLayout(self.extra_opts_widget)
+        eo_layout.setContentsMargins(0, 5, 0, 50)  # top=10, bottom=10
+        eo_layout.setSpacing(5)
+        eo_layout.addWidget(self.rescan_widget)
+        eo_layout.addWidget(self.cleanup_widget)
+        self.extra_opts_widget.setFixedHeight(self.button_size.height()*2+60)
+
+        self.extra_opts_widget.setVisible(False)
+        self.widgets.append(self.extra_opts_widget)
+
+        # Add container to parent layout
+        layout.addWidget(self.extra_opts_widget)
+        
+        self.warnings=[False]*len(self.paths)
+
         # Progress bar and final buttons (Cancel, Proceed)
         progress_widget = QWidget()
         progress_layout = QHBoxLayout()
@@ -228,8 +309,13 @@ class FolderLoopDialog(QDialog):
         self.setLayout(layout)
 
         # Set window maximum height and margins
+        self.on_cleanup_toggled(self.cleanup_button.isChecked())
+        self.on_rescan_toggled(self.rescan_button.isChecked())
+        self.update_extraopts_visibility(FlagAnimation=False)
         self.setFixedHeight(self.max_height)
         self.setContentsMargins(self.margin_size*2, self.margin_size, self.margin_size*2, self.margin_size)
+        self.setMinimumWidth(640)
+        self.setMaximumWidth(800)
 
         # Timer for progress
         self.iteration = 0
@@ -271,6 +357,51 @@ class FolderLoopDialog(QDialog):
                 button.setIconSize(self.icon_size)
                 button.setIcon(self.icons[self.options_list[k]][0])  # Checked state icon
                 self.step_options[index]=k
+                self.update_extraopts_visibility() 
+
+    def update_extraopts_visibility(self,FlagAnimation=True):
+        """Show extra row if any row has 'change_folder' checked; hide otherwise."""
+        try:
+            idx_change = self.options_list.index("change_folder")
+        except ValueError:
+            idx_change = -1
+
+        show = (idx_change >= 0) and any(
+            (opt == idx_change) for opt in self.step_options if isinstance(opt, int)
+        )
+
+        if self.extra_opts_widget.isVisible() != show:
+            self.extra_opts_widget.setVisible(show)
+            extra_opts_widget = self.extra_opts_widget.height()
+            maxHeight = self.nstep * (self.button_size.height() + self.row_spacing) + int(show)*extra_opts_widget + self.min_height
+            if FlagAnimation:
+                self.window_resize(maxHeight)
+            self.max_height = maxHeight
+
+    def on_cleanup_toggled(self, checked: bool):
+        """Sync icon/size and label text when the extra toggle is changed."""
+        self.cleanup_button.setIcon(self.icons["auto_purge"][0 if checked else 1])
+        self.cleanup_button.setIconSize(self.icon_size if checked else self.icon_size_off)
+        self.cleanup_label.setText(
+            "Image-missing pairs will be removed automatically."
+            if checked else
+            "Image-missing pairs are kept; batch copy may raise warnings."
+        )
+        self.cleanup_label.setStyleSheet("color: none;" if checked else "color: rgb(125,125,125);")
+        self.cleanup_enabled = bool(checked)
+
+    def on_rescan_toggled(self, checked: bool):
+        """Sync icon/size and label text when the rescan toggle is changed."""
+        self.rescan_button.setIcon(self.icons["rescan"][0 if checked else 1])
+        self.rescan_button.setIconSize(self.icon_size if checked else self.icon_size_off)
+
+        self.rescan_label.setText(
+            "The input folder will be re-scanned; input image list may differ or trigger warnings."
+            if checked else
+            "No folder scan; images identified in the master process will be used."
+        )
+        self.rescan_label.setStyleSheet("color: none;" if checked else "color: rgb(125,125,125);")
+        self.rescan_enabled = bool(checked)
 
     def on_proceed(self):
         """Start or stop the progress loop depending on the button state."""
@@ -300,14 +431,17 @@ class FolderLoopDialog(QDialog):
         """Update the progress bar on each timer tick."""
         if self.iteration < self.progress_bar.maximum():
             timesleep(time_sleep_loop)
-            self.title_label.setText(self.paths[self.iteration])
-            self.func(self.iteration,self.step_options)
+            title_text=self.paths[self.iteration][:48]+f"{'...' if len(self.paths[self.iteration])>50 else ''}"
+            self.title_label.setText(title_text)
+            self.warnings[self.iteration]=self.func(self.iteration,self.step_options,self.cleanup_enabled,self.rescan_enabled)
             self.progress_bar.setValue(self.iteration)
             self.iteration += 1
             if self.loop_running: self.timer.start(0) 
         else:
             self.progress_bar.setValue(self.progress_bar.maximum())
             self.stop_progress()
+            self.hide()
+            self.show_batch_issues_dialog()
             if not self.animation: self.done(0)  # Closes the dialog when complete
 
     def cancel(self):
@@ -332,6 +466,62 @@ class FolderLoopDialog(QDialog):
 
     def window_resize(self, h):
         self.setFixedHeight(h)
+        
+    def show_batch_issues_dialog(self):
+        """Show a summary dialog listing all destination folders with warnings=True."""
+        issues=[(i,p) for i,p in enumerate(self.paths) if i<len(self.warnings) and self.warnings[i]]
+        if not issues: return
+
+        dlg=QDialog(self); dlg.setWindowTitle("Batch copy issues")
+        font=dlg.font()
+        font.setPixelSize(fontPixelSize)
+        dlg.setFont(font)
+        lay=QVBoxLayout(dlg)
+
+       # --- Warning header with icon ---
+        icon_width=96
+        warn_layout = QHBoxLayout()
+        warn_icon = QLabel()
+        warn_pix = QPixmap(icons_path + "warning.png").scaled(
+            icon_width, icon_width, Qt.KeepAspectRatio, Qt.SmoothTransformation
+        )
+        warn_icon.setPixmap(warn_pix)
+        warn_icon.setScaledContents(False)
+        #warn_icon.setAlignment(Qt.AlignTop)
+        warn_icon.setFixedWidth(icon_width)
+
+        head = QLabel(
+            f"{len(issues)} destination folder{'s' if len(issues)>1 else ''} could require attention: "
+            "potential warnings during batch copy or image-set mismatch!\n\n"
+            "Please note that the interface may not explicitly flag these cases. "
+            "Copy the paths below if you wish to inspect the corresponding processes.\n",
+            dlg
+        )
+        head.setWordWrap(True)
+
+        warn_layout.addWidget(warn_icon)
+        warn_layout.addWidget(head)
+        lay.addLayout(warn_layout)
+
+        tree=QTreeWidget(dlg); tree.setHeaderHidden(True)
+        tree.header().setStretchLastSection(True)
+        for _,p in issues:
+            item=QTreeWidgetItem([p])
+            item.setToolTip(0,p)
+            tree.addTopLevelItem(item)
+        lay.addWidget(tree)
+
+        # actions
+        btns=QHBoxLayout()
+        def _copy():
+            txt="\n".join(p for _,p in issues)
+            QApplication.clipboard().setText(txt)
+        copy_btn=QPushButton("Copy paths"); copy_btn.clicked.connect(_copy)
+        close_btn=QPushButton("Close"); close_btn.clicked.connect(dlg.accept)
+        btns.addWidget(copy_btn); btns.addStretch(1); btns.addWidget(close_btn)
+        lay.addLayout(btns)
+
+        dlg.resize(720, 360); dlg.exec()
 
 if __name__ == "__main__":
     import random