GridCal 5.1.42__tar.gz → 5.1.43__tar.gz

{GridCal-5.1.42 → GridCal-5.1.43}/GridCal/Gui/Diagrams/MapWidget/grid_map_widget.py

@@ -57,11 +57,11 @@ import GridCal.Gui.Visualization.visualization as viz
 import GridCalEngine.Devices.Diagrams.palettes as palettes
 from GridCal.Gui.Diagrams.graphics_manager import ALL_MAP_GRAPHICS
 from GridCal.Gui.Diagrams.MapWidget.Tiles.tiles import Tiles
-from GridCal.Gui.Diagrams.base_diagram_widget import BaseDiagramWidget
+from GridCal.Gui.Diagrams.base_diagram_widget import BaseDiagramWidget, qimage_to_cv
 from GridCal.Gui.messages import error_msg
 
 if TYPE_CHECKING:
-    from GridCal.Gui.Main.GridCalMain import MainGUI
+    from GridCal.Gui.Main.SubClasses.Model.diagrams import DiagramsMain
 
 MAP_BRANCH_GRAPHIC_TYPES = Union[
     MapAcLine, MapDcLine, MapHvdcLine, MapFluidPathLine
@@ -207,7 +207,7 @@ class GridMapWidget(BaseDiagramWidget):
     """
 
     def __init__(self,
-                 gui: MainGUI,
+                 gui: DiagramsMain,
                  tile_src: Tiles,
                  start_level: int,
                  longitude: float,
@@ -1147,25 +1147,14 @@ class GridMapWidget(BaseDiagramWidget):
 
                     graphic_object.set_colour(color=color, w=weight, style=style, tool_tip=tooltip)
 
-    def get_image(self, transparent: bool = False) -> Tuple[QImage, int, int]:
+    def get_image(self, transparent: bool = False) -> QImage:
         """
         get the current picture
         :return: QImage, width, height
         """
-        w = self.width()
-        h = self.height()
-
-        # image = QImage(w, h, QImage.Format_RGB32)
-        # image.fill(Qt.white)
-        #
-        # painter = QPainter(image)
-        # painter.setRenderHint(QPainter.Antialiasing)
-        # self.map.view.render(painter)  # self.view stores the grid widgets
-        # # self.render(painter)
-        # painter.end()
         image = self.map.grab().toImage()
 
-        return image, w, h
+        return image
 
     def take_picture(self, filename: str):
         """
@@ -1174,7 +1163,7 @@ class GridMapWidget(BaseDiagramWidget):
         name, extension = os.path.splitext(filename.lower())
 
         if extension == '.png':
-            image, _, _ = self.get_image()
+            image = self.get_image()
             image.save(filename)
 
         elif extension == '.svg':
@@ -1193,6 +1182,14 @@ class GridMapWidget(BaseDiagramWidget):
         else:
             raise Exception('Extension ' + str(extension) + ' not supported :(')
 
+    # def capture_video_frame(self):
+    #     """
+    #     Save video frame
+    #     """
+    #     image, w, h = self.get_image()
+    #     cv2_image = qimage_to_cv(image)
+    #     self._video.write(cv2_image)
+
     def new_substation_diagram(self, substation: Substation):
         """
 

{GridCal-5.1.42 → GridCal-5.1.43}/GridCal/Gui/Diagrams/SchematicWidget/schematic_widget.py

@@ -35,7 +35,6 @@ from PySide6.QtGui import (QIcon, QPixmap, QImage, QPainter, QStandardItemModel,
 from PySide6.QtWidgets import (QGraphicsView, QMessageBox, QGraphicsScene, QGraphicsSceneMouseEvent, QGraphicsItem)
 from PySide6.QtSvg import QSvgGenerator
 
-from GridCal.Gui.Diagrams.graphics_manager import ALL_GRAPHICS
 from GridCalEngine.Devices.types import ALL_DEV_TYPES, INJECTION_DEVICE_TYPES, FLUID_TYPES, BRANCH_TYPES
 from GridCalEngine.Devices.multi_circuit import MultiCircuit
 from GridCalEngine.Devices.Substation.bus import Bus
@@ -55,7 +54,7 @@ from GridCalEngine.Devices.Fluid import FluidNode, FluidPath
 from GridCalEngine.Devices.Diagrams.schematic_diagram import SchematicDiagram
 from GridCalEngine.Devices.Diagrams.graphic_location import GraphicLocation
 from GridCalEngine.Simulations import PowerFlowTimeSeriesResults
-from GridCalEngine.enumerations import DeviceType, SimulationTypes, ResultTypes
+from GridCalEngine.enumerations import DeviceType, ResultTypes
 from GridCalEngine.basic_structures import Vec, CxVec, IntVec, Logger
 
 from GridCal.Gui.Diagrams.SchematicWidget.terminal_item import BarTerminalItem, RoundTerminalItem
@@ -84,7 +83,7 @@ import GridCalEngine.Devices.Diagrams.palettes as palettes
 from GridCal.Gui.messages import info_msg, error_msg, warning_msg, yes_no_question
 
 if TYPE_CHECKING:
-    from GridCal.Gui.Main.GridCalMain import MainGUI
+    from GridCal.Gui.Main.SubClasses.Model.diagrams import DiagramsMain
 
 BRANCH_GRAPHICS = Union[
     LineGraphicItem,
@@ -218,7 +217,7 @@ class SchematicLibraryModel(QStandardItemModel):
         :param index: 
         :return: 
         """
-        return Qt.ItemIsEnabled | Qt.ItemIsSelectable | Qt.ItemFlag.ItemIsDragEnabled
+        return Qt.ItemFlag.ItemIsEnabled | Qt.ItemFlag.ItemIsSelectable | Qt.ItemFlag.ItemIsDragEnabled
 
 
 class SchematicScene(QGraphicsScene):
@@ -298,7 +297,7 @@ class CustomGraphicsView(QGraphicsView):
         """
 
         # By pressing ctrl while dragging, we can move the grid
-        if event.modifiers() & Qt.ControlModifier:
+        if event.modifiers() & Qt.KeyboardModifier.ControlModifier:
             self.drag_mode = QGraphicsView.DragMode.ScrollHandDrag
         else:
             self.drag_mode = QGraphicsView.DragMode.RubberBandDrag
@@ -340,7 +339,7 @@ class SchematicWidget(BaseDiagramWidget):
     """
 
     def __init__(self,
-                 gui: MainGUI,
+                 gui: DiagramsMain,
                  circuit: MultiCircuit,
                  diagram: Union[SchematicDiagram, None],
                  default_bus_voltage: float = 10.0,
@@ -441,7 +440,7 @@ class SchematicWidget(BaseDiagramWidget):
         if event.mimeData().hasFormat('component/name'):
             obj_type = event.mimeData().data('component/name')
 
-            point0 = self.editor_graphics_view.mapToScene(event.position().x(), event.position().y())
+            point0 = self.editor_graphics_view.mapToScene(int(event.position().x()), int(event.position().y()))
             x0 = point0.x()
             y0 = point0.y()
 
@@ -1945,7 +1944,7 @@ class SchematicWidget(BaseDiagramWidget):
                 bus.y = y[i]
             i += 1
 
-    def get_image(self, transparent: bool = False) -> Tuple[QImage, int, int]:
+    def get_image(self, transparent: bool = False) -> QImage:
         """
         get the current picture
         :param transparent: Set a transparent background
@@ -1967,7 +1966,7 @@ class SchematicWidget(BaseDiagramWidget):
         painter.end()
         # image = self.editor_graphics_view.grab().toImage()
 
-        return image, w, h
+        return image
 
     def take_picture(self, filename: str):
         """
@@ -1976,7 +1975,7 @@ class SchematicWidget(BaseDiagramWidget):
         name, extension = os.path.splitext(filename.lower())
 
         if extension == '.png':
-            image, _, _ = self.get_image(transparent=False)
+            image = self.get_image(transparent=False)
             image.save(filename)
 
         elif extension == '.svg':

{GridCal-5.1.42 → GridCal-5.1.43}/GridCal/Gui/Diagrams/base_diagram_widget.py

@@ -17,7 +17,6 @@
 from __future__ import annotations
 from typing import List, Dict, Union, Tuple, Callable, TYPE_CHECKING
 import numpy as np
-import pandas as pd
 import cv2
 from matplotlib import pyplot as plt
 
@@ -42,18 +41,18 @@ from GridCalEngine.basic_structures import Vec, CxVec, IntVec
 from GridCalEngine.Devices.Diagrams.schematic_diagram import SchematicDiagram
 from GridCalEngine.Devices.Diagrams.map_diagram import MapDiagram
 from GridCalEngine.Simulations.types import DRIVER_OBJECTS
-from GridCalEngine.basic_structures import Logger
+from GridCalEngine.basic_structures import Logger, Mat
 from GridCalEngine.enumerations import SimulationTypes, ResultTypes
+import GridCalEngine.Devices.Diagrams.palettes as palettes
 
 from GridCal.Gui.Diagrams.graphics_manager import GraphicsManager
-import GridCalEngine.Devices.Diagrams.palettes as palettes
 from GridCal.Gui.messages import yes_no_question, info_msg
 from GridCal.Gui.object_model import ObjectsModel
 
 if TYPE_CHECKING:
     from GridCal.Gui.Diagrams.MapWidget.grid_map_widget import MapLibraryModel, GridMapWidget
     from GridCal.Gui.Diagrams.SchematicWidget.schematic_widget import SchematicLibraryModel, SchematicWidget
-    from GridCal.Gui.Main.GridCalMain import MainGUI
+    from GridCal.Gui.Main.SubClasses.Model.diagrams import DiagramsMain
 
 
 def change_font_size(obj, font_size: int):
@@ -68,6 +67,84 @@ def change_font_size(obj, font_size: int):
     obj.setFont(font1)
 
 
+def qimage_tocv2_by_disk(qimage: QImage, logger: Logger, file_path):
+    """
+
+    :param qimage: Qimage
+    :param logger: Logger
+    :param file_path: temp file path
+    :return:
+    """
+    # Convert QImage to PNG format and save
+    if not qimage.save(file_path, "PNG"):
+        logger.add_error(msg=f"Error: Could not save QImage to {file_path}")
+        return None
+
+    # Use OpenCV to read the saved image
+    opencv_image = cv2.imread(file_path)
+    if opencv_image is None:
+        logger.add_error(msg=f"Error: Could not save QImage to {file_path}")
+        return None
+
+    return opencv_image
+
+
+def qimage_to_cv(qimage: QImage, logger: Logger, force_disk=False) -> np.ndarray:
+    """
+    Convert a image from Qt to an OpenCV image
+    :param qimage: Qimage
+    :param logger: Logger
+    :param force_disk: if true, the image is converted by saving to disk and loading again with opencv
+    :return: OpenCv matrix
+    """
+    width = qimage.width()
+    height = qimage.height()
+
+    if force_disk:
+        opencv_image = qimage_tocv2_by_disk(qimage, logger, file_path="__img__.png")
+
+        return opencv_image
+    else:
+        try:
+            # convert picture using the memory
+            # we need to remove the alpha channel, otherwise the video frame is not saved
+            cv_mat = np.array(qimage.constBits()).reshape(height, width, 4).astype(np.uint8)[:, :, :3]
+
+            return cv_mat
+
+        except ValueError as e:
+
+            logger.add_error(msg=f"Could not convert frame: {e}, failed over to second image conversion method.")
+
+            try:
+                # Convert the QImage to RGB format if it is not already in that format
+                qimage = qimage.convertToFormat(QImage.Format.Format_RGB888)
+
+                # Get the pointer to the data and stride (bytes per line)
+                ptr = qimage.bits()
+                # ptr.itemsize = qimage.sizeInBytes()  # Set the size of the memoryview
+                stride = qimage.bytesPerLine()  # Get the number of bytes per line (width * channels + padding)
+
+                # Create a numpy array with the correct shape based on the stride
+                arr = np.array(ptr).reshape((height, stride // 3, 3)).astype(np.uint8)  # Adjust for stride
+
+                # Crop the width to the actual image width (in case stride > width * channels)
+                arr = arr[:, :width, :]
+
+                # Convert RGB to BGR for OpenCV
+                cv_mat = cv2.cvtColor(arr, cv2.COLOR_RGB2BGR)
+
+                return cv_mat
+            except ValueError as e2:
+                logger.add_error(msg=f"Could not convert frame: {e2}, failed over to disk converison method")
+
+                # try the last method, saving to disk and reading again
+
+                opencv_image = qimage_tocv2_by_disk(qimage, logger, file_path="__img__.png")
+
+                return opencv_image
+
+
 class BaseDiagramWidget(QSplitter):
     """
     Common diagram widget to host common functions
@@ -75,7 +152,7 @@ class BaseDiagramWidget(QSplitter):
     """
 
     def __init__(self,
-                 gui: MainGUI,
+                 gui: DiagramsMain,
                  circuit: MultiCircuit,
                  diagram: Union[SchematicDiagram, MapDiagram],
                  library_model: Union[MapLibraryModel, SchematicLibraryModel],
@@ -508,7 +585,7 @@ class BaseDiagramWidget(QSplitter):
         """
         return 0
 
-    def get_image(self, transparent: bool = False) -> Tuple[QImage, int, int]:
+    def get_image(self, transparent: bool = False) -> QImage:
         """
         get the current picture
         :param transparent: Set a transparent background
@@ -523,41 +600,61 @@ class BaseDiagramWidget(QSplitter):
         """
         pass
 
-    def start_video_recording(self, fname: str, fps: int = 30) -> Tuple[int, int]:
+    def start_video_recording(self, fname: str, fps: int = 30, logger: Logger = Logger()) -> Tuple[int, int]:
         """
         Save video
         :param fname: file name
         :param fps: frames per second
+        :param logger: LOgger
         :returns width, height
         """
 
-        w = self.get_picture_width()
-        h = self.get_picture_height()
-
-        self._video = cv2.VideoWriter(filename=fname,
-                                      fourcc=cv2.VideoWriter_fourcc(*'mp4v'),
-                                      fps=fps,
-                                      frameSize=(w, h))
+        image = self.get_image()
+        w = image.width()
+        h = image.height()
+        cv2_image = qimage_to_cv(image, logger)
+        w2, h2, _ = cv2_image.shape
+
+        if fname.endswith('.mp4'):
+            self._video = cv2.VideoWriter(filename=fname,
+                                          fourcc=cv2.VideoWriter_fourcc(*'mp4v'),
+                                          fps=fps,
+                                          frameSize=(w, h))
+        elif fname.endswith('.avi'):
+            self._video = cv2.VideoWriter(filename=fname + '.avi',
+                                          fourcc=cv2.VideoWriter_fourcc(*'XVID'),
+                                          fps=fps,
+                                          frameSize=(w, h))
+        else:
+            raise Exception(f"File format not recognized {fname}")
 
         return w, h
 
-    def capture_video_frame(self):
+    def capture_video_frame(self, w: int, h: int, logger: Logger):
         """
         Save video frame
         """
+        image = self.get_image()
+        w2 = image.width()
+        h2 = image.height()
+
+        if w != w2:
+            logger.add_error(f"Width {w2} different from expected width {w}")
+
+        if h != h2:
+            logger.add_error(f"Height {h2} different from expected width {h}")
 
-        image, w, h = self.get_image()
+        cv2_image = qimage_to_cv(image, logger)
 
-        # convert picture using the memory
-        # we need to remove the alpha channel, otherwise the video frame is not saved
-        frame = np.array(image.constBits()).reshape(h, w, 4).astype(np.uint8)[:, :, :3]
-        self._video.write(frame)
+        if cv2_image is not None:
+            self._video.write(cv2_image)
 
     def end_video_recording(self):
         """
         Finalize video recording
         """
         self._video.release()
+        print("Video released")
 
     def update_label_drwaing_status(self, device: ALL_DEV_TYPES, draw_labels: bool) -> None:
         """

{GridCal-5.1.42 → GridCal-5.1.43}/GridCal/Gui/Main/SubClasses/Model/diagrams.py

@@ -14,6 +14,8 @@
 # You should have received a copy of the GNU Lesser General Public License
 # along with this program; if not, write to the Free Software Foundation,
 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+from __future__ import annotations
+
 import os
 from typing import List, Tuple, Union
 
@@ -26,8 +28,10 @@ from pandas.plotting import register_matplotlib_converters
 import GridCalEngine.Devices.Diagrams.palettes as palettes
 from GridCalEngine.IO.file_system import get_create_gridcal_folder
 from GridCal.Gui.general_dialogues import (CheckListDialogue, StartEndSelectionDialogue, InputSearchDialogue,
-                                           InputNumberDialogue)
+                                           InputNumberDialogue, LogsDialogue)
 from GridCalEngine.Devices.types import ALL_DEV_TYPES
+from GridCalEngine.Utils.progress_bar import print_progress_bar
+from GridCalEngine.basic_structures import Logger
 from GridCalEngine.enumerations import SimulationTypes
 from GridCalEngine.Devices.Diagrams.schematic_diagram import SchematicDiagram
 
@@ -52,6 +56,69 @@ ALL_EDITORS = Union[SchematicWidget, GridMapWidget]
 ALL_EDITORS_NONE = Union[None, SchematicWidget, GridMapWidget]
 
 
+class VideoExportWorker(QtCore.QThread):
+    """
+    VideoExportWorker
+    """
+    progress_signal = QtCore.Signal(float)
+    progress_text = QtCore.Signal(str)
+    done_signal = QtCore.Signal()
+
+    def __init__(self, filename, diagram: SchematicWidget | GridMapWidget,
+                 fps: int, start_idx: int, end_idx: int, current_study: str,
+                 grid_colour_function):
+        """
+
+        :param filename:
+        :param diagram:
+        :param fps:
+        :param start_idx:
+        :param end_idx:
+        :param current_study:
+        :param grid_colour_function:
+        """
+        QtCore.QThread.__init__(self)
+
+        self.filename = filename
+        self.diagram = diagram
+        self.fps = fps
+        self.start_idx = start_idx
+        self.end_idx = end_idx
+        self.current_study = current_study
+        self.grid_colour_function = grid_colour_function
+
+        self.logger = Logger()
+
+    def run(self):
+        """
+        Run function
+        :return:
+        """
+        # start recording...
+        w, h = self.diagram.start_video_recording(fname=self.filename, fps=self.fps, logger=self.logger)
+
+        # paint and capture
+        for t_idx in range(self.start_idx, self.end_idx):
+            self.grid_colour_function(diagram=self.diagram,
+                                      current_study=self.current_study,
+                                      t_idx=t_idx,
+                                      allow_popups=False)
+
+            self.diagram.capture_video_frame(w=w, h=h, logger=self.logger)
+
+            self.progress_text.emit(f"Saving frame {t_idx} / {self.end_idx}")
+            self.progress_signal.emit(t_idx / self.end_idx)
+
+            print_progress_bar(t_idx + 1, self.end_idx)
+
+        # finalize
+        self.diagram.end_video_recording()
+
+        self.logger.add_info(f"Video saved to {self.filename}")
+
+        self.done_signal.emit()
+
+
 class DiagramsMain(CompiledArraysMain):
     """
     Diagrams Main
@@ -156,6 +223,9 @@ class DiagramsMain(CompiledArraysMain):
         # configure matplotlib for pandas time series
         register_matplotlib_converters()
 
+        # task watcher for video export
+        self.video_thread: VideoExportWorker | None = None
+
         # --------------------------------------------------------------------------------------------------------------
         self.ui.actionTakePicture.triggered.connect(self.take_picture)
         self.ui.actionRecord_video.triggered.connect(self.record_video)
@@ -1167,6 +1237,7 @@ class DiagramsMain(CompiledArraysMain):
 
                 # create the map widget
                 map_widget = GridMapWidget(
+                    gui=self,
                     tile_src=tile_source,
                     start_level=diagram.start_level,
                     longitude=diagram.longitude,
@@ -1454,7 +1525,7 @@ class DiagramsMain(CompiledArraysMain):
                 if isinstance(diagram, (SchematicWidget, GridMapWidget)):
 
                     # declare the allowed file types
-                    files_types = "MP4 (*.mp4);;"
+                    files_types = "MP4 (*.mp4);;AVI (*.avi);;"
 
                     f_name = str(os.path.join(self.project_directory, self.ui.grid_name_line_edit.text()))
 
@@ -1463,38 +1534,71 @@ class DiagramsMain(CompiledArraysMain):
                                                                                     f_name, files_types)
 
                     if filename != "":
-                        if not filename.endswith('.mp4'):
+                        if type_selected == "MP4 (*.mp4)" and not filename.endswith('.mp4'):
                             filename += ".mp4"
 
-                        fps = self.ui.fps_spinBox.value()
-                        start_idx = self.get_simulation_start()
-                        end_idx = self.get_simulation_end()
-                        current_study = self.ui.available_results_to_color_comboBox.currentText()
-
-                        # start recording...
-                        diagram.start_video_recording(fname=filename, fps=fps)
-
-                        # paint and capture
-                        for t_idx in range(start_idx, end_idx):
-                            self.grid_colour_function(diagram=diagram,
-                                                      current_study=current_study,
-                                                      t_idx=t_idx,
-                                                      allow_popups=False)
-
-                            diagram.capture_video_frame()
-
-                            print(f"Saving frame {t_idx} / {end_idx}")
-
-                        # finalize
-                        diagram.end_video_recording()
-                        print(f"Recording saved to {filename}")
-
+                        if type_selected == "AVI (*.avi)" and not filename.endswith('.avi'):
+                            filename += ".avi"
+
+                        # self.thread_pool.start(lambda: self.record_video_now(filename, diagram))
+                        self.video_thread = VideoExportWorker(
+                            filename=filename,
+                            diagram=diagram,
+                            fps=self.ui.fps_spinBox.value(),
+                            start_idx=self.get_simulation_start(),
+                            end_idx=self.get_simulation_end(),
+                            current_study=self.ui.available_results_to_color_comboBox.currentText(),
+                            grid_colour_function=self.grid_colour_function
+                        )
+                        self.video_thread.progress_signal.connect(self.ui.progressBar.setValue)
+                        self.video_thread.progress_text.connect(self.ui.progress_label.setText)
+                        self.video_thread.done_signal.connect(self.post_video_export)
+                        self.video_thread.run()  # we cannot run another thread accesing the main thread objects...
             else:
                 info_msg("There is not diagram selected", "Record video")
 
         else:
             info_msg("There are no time series", "Record video")
 
+    def post_video_export(self):
+        """
+
+        :return:
+        """
+        if self.video_thread.logger.has_logs():
+            dlg = LogsDialogue("Video export", self.video_thread.logger, True)
+            dlg.exec_()
+
+    # def record_video_now(self, filename, diagram: SchematicWidget | GridMapWidget):
+    #     """
+    #
+    #     :param filename:
+    #     :param diagram:
+    #     :return:
+    #     """
+    #     fps = self.ui.fps_spinBox.value()
+    #     start_idx = self.get_simulation_start()
+    #     end_idx = self.get_simulation_end()
+    #     current_study = self.ui.available_results_to_color_comboBox.currentText()
+    #
+    #     # start recording...
+    #     diagram.start_video_recording(fname=filename, fps=fps)
+    #
+    #     # paint and capture
+    #     for t_idx in range(start_idx, end_idx):
+    #         self.grid_colour_function(diagram=diagram,
+    #                                   current_study=current_study,
+    #                                   t_idx=t_idx,
+    #                                   allow_popups=False)
+    #
+    #         diagram.capture_video_frame()
+    #
+    #         print(f"Saving frame {t_idx} / {end_idx}")
+    #
+    #     # finalize
+    #     diagram.end_video_recording()
+    #     print(f"Recording saved to {filename}")
+
     def set_xy_from_lat_lon(self):
         """
         Get the x, y coordinates of the buses from their latitude and longitude

{GridCal-5.1.42 → GridCal-5.1.43}/GridCal/Gui/Main/SubClasses/io.py

@@ -936,9 +936,13 @@ class IoMain(ConfigurationMain):
                     data_dict = self.last_file_driver.load_session_objects(session_name=session_name,
                                                                            study_name=study_name)
 
-                    self.session.register_driver_from_disk_data(grid=self.circuit,
-                                                                study_name=study_name,
-                                                                data_dict=data_dict)
+                    logger = self.session.register_driver_from_disk_data(grid=self.circuit,
+                                                                         study_name=study_name,
+                                                                         data_dict=data_dict)
+
+                    if logger.has_logs():
+                        dlg = LogsDialogue(name="Results parsing", logger=logger, expand_all=True)
+                        dlg.exec()
 
                     self.update_available_results()
                 else:

{GridCal-5.1.42 → GridCal-5.1.43}/GridCal/Gui/profiles_model.py

@@ -263,14 +263,15 @@ class ProfilesModel(WrappableTableModel):
             return None
 
         if role == QtCore.Qt.ItemDataRole.DisplayRole:
-            if len(self.elements):
-                if orientation == QtCore.Qt.Orientation.Horizontal:
+
+            if orientation == QtCore.Qt.Orientation.Horizontal:
+                if section < len(self.elements):
                     return str(self.elements[section].name)
-                elif orientation == QtCore.Qt.Orientation.Vertical:
-                    if self.time_array is None:
-                        return str(section)
-                    else:
-                        return pd.to_datetime(self.time_array[section]).strftime('%d-%m-%Y %H:%M:%S')
+            elif orientation == QtCore.Qt.Orientation.Vertical:
+                if self.time_array is None:
+                    return str(section)
+                else:
+                    return pd.to_datetime(self.time_array[section]).strftime('%d-%m-%Y %H:%M:%S')
 
         return None
 

{GridCal-5.1.42 → GridCal-5.1.43}/GridCal/Gui/table_view_header_wrap.py

@@ -51,7 +51,9 @@ class HeaderViewWithWordWrap(QtWidgets.QHeaderView):
         """
         mdl: WrappableTableModel = self.model()
         if mdl:
-            headerText = mdl.headerData(logicalIndex, self.orientation(), QtCore.Qt.ItemDataRole.DisplayRole)
+            headerText = mdl.headerData(section=logicalIndex,
+                                        orientation=self.orientation(),
+                                        role=QtCore.Qt.ItemDataRole.DisplayRole)
             option = QtWidgets.QStyleOptionHeader()
             self.initStyleOption(option)
             option.section = logicalIndex