stacked-pdf-generator 1.1.1 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 56ae6f60c86521d34dfb181497a9d9b97a0796780fa5bed10e137ddb48f5a2c7
-  data.tar.gz: ee2f9c06fde0a77814e88f9f65015acccd73c6c2e0fb6131811e6326a60a98fd
+  metadata.gz: ea9f2232d17d099af488808839dddb8c3fab9f5c987fce3a82413d21654f8107
+  data.tar.gz: 34cf1e0945f1630d3f16e9256fafd9ecd55eec655fd4daea1b55a1140eb9190e
 SHA512:
-  metadata.gz: c46b93d4b0074c76f0733e153b4a46e50a010332f76ca3a243ee042c9e7b4c90ff444a9cebf4bac874d1bd5ab28f13729aeb02ac73cbcad0969149e3c53311fb
-  data.tar.gz: b58b49aea0905b0faa3cdc6ac2a89e35d6862e536aa781c06c9e57361ad17f09b02de3d431170634647b80798e033534f97e73e2bd42c971e70b1b34ec430892
+  metadata.gz: 046cef8c86c81630b03057805daed45301249533adfe7c4fb894880a62dbb2da43bc7c1ef41e641ad24a14f87b3d7e2671f60135c090573817660e5e8080ef37
+  data.tar.gz: 26e2f24a82a8ea91abe5d342ca9e4ac72c352be36ebbd54a39034ceab5ab7cca1d34845b0ea40abc1994df1bf7d20a6eef0bd41e3171d83eb36ad78b49811490

data/exe/stacked-pdf-generator

@@ -7,7 +7,8 @@ lib_path = File.expand_path('../lib', __dir__)
 $LOAD_PATH.unshift(lib_path) unless $LOAD_PATH.include?(lib_path)
 require 'stacked_pdf_generator'
 
-options = { portrait: false, two_sided_flipped: false }
+options = { portrait: false, two_sided_flipped: false, crop_from_marks: false }
+crop_box = {}
 parser = OptionParser.new do |opts|
   opts.banner = 'Usage: stacked-pdf-generator --input INPUT --output OUTPUT [options]'
 
@@ -26,6 +27,28 @@ parser = OptionParser.new do |opts|
     options[:two_sided_flipped] = true
   end
 
+  opts.separator ''
+  opts.separator 'Crop-from-marks options (input PDF carries printer crop marks):'
+
+  opts.on('--crop-from-marks',
+          'Auto-detect crop marks on the first page and crop every page to the area they delimit') do
+    options[:crop_from_marks] = true
+  end
+  opts.on('--crop-top MM', Float, 'Manual crop: Y of the top edge in mm (from page bottom)') { |v| crop_box[:top] = v }
+  opts.on('--crop-bottom MM', Float, 'Manual crop: Y of the bottom edge in mm (from page bottom)') { |v| crop_box[:bottom] = v }
+  opts.on('--crop-left MM', Float, 'Manual crop: X of the left edge in mm (default 0)') { |v| crop_box[:left] = v }
+  opts.on('--crop-right MM', Float, 'Manual crop: X of the right edge in mm (default page width)') { |v| crop_box[:right] = v }
+  opts.on('--mark-max-length MM', Float,
+          'Detection: maximum length of a crop-mark segment in mm (default ~10.6)') do |v|
+    options[:mark_max_length_mm] = v
+  end
+  opts.on('--mark-edge-tolerance MM', Float,
+          'Detection: how close a mark must be to the page edge in mm (default ~0.35)') do |v|
+    options[:mark_edge_tolerance_mm] = v
+  end
+
+  opts.separator ''
+
   opts.on('-v', '--version', 'Print version') do
     puts StackedPdfGenerator::VERSION
     exit 0
