PDF转为图像文件

for pdf in "$@"; do
    /usr/bin/swift /Users/<用户名>/.local/bin/pdf2png.swift "$pdf"
done

mkdir -p ~/.local/bin

import Foundation
import CoreGraphics
import ImageIO
import UniformTypeIdentifiers

let args = CommandLine.arguments

guard args.count >= 2 else {
    fputs("Usage: pdf2png.swift <file.pdf>\n", stderr)
    exit(1)
}

let pdfPath = args[1]
let pdfURL = URL(fileURLWithPath: pdfPath)

guard let document = CGPDFDocument(pdfURL as CFURL) else {
    fputs("Cannot open PDF: \(pdfPath)\n", stderr)
    exit(1)
}

let directory = pdfURL.deletingLastPathComponent()
let baseName = pdfURL.deletingPathExtension().lastPathComponent

// Approximately matches the raster size produced by Preview
// in the sample PDFs.
let scale: CGFloat = 3.8

for pageNumber in 1...document.numberOfPages {

    guard let page = document.page(at: pageNumber) else {
        fputs("Cannot read page \(pageNumber)\n", stderr)
        continue
    }

    /*
     IMPORTANT:
     Use CropBox rather than MediaBox.

     Many PDFs, especially electronic invoices, contain a large
     MediaBox but define the actual visible page using CropBox.
     Preview follows the CropBox as well.
    */
    let boxType: CGPDFBox = .cropBox
    let box = page.getBoxRect(boxType)

    let rotation = page.rotationAngle

    let pageWidth: CGFloat
    let pageHeight: CGFloat

    if rotation == 90 || rotation == 270 {
        pageWidth = box.height
        pageHeight = box.width
    } else {
        pageWidth = box.width
        pageHeight = box.height
    }

    let pixelWidth = Int(round(pageWidth * scale))
    let pixelHeight = Int(round(pageHeight * scale))

    guard pixelWidth > 0, pixelHeight > 0 else {
        fputs("Invalid page size on page \(pageNumber)\n", stderr)
        continue
    }

    guard let context = CGContext(
        data: nil,
        width: pixelWidth,
        height: pixelHeight,
        bitsPerComponent: 8,
        bytesPerRow: 0,
        space: CGColorSpaceCreateDeviceRGB(),
        bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue
    ) else {
        fputs("Cannot create bitmap context for page \(pageNumber)\n", stderr)
        continue
    }

    // White background.
    context.setFillColor(CGColor.white)
    context.fill(
        CGRect(
            x: 0,
            y: 0,
            width: CGFloat(pixelWidth),
            height: CGFloat(pixelHeight)
        )
    )

    context.saveGState()

    // Convert PDF points to bitmap pixels.
    context.scaleBy(x: scale, y: scale)

    let targetRect = CGRect(
        x: 0,
        y: 0,
        width: pageWidth,
        height: pageHeight
    )

    /*
     Let Core Graphics handle:
       - CropBox origin
       - PDF coordinate system
       - page rotation
       - translation into the output bitmap
    */
    let transform = page.getDrawingTransform(
        boxType,
        rect: targetRect,
        rotate: 0,
        preserveAspectRatio: true
    )

    context.concatenate(transform)
    context.drawPDFPage(page)

    context.restoreGState()

    guard let image = context.makeImage() else {
        fputs("Cannot render page \(pageNumber)\n", stderr)
        continue
    }

    let outputName: String

    if document.numberOfPages == 1 {
        outputName = "\(baseName).png"
    } else {
        outputName = String(
            format: "%@-%03d.png",
            baseName,
            pageNumber
        )
    }

    let outputURL = directory.appendingPathComponent(outputName)

    guard let destination = CGImageDestinationCreateWithURL(
        outputURL as CFURL,
        UTType.png.identifier as CFString,
        1,
        nil
    ) else {
        fputs("Cannot create output file: \(outputURL.path)\n", stderr)
        continue
    }

    CGImageDestinationAddImage(
        destination,
        image,
        nil
    )

    if !CGImageDestinationFinalize(destination) {
        fputs("Failed to write: \(outputURL.path)\n", stderr)
        continue
    }

    print(
        "Created: \(outputURL.path) " +
        "(\(pixelWidth) × \(pixelHeight))"
    )
}