fixed jammer to work with variable input and output sizes including compatibility validation

Author: matthaeusheer

planvec/gui/planvec_gui.py

@@ -13,14 +13,16 @@
 from planvec.gui.team_dir_dialog import TeamDirDialog
 from planvec.gui.ui_generated.planvec_ui import Ui_planvec
 from planvec.gui.video_stream import FrameBuffer, VideoStreamThread
-from planvec.pdf_jammer import PdfJammer
+from planvec.pdf_jammer import PdfJammer, PdfAndPlateSizeIncompatibleException
 from planvec.utils.date_utils import get_date_tag
 from planvec.utils.camera_utils import get_physical_camera_device_indices
 from planvec.planvec_paths import DATA_DESKTOP_DIR_PATH
 
 from dotmap import DotMap
 from typing import Tuple
 
+from planvec.utils.qt_utils import get_text_or_placeholder_text
+
 
 class PlanvecGui:
     """Adds logic and behaviour to the ui elements."""
@@ -234,7 +236,17 @@ def _execute_successful_jam_info_box(msg: str) -> None:
 
         if button_return.text() == '&OK':
             pdf_jammer = PdfJammer(data_manager=self.data_manager,
-                                   out_dir_path=DATA_DESKTOP_DIR_PATH / get_date_tag())
+                                   out_dir_path=DATA_DESKTOP_DIR_PATH / get_date_tag(),
+                                   plate_width=int(get_text_or_placeholder_text(self.ui.outputSizeWidth)),
+                                   plate_height=int(get_text_or_placeholder_text(self.ui.outputSizeHeight)),
+                                   pdf_width=int(get_text_or_placeholder_text(self.ui.inputSizeWidth)),
+                                   pdf_height=int(get_text_or_placeholder_text(self.ui.inputSizeHeight)))
+            try:
+                pdf_jammer.validate_pdf_and_plate_sizes_compatibility()
+            except PdfAndPlateSizeIncompatibleException as exception:
+                error_box = ErrorMsgBox(exception.message)
+                error_box.execute()
+                return
 
             school_name = self.ui.schoolName_2.text()
             team_name = self.ui.teamName_2.text()

planvec/gui/processing.py

@@ -58,7 +58,6 @@ def get_curr_out_fig(self) -> plt.Figure:
 
     def toggle_stopped(self):
         self.stopped = not self.stopped
-        print(f"Toggled stop video. Currently: {'STOPPED' if self.stopped else 'RUNNING'}")
 
     def set_input_width(self, width_cm) -> None:
         _, current_height_inches = self.processing_config.out_size_inches