@@ -59,6 +82,8 @@ if options[:pages_per_sheet].nil? && (options[:rows].nil? || options[:columns].n
   exit 1
 end
 
+options[:crop_box] = crop_box unless crop_box.empty?
+
 result = StackedPdfGenerator.call(
   input_path: options[:input_path],
   output_path: options[:output_path],
@@ -69,7 +94,11 @@ result = StackedPdfGenerator.call(
   autoscale: options[:autoscale],
   portrait: options[:portrait],
   sheet_margins: options[:sheet_margins],
-  two_sided_flipped: options[:two_sided_flipped]
+  two_sided_flipped: options[:two_sided_flipped],
+  crop_from_marks: options[:crop_from_marks],
+  crop_box: options[:crop_box],
+  mark_max_length_mm: options[:mark_max_length_mm],
+  mark_edge_tolerance_mm: options[:mark_edge_tolerance_mm]
 )
 
 if result.success?

data/lib/stacked_pdf_generator/crop_mark_detector.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require 'hexapdf'
+require 'hexapdf/content/processor'
+
+module StackedPdfGenerator
+  # Detects printer crop marks on the first page of a PDF and returns the
+  # rectangular region delimited by them.
+  #
+  # Pattern expected: 4 short horizontal segments (or rectangles) per page,
+  # 2 at the top (left + right edges) and 2 at the bottom. Marks must touch
+  # either the left edge (x ≈ 0) or the right edge (x ≈ page_width). Only the
+  # vertical extent is constrained by the marks; horizontally we keep the full
+  # page width.
+  module CropMarkDetector
+    DEFAULT_MARK_MAX_LENGTH_MM = 30.0 / 72.0 * 25.4 # ≈ 10.6 mm (30 pts)
+    DEFAULT_EDGE_TOLERANCE_MM  = 1.0 / 72.0 * 25.4  # ≈ 0.35 mm (1 pt)
+    HORIZONTAL_TOLERANCE_PTS   = 0.5
+    Y_CLUSTER_TOLERANCE_PTS    = 2.0
+
+    DetectedBox = Struct.new(:left, :bottom, :right, :top, :page_width, :page_height,
+                             keyword_init: true)
+
+    module_function
+
+    # Inspect the first page of +pdf_path+ and return a DetectedBox in PDF
+    # points, or raise ProcessingError with a descriptive message.
+    def call(pdf_path, mark_max_length_pts: DEFAULT_MARK_MAX_LENGTH_MM * 72.0 / 25.4,
+             edge_tolerance_pts: DEFAULT_EDGE_TOLERANCE_MM * 72.0 / 25.4)
+      doc = HexaPDF::Document.open(pdf_path)
+      page = doc.pages[0]
+      raise ProcessingError, 'PDF has no pages' unless page
+
+      page_w = page.box.width.to_f
+      page_h = page.box.height.to_f
+      collector = LineCollector.new
+      page.process_contents(collector)
+
+      candidates = filter_candidates(collector.lines, page_w,
+                                     mark_max_length_pts: mark_max_length_pts,
+                                     edge_tolerance_pts: edge_tolerance_pts)
+
+      if candidates.empty?
+        raise ProcessingError,
+              "No crop marks detected on page 1 (looked for short horizontal " \
+              "segments touching the left or right edge; mark_max_length=" \
+              "#{mark_max_length_pts.round(2)}pts, edge_tolerance=" \
+              "#{edge_tolerance_pts.round(2)}pts). Inspected " \
+              "#{collector.lines.size} path segments."
+      end
+
+      clusters = cluster_by_y(candidates)
+      validate_clusters!(clusters, page_w, edge_tolerance_pts)
+
+      ys = clusters.map { |c| median(c.map { |seg| seg[1] }) }.sort
+      DetectedBox.new(left: 0.0, bottom: ys.first, right: page_w, top: ys.last,
+                      page_width: page_w, page_height: page_h)
+    end
+
+    def filter_candidates(lines, page_w, mark_max_length_pts:, edge_tolerance_pts:)
+      lines.select do |x0, y0, x1, y1|
+        next false unless (y0 - y1).abs < HORIZONTAL_TOLERANCE_PTS
+        next false if (x1 - x0).abs > mark_max_length_pts
+
+        touches_left  = [x0, x1].min <= edge_tolerance_pts
+        touches_right = [x0, x1].max >= page_w - edge_tolerance_pts
+        touches_left || touches_right
+      end
+    end
+
+    def cluster_by_y(segments)
+      sorted = segments.sort_by { |seg| seg[1] }
+      clusters = []
+      sorted.each do |seg|
+        if clusters.last && (seg[1] - clusters.last.last[1]).abs <= Y_CLUSTER_TOLERANCE_PTS
+          clusters.last << seg
+        else
+          clusters << [seg]
+        end
+      end
+      clusters
+    end
+
+    def validate_clusters!(clusters, page_w, edge_tolerance_pts)
+      ys_summary = clusters.map { |c| median(c.map { |seg| seg[1] }).round(2) }
+
+      if clusters.size != 2
+        raise ProcessingError,
+              "Expected 2 Y-rows of crop marks (top + bottom), found " \
+              "#{clusters.size}. Y values: #{ys_summary.inspect}, " \
+              "marks per row: #{clusters.map(&:size).inspect}."
+      end
+
+      clusters.each_with_index do |cluster, idx|
+        has_left  = cluster.any? { |x0, _, x1, _| [x0, x1].min <= edge_tolerance_pts }
+        has_right = cluster.any? { |x0, _, x1, _| [x0, x1].max >= page_w - edge_tolerance_pts }
+        unless has_left && has_right
+          raise ProcessingError,
+                "Crop mark row at y=#{ys_summary[idx]} is missing " \
+                "#{has_left ? '' : 'left'}#{has_left || has_right ? '' : ' & '}" \
+                "#{has_right ? '' : 'right'} mark. Found #{cluster.size} marks."
+        end
+      end
+    end
+
+    def median(values)
+      sorted = values.sort
+      n = sorted.length
+      n.odd? ? sorted[n / 2] : (sorted[n / 2 - 1] + sorted[n / 2]) / 2.0
+    end
+
+    # Walks the page content stream and records every line/rectangle edge
+    # in page coordinates (CTM applied).
+    class LineCollector < HexaPDF::Content::Processor
+      attr_reader :lines
+
+      def initialize
+        super
+        @lines = []
+        @current = nil
+      end
+
+      def move_to(x, y)
+        @current = [x, y]
+      end
+
+      def line_to(x, y)
+        if @current
+          tx0, ty0 = transform_point(*@current)
+          tx1, ty1 = transform_point(x, y)
+          @lines << [tx0, ty0, tx1, ty1]
+        end
+        @current = [x, y]
+      end
+
+      def append_rectangle(x, y, w, h)
+        edges = [
+          [x, y, x + w, y],
+          [x + w, y, x + w, y + h],
+          [x + w, y + h, x, y + h],
+          [x, y + h, x, y]
+        ]
+        edges.each do |x0, y0, x1, y1|
+          tx0, ty0 = transform_point(x0, y0)
+          tx1, ty1 = transform_point(x1, y1)
+          @lines << [tx0, ty0, tx1, ty1]
+        end
+      end
+
+      # Path-painting operators we don't care about, but Processor expects them.
+      %i[close_subpath end_path stroke_path close_and_stroke_path
+         fill_path_non_zero fill_path_even_odd
+         fill_and_stroke_path_non_zero close_fill_and_stroke_path_non_zero
+         fill_and_stroke_path_even_odd close_fill_and_stroke_path_even_odd
+         curve_to curve_to_no_first_control curve_to_no_second_control
+         clip_path_non_zero clip_path_even_odd].each do |op|
+        define_method(op) { |*| }
+      end
+
+      private
+
+      def transform_point(x, y)
+        ctm = graphics_state.ctm
+        [ctm.a * x + ctm.c * y + ctm.e, ctm.b * x + ctm.d * y + ctm.f]
+      end
+    end
+  end
+end

data/lib/stacked_pdf_generator/crop_marks_processor.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'hexapdf'
+
+module StackedPdfGenerator
+  # Applies a uniform crop rectangle (in PDF points) to every page of a source
+  # PDF, writing a new PDF whose CropBox and MediaBox match the requested
+  # region. Used as a pre-processing step before the imposition pipeline when
+  # the input contains printer crop marks.
+  module CropMarksProcessor
+    module_function
+
+    # Crop +input_path+ → +output_path+ using the given +box+ (a 4-element
+    # array [left, bottom, right, top] in PDF points).
+    def call(input_path, output_path, box)
+      validate_box!(box)
+      doc = HexaPDF::Document.open(input_path)
+      doc.pages.each do |page|
+        page[:CropBox] = box.dup
+        page[:MediaBox] = box.dup
+        page.delete(:BleedBox)
+        page.delete(:TrimBox)
+        page.delete(:ArtBox)
+      end
+      doc.write(output_path, optimize: true)
+      output_path
+    end
+
+    def validate_box!(box)
+      raise ProcessingError, 'Crop box must have 4 numeric values' unless box.is_a?(Array) && box.length == 4
+
+      left, bottom, right, top = box.map(&:to_f)
+      raise ProcessingError, "Crop box has zero or negative width (left=#{left}, right=#{right})" if right <= left
+      raise ProcessingError, "Crop box has zero or negative height (bottom=#{bottom}, top=#{top})" if top <= bottom
+    end
+  end
+end

data/lib/stacked_pdf_generator/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module StackedPdfGenerator
-  VERSION = '1.1.1'
+  VERSION = '1.2.0'
 end

data/lib/stacked_pdf_generator.rb

@@ -6,6 +6,8 @@ require 'securerandom'
 require 'stacking_order'
 
 require_relative 'stacked_pdf_generator/version'
+require_relative 'stacked_pdf_generator/crop_mark_detector'
+require_relative 'stacked_pdf_generator/crop_marks_processor'
 
 # Provides library and CLI helpers for generating stack-cut friendly PDFs using
 # pdfjam/podofocrop tooling and stacking-order-based page sequencing.
@@ -14,6 +16,8 @@ module StackedPdfGenerator
 
   Result = Struct.new(:success?, :message, keyword_init: true)
 
+  PT_PER_MM = 72.0 / 25.4
+
   module_function
 
   def call(**kwargs)
@@ -24,10 +28,13 @@ module StackedPdfGenerator
   # and sequences pages via stacking-order to build the final PDF.
   class Generator
     attr_reader :input_path, :output_path, :paper_size, :autoscale, :portrait,
-                :sheet_margins_raw, :rows, :columns, :pages_per_sheet, :two_sided_flipped
+                :sheet_margins_raw, :rows, :columns, :pages_per_sheet, :two_sided_flipped,
+                :crop_from_marks, :crop_box_mm, :mark_max_length_mm, :mark_edge_tolerance_mm
 
     def initialize(input_path:, output_path:, paper_size:, autoscale:, portrait:, rows: nil, columns: nil,
-                   pages_per_sheet: nil, sheet_margins: nil, two_sided_flipped: false)
+                   pages_per_sheet: nil, sheet_margins: nil, two_sided_flipped: false,
+                   crop_from_marks: false, crop_box: nil,
+                   mark_max_length_mm: nil, mark_edge_tolerance_mm: nil)
       @input_path = input_path
       @output_path = output_path
       @paper_size = paper_size.to_s.upcase
@@ -38,18 +45,23 @@ module StackedPdfGenerator
       @columns = columns.nil? ? nil : Integer(columns)
       @pages_per_sheet = pages_per_sheet.nil? ? nil : Integer(pages_per_sheet)
       @two_sided_flipped = boolean_cast(two_sided_flipped)
+      @crop_from_marks = boolean_cast(crop_from_marks)
+      @crop_box_mm = crop_box # hash {top:, bottom:, left:, right:} in mm, optional
+      @mark_max_length_mm = mark_max_length_mm
+      @mark_edge_tolerance_mm = mark_edge_tolerance_mm
       normalize_layout_dimensions!
     end
 
     def call
       validate_arguments!
+      apply_crop_from_marks if crop_pre_processing?
       run_pdfjam
       finalize_output
       Result.new(success?: true, message: '')
     rescue ProcessingError => e
       Result.new(success?: false, message: e.message)
     ensure
-      cleanup_tempfile
+      cleanup_tempfiles
     end
 
     private
@@ -60,6 +72,60 @@ module StackedPdfGenerator
       raise ProcessingError, 'pages_per_sheet must be positive' unless pages_per_sheet.positive?
     end
 
+    def crop_pre_processing?
+      crop_from_marks || crop_box_mm
+    end
+
+    def apply_crop_from_marks
+      box_pts = crop_box_mm ? manual_crop_box_pts : detect_crop_box_pts
+      CropMarksProcessor.call(input_path, cropped_input_path, box_pts)
+      @input_path = cropped_input_path
+    end
+
+    def detect_crop_box_pts
+      detector_args = {}
+      detector_args[:mark_max_length_pts] = mark_max_length_mm * PT_PER_MM if mark_max_length_mm
+      detector_args[:edge_tolerance_pts]  = mark_edge_tolerance_mm * PT_PER_MM if mark_edge_tolerance_mm
+
+      detected = CropMarkDetector.call(input_path, **detector_args)
+      [detected.left, detected.bottom, detected.right, detected.top]
+    end
+
+    def manual_crop_box_pts
+      sym = crop_box_mm.transform_keys(&:to_sym)
+      missing = %i[top bottom].reject { |k| sym.key?(k) }
+      raise ProcessingError, "Manual crop_box missing keys: #{missing.inspect}" unless missing.empty?
+
+      page_w_pts, page_h_pts = first_page_dimensions_pts
+      left  = (sym[:left]  || 0.0).to_f * PT_PER_MM
+      right = sym[:right] ? sym[:right].to_f * PT_PER_MM : page_w_pts
+      # Manual values are given in mm from the bottom-left origin of the page,
+      # which matches the PDF coordinate system.
+      bottom = sym[:bottom].to_f * PT_PER_MM
+      top    = sym[:top].to_f * PT_PER_MM
+
+      raise ProcessingError, "Manual crop top (#{top.round(2)}pts) exceeds page height (#{page_h_pts.round(2)}pts)" if top > page_h_pts + 0.5
+      raise ProcessingError, "Manual crop right (#{right.round(2)}pts) exceeds page width (#{page_w_pts.round(2)}pts)" if right > page_w_pts + 0.5
+
+      [left, bottom, right, top]
+    end
+
+    def first_page_dimensions_pts
+      doc = HexaPDF::Document.open(input_path)
+      page = doc.pages[0]
+      raise ProcessingError, 'PDF has no pages' unless page
+
+      [page.box.width.to_f, page.box.height.to_f]
+    end
+
+    def cropped_input_path
+      @cropped_input_path ||= begin
+        dirname = File.dirname(output_path)
+        FileUtils.mkdir_p(dirname)
+        File.join(dirname, "stacked_cropped_#{SecureRandom.hex(6)}.pdf")
+      end
+    end
+
     def run_pdfjam
       sequence = page_sequence
       cmd = [
@@ -93,8 +159,9 @@ module StackedPdfGenerator
       end
     end
 
-    def cleanup_tempfile
+    def cleanup_tempfiles
       FileUtils.rm_f(temp_output_path) if defined?(@temp_output_path) && File.exist?(@temp_output_path)
+      FileUtils.rm_f(@cropped_input_path) if defined?(@cropped_input_path) && @cropped_input_path && File.exist?(@cropped_input_path)
     end
 
     def temp_output_path

metadata

@@ -1,15 +1,35 @@
 --- !ruby/object:Gem::Specification
 name: stacked-pdf-generator
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.2.0
 platform: ruby
 authors:
 - Jeremy
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-11-26 00:00:00.000000000 Z
+date: 2026-05-04 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: hexapdf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: stacking-order
   requirement: !ruby/object:Gem::Requirement
@@ -37,6 +57,8 @@ files:
 - README.md
 - exe/stacked-pdf-generator
 - lib/stacked_pdf_generator.rb
+- lib/stacked_pdf_generator/crop_mark_detector.rb
+- lib/stacked_pdf_generator/crop_marks_processor.rb
 - lib/stacked_pdf_generator/version.rb
 homepage: https://github.com/jeremy/stacked-pdf-generator
 licenses: