wolfhece 2.2.28__py3-none-any.whl → 2.2.29__py3-none-any.whl

wolfhece/lb7208_ntv2/be_ign_README.txt

@@ -0,0 +1,36 @@
+# be_ign_README.txt
+
+The files in this section result from the conversion of datasets originating
+from [IGN Belgium](http://www.ngi.be)
+
+## Included grids
+
+### Belgium: BD72 -> ETRS89
+
+Grid transformation from Belgium Datum 72 to ETRS89 in Belgium.
+
+*Source*: [IGN](http://www.ngi.be/Common/Lambert2008/NTv2.zip)
+*Format*: GeoTIFF converted from NTv2
+*License*: [Creative Commons Attribution 4.0](https://creativecommons.org/licenses/by/4.0/)
+*Credit*: (c)2014-2016 Grid created by Nicolas SIMON.
+
+It provides an accuracy better than 5mm in 99.6% of validation points and a
+worst case of 1.3 cm outside the border.
+Recommended to transform from Belgian Lambert 72 (EPSG:31370) to Belgian Lambert 2008 (EPSG:3812)
+Documentation in French: (http://www.ngi.be/FR/FR2-1-7.shtm)
+Documentation in Dutch:  (http://www.ngi.be/NL/NL2-1-7.shtm)
+
+* be_ign_bd72lb72_etrs89lb08.tif
+
+### Belgium vertical grid:
+
+*Source*: [IGN](https://www.ngi.be/website/wp-content/uploads/2020/07/hBG18_fr.zip)
+*Format*: GeoTIFF converted from 'XYZ ASCII Grid'
+*License*: [Creative Commons Attribution 4.0](https://creativecommons.org/licenses/by/4.0/)
+*Credit*: C. Slobbe, R. Klees, H.H. Farahani, L. Huisman, B. Alberts, P. Voet, F. De Doncker (2018). The Belgian hybrid quasi-geoid: hBG18. V. 1.0. GFZ Data Services. http://doi.org/10.5880/isg.2018.003  
+*Horizontal CRS*: EPSG:4937 (ETRS89)
+
+Vertical transformation for Geoid model hGB18. Used to make the transitions 
+from heights in vertical CRS (EPSG:5710 - Ostend height) to heights above the ellipsoid in ETRS89 (EPSG:4937).
+
+* be_ign_hBG18.tif

wolfhece/mesh2d/gpu_2d.py

@@ -88,8 +88,17 @@ class Sim_2D_GPU():
         self.magnetic_grid:header_wolf = None
 
         if (self.dir /'parameters.json').exists():
-            self._sim = SimpleSimulation.load(self.dir)
-            self.infiltration = infiltration_GPU(self)
+            try:
+                self._sim = SimpleSimulation.load(self.dir)
+            except Exception as e:
+                logging.error(_("Error loading simulation from directory {dir}: {error}").format(dir=self.dir, error=str(e)))
+                logging.error(_("Please check your files and try again."))
+                return
+
+            try:
+                self.infiltration = infiltration_GPU(self)
+            except Exception as e:
+                logging.error(_("Error initializing infiltration GPU: {error}").format(error=str(e)))
 
         # Fine arrays with type
         self.files_array={'Characteristics':[

wolfhece/report/compare_arrays.py

@@ -4,13 +4,17 @@ import numpy.ma as ma
 from pathlib import Path
 import matplotlib.pyplot as plt
 from enum import Enum
-from scipy.ndimage import label, sum_labels
+from scipy.ndimage import label, sum_labels, find_objects
 import pymupdf as pdf
+import wx
+from tqdm import tqdm
+from matplotlib import use, get_backend
 
 from .common import A4_rect, rect_cm, list_to_html, list_to_html_aligned, get_rect_from_text
 from .common import inches2cm, pts2cm, cm2pts, cm2inches, DefaultLayoutA4, NamedTemporaryFile, pt2inches, TemporaryDirectory
 from ..wolf_array import WolfArray, header_wolf, vector, zone, Zones, wolfvertex as wv, wolfpalette
 from ..PyTranslate import _
+from .pdf import PDFViewer
 
 class ArrayDifferenceLayout(DefaultLayoutA4):
     """
@@ -98,8 +102,16 @@ class ArrayDifference():
 
         self._background = 'IGN'
 
+        self._contour = None
+        self._external_border = None
+
     @property
     def contour(self) -> vector:
+        """ Get the contour of the difference part. """
+
+        if self._contour is not None and isinstance(self._contour, vector):
+            return self._contour
+
         ret = self.reference.suxsuy_contour(abs=True)
         ret = ret[2]
 
@@ -111,8 +123,11 @@ class ArrayDifference():
     @property
     def external_border(self) -> vector:
         """
-        Get the bounds of the reference array.
+        Get the bounds of the difference part.
         """
+        if self._external_border is not None and isinstance(self._external_border, vector):
+            return self._external_border
+
         ret = vector(name=_("External border"))
         (xmin, xmax), (ymin, ymax) = self.reference.get_bounds()
         ret.add_vertex(wv(xmin, ymin))
@@ -194,6 +209,13 @@ class ArrayDifference():
                                         Walonmap= True,
                                         cat = 'IMAGERIE/ORTHO_2022_ETE',
                                         )
+        else:
+            self.reference.plot_matplotlib(figax=figax, figsize = self.default_size_arrays,
+                                        first_mask_data=False, with_legend=False,
+                                        update_palette= False,
+                                        Walonmap= False,
+                                        )
+
 
         self.reference.array.mask[:,:] = old_mask
 
@@ -225,11 +247,23 @@ class ArrayDifference():
         new = WolfArray(srcheader=h)
         new.array.mask[:,:] = True
 
-        new.plot_matplotlib(figax=figax, figsize = self.default_size_arrays,
-                                       first_mask_data=False, with_legend=False,
-                                       update_palette= False,
-                                       Walonmap= True,
-                                       cat = 'IMAGERIE/ORTHO_2022_ETE')
+        if self._background.upper() == 'IGN' or self._background.upper() == 'NGI':
+            new.plot_matplotlib(figax=figax, figsize = self.default_size_arrays,
+                                        first_mask_data=False, with_legend=False,
+                                        update_palette= False,
+                                        IGN= True,
+                                        cat = 'orthoimage_coverage')
+        elif self._background.upper() == 'WALONMAP':
+            new.plot_matplotlib(figax=figax, figsize = self.default_size_arrays,
+                                        first_mask_data=False, with_legend=False,
+                                        update_palette= False,
+                                        Walonmap= True,
+                                        cat = 'IMAGERIE/ORTHO_2022_ETE')
+        else:
+            new.plot_matplotlib(figax=figax, figsize = self.default_size_arrays,
+                                        first_mask_data=False, with_legend=False,
+                                        update_palette= False,
+                                        Walonmap= False)
 
         self.external_border.plot_matplotlib(ax=ax)
 
@@ -295,7 +329,8 @@ class ArrayDifference():
 
         fig, ax = figax
 
-        ax.hist(self.reference.array.compressed(), density=density, alpha = alpha, **kwargs)
+        data = self.reference.array.compressed()
+        ax.hist(data, bins = min(100, int(len(data)/4)), density=density, alpha = alpha, **kwargs)
         # ax.set_xlabel("Value")
         # ax.set_ylabel("Frequency")
         return fig, ax
@@ -309,7 +344,8 @@ class ArrayDifference():
 
         fig, ax = figax
 
-        ax.hist(self.to_compare.array.compressed(), density=density, alpha = alpha, **kwargs)
+        data = self.to_compare.array.compressed()
+        ax.hist(data, bins= min(100, int(len(data)/4)), density=density, alpha = alpha, **kwargs)
         # ax.set_xlabel("Value")
         # ax.set_ylabel("Frequency")
         return fig, ax
@@ -349,7 +385,7 @@ class ArrayDifference():
         fig, ax = figax
 
         difference_data = self.difference.array.compressed()
-        ax.hist(difference_data, density=density, alpha=alpha, **kwargs)
+        ax.hist(difference_data, bins= min(100, int(len(difference_data)/4)), density=density, alpha=alpha, **kwargs)
 
         # ax.set_xlabel("Value")
         # ax.set_ylabel("Frequency")
@@ -396,7 +432,6 @@ class ArrayDifference():
                 if 'Histogram' in key:
                     fig.tight_layout()
 
-
                 # convert canvas to PNG and insert it into the PDF
                 temp_file = NamedTemporaryFile(delete=False, suffix='.png')
                 fig.savefig(temp_file, format='png', bbox_inches='tight', dpi=self._dpi)
@@ -419,6 +454,7 @@ class ArrayDifference():
     def create_report(self, output_file: str | Path = None) -> Path:
         """ Create a page report for the array difference. """
 
+        from time import sleep
         if output_file is None:
             output_file = Path(f"array_difference_{self.index}.pdf")
 
@@ -429,6 +465,7 @@ class ArrayDifference():
         layout.create_report()
         self._complete_report(layout)
         layout.save_report(output_file)
+        sleep(0.2)  # Ensure the file is saved before returning
 
         return output_file
 
@@ -459,6 +496,10 @@ class CompareArrays:
 
         self.difference_parts:dict[int, ArrayDifference] = {}
 
+        self._pdf_path = None
+
+        self._background = 'IGN'
+
     @property
     def difference(self) -> WolfArray:
 
@@ -467,6 +508,24 @@ class CompareArrays:
 
         return self.array_to_compare - self.array_reference
 
+    def get_zones(self):
+        """
+        Get a Zones object containing the differences.
+        """
+
+        ret_zones = Zones()
+        exterior = zone(name=_("External border"))
+        contours = zone(name=_("Contours"))
+
+        ret_zones.add_zone(exterior, forceparent=True)
+        ret_zones.add_zone(contours, forceparent=True)
+
+        for diff in self.difference_parts.values():
+            exterior.add_vector(diff.external_border, forceparent=True)
+            contours.add_vector(diff.contour, forceparent=True)
+
+        return ret_zones
+
     def plot_position(self, figax:tuple[plt.Figure, plt.Axes]=None) -> tuple[plt.Figure, plt.Axes]:
         """
         Plot the reference array with a background.
@@ -487,14 +546,27 @@ class CompareArrays:
         new = WolfArray(srcheader=h)
         new.array.mask[:,:] = True
 
+        if self._background.upper() == 'IGN' or self._background.upper() == 'NGI':
 
-        new.plot_matplotlib(figax=figax, figsize = self.default_size_arrays,
-                                    first_mask_data=False, with_legend=False,
-                                    update_palette= False,
-                                    IGN= True,
-                                    cat = 'orthoimage_coverage',
-                                    )
-
+            new.plot_matplotlib(figax=figax, figsize = self.default_size_arrays,
+                                        first_mask_data=False, with_legend=False,
+                                        update_palette= False,
+                                        IGN= True,
+                                        cat = 'orthoimage_coverage',
+                                        )
+        elif self._background.upper() == 'WALONMAP':
+            new.plot_matplotlib(figax=figax, figsize = self.default_size_arrays,
+                                        first_mask_data=False, with_legend=False,
+                                        update_palette= False,
+                                        Walonmap= True,
+                                        cat = 'IMAGERIE/ORTHO_2022_ETE',
+                                        )
+        else:
+            new.plot_matplotlib(figax=figax, figsize = self.default_size_arrays,
+                                        first_mask_data=False, with_legend=False,
+                                        update_palette= False,
+                                        Walonmap= False,
+                                        )
         return fig, ax
 
     def plot_cartoweb(self, figax:tuple[plt.Figure, plt.Axes]=None) -> tuple[plt.Figure, plt.Axes]:
@@ -517,14 +589,20 @@ class CompareArrays:
         new = WolfArray(srcheader=h)
         new.array.mask[:,:] = True
 
-
-        new.plot_matplotlib(figax=figax, figsize = self.default_size_arrays,
-                                    first_mask_data=False, with_legend=False,
-                                    update_palette= False,
-                                    Cartoweb= True,
-                                    cat = 'overlay',
-                                    )
-
+        if self._background.upper() == 'IGN' or self._background.upper() == 'NGI':
+            new.plot_matplotlib(figax=figax, figsize = self.default_size_arrays,
+                                        first_mask_data=False, with_legend=False,
+                                        update_palette= False,
+                                        Cartoweb= True,
+                                        cat = 'overlay',
+                                        )
+        else:
+            new.plot_matplotlib(figax=figax, figsize = self.default_size_arrays,
+                                        first_mask_data=False, with_legend=False,
+                                        update_palette= False,
+                                        Cartoweb= False,
+                                        cat = 'overlay',
+                                        )
         return fig, ax
 
     def plot_topo_grey(self, figax:tuple[plt.Figure, plt.Axes]=None) -> tuple[plt.Figure, plt.Axes]:
@@ -547,14 +625,20 @@ class CompareArrays:
         new = WolfArray(srcheader=h)
         new.array.mask[:,:] = True
 
-
-        new.plot_matplotlib(figax=figax, figsize = self.default_size_arrays,
-                                    first_mask_data=False, with_legend=False,
-                                    update_palette= False,
-                                    Cartoweb= True,
-                                    cat = 'topo_grey',
-                                    )
-
+        if self._background.upper() == 'IGN' or self._background.upper() == 'NGI':
+            new.plot_matplotlib(figax=figax, figsize = self.default_size_arrays,
+                                        first_mask_data=False, with_legend=False,
+                                        update_palette= False,
+                                        Cartoweb= True,
+                                        cat = 'topo_grey',
+                                        )
+        else:
+            new.plot_matplotlib(figax=figax, figsize = self.default_size_arrays,
+                                        first_mask_data=False, with_legend=False,
+                                        update_palette= False,
+                                        Cartoweb= False,
+                                        cat = 'topo_grey',
+                                        )
         return fig, ax
 
     def plot_reference(self, figax:tuple[plt.Figure, plt.Axes]=None) -> tuple[plt.Figure, plt.Axes]:
@@ -568,7 +652,7 @@ class CompareArrays:
 
         self.array_reference.plot_matplotlib(figax=figax, figsize = self.default_size_arrays, first_mask_data=False, with_legend=True, update_palette= False)
 
-        for diff in self.difference_parts.values():
+        for diff in tqdm(self.difference_parts.values(), desc="Plotting external borders"):
             diff.external_border.plot_matplotlib(ax=ax)
 
         return fig, ax
@@ -584,7 +668,7 @@ class CompareArrays:
 
         self.array_to_compare.plot_matplotlib(figax=figax, figsize = self.default_size_arrays, first_mask_data=False, with_legend=True, update_palette= False)
 
-        for diff in self.difference_parts.values():
+        for diff in tqdm(self.difference_parts.values(), desc="Plotting contours"):
             diff.contour.plot_matplotlib(ax=ax)
 
         return fig, ax
@@ -606,11 +690,22 @@ class CompareArrays:
         diff.plot_matplotlib(figax=figax, figsize = self.default_size_arrays, first_mask_data=False, with_legend=True, update_palette= False)
         return fig, ax
 
-    def localize_differences(self, threshold: float = 0.0) -> np.ndarray:
+    def localize_differences(self, threshold: float = 0.0,
+                             ignored_patche_area:float = 1.) -> np.ndarray:
+        """ Localize the differences between the two arrays and label them.
+
+        :param threshold: The threshold value to consider a difference significant.
+        :param ignored_patche_area: The area of patches to ignore (in m²).
+        """
+
+        assert threshold >= 0, "Threshold must be a non-negative value."
 
         labeled_array = self.difference.array.data.copy()
         labeled_array[self.array_reference.array.mask] = 0
 
+        # apply threshold
+        labeled_array[np.abs(labeled_array) < threshold] = 0
+
         self.labeled_array, self.num_features = label(labeled_array)
 
         self.nb_cells = []
@@ -620,13 +715,29 @@ class CompareArrays:
 
         self.nb_cells.sort(key=lambda x: x[0], reverse=True)
 
+        # find features where nb_cells is lower than ignored_patche_area / (dx * dy)
+        ignored_patche_cells = int(ignored_patche_area / (self.array_reference.dx * self.array_reference.dy))
+        self.last_features = self.num_features
+        for idx, (nb_cell, idx_feature) in enumerate(self.nb_cells):
+            if nb_cell <= ignored_patche_cells:
+                self.last_features = idx
+                break
+
+        all_slices = find_objects(self.labeled_array)
+
+        logging.info(f"Total number of features found: {self.last_features}")
+
         # find xmin, ymin, xmax, ymax for each feature
-        for idx_feature in range(1, self.num_features + 1):
-            mask = self.labeled_array == idx_feature
-            i, j = np.where(mask)
+        for idx_feature, slices in tqdm(zip(range(1, self.num_features+1), all_slices), desc="Processing features", unit="feature"):
+            mask = self.labeled_array[slices] == idx_feature
+            nb_in_patch = np.count_nonzero(mask)
+
+            if nb_in_patch <= ignored_patche_cells:
+                logging.debug(f"Feature {idx_feature} has too few cells ({np.count_nonzero(mask)}) and will be ignored.")
+                continue
 
-            imin, imax = i.min(), i.max()
-            jmin, jmax = j.min(), j.max()
+            imin, imax = slices[0].start, slices[0].stop - 1
+            jmin, jmax = slices[1].start, slices[1].stop - 1
 
             imin = int(max(imin - 1, 0))
             imax = int(min(imax + 1, self.labeled_array.shape[0] - 1))
@@ -635,17 +746,25 @@ class CompareArrays:
 
             ref_crop = self.array_reference.crop(imin, jmin, imax-imin+1, jmax-jmin+1)
             to_compare_crop = self.array_to_compare.crop(imin, jmin, imax-imin+1, jmax-jmin+1)
+            label_crop = self.labeled_array[imin:imax+1, jmin:jmax+1].copy()
 
-            ref_crop.array.mask[:,:] = ~mask[imin:imax+1, jmin:jmax+1]
-            ref_crop.set_nullvalue_in_mask()
 
-            to_compare_crop.array.mask[:,:] = ~mask[imin:imax+1, jmin:jmax+1]
+            to_compare_crop.array.mask[:,:] = ref_crop.array.mask[:,:] = self.labeled_array[imin:imax+1, jmin:jmax+1] != idx_feature
+
+            ref_crop.set_nullvalue_in_mask()
             to_compare_crop.set_nullvalue_in_mask()
+            label_crop[label_crop != idx_feature] = 0
 
-            ref_crop.count()
-            to_compare_crop.nbnotnull = ref_crop.nbnotnull
+            ref_crop.nbnotnull = nb_in_patch
+            to_compare_crop.nbnotnull = nb_in_patch
 
-            self.difference_parts[idx_feature] = ArrayDifference(ref_crop, to_compare_crop, idx_feature, self.labeled_array[imin:imax+1, jmin:jmax+1].copy())
+            self.difference_parts[idx_feature] = ArrayDifference(ref_crop, to_compare_crop, idx_feature, label_crop)
+
+        assert self.last_features == len(self.difference_parts), \
+            f"Last feature index {self.last_features} does not match the number of differences found"
+
+        self.num_features = self.last_features
+        logging.info(f"Number of features after filtering: {self.num_features}")
 
         return self.labeled_array
 
@@ -721,9 +840,10 @@ class CompareArrays:
         surf = self.array_reference.dx * self.array_reference.dy
 
         # Extract the number of cells for each feature
-        nb_cells = [item[0] * surf for item in self.nb_cells]
+        nb_cells = [item[0] * surf for item in self.nb_cells[:self.last_features]]
 
-        ax.hist(nb_cells, density=density, alpha=alpha, **kwargs)
+        if len(nb_cells) > 0:
+            ax.hist(nb_cells, bins= min(100, int(len(nb_cells)/4)), density=density, alpha=alpha, **kwargs)
 
         ax.set_title(_("Histogram of surface in each feature [m²]"))
 
@@ -748,13 +868,22 @@ class CompareArrays:
 
         fig, ax = figax
 
-        # Calculate the difference between the two arrays
-        diff = self.difference
+        # # Calculate the difference between the two arrays
+        # diff = self.difference
 
-        volumes = np.bincount(self.labeled_array.ravel(), weights=diff.array.ravel()) * self.array_reference.dx * self.array_reference.dy
+        volumes = []
+        for idx in tqdm(self.nb_cells[:self.last_features], desc="Calculating volumes"):
+            # Get the feature index
+            feature_index = idx[1]
+            part = self.difference_parts[feature_index]
+            # Create a mask for the feature
+            mask = part.label == feature_index
+            # Calculate the volume for this feature
+            volumes.append(np.ma.sum(part.difference.array[mask]) * self.array_reference.dx * self.array_reference.dy)
 
         # Create a histogram of the differences
-        ax.hist(volumes, density=density, alpha=alpha, **kwargs)
+        if len(volumes) > 0:
+            ax.hist(volumes, bins= min(100, int(len(volumes)/4)), density=density, alpha=alpha, **kwargs)
 
         ax.set_title(_("Histogram of net volumes [m³]"))
 
@@ -809,7 +938,9 @@ class CompareArrays:
 
 
 
-    def create_report(self, output_file: str | Path = None, append_all_differences: bool = True) -> None:
+    def create_report(self, output_file: str | Path = None,
+                      append_all_differences: bool = True,
+                      nb_max_differences:int = -1) -> None:
         """ Create a page report for the array comparison. """
 
         if output_file is None:
@@ -822,6 +953,14 @@ class CompareArrays:
         layout.create_report()
         self._complete_report(layout)
 
+        if nb_max_differences < 0:
+            nb_max_differences = len(self.difference_parts)
+        elif nb_max_differences > len(self.difference_parts):
+            logging.warning(f"Requested {nb_max_differences} differences, but only {len(self.difference_parts)} are available. Using all available differences.")
+        elif nb_max_differences < len(self.difference_parts):
+            logging.info(f"Limiting to {nb_max_differences} differences.")
+
+        features_to_treat = [feature[1] for feature in self.nb_cells[:nb_max_differences]]
 
         with TemporaryDirectory() as temp_dir:
 
@@ -833,12 +972,83 @@ class CompareArrays:
 
             if append_all_differences:
                 # Add each difference report to the main layout
-                all_pdfs.extend([diff.create_report(Path(temp_dir) / f"array_difference_{idx}.pdf") for idx, diff in self.difference_parts.items()])
+                all_pdfs.extend([self.difference_parts[idx].create_report(Path(temp_dir) / f"array_difference_{idx}.pdf") for idx in tqdm(features_to_treat, desc="Creating individual difference reports")])
 
-            for pdf_file in all_pdfs:
+            for pdf_file in tqdm(all_pdfs, desc="Compiling PDFs"):
                 layout._doc.insert_file(pdf_file)
 
         # create a TOC
         layout._doc.set_toc(layout._doc.get_toc())
 
-        layout.save_report(output_file)
+        layout.save_report(output_file)
+        self._pdf_path = output_file
+
+    @property
+    def pdf_path(self) -> Path:
+        """ Return the path to the generated PDF report. """
+        if hasattr(self, '_pdf_path'):
+            return self._pdf_path
+        else:
+            raise AttributeError("PDF path not set. Please create the report first.")
+
+class CompareArrays_wx(PDFViewer):
+
+    def __init__(self, reference: WolfArray | str | Path,
+                 to_compare: WolfArray | str | Path,
+                 ignored_patche_area:float = 2.0,
+                 nb_max_patches:int = 10,
+                 threshold: float = 0.01,
+                 dpi=200, **kwargs):
+        """ Initialize the Simple Simulation GPU Report Viewer for comparison """
+
+        super(CompareArrays_wx, self).__init__(None, **kwargs)
+
+        use('agg')
+
+        if isinstance(reference, WolfArray) and isinstance(to_compare, WolfArray):
+            if np.any(reference.array.mask != to_compare.array.mask):
+                logging.warning("The masks of the two arrays are not identical. This may lead to unexpected results.")
+                dlg = wx.MessageDialog(self,
+                                       _("The masks of the two arrays are not identical.\nThis may lead to unexpected results.\n\nWe will use the reference mask for the comparison."),
+                                       _("Warning"),
+                                       wx.OK | wx.ICON_WARNING)
+                dlg.ShowModal()
+                dlg.Destroy()
+                to_compare = WolfArray(mold=to_compare)
+                to_compare.array.mask[:,:] = reference.array.mask[:,:]
+
+        self._report = CompareArrays(reference, to_compare)
+
+        self._report._dpi = dpi
+        self._report.localize_differences(threshold=threshold,
+                                          ignored_patche_area=ignored_patche_area)
+        self._report.create_report(nb_max_differences=nb_max_patches)
+
+        # Load the PDF into the viewer
+        if self._report.pdf_path is None:
+            logging.error("No report created. Cannot load PDF.")
+            return
+
+        self.load_pdf(self._report.pdf_path)
+        self.viewer.SetZoom(-1)  # Fit to width
+
+        # Set the title of the frame
+        self.SetTitle("Simple Simulation GPU Comparison Report")
+
+        self.Bind(wx.EVT_CLOSE, self.on_close)
+
+        use('wxagg')
+
+    def on_close(self, event):
+        """ Handle the close event to clean up resources """
+        self.viewer.pdfdoc.pdfdoc.close()
+        self.Destroy()
+
+    def get_zones(self) -> Zones:
+        """
+        Get the zones from the report.
+        """
+        ret = self._report.get_zones()
+        ret.prep_listogl()
+
+        return ret