@@ -94,7 +93,6 @@ def _calculate_display_shape_in_pixels(width_in_inches: float, height_in_inches:
     @QtCore.pyqtSlot()
     def toggle_canny_slot(self) -> None:
         self.do_canny = not self.do_canny
-        print(f"Toggled canny. Currently doing canny? {'YES' if self.do_canny else 'NO'}")
 
     @staticmethod
     def process_frame(img, processing_config: DotMap, color_ranges: dict, do_canny: bool, ax: plt.Axes) -> (plt.Axes, QImage):

planvec/pdf_jammer.py

@@ -3,28 +3,24 @@
 import math
 from pathlib import Path
 
-from dotmap import DotMap
-
 from planvec.gui.datamanager import DataManager
 from planvec.utils.date_utils import get_date_time_tag
-from config import planvec_config
 from typing import Dict, List
 
-
-# todo: need not hardcode but use values from GUI for this
-PLATE_WIDTH = 50
-PLATE_HEIGHT = 80
-PDF_WIDTH = 20
-PDF_HEIGHT = 14
-
 UNITE_FILE_TEMPL = 'unite_plate-{plate_idx}_{date_time_tag}.pdf'
 JAMMED_FILE_TEMPL = 'jammed_plate-{plate_idx}_{date_time_tag}.pdf'
 
 
 class PdfJammer:
-    def __init__(self, data_manager: DataManager, out_dir_path: Path, verbose: bool = True):
+    def __init__(self, data_manager: DataManager, out_dir_path: Path, 
+                 plate_width: int, plate_height: int, pdf_width: int, pdf_height: int,
+                 verbose: bool = True):
         self.data_manager = data_manager
         self.out_dir = out_dir_path
+        self.plate_width = plate_width
+        self.plate_height = plate_height
+        self.pdf_width = pdf_width
+        self.pdf_height = pdf_height
         self.verbose = verbose
 
     def run(self, pdf_paths: List[str]) -> None:
@@ -41,23 +37,23 @@ def run(self, pdf_paths: List[str]) -> None:
     def create_commands(self, pdfs) -> (List[List[str]], List[List[str]]):
         """Main function to arrange all pdfs in the input list on one or more single-page pdfs."""
         self.print_general_info(len(pdfs))
-        n_grippers_per_plate = calc_max_n_pdfs_per_plate(PLATE_WIDTH, PLATE_HEIGHT, PDF_WIDTH, PDF_HEIGHT)
+        n_pdfs_per_plate = calc_max_n_pdfs_per_plate(self.plate_width, self.plate_height, self.pdf_width, self.pdf_height)
         unite_commands = []
         jam_commands = []
-        for plate_idx, pdfs_chunk in enumerate(chunks(pdfs, n_grippers_per_plate)):
+        for plate_idx, pdfs_chunk in enumerate(chunks(pdfs, n_pdfs_per_plate)):
             unite_command, unite_file_path = self._create_unite_command(pdfs_chunk, plate_idx)
             jam_command = self._create_jam_command(unite_file_path, len(pdfs_chunk))
             # Step one: 'pdfunite' -> Merge all pdfs of this chunk into one pdf as pages
             unite_commands.append(unite_command)
             # Step two: 'pdfjam' -> Arrange all pages in the united pdf on a board given the dimensions of the
             #                       board and the individual pdfs.
             jam_commands.append(jam_command)
-            self.print_plate_info(len(pdfs_chunk), plate_idx, jam_command[-1])
+            self.print_plate_info(len(pdfs_chunk), plate_idx, jam_command[-1], self.plate_width, self.pdf_width, self.pdf_height)
         return unite_commands, jam_commands
 
     def _create_unite_command(self, pdfs, plate_idx):
         """Creates the subprocess command to merge multiple pdfs to one pdf with multiple pages."""
-        n_grippers_per_plate = calc_max_n_pdfs_per_plate(PLATE_WIDTH, PLATE_HEIGHT, PDF_HEIGHT, PDF_HEIGHT)
+        n_grippers_per_plate = calc_max_n_pdfs_per_plate(self.plate_width, self.plate_height, self.pdf_height, self.pdf_height)
         if len(pdfs) > n_grippers_per_plate:
             raise ValueError(f'Cannot have more than {n_grippers_per_plate} on one plate! Given: {len(pdfs)}.')
         out_file_name = UNITE_FILE_TEMPL.format(plate_idx=plate_idx,
@@ -67,21 +63,21 @@ def _create_unite_command(self, pdfs, plate_idx):
         return command, out_file_path
 
     def _create_jam_command(self, united_file_path, n_pdfs):
-        """Creates a list of strings representing the subprocess command to jam them ."""
+        """Creates a list of strings representing the subprocess command to jam them."""
         out_dir_path, united_file_name = os.path.split(united_file_path)
         jam_file_name = '_'.join(['jammed', united_file_name.split('_', 1)[1]])
         out_file_path = os.path.join(self.data_manager.out_dir_path, jam_file_name)
 
-        max_pdfs_per_plate = calc_max_n_pdfs_per_plate(PLATE_WIDTH, PLATE_HEIGHT, PDF_WIDTH, PDF_HEIGHT)
-        n_max_cols = calc_max_n_horizontal(PLATE_WIDTH, PDF_WIDTH)
-        n_max_rows = calc_max_n_vertical(PLATE_HEIGHT, PDF_HEIGHT)
+        max_pdfs_per_plate = calc_max_n_pdfs_per_plate(self.plate_width, self.plate_height, self.pdf_width, self.pdf_height)
+        n_max_cols = calc_max_n_horizontal(self.plate_width, self.pdf_width)
+        n_max_rows = calc_max_n_vertical(self.plate_height, self.pdf_height)
         n_cols = n_pdfs if n_pdfs < n_max_cols else n_max_cols
         n_rows = math.ceil(n_pdfs / n_cols)
         assert n_rows <= n_max_rows, f'n_rows ({n_rows}) cannot be larger than n_max_rows ({n_max_rows}).'
-        width = n_cols * PDF_WIDTH
-        height = n_rows * PDF_HEIGHT
+        output_width = n_cols * self.pdf_width
+        output_height = n_rows * self.pdf_height
         command = ['pdfjam'] + [f'--nup {n_cols}x{n_rows}'] + [united_file_path] + [
-            f"--papersize \'{{{width}cm, {height}cm}}\'"]
+            f"--papersize \'{{{output_width}cm, {output_height}cm}}\'"]
         command += [f'--outfile {out_file_path}']
         return command
 
@@ -134,32 +130,43 @@ def print_pdf_paths(teams_pdf_dict: Dict[str, List[str]]) -> None:
                 print(f'   {os.path.split(path)[1]}')
 
     def print_general_info(self, n_pdfs_total):
-        max_pdfs_per_plate = calc_max_n_pdfs_per_plate(PLATE_WIDTH, PLATE_HEIGHT, PDF_WIDTH, PDF_HEIGHT)
+        max_pdfs_per_plate = calc_max_n_pdfs_per_plate(self.plate_width, self.plate_height, self.pdf_width, self.pdf_height)
         n_plates = calc_n_plates(max_pdfs_per_plate, n_pdfs_total)
         print(f'Collecting output from {self.data_manager.out_dir_path}...')
         print(f'Found {n_pdfs_total} pdf output files.')
         pdfs_dict = self.accumulate_pdf_paths_all_schools_and_teams()
         PdfJammer.print_pdf_paths(pdfs_dict)
         print(f'Given dimensions:')
-        print(f' Plate width:\t {PLATE_WIDTH}')
-        print(f' Plate height:\t {PLATE_HEIGHT}')
-        print(f' PDF width:\t\t {PDF_WIDTH}')
-        print(f' PDF width:\t\t {PDF_HEIGHT}')
+        print(f' Plate width:\t {self.plate_width}')
+        print(f' Plate height:\t {self.plate_height}')
+        print(f' PDF width:\t\t {self.pdf_width}')
+        print(f' PDF width:\t\t {self.pdf_height}')
         print(f' which means maximum {max_pdfs_per_plate} PDF\'s per plate and...')
         print(f' and in this case {n_plates} {"plates" if n_plates > 1 else "plate"} '
               f'for {n_pdfs_total} PDF\'s in total.')
 
     @staticmethod
-    def print_plate_info(n_pdfs_on_plate, plate_idx, out_file_path):
-        n_cols, n_rows = calc_n_cols_rows(n_pdfs_on_plate)
-        final_width, final_height = calc_final_width_height(n_cols, n_rows)
+    def print_plate_info(n_pdfs_on_plate, plate_idx, out_file_path, plate_width, pdf_width, pdf_height):
+        n_cols, n_rows = calc_n_cols_rows(n_pdfs_on_plate, plate_width, pdf_width)
+        final_width, final_height = calc_final_width_height(n_cols, n_rows, pdf_width, pdf_height)
         print(f'Plate {plate_idx + 1}: ')
         print(f'\t{n_pdfs_on_plate} PDF{"s" if n_pdfs_on_plate > 1 else ""} on this plate.')
         print(f'\tGrid dimensions {n_cols}{"cols" if n_cols > 1 else "col"} x '
               f'{n_rows}{"rows" if n_rows > 1 else "row"} with a total size of '
               f'{final_width}x{final_height} cm')
         print(f'\t{out_file_path}')
 
+    def validate_pdf_and_plate_sizes_compatibility(self) -> None:
+        if self.pdf_width > self.plate_width:
+            raise PdfAndPlateSizeIncompatibleException("PDF Input kann nicht breiter als Output Platte sein!")
+        if self.pdf_height > self.plate_height:
+            raise PdfAndPlateSizeIncompatibleException("PDF Input kann nicht höher als Output Platte sein!")
+
+
+class PdfAndPlateSizeIncompatibleException(Exception):
+    def __init__(self, message: str) -> None:
+        self.message = message
+
 
 def calc_max_n_horizontal(plate_width, pdf_width):
     return plate_width // pdf_width
@@ -179,17 +186,17 @@ def calc_n_plates(max_pdfs_per_plate, n_pdfs):
     return math.ceil(n_pdfs / max_pdfs_per_plate)
 
 
-def calc_n_cols_rows(n_pdfs):
+def calc_n_cols_rows(n_pdfs, plate_width, pdf_width):
     """Given the dimensions of the plate and single pdf and the number of pdfs, how many cols and rows are required."""
-    n_max_cols = calc_max_n_horizontal(PLATE_WIDTH, PDF_WIDTH)
+    n_max_cols = calc_max_n_horizontal(plate_width, pdf_width)
     n_cols = n_pdfs if n_pdfs < n_max_cols else n_max_cols
     n_rows = math.ceil(n_pdfs / n_cols)
     return n_cols, n_rows
 
 
-def calc_final_width_height(n_cols, n_rows):
-    width = n_cols * PDF_WIDTH
-    height = n_rows * PDF_HEIGHT
+def calc_final_width_height(n_cols, n_rows, pdf_width, pdf_height):
+    width = n_cols * pdf_width
+    height = n_rows * pdf_height
     return width, height
 
 

planvec/utils/qt_utils.py

@@ -0,0 +1,9 @@
+from PyQt5.QtWidgets import QLineEdit
+
+
+def get_text_or_placeholder_text(text_widget: QLineEdit) -> str:
+    """If a text is present, that is not '', grab the text, else, grab the placeholder text."""
+    if text_widget.text() != '':
+        return text_widget.text()
+    else:
+        return text_widget.placeholderText()