Skip to content
The Chat Archive
o1-preview-2024-09-12· OpenAI WildChat-4.8M (AI2)

def applyCutandStackimposition(self, inputpdfpath, outputpdfpath): """Áp dụng phương…

  1. User

    def apply_CutandStack_imposition(self, input_pdf_path, output_pdf_path): """Áp dụng phương pháp dàn trang cut and stack để sắp xếp các trang theo yêu cầu."""

                # Lấy các tham số từ giao diện người dùng
                new_page_width = self.new_page_width_var.get()
                new_page_height = self.new_page_height_var.get()
                margin_top = self.margin_top_var.get()
                margin_bottom = self.margin_bottom_var.get()
                margin_left = self.margin_left_var.get()
                margin_right = self.margin_right_var.get()
                cropmark_offset = self.cropmark_offset_var.get()
                cropmark_length = self.cropmark_length_var.get()
    
                # Chuyển đổi đơn vị từ mm sang điểm
                new_page_width_pt = self.mm_to_points(new_page_width)
                new_page_height_pt = self.mm_to_points(new_page_height)
                margin_top_pt = self.mm_to_points(margin_top)
                margin_bottom_pt = self.mm_to_points(margin_bottom)
                margin_left_pt = self.mm_to_points(margin_left)
                margin_right_pt = self.mm_to_points(margin_right)
                cropmark_offset_pt = self.mm_to_points(cropmark_offset)
                crop_length_pt = self.mm_to_points(cropmark_length)
    
                crop_thickness = 0.5  # Độ dày của crop marks
    
                # Tính toán khu vực có thể sử dụng
                available_width = new_page_width_pt - margin_left_pt - margin_right_pt
                available_height = new_page_height_pt - margin_top_pt - margin_bottom_pt
    
                # Đọc tệp PDF đầu vào
                doc = fitz.open(input_pdf_path)
                total_pages = len(doc)
    
                # Lấy kích thước trang đầu vào
                input_page = doc.load_page(0)
                bbox = input_page.rect
                entry_width_orig = bbox.width
                entry_height_orig = bbox.height
    
                # Các tùy chọn xoay và không xoay
                options = [
                    {'rotate': False, 'entry_width': entry_width_orig, 'entry_height': entry_height_orig},
                    {'rotate': True, 'entry_width': entry_height_orig, 'entry_height': entry_width_orig},
                ]
    
                # Xác định cách sắp xếp tốt nhất
                best_arrangement = None
                max_total_entries = 0
                for option in options:
                    entries_per_row = int(available_width // option['entry_width'])
                    entries_per_column = int(available_height // option['entry_height'])
                    total_entries = entries_per_row * entries_per_column
                    if total_entries > max_total_entries:
                        max_total_entries = total_entries
                        best_arrangement = option.copy()
                        best_arrangement['entries_per_row'] = entries_per_row
                        best_arrangement['entries_per_column'] = entries_per_column
    
                if not best_arrangement or best_arrangement['entries_per_row'] == 0 or best_arrangement['entries_per_column'] == 0:
                    messagebox.showerror("Error", "Kích thước trang hoặc lề quá nhỏ để sắp xếp nội dung.")
                    doc.close()
                    return
    
                # Tính toán tổng kích thước lưới để căn giữa nội dung
                total_grid_width = best_arrangement['entries_per_row'] * best_arrangement['entry_width']
                total_grid_height = best_arrangement['entries_per_column'] * best_arrangement['entry_height']
                x_offset = margin_left_pt + (available_width - total_grid_width) / 2
                y_offset = margin_top_pt + (available_height - total_grid_height) / 2
    
                # Tạo tài liệu mới cho kết quả
                new_doc = fitz.open()
    
                # Tách các trang lẻ và trang chẵn
                odd_pages = [i for i in range(total_pages) if i % 2 == 0]   # Trang lẻ (0-based index)
                even_pages = [i for i in range(total_pages) if i % 2 != 0]  # Trang chẵn
    
                # Tính toán số lượng tờ in cho trang lẻ và trang chẵn
                entries_per_sheet = best_arrangement['entries_per_row'] * best_arrangement['entries_per_column']
                num_sheets_odd = (len(odd_pages) + entries_per_sheet - 1) // entries_per_sheet
                num_sheets_even = (len(even_pages) + entries_per_sheet - 1) // entries_per_sheet
                num_sheets = max(num_sheets_odd, num_sheets_even)
    
                for sheet_index in range(num_sheets):
                    # Sắp xếp các trang lẻ (từ trái sang phải)
                    front_page = new_doc.new_page(width=new_page_width_pt, height=new_page_height_pt)
                    arranged_rects_front = []
    
                    for row in range(best_arrangement['entries_per_column']):
                        for col in range(best_arrangement['entries_per_row']):
                            page_number = col * best_arrangement['entries_per_column'] + row + sheet_index * entries_per_sheet
                            if page_number >= len(odd_pages):
                                continue
                            page_num = odd_pages[page_number]
    
                            x = x_offset + col * best_arrangement['entry_width']
                            y = y_offset + row * best_arrangement['entry_height']
                            rect = fitz.Rect(
                                x,
                                y,
                                x + best_arrangement['entry_width'],
                                y + best_arrangement['entry_height']
                            )
                            if best_arrangement['rotate']:
                                front_page.show_pdf_page(rect, doc, pno=page_num, rotate=90)
                            else:
                                front_page.show_pdf_page(rect, doc, pno=page_num)
                            arranged_rects_front.append((rect, row, col))
    
                    # Thêm crop marks cho mặt trước
                    for rect, row, col in arranged_rects_front:
                        edges = []
                        if row == 0:
                            edges.append('top')
                        if row == best_arrangement['entries_per_column'] - 1:
                            edges.append('bottom')
                        if col == 0:
                            edges.append('left')
                        if col == best_arrangement['entries_per_row'] - 1:
                            edges.append('right')
                        if edges:
                            self.add_crop_marks(front_page, rect, edges, cropmark_offset_pt, crop_length_pt, crop_thickness)
    
                    # Sắp xếp các trang chẵn (từ phải sang trái, đảo ngược cột)
                    back_page = new_doc.new_page(width=new_page_width_pt, height=new_page_height_pt)
                    arranged_rects_back = []
    
                    for row in range(best_arrangement['entries_per_column']):
                        for col in range(best_arrangement['entries_per_row']):
                            page_number = col * best_arrangement['entries_per_column'] + row + sheet_index * entries_per_sheet
                            if page_number >= len(even_pages):
                                continue
                            page_num = even_pages[page_number]
    
                            # Đảo ngược cột để sắp xếp từ phải sang trái
                            reversed_col = best_arrangement['entries_per_row'] - 1 - col
                            x = x_offset + reversed_col * best_arrangement['entry_width']
                            y = y_offset + row * best_arrangement['entry_height']
                            rect = fitz.Rect(
                                x,
                                y,
                                x + best_arrangement['entry_width'],
                                y + best_arrangement['entry_height']
                            )
                            if best_arrangement['rotate']:
                                back_page.show_pdf_page(rect, doc, pno=page_num, rotate=90)
                            else:
                                back_page.show_pdf_page(rect, doc, pno=page_num)
                            arranged_rects_back.append((rect, row, reversed_col))
    
    
                    # Thêm crop marks cho mặt sau
                    for rect, row, col in arranged_rects_back:
                        edges = []
                        if row == 0:
                            edges.append('top')
                        if row == best_arrangement['entries_per_column'] - 1:
                            edges.append('bottom')
                        if col == 0:
                            edges.append('left')
                        if col == best_arrangement['entries_per_row'] - 1:
                            edges.append('right')
                        if edges:
                            self.add_crop_marks(back_page, rect, edges, cropmark_offset_pt, crop_length_pt, crop_thickness)
    
                # Lưu tệp PDF đã áp dụng imposition
                new_doc.save(output_pdf_path)
                new_doc.close()
                doc.close()  hãy xem mã này hiện tại và tôi lấy ví dụ cụ thể như sau file PDF TÔI CÓ 200 TRANG  CÓ KÍCH THƯỚC LÀ 9X5.5 CMCÁC TRANG CHẴN ĐƯỢC ĐÁNH SỐ THỨ TỰ TỪ 1 ĐẾN 100 VÀ CÁC TRANG LẺ CŨNG ĐƯỢC ĐÁNH SỐ THỨ TỰ TỪ 1 ĐẾN 100 CẤU TRÚC FILE PDF NHƯ SAU TRANG 1 (SỐ 1), (TRANG 2 SỐ 1), TRANG 3(SỐ 2), TRANG 4(SỐ 2)V.... LẦN LƯỢT CHO ĐẾN HẾT 200, KHI SẮP XẾP CHÚNG LÊN KT a4 THÌ  TA ĐƯỢC 20 TRANG A4 TRONG ĐÓ CÁC TRANG LẺ SẮP CÙNG NHAU THEO QUY TĂC CUT AND STACK GỒM CÓ 2 CỘT VÀ 5 DÒNG TỪ TRÁI QUA PHẢI  TỪ TRÊN XUỐNG DƯỚI LẦN LƯỢT 1-51,11-61,21-71,31-81,41-91 , VÀ CÁC TRANG CHẴN CŨNG ĐANG SẮP XẾP ĐÚNG Y NHƯ VẬY NHƯNG NẾU ĐÚNG NHƯ CÁI TÔI MUỐN THÌ CÁC TRANG CHẲN PHẢI LÀ 51-1,61-11,71-21,81-31,91-41 THÌ TÔI PHẢI SỬA THỂ NÀO ĐỂ CHO RA KẾT QUẢ LÀ  TRANG CHẲN PHẢI LÀ 51-1,61-11,71-21,81-31,91-41
    
  2. Assistant

    To achieve your desired page arrangement for the even pages (back pages), you need to modify the way page_number is calculated in your code. Specifically, you want the even pages to be arranged in a different sequence than the odd pages.

    Here's how you can adjust your code to match the desired output:

    Modify the page_number calculation for both odd and even pages.

    For the odd pages (front pages):

    for row in range(best_arrangement['entries_per_column']):
        for col in range(best_arrangement['entries_per_row']):
            page_number = row * 10 + col * 50 + sheet_index * entries_per_sheet
            if page_number >= len(odd_pages):
                continue
            page_num = odd_pages[page_number]
    

    For the even pages (back pages), you need to consider the reversed columns since you are arranging from right to left:

    for row in range(best_arrangement['entries_per_column']):
        for col in range(best_arrangement['entries_per_row']):
            reversed_col = best_arrangement['entries_per_row'] - 1 - col
            page_number = row * 10 + reversed_col * 50 + sheet_index * entries_per_sheet
            if page_number >= len(even_pages):
                continue
            page_num = even_pages[page_number]
    

    Explanation:

    • For Odd Pages:

      • page_number = row * 10 + col * 50 + sheet_index * entries_per_sheet
        • This formula is designed to create the sequence you desire for the odd pages.
        • For example, with entries_per_row = 2 and entries_per_column = 5:
          • When col = 0: page_number = row * 10
            • This gives page numbers like 0, 10, 20, 30, 40.
          • When col = 1: page_number = row * 10 + 50
            • This gives page numbers like 50, 60, 70, 80, 90.
    • For Even Pages:

      • Because you're arranging from right to left, you need to reverse the columns:
        • reversed_col = best_arrangement['entries_per_row'] - 1 - col
      • Then, adjust the page_number calculation:
        • page_number = row * 10 + reversed_col * 50 + sheet_index * entries_per_sheet
          • This swaps the columns compared to the odd pages, giving you the sequence you desire.

    Implementing the Changes:

    Adjust the relevant sections in your apply_CutandStack_imposition function to use the new page_number calculations.

    Example Code Adjustment:

    # Odd Pages (Front)
    for row in range(best_arrangement['entries_per_column']):
        for col in range(best_arrangement['entries_per_row']):
            page_number = row * 10 + col * 50 + sheet_index * entries_per_sheet
            if page_number >= len(odd_pages):
                continue
            page_num = odd_pages[page_number]
            # (Rest of your code remains the same.)
    
    # Even Pages (Back)
    for row in range(best_arrangement['entries_per_column']):
        for col in range(best_arrangement['entries_per_row']):
            reversed_col = best_arrangement['entries_per_row'] - 1 - col
            page_number = row * 10 + reversed_col * 50 + sheet_index * entries_per_sheet
            if page_number >= len(even_pages):
                continue
            page_num = even_pages[page_number]
            # (Rest of your code remains the same.)
    

    Notes:

    • Ensure that sheet_index * entries_per_sheet is included if you have multiple sheets and need to account for them.
    • Adjust the multiplier values (10 and 50) based on your specific requirements (these values are derived from the patterns you provided).
    • The if page_number >= len(odd_pages): check ensures you don't attempt to access pages that don't exist.

    By making these changes, your even pages should now be arranged in the sequence: 51-1, 61-11, 71-21, 81-31, 91-41, as you desired.