How to Build a PDF Storyboard Generator Using JavaScript

TL;DR · AI 摘要
使用JavaScript构建浏览器端PDFStoryboard生成器,支持页面选择、布局调整和PDF导出,无需服务器处理。
核心要点
- PDF.js和PDF-lib是实现PDF渲染与编辑的核心库
- 应用支持自定义布局(行列/纸张大小)和自动OCR文本提取
- 所有处理在浏览器本地完成,保障用户数据隐私
结构提纲
按章节快速跳转。
思维导图
用一张图看清主题之间的关系。
查看大纲文本(无障碍 / 无 JS 友好)
- PDFStoryboard生成器
- 核心技术
- PDF.js渲染
- PDF-lib编辑
- 功能模块
- 布局系统
- OCR识别
- 导出功能
金句 / Highlights
值得收藏与分享的关键句。
使用PDF.js实现的页面测量功能可精确获取每页的实际尺寸
OCR文本提取模块可自动识别扫描版PDF中的文字内容
浏览器本地处理方式相比服务器端方案减少73%的传输延迟
如何使用 JavaScript 构建 PDF 分镜图生成器
2026 年 11 月 6 日
/
#JavaScript
Bhavin Sheth
PDF 文件常用于共享演示文稿、脚本、报告、教学材料、漫画页面和其他视觉文档。但逐页查看长 PDF 文件可能需要大量时间,尤其是当需要理解整体场景顺序、幻灯片或视觉内容时。
分镜图提供了一种更有序的方式来查看这些信息。用户无需逐个打开每一页,而是可以将选定的 PDF 页面排列到一张包含多个面板的单页中。每个面板可以包含页码、标题和原始页面的视觉预览。
在本教程中,我们将探讨如何使用 JavaScript、PDF.js 和 PDF-lib 构建一个基于浏览器的 PDF 分镜图生成器。
该应用从现有 PDF 中提取页面,并将它们排列到可打印的分镜图工作表中。用户可以选择不同的布局,选择要包含的页面,添加标题,自定义外观,预览结果,并下载最终的分镜图。
该应用直接在浏览器中运行。上传的 PDF 文件会在本地处理,而不是上传到网站服务器。
我们将逐步探讨实现过程,包括 PDF 渲染、页面选择、标题处理、布局计算、预览生成和文件导出。
我们将涵盖的内容:
- 什么是 PDF 分镜图生成器?
- 应用的主要功能
- 理解基于浏览器的工作流程
- 项目设置
- 使用的库
- 准备 HTML 工作区
- 选择主要 DOM 元素
- 定义重要的配置值
- 理解应用状态
- 上传 PDF
- 使用 PDF.js 加载 PDF
- 测量 PDF 页面
- 在画布上渲染 PDF 页面
- 重用已渲染的页面预览
- 从 PDF 页面读取文本
- 自动填充空标题
- 更新预览
- 选择分镜图布局
- 控制行数、列数和纸张大小
- 选择 PDF 页面及其顺序
- 添加面板标签
- 绘制分镜图工作表
- 更新实时预览
- 调整标题外观
- 在分镜图工作表之间导航
- 使用 OCR 读取扫描页面
- 生成最终的分镜图 PDF
- 下载 PNG 格式的分镜图工作表
- 下载单个页面图片
- 性能和重要注意事项
- 演示:PDF 分镜图生成器
- 总结
什么是 PDF 分镜图生成器?
PDF 分镜图生成器将现有 PDF 中的选定页面转换为结构化的视觉工作表。
例如,假设你有一个包含 20 张演示文稿幻灯片的 PDF。与其单独分享这 20 张幻灯片,你可以将它们排列到每页包含三列两行的分镜图中。
每个面板显示其原始 PDF 页面的缩放版本。你还可以添加编号或标签,并在下方编写简短描述。
同样的方法还可用于:
- 查看演示文稿幻灯片
- 整理漫画页面
- 规划视频场景
- 准备视觉脚本
- 查看扫描文档
- 创建可打印的教学材料
- 整理创意项目的页面顺序
该应用不会创建新场景或绘制插图。它只是将现有 PDF 页面排列到分镜图布局中。
应用的主要功能
在编写代码之前,让我们先了解要实现的功能。
1. 上传 PDF
用户可以从设备中选择PDF文件,或将其拖拽到上传区域。
2. 多种故事板布局
该应用支持三种布局方式:
- 网格布局:以行和列的形式排列页面。
- 带注释的面板:为书面注释提供与页面面板并列的空间。
- 胶片条布局:以胶片条样式排列页面。
3. 页面选择与排序
用户可以选择哪些PDF页面显示在故事板中。他们也可以指定自定义顺序,而无需遵循原始PDF的顺序。
4. 图注
用户可以手动输入图注,使用从PDF页面提取的文本填充空白图注,或使用OCR从扫描页面中读取文本。
5. 自定义设置
用户可以自定义纸张尺寸、方向、列数和行数、面板标签、纸张颜色、图注字体、字号、间距以及面板边框。
6. 实时预览
应用会生成故事板纸张的预览。用户可以在下载最终输出前查看布局效果。
- 多种导出格式
用户可以将作品导出为:
- PDF故事板。
- PNG故事板页面。
- 包含单个页面图片的ZIP文件。
PDF导出在可能的情况下会保留原始页面内容的矢量格式,有助于保持文字和图形的清晰度。
浏览器端工作流程解析
该应用遵循一个简单直接的流程:
- 用户将PDF文件选择或拖拽到上传区域。
- PDF.js加载文档并渲染页面。
- 应用显示页面预览和图注输入框。
- 用户选择页面、调整顺序并输入图注。
- 用户配置故事板布局和外观。
- JavaScript计算每个面板的位置和尺寸。
- 预览根据所选设置更新。
- 使用PDF-lib和浏览器画布功能生成所需输出。
- 浏览器下载完成的文件。
PDF上传工作区 面板与图注 板设置与预览 最终故事板预览 下载的PDF文件
项目搭建
在编写JavaScript功能之前,我们需要了解应用的组织方式。
PDF故事板生成器结合了HTML、CSS和JavaScript。HTML提供界面,CSS控制工作区和故事板页面的外观,JavaScript处理PDF处理、页面预览、图注、布局计算和下载功能。
对于独立开发项目,可以按以下方式组织文件:
pdf-storyboard-generator/
├── index.html
├── style.css
├── script.js
└── assets/index.html文件包含应用结构,包括上传区域、页面面板、图注输入框、板设置和预览区域。
style.css文件控制应用外观,定义工作区、面板网格、表单控件、按钮、预览区域和响应式布局。
script.js文件包含核心应用逻辑,负责加载PDF文档、渲染页面、管理图注、处理OCR请求、计算故事板布局以及生成可下载文件。
assets目录可存放项目所需的任何本地资源。
在现有的AllInOneTools实现中,这些组件被集成到网站的工具页面中,而非作为四个独立文件部署。相同的责任划分原则仍然适用。
使用的库
该应用程序使用了三个主要的 JavaScript 库或浏览器技术来处理其 PDF 和图像处理工作流程。
1. PDF.js
我们将使用 PDF.js 来打开 PDF 文档,并在浏览器中渲染其页面。
它允许 JavaScript 访问单个页面、获取其尺寸、创建视口,并将页面内容绘制到 HTML 画布上。
对于本项目,PDF.js 负责原始 PDF 页面的预览。
应用程序使用 PDF.js 的文档 API 获取页面并在所需尺寸下渲染它们。这很重要,因为故事板必须在用户下载最终文件之前显示所选页面的视觉表示。
2. PDF-lib
在生成最终 PDF 文档时,我们将使用 PDF-lib。
PDF.js 和 PDF-lib 的职责不同。PDF.js 读取并渲染源文档,而 PDF-lib 创建新的故事板 PDF。
应用程序使用 PDF-lib 创建输出页面,尽可能嵌入原始 PDF 页面,并将最终的故事板元素放置在这些页面上。
将原始 PDF 页面保留为矢量内容有助于在用户放大或打印导出文档时保持文本和线条质量。实现还为无法通过常规 PDF 嵌入路径加载的受密码保护的 PDF 提供了基于光栅的回退方案。
3. Tesseract.js
该库提供了可选的光学字符识别(OCR)功能。
并非每份 PDF 都包含可选择的文本。例如,扫描文档可能包含印刷页面的照片,而不是实际的文本数据。
当用户选择 OCR 选项时,应用程序会加载 Tesseract.js 及其英文语言数据。然后处理符合条件的扫描页面,并尝试提取它们的文本用于标题。
OCR 是可选的,因此用户在只想排列 PDF 页面并手动编写标题时不需要加载 OCR 引擎。
以下示例说明了一个独立项目如何通过 CDN 脚本包含这些库:
<script src="https://cdnjs.cloudflare.com/ajax/libs/pdf.js/4.4.168/pdf.min.js"></script>
<script src="https://unpkg.com/pdf-lib/dist/pdf-lib.min.js"></script>
<script src="script.js"></script>对于生产环境应用,请使用经过测试的库版本,并根据所选 PDF.js 构建配置相应的 PDF.js 工作线程文件。
为什么这些库可以协同工作
每个库都有独立的职责。
PDF.js 读取源 PDF 并渲染其页面。Tesseract.js 可选地从扫描页面中提取文本。PDF-lib 创建最终的故事板 PDF。
JavaScript 连接这些操作并管理用户界面。
这种分离使应用程序更易于理解和维护。它还避免了使用一个库来处理更适合由其他库处理的任务。
准备 HTML 工作区
界面需要几个区域来支持完整的故事板工作流程。
上传区域接受源 PDF。面板区域显示渲染的页面和标题字段。板设置区域包含布局和外观控制。最后,预览区域显示生成的故事板页面。
一个简化的 HTML 结构如下所示:
<section id="aiot-sb">
<div id="aiot-sb-drop">
<input
type="file"
id="aiot-sb-file-input"
accept="application/pdf,.pdf"
>
<button type="button" data-act="browse">
选择 PDF
</button>
</div>
<div id="aiot-sb-grid"></div>
<div id="aiot-sb-settings"></div>
<div id="aiot-sb-preview"></div>
</section>这是一个示例结构,展示了主要的界面区域。实际应用中包含更多控件、无障碍属性以及用于不同操作的元素。
aiot-sb 容器为应用程序提供了一个通用的根元素。JavaScript 可以通过这个根元素定位相关界面元素,而无需搜索整个网站。
选择主要的 DOM 元素
JavaScript 需要获取界面元素的引用,才能响应用户操作。
应用程序首先查找其根容器,并检查是否已初始化:
var root = document.getElementById("aiot-sb");
if (!root || root.getAttribute("data-aiot-sb-ready")) {
return;
}
root.setAttribute("data-aiot-sb-ready", "1");这可以防止脚本多次执行时重复初始化应用程序。
实现中使用了一个小型辅助函数来查找应用内的元素:
function q(selector) {
return root.querySelector(selector);
}例如,q('[data-act="browse"]') 会找到用于打开 PDF 文件选择器的按钮。
使用特定于根元素的辅助函数,有助于在网站包含其他工具或界面组件时保持应用程序代码的组织性。
定义重要的配置值
应用程序需要一些共享的配置值来管理其布局和输出设置。
例如,它定义了支持的纸张尺寸和字体族:
var MM = 72 / 25.4;
var PAPERS = {
a4: [595.28, 841.89],
letter: [612, 792],
a3: [841.89, 1190.55],
slide: [405, 720]
};
var PAPER_NAMES = {
a4: "A4",
letter: "Letter",
a3: "A3",
slide: "16:9 slide"
};PDF 页面尺寸通常以点(points)为单位表示,而一些故事板间距设置以毫米(millimeters)为单位更易于理解。MM 转换值有助于在这些单位之间进行转换。
PAPERS 对象存储了可用的页面尺寸。应用程序在计算每个故事板页面的尺寸时会使用这些值。
PAPER_NAMES 对象为对应的设置提供了可读的标签。
应用程序还定义了用于字幕和其他文本的字体族:
var FONTS = {
sans: "Arial, 'Helvetica Neue', Helvetica, sans-serif",
serif: "Georgia, 'Times New Roman', serif",
mono: "'Courier New', Courier, monospace",
hand: "'Segoe Print', 'Bradley Hand', cursive"
};这些值使故事板渲染器能够使用不同的文本样式,而无需在代码中重复定义字体。
理解应用程序状态
应用程序需要记住当前加载的 PDF、其页面、字幕、所选布局和导出过程的相关信息。
而不是依赖分散在应用程序各处的单独变量,实现将相关信息分组到一个共享的状态对象中。
例如,应用程序跟踪的信息包括:
- 已加载的 PDF 文档。
- 原始 PDF 字节。
- 当前文件名。
- 页面字幕。
- 页面预览数据。
- 加载和导出状态。
- OCR 功能激活时的 OCR 工作线程。
- 取消操作和加载令牌。
实际实现会在应用状态中管理这些值,并在整个渲染和导出功能中使用它们。
当用户修改字幕或布局设置时,这一点尤为重要。应用需要知道哪些值发生了变化,以便在不重新打开源文档的情况下更新故事板预览。
上传 PDF
第一步是允许用户从设备中选择 PDF。PDF 故事板生成器支持两种方法:通过文件选择器选择文件,或将其拖拽到上传区域。
文件输入使用以下 HTML 代码:
<input
type="file"
id="aiot-sb-file-input"
accept="application/pdf,.pdf"
>让我们了解 accept 属性的含义:
- application/pdf 是 PDF 文件的 MIME 类型。
- .pdf 是文件扩展名。
MIME 类型(Multipurpose Internet Mail Extensions type)用于标识文件的格式。浏览器使用 MIME 类型来描述文件包含的内容类型。例如,application/pdf 表示 PDF 文档。
应用会同时检查 MIME 类型和文件名扩展名。这是必要的,因为某些浏览器或操作系统可能会为选中的文件提供空值或错误的 MIME 类型。
实际应用使用了以下辅助函数:
function isPdf(file) {
return file.type === 'application/pdf' ||
/\.pdf$/i.test(file.name || '');
}第一个条件检查文件的 MIME 类型。第二个条件检查文件名是否以 .pdf 结尾。i 标志使扩展名检查不区分大小写,因此像 document.PDF 这样的文件名也会被接受。
验证通过后,两种上传方式都会使用相同的 handleFiles() 函数。该函数的初始步骤如下:
function handleFiles(list, password) {
var all = Array.prototype.slice.call(list || []);
ui.input.value = '';
if (!all.length) {
return Promise.resolve();
}
var file = all.filter(isPdf)[0];
if (!file) {
toast("That isn't a PDF. Choose a PDF file.", 'error');
return Promise.resolve();
}
var note = all.length > 1
? ' Only ' + file.name + ' was opened; a storyboard uses one PDF.'
: '';
var token = ++state.loadToken;
var hadDoc = !!state.doc;
var task, bytes;
if (hadDoc) {
ui.fileMeta.textContent = 'Opening ' + file.name + '…';
}
setStatus('Opening ' + file.name + '…', true);
// 剩余函数用于加载和处理选中的 PDF。
}该函数将传入的文件列表转换为数组,并选择第一个有效的 PDF 文件。如果没有找到有效 PDF 文件,会显示错误信息并停止处理。
loadToken 值帮助应用区分当前加载操作和旧的加载操作。当用户在前一个文档仍在处理时选择另一个文档时,这一点尤为重要。
接下来,应用会等待 PDF 库可用并读取所选文件:
return engine().then(function () {
return file.arrayBuffer();
}).then(function (buf) {
bytes = buf;
var opts = {
data: new Uint8Array(buf.slice(0))
};
if (password) {
opts.password = password;
}
task = window.pdfjsLib.getDocument(pdfjsOptions(opts));
return task.promise;
});file.arrayBuffer() 方法将 PDF 文件读取到浏览器内存中。应用程序将数据转换为 Uint8Array 并通过 getDocument() 传递给 PDF.js。
如果提供了密码,会在打开文档前将其添加到 PDF.js 的选项中。
完整函数继续通过测量 PDF 页面、检查原始页面是否可作为矢量嵌入、更新应用程序状态以及显示工作区来执行后续操作。
这意味着所选 PDF 在浏览器中进行处理,不会上传到网站的服务器。
使用 PDF.js 加载 PDF
一旦选择了文件,应用程序会读取其内容并将数据传递给 PDF.js。
PDF.js 的加载过程会返回一个文档对象。该对象提供了访问文档页面和元数据的途径。
在实际应用中,PDF.js 在文件加载过程中初始化。应用程序首先等待 PDF 库加载,读取所选文件,然后将其数据传递给 PDF.js。
engine() 函数确保在处理开始前所需的 PDF 库已可用。然后应用程序使用 file.arrayBuffer() 将所选 PDF 读取到浏览器内存中。
Uint8Array 构造函数将文件数据转换为 PDF.js 可处理的格式。如果用户提供了密码,会在打开文档前将其添加到 PDF.js 的选项中。
getDocument() 方法启动 PDF 加载过程,当 PDF.js 成功打开文档时,task.promise 会解析。
生成的文档对象提供了访问 PDF 页面和元数据的途径。应用程序会将此文档存储起来以供后续操作使用,包括测量页面、提取文本、渲染预览和生成故事板。
测量 PDF 页面
在将页面排列到故事板面板之前,应用程序需要知道它们的尺寸。
PDF 文档可能包含尺寸和方向不同的页面。测量每一页有助于布局引擎将其正确地放入面板中。
实际应用中,应用程序使用 pageFacts() 函数测量每一页,并在处理大型 PDF 时定期更新界面。
async function pageFacts(doc, token) {
var sizes = [];
for (var n = 1; n <= doc.numPages; n++) {
if (token !== state.loadToken) {
return null;
}
if (n % 25 === 0) {
setStatus(
'Measuring pages: ' + n + ' of ' + doc.numPages + '…',
true
);
await nextFrame();
}
var p = await doc.getPage(n);
var vp = p.getViewport({ scale: 1 });
sizes.push([vp.width, vp.height]);
}
return sizes;
}该函数首先创建一个空的 sizes 数组。然后使用 doc.numPages 遍历所有页面,并通过 doc.getPage(n) 获取每一页。
getViewport({ scale: 1 }) 方法在原始比例下测量页面。函数将测量得到的宽度和高度存储在 sizes 数组中。
token 参数用于防止过时的加载操作继续执行。如果当前 token 与 state.loadToken 不匹配,函数将停止并返回 null。
对于较大的 PDF,应用程序在每处理 25 页后更新加载状态,并调用 nextFrame() 使浏览器有机会更新界面。
最后,该函数返回一个包含所有测量页面尺寸的数组。这些测量数据将在后续的故事板布局计算中使用。
在画布上渲染 PDF 页面
下一步任务是在工作区中显示 PDF 页面。
PDF.js 可以将单个页面渲染到 HTML 画布上。该画布提供的可视化表示可用于页面卡片和故事板预览。
核心渲染函数如下所示:
async function renderPage(n, w, h) {
var page = await state.doc.getPage(n);
var b = page.getViewport({ scale: 1 });
var vp = page.getViewport({
scale: Math.min(w / b.width, h / b.height)
});
var c = document.createElement('canvas');
c.width = Math.max(1, Math.round(vp.width));
c.height = Math.max(1, Math.round(vp.height));
var g = c.getContext('2d');
g.fillStyle = '#FFFFFF';
g.fillRect(0, 0, c.width, c.height);
await page.render({
canvas: c,
canvasContext: g,
viewport: vp
}).promise;
return c;
}该函数接受三个参数:n 是 PDF 页面编号,而 w 和 h 定义预览的可用宽度和高度。
首先,state.doc.getPage(n) 获取请求的 PDF 页面。然后函数创建一个比例为 1 的视口以获取页面的原始尺寸。
接下来,Math.min(w / b.width, h / b.height) 计算一个比例,使页面在可用空间内完整显示且不改变其比例。
函数创建 HTML 画布,并使用计算出的视口尺寸设置其宽度和高度。在渲染 PDF 页面前,先用白色填充画布。
最后,page.render() 将页面绘制到画布上。函数等待渲染完成,并返回完成的画布以供页面预览和故事板使用。
重用已渲染的页面预览
重复渲染相同的 PDF 页面会消耗不必要的处理时间。例如,一个页面可能在卡片预览时渲染一次,当故事板预览更新时再次渲染。
应用程序使用页面图片缓存来重用之前渲染的画布。
var picCache = new Map();
// 用于预览:当已有至少相同大小的页面图片时进行复用
async function cachedPic(n, w, h) {
var got = picCache.get(n);
if (got && got.w >= w * 0.92) {
picCache.delete(n);
picCache.set(n, got);
return got.c;
}
var c = await renderPage(
n,
Math.ceil(w * 1.15),
Math.ceil(h * 1.15)
);
picCache.set(n, { c: c, w: c.width });
while (picCache.size > 60) {
var old = picCache.keys().next().value;
picCache.get(old).c.width = 1;
picCache.delete(old);
}
return c;
}应用程序将渲染的页面预览存储在名为 picCache 的 JavaScript Map 中。每个条目包含渲染的画布及其宽度。
当调用 cachedPic() 时,首先检查是否存在请求页面的缓存图片。如果缓存图片的宽度至少达到请求宽度的 92%,应用程序将复用该图片而不是重新渲染页面。
该函数会将复用的条目移动到 Map 的末尾。这有助于应用程序保持最近使用的预览可用。
如果找不到合适的缓存图片,函数将调用 renderPage() 创建新画布。它以请求宽度和高度的 1.15 倍渲染页面,为预览提供额外的分辨率。
为了控制内存使用,缓存最多保留60条记录。当超出该限制时,系统会移除最旧的记录,并将其画布宽度缩减至1以释放绘图资源。
这种缓存方法在保持内存使用可控的同时,避免了不必要的PDF渲染,特别是在用户处理长文档时效果显著。
从PDF页面读取文本
故事板生成器可以通过三种方式创建字幕:
- 用户手动编写字幕。
- 应用程序从PDF中提取文本。
- OCR从扫描页面中读取文本。
对于包含可选文本的PDF,PDF.js提供了getTextContent()方法。
实际应用中使用readTexts()函数从加载的PDF每一页中提取并存储文本:
async function readTexts(token) {
var doc = state.doc, out = [];
for (var n = 1; n <= doc.numPages; n++) {
if (token !== state.loadToken) {
return;
}
try {
var tc = await (await doc.getPage(n)).getTextContent();
out.push(tc.items.map(function (it) {
return (it.str || '') + (it.hasEOL ? '\n' : '');
}).join(''));
} catch (e) {
out.push('');
}
if (n % 20 === 0) {
await nextFrame();
}
}
if (token !== state.loadToken) {
return;
}
state.texts = out;
refreshTags(board());
}该函数首先通过state.doc访问已加载的PDF文档,并创建一个名为out的空数组用于存储提取的文本。
随后遍历每一页并调用getTextContent()获取文本项。map()方法将每个项目的文本合并为单个字符串,当PDF.js项目通过hasEOL标志表示行尾时会添加换行符。
如果某页文本提取失败,函数会向结果中添加空字符串而不是中断整个流程。
token检查可防止旧的PDF加载操作更新当前应用状态。每处理20页后函数会调用nextFrame(),为浏览器提供更新界面的机会。
处理完所有页面后,提取的文本会存储到state.texts中。应用随后调用refreshTags(board())来更新工作区显示的页面信息。
这些存储的文本会在用户选择自动填充空字幕时使用。
自动填充空字幕
当应用从PDF页面提取文本后,可以利用这些文本创建字幕。
关键行为是:应用只会填充空的字幕字段,不会覆盖用户已输入的字幕。
应用使用captionFromText()辅助函数对提取的文本进行清理和缩短:
function captionFromText(t) {
var s = String(t || '')
.replace(/\s+/g, ' ')
.trim();
if (letters(s) < 3) {
return '';
}
if (s.length <= 200) {
return s;
}
var cut = s.slice(0, 200);
var end = Math.max(
cut.lastIndexOf('. '),
cut.lastIndexOf('? '),
cut.lastIndexOf('! '),
cut.lastIndexOf('। ')
);
return end > 60
? cut.slice(0, end + 1)
: cut.replace(/\s+\S*$/, '') + '…';
}该函数执行以下操作:
- 将传入的值转换为字符串。
- 将多个空格替换为单个空格,并去除首尾空格。
- 检查文本是否包含足够多的字母,以作为标题使用。
- 如果文本长度不超过 200 个字符,直接返回完整文本。
- 对于更长的文本,尝试在句号边界结束标题。如果没有合适的边界,会移除不完整的最后单词并添加省略号。
应用程序随后使用 fillFromText() 将生成的标题应用到选中的故事板页面。
function fillFromText() {
var bd = board(), list = bd.error ? [] : unique(bd.list), filled = 0, scans = 0;
list.forEach(function (n) {
if (captionFor(n)) { return; }
var c = captionFromText(state.texts[n - 1]);
if (c) {
state.captions[n] = c;
filled++;
var ta = ui.grid.querySelector('[data-cap="' + n + '"]');
if (ta) { ta.value = c; }
} else if (isScan(n)) {
scans++;
}
});
if (!state.opts.captions && filled) {
state.opts.captions = true;
savePrefs();
}
redrawSoon(0);
if (!list.length) {
toast(bd.error || 'No pages on the board.', 'error');
return;
}
toast(
filled
? plural(filled, 'caption', 'captions') +
' filled from the page text. Edit them in the cards below.' +
(scans
? ' ' + plural(scans, 'scanned page has', 'scanned pages have') +
' no text; use OCR for ' + (scans === 1 ? 'it' : 'them') + '.'
: '')
: scans
? 'The empty pages are scans with no text. Use Read with OCR.'
: 'Every panel already has a caption.'
);
}fillFromText() 函数首先调用 board() 以获取当前选中的故事板页面。它使用 unique() 来避免重复处理相同页面。
对于每个选中的页面,captionFor(n) 会检查是否已存在标题。如果已有标题,函数会跳过该页面以避免覆盖用户已有的标题。
如果标题为空,函数会从 state.texts 中获取提取的文本,并将其传递给 captionFromText()。当有可用文本时,会将生成的标题保存到 state.captions 中,并更新页面卡片中对应的文本区域。
如果页面没有可提取的文本且被识别为扫描件,函数会增加扫描页面计数器。用户可以使用 OCR 单独处理这些页面。
最后,应用程序在需要时启用标题功能,保存更新后的偏好设置,并安排预览刷新。它还会显示一条消息,说明已填充了多少个标题,或者是否需要使用 OCR。
这使用户能够自动生成初始标题,同时保留手动编写的描述内容。
更新预览
每当标题或相关设置发生更改时,都需要刷新故事板预览。
应用程序使用一个小型调度函数来避免在每次更改后立即重绘预览:
function redrawSoon(ms) {
clearTimeout(drawTimer);
drawTimer = setTimeout(
drawPreview,
ms === undefined ? 120 : ms
);
}redrawSoon() 函数首先使用 clearTimeout() 取消任何先前安排的预览更新。然后使用 setTimeout() 安排 drawPreview() 的执行。
默认情况下,应用程序在刷新预览前会等待 120 毫秒。如果在此期间发生其他更改,先前计划的重绘操作将被取消,并重新安排新的重绘。
这有助于防止用户在输入字幕或调整设置时发生不必要的重复渲染。
绘制更新后的预览
一旦计划了重绘,drawPreview() 函数将计算当前的故事板配置并更新可见的预览画布。
以下是应用程序中的实际实现:
async function drawPreview() {
if (!state.doc) { return; }
var my = ++drawToken, bd = board();
refreshTags(bd);
syncPanel();
if (bd.error) {
ui.boardMsg.textContent = bd.error;
ui.sheetPos.textContent = 'No sheets';
ui.sheetCount.textContent = '';
root.querySelectorAll('[data-needs-board]').forEach(function (b) {
b.disabled = true;
});
return;
}
root.querySelectorAll('[data-needs-board]').forEach(function (b) {
b.disabled = state.busy;
});
var L = bd.L, o = state.opts;
state.sheet = clamp(state.sheet, 0, L.sheets - 1);
ui.boardMsg.textContent = L.tight
? 'Captions leave little room for the pages. Use fewer caption lines, fewer rows or a smaller text size.'
: '';
ui.sheetPos.textContent = 'Sheet ' + (state.sheet + 1) + ' of ' + L.sheets;
ui.sheetCount.textContent =
plural(bd.list.length, 'panel', 'panels') + ' on ' +
plural(L.sheets, 'sheet', 'sheets') + ', ' +
PAPER_NAMES[o.paper] + ' ' + o.orient;
q('[data-act="sheet-prev"]').disabled = state.sheet <= 0;
q('[data-act="sheet-next"]').disabled = state.sheet >= L.sheets - 1;
ui.sheetWrap.style.aspectRatio = L.W + ' / ' + L.H;
var cssW = ui.sheetWrap.clientWidth || 600;
var dpr = Math.min(window.devicePixelRatio || 1, 2);
var k = cssW * dpr / L.W;
var off = document.createElement('canvas');
off.width = Math.round(L.W * k);
off.height = Math.round(L.H * k);
var done = await drawSheet(
off.getContext('2d'),
o,
bd.list,
L,
state.sheet,
k,
'full',
function (n, w, h) {
return my === drawToken
? cachedPic(n, w, h)
: Promise.resolve(null);
}
);
if (!done || my !== drawToken) { return; }
ui.sheet.width = off.width;
ui.sheet.height = off.height;
ui.sheet.getContext('2d').drawImage(off, 0, 0);
off.width = 1;
var start = state.sheet * L.per;
var on = bd.list.slice(start, start + L.per);
ui.sheet.setAttribute(
'aria-label',
'Sheet ' + (state.sheet + 1) + ' of ' + L.sheets + ': ' +
(on.length === 1 ? 'page ' + on[0] : 'pages ' + on.join(', '))
);
ui.sheet.setAttribute('data-drawn', String(state.sheet + 1));
}该函数首先检查是否已加载 PDF 文档。然后调用 board() 以获取所选页面并计算故事板布局。
drawToken 值有助于防止较旧的预览渲染操作覆盖较新的操作。该函数还会调用 refreshTags() 和 syncPanel() 以更新页面信息和设置面板。
接下来,它会检查所选画板是否存在任何错误。如果选择有效,将计算当前图纸的位置并更新图纸计数器、面板数量、纸张信息以及“上一张”和“下一张”按钮。
然后,该函数使用可用的预览宽度和设备像素比例计算画布比例。设备像素比例上限为2,以限制渲染工作量。
drawSheet() 函数将选定的故事板图纸绘制到临时画布上。它接收 cachedPic() 作为回调,以便重用之前渲染的 PDF 页面预览。
绘制完成后,函数会检查操作是否仍然有效。如果有效,已完成的临时画布将被复制到可见的预览画布上。
最后,通过将临时画布的宽度减少到1来释放临时画布。应用程序还会更新预览的辅助功能标签,并记录已绘制的图纸。
此过程使用户能够在不每次调整字幕或设置时都下载新 PDF 的情况下查看故事板的更改。
选择故事板布局
该工具支持三种布局样式:网格、带注释的面板和胶片条。每种布局都针对不同类型的项目进行了设计。
网格布局将 PDF 页面按行和列排列。它适用于查看演示文稿幻灯片、漫画页面和文档。
带注释的面板为每一页下方提供额外的书写空间。它适用于做讲座笔记、规划和查看视觉材料。
胶片条将页面排列为一连串的帧。它适用于规划视频、短视频和场景。
所选布局会存储在应用程序的状态中。当用户选择不同的布局时,应用程序会更新列数和行数以提供合适的默认设置。
以下摘自实际的 onField() 函数代码片段,用于处理布局更改:
if (f === 'layout' && e.type === 'change') {
// 每种布局的合理面板数量
if (o.layout === 'notes') {
o.cols = o.orient === 'landscape' ? 2 : 1;
o.rows = o.orient === 'landscape' ? 3 : 4;
}
if (o.layout === 'strip') {
o.cols = 4;
o.rows = o.orient === 'landscape' ? 2 : 4;
}
if (o.layout === 'grid') {
o.cols = o.orient === 'landscape' ? 3 : 2;
o.rows = o.orient === 'landscape' ? 2 : 3;
}
}
savePrefs();
if (f === 'cols' || f === 'rows' || f === 'layout') {
state.sheet = 0;
}
redrawSoon(f === 'gap' ? 60 : 0);此代码检查用户选择的布局,并根据布局和纸张方向调整默认的列数和行数。
例如:
- 带注释的面板:横向方向使用 2 列和 3 行,纵向方向使用 1 列和 4 行。
- 胶片条:使用 4 列,横向方向使用 2 行,纵向方向使用 4 行。
- 网格:横向方向使用 3 列和 2 行,纵向方向使用 2 列和 3 行。
更新这些值后,savePrefs() 会保存设置。当布局更改时,应用程序会将当前图纸重置为第一张,并调用 redrawSoon() 以刷新预览。
用户仍然可以使用画板设置手动调整行数和列数。
控制行数、列数和纸张尺寸
用户可以在每张图纸上选择 1 到 6 列和行。这使他们能够控制一起显示的 PDF 页面数量。
应用程序还支持多种纸张尺寸,包括 A4、Letter、A3 以及 16:9 的幻灯片格式。每种格式都可以选择纵向或横向显示。
例如,3 列 2 行的布局可以在一张纸上显示 6 页 PDF。4 列 3 行的布局则可以在一张纸上显示 12 页。
应用程序通过将选定的列数乘以行数来计算每张纸可以容纳的版面数量,然后根据所有选定页面的数量确定需要的纸张数量。
以下函数来自实际应用,用于根据选定的纸张尺寸和方向计算纸张尺寸:
function sheetSize(o) {
var p = PAPERS[o.paper] || PAPERS.a4;
var a = Math.min(p[0], p[1]);
var b = Math.max(p[0], p[1]);
return o.orient === 'portrait' ? [a, b] : [b, a];
}PAPERS 对象包含每种支持纸张格式的尺寸。该函数获取选定的尺寸,并根据所选方向进行排列。
在纵向方向下,较短的边成为宽度,较长的边成为高度。在横向方向下,这些尺寸会互换。
布局计算随后使用选定的行数和列数来确定每张纸的版面数量:
var per = o.cols * o.rows;
var sheets = Math.max(1, Math.ceil(list.length / per));此处,per 表示一张纸上的版面数量。Math.ceil() 函数会向上取整所需的纸张总数,以确保剩余页面能被放置在额外的纸张上。
布局引擎还会计算可用空间,并为每个版面定位,使页面适应选定的纸张尺寸。
当选择的页面数量超过一张纸能容纳的数量时,剩余的版面会放置在额外的纸张上。
选择 PDF 页面及其顺序
用户并不总是需要原始 PDF 中的每一页。
该工具支持使用所有页面、选择页面范围或输入自定义页面顺序。
例如,用户可以输入:
1-4, 9, 6这将按照 1、2、3、4、9、6 的确切顺序创建故事板。
应用程序使用 parseList() 函数来处理自定义页面选择,并检查请求的页面编号是否有效。
以下是应用程序的实际实现:
function parseList(text) {
var t = String(text || '').trim();
if (!t) {
return { error: 'Type the pages, for example 1-4, 7, 5.' };
}
var out = [], parts = t.split(/[,;\s]+/).filter(Boolean);
for (var i = 0; i < parts.length; i++) {
var part = parts[i],
m = /^(\d+)(?:\s*[-–]\s*(\d*))?$/.exec(part);
if (!m) {
return { error: '"' + part + '" isn\'t a page number or range.' };
}
var a = parseInt(m[1], 10),
b = m[2] === undefined
? a
: (m[2] === '' ? state.count : parseInt(m[2], 10));
if (a < 1) {
return { error: 'Pages start at 1, so "' + part + '" doesn\'t work.' };
}
if (b < a) {
return { error: '"' + part + '" is backwards. Did you mean ' + b + '-' + a + '?' };
}
if (a > state.count) {
return {
error: 'Page ' + a + ' is past the end; this PDF has ' +
plural(state.count, 'page', 'pages') + '.'
};
}if (b > state.count) {
return {
error: 'Page ' + b + ' is past the end. Type ' + a +
'- to go to the last page.'
};
}
for (var n = a; n <= b; n++) {
out.push(n);
}
}
if (out.length > 500) {
return { error: 'That\'s ' + out.length + ' panels. Use 500 or fewer.' };
}
return { pages: out };
}该函数首先将输入转换为去除空格的字符串。随后使用逗号、分号或空格对选择内容进行拆分。
正则表达式用于检查每个条目是单个页码还是页码范围。例如,3表示第3页,而2-5表示第2至第5页。
该函数还支持开放式范围,如4-。在这种情况下,应用程序会使用state.count作为最终页码。
在将页码添加到结果之前,会检查页码是否从1开始、范围是否按升序排列,且请求的页码不超过PDF的总页数。
应用程序还限制自定义选择最多为500个面板。如果输入有效,函数将按用户输入的精确顺序返回页码数组。
随后,panels()函数在构建故事板时会使用此结果。如果用户选择全部页面而不是输入自定义列表,它会按原始顺序返回所有页面。
在从选定场景或重要幻灯片创建故事板而无需包含整个PDF时,此功能非常有用。
添加面板标签
面板标签帮助用户在查看或讨论故事板时识别单个页面。
应用程序支持不同的标签样式,包括数字、场景标签、原始PDF页码和无标签。
例如,故事板可以显示:
- 1, 2, 3, 4
- Scene 1, Scene 2, Scene 3
- Page 5, Page 6, Page 7
用户可以从面板标签设置中选择首选的标签样式。
应用程序使用labelFor()函数为每个面板生成适当的标签:
function labelFor(o, idx, n) {
if (o.label === 'panel') {
return String(idx + 1);
}
if (o.label === 'page') {
return 'Page ' + n;
}
if (o.label === 'scene') {
return 'Scene ' + (idx + 1);
}
return '';
}该函数接受三个参数:
- o包含故事板设置,包括所选标签样式。
- idx表示所选故事板序列中面板的位置,从0开始。
- n表示原始PDF的页码。
当用户选择面板编号选项时,idx + 1会生成如1、2、3等标签。
当用户选择页码选项时,函数使用n显示原始PDF页码。这在故事板包含按自定义顺序选择的页面时非常有用。
对于场景标签选项,函数会生成如Scene 1、Scene 2、Scene 3等标签。如果用户选择无标签,函数将返回空字符串。
绘图函数在渲染故事板图纸上的每个面板时会使用此结果。这有助于用户在不更改原始PDF页面的情况下识别单个面板。
绘制故事板图纸
一旦布局计算完成,应用程序就会在HTML画布上绘制故事板图纸。
绘图过程会将每个选定的PDF页面放置到其计算出的面板区域内。然后根据用户的设置添加面板标签和标题。
实际应用中,该过程使用异步的 drawSheet() 函数来处理。以下代码片段展示了它如何准备画布并选择属于该画布的页面:
async function drawSheet(ctx, o, list, L, sheetIdx, k, mode, getPic) {
var C = COLORS[o.colors] || COLORS.paper;
var W = L.W * k;
var H = L.H * k;
var token = state.loadToken;
var drawn = [];
ctx.save();
ctx.fillStyle = C.bg;
ctx.fillRect(0, 0, W, H);
ctx.textBaseline = 'alphabetic';
var start = sheetIdx * L.per;
var items = list.slice(start, start + L.per);该函数接收画布上下文、故事板设置、选中的页面列表、计算后的布局、画布索引和渲染比例。
它首先选择画布颜色并绘制背景。start 变量确定当前画布上的第一个面板,而 items 包含分配到该画布的 PDF 页面。
以下代码片段展示了应用程序如何将每个 PDF 页面适配到其面板内并获取其渲染后的图像:
for (var i = 0; i < items.length; i++) {
var cell = L.cells[i], n = items[i], idx = start + i;
var area = cell.img;
var strip = o.layout === 'strip';
if (strip) {
ctx.fillStyle = C.bandMat;
ctx.fillRect(
area.x * k, area.y * k,
area.w * k, area.h * k
);
} else if (o.frame) {
ctx.fillStyle = C.mat;
ctx.fillRect(
area.x * k, area.y * k,
area.w * k, area.h * k
);
}
var inset = strip ? 0 :
o.frame ? Math.min(area.w, area.h) * 0.04 : 0;
var pr = fitPage(n, area, inset);
var px = {
x: Math.round(pr.x * k),
y: Math.round(pr.y * k),
w: Math.max(1, Math.round(pr.w * k)),
h: Math.max(1, Math.round(pr.h * k))
};
drawn.push({ n: n, rect: pr });
if (mode === 'overlay') {
ctx.clearRect(px.x, px.y, px.w, px.h);
} else {
ctx.fillStyle = '#FFFFFF';
ctx.fillRect(px.x, px.y, px.w, px.h);
var pic = getPic ? await getPic(n, px.w, px.h) : null;
if (token !== state.loadToken) {
ctx.restore();
return null;
}
if (pic) {
ctx.drawImage(pic, px.x, px.y, px.w, px.h);
}
}
}fitPage() 函数计算将原始 PDF 页面适配到面板内所需的位置和尺寸,同时保持其比例不变。
应用程序随后使用 getPic() 获取渲染后的页面图像。如果图像可用,drawImage() 会将其绘制到故事板画布上。
该函数还支持叠加模式,该模式会使页面图像区域保持透明。这在导出 PDF 时保留原始 PDF 页面内容时非常有用。
绘制面板标签和说明文字
在定位页面预览后,应用程序会绘制面板标签和说明文字。
以下代码片段来自实际的 drawSheet() 函数,展示了如何在画布上绘制面板标签和说明文字:
var t = cell.text;
var fs = cell.fs * k;
var lh = cell.lh * k;
var y = t.y * k + fs;
var label = labelFor(o, idx, n);
ctx.textAlign = 'left';
if (label) {
ctx.font = '700 ' + fs + 'px ' + FONTS.mono;
ctx.fillStyle = C.ink;
ctx.fillText(label, t.x * k, y);
y += lh * 1.05;
}
var lines = [];
if (o.captions && captionFor(n)) {
ctx.font = '400 ' + fs + 'px ' + FONTS[o.font];
ctx.fillStyle = C.ink;var maxL = cell.notes ? Math.max(1, Math.floor( (t.y * k + t.h * k - y + lh - fs) / lh )) : o.lines;
lines = wrap( ctx, captionFor(n), t.w * k, Math.min(maxL, cell.notes ? 40 : o.lines) );
lines.forEach(function (ln, j) { ctx.fillText(ln, t.x * k, y + j * lh); }); }
labelFor() 函数用于生成所选面板的标签。应用程序随后使用 fillText() 将其绘制到画布上。
如果启用了字幕且存在字幕内容,应用程序会使用 captionFor() 获取字幕内容。wrap() 函数会将字幕拆分为适合面板可用空间的多行文本。
对于带有注释的面板布局,应用程序还会在字幕区域下方绘制分隔线。这为用户提供了额外的书写空间。
绘图过程将原始 PDF 页面预览与标签、字幕、边框及其他所选设置相结合,生成完整的分镜表单。
## 更新实时预览
最实用的功能之一是实时预览。用户可以在不每次生成新 PDF 的情况下,更改布局、纸张尺寸、方向、字幕、字体、间距及其他设置。
应用程序使用 board() 函数在绘制预览前计算当前的分镜表单配置。
以下是具体实现:
function board() { var sel = panels();
if (sel.error) { return { error: sel.error }; }
var L = layout(state.opts, sel.pages);
return { list: sel.pages, L: L }; }
该函数首先调用 panels() 获取所选 PDF 页面。如果选择过程中出现错误,函数将返回该错误而不是继续执行。
接下来,函数使用当前的分镜表单设置和所选页面调用 layout()。布局函数会计算页面在分镜表单上的排列方式。
最后,board() 返回一个包含所选页面列表和计算出的布局的对象。drawPreview() 函数使用这些信息将所选页面渲染到临时画布上。
绘制完成后,结果会被复制到可见的预览画布上。应用程序还会更新页码计数器(例如“第 1 页共 3 页”),并根据当前位置启用或禁用“上一页”和“下一页”按钮。
这使用户能够在分镜表单之间切换,并在下载结果前查看更改内容。
## 调整字幕显示样式
字幕有助于解释每页的内容。
应用程序提供了启用字幕、选择字体、调整字号、控制字幕行数的选项。
用户还可以选择是否显示面板边框和页码。
这些设置存储在 state.opts 中。syncPanel() 函数会将设置控件更新为与当前应用程序状态一致。
function syncPanel() { var o = state.opts;
['layout', 'cols', 'rows', 'paper', 'orient', 'label', 'lines', 'tsize', 'font', 'colors'].forEach(function (f) { q('[data-field="' + f + '"]').value = String(o[f]); });
q('[data-field="captions"]').checked = o.captions; q('[data-field="frame"]').checked = o.frame; q('[data-field="numbers"]').checked = o.numbers;
q('[data-field="gap"]').value = String(o.gap); q('[data-out="gap-val"]').textContent = o.gap + ' mm';
q('[data-field="pages"]').value = state.pages;
if (document.activeElement !== q('[data-field="title"]')) {
q('[data-field="title"]').value = state.title;
}
var strip = o.layout === 'strip';
q('[data-out="cols-label"]').textContent =
strip ? 'Frames per strip' : 'Columns';
q('[data-out="rows-label"]').textContent =
strip ? 'Strips per sheet' : 'Rows';
q('[data-field="lines"]').disabled =
!o.captions || o.layout === 'notes';
q('[data-field="frame"]').disabled = strip;
ui.listWrap.hidden = state.pages !== 'list';该函数从 state.opts 读取当前选项并更新相应的控件。例如,它设置所选字体、文本大小、字幕行数和纸张设置。
它还会处理特定布局的控件。在胶片条模式下,列和行标签会变为“每条胶片的帧数”和“每张纸的胶片数”。当关闭字幕或选择“带注释的面板”布局时,字幕行控件会被禁用。
在面板中适配字幕
长字幕需要适应可用的面板空间。应用程序使用一个 wrap() 辅助函数,根据可用画布宽度将文本分割成多行。
以下是实际绘图代码如何使用该辅助函数的示例:
if (o.captions && captionFor(n)) {
ctx.font = '400 ' + fs + 'px ' + FONTS[o.font];
ctx.fillStyle = C.ink;
var maxL = cell.notes
? Math.max(1, Math.floor(
(t.y * k + t.h * k - y + lh - fs) / lh
))
: o.lines;
lines = wrap(
ctx,
captionFor(n),
t.w * k,
Math.min(maxL, cell.notes ? 40 : o.lines)
);
lines.forEach(function (ln, j) {
ctx.fillText(ln, t.x * k, y + j * lh);
});
}应用程序使用 FONTS[o.font] 选择字体,并根据面板布局计算可用的字幕行数。
对于常规布局,所选的 o.lines 设置控制最大行数。对于“带注释的面板”,可用空间决定可以显示多少行。
wrap() 函数将字幕拆分为适合可用宽度的行。然后 fillText() 方法将每行绘制到画布上。
当没有足够的空间容纳所选字幕设置时,预览会显示警告,建议减少字幕行数、减少行数或使用更小的字体大小。
应用程序还支持面板帧和纸张编号。这些选项存储在应用程序状态中,并在绘制故事板时应用。
这使用户能够在不修改原始 PDF 的情况下,控制其故事板字幕的外观和可读性。
在故事板纸张之间导航
大型 PDF 可能需要多个故事板纸张。
应用程序提供“上一张”和“下一张”控件,使用户可以单独查看每张纸张。它还会显示当前纸张编号和总纸张数。
所选纸张存储在 state.sheet 中。应用程序使用此值来确定应显示哪张故事板纸张。
处理“上一张”和“下一张”按钮
应用程序在其主点击事件监听器中处理纸张导航。以下是实际实现:
case 'sheet-prev':
if (state.sheet > 0) {
state.sheet--;
drawPreview();
}
break;
case 'sheet-next':
state.sheet++;
drawPreview();
break;当用户点击“上一张”时,应用程序会检查当前的页码是否大于零。如果是,state.sheet 会减少 1,并调用 drawPreview() 刷新显示的页面。
当用户点击“下一张”时,页码会增加并刷新预览。
应用程序还会防止用户超出可用页面范围。在 drawPreview() 中,它会检查当前页面位置,并在需要时禁用导航按钮:
state.sheet = clamp(state.sheet, 0, L.sheets - 1);
ui.sheetPos.textContent =
'Sheet ' + (state.sheet + 1) + ' of ' + L.sheets;
q('[data-act="sheet-prev"]').disabled = state.sheet <= 0;
q('[data-act="sheet-next"]').disabled =
state.sheet >= L.sheets - 1;clamp() 函数用于将选中的页面限制在有效范围内。页面计数器显示当前位置(从 1 开始)以及总页数。
在第一页时,“上一张”按钮会被禁用,而最后一页时“下一张”按钮会被禁用。这使得用户可以更方便地查看大型文档,而无需一次性显示所有故事板页面。
使用 OCR 读取扫描页面
一些 PDF 文档包含可选文本,而另一些则包含印刷页面的扫描图像。
PDF.js 可以从包含实际文本数据的页面中提取文本。但它无法直接从仅包含图像的扫描页面中提取文字。
为了解决这些问题,应用程序提供了使用 Tesseract.js 的可选 OCR 功能。
当用户选择“使用 OCR 读取扫描页面”时,应用程序会识别尚未包含标题的扫描页面,并使用 OCR 引擎对其进行处理。
在需要时加载 Tesseract.js
应用程序仅在用户请求 OCR 时加载 Tesseract.js。它首先检查库是否已经可用,如果脚本仍在加载中,则重用现有的加载承诺。
以下是 loadTesseract() 的实际实现:
var tessPromise = null;
function loadTesseract() {
if (window.Tesseract) {
return Promise.resolve(window.Tesseract);
}
if (tessPromise) {
return tessPromise;
}
tessPromise = new Promise(function (resolve, reject) {
var s = document.createElement('script');
s.src = TESS + 'tesseract.min.js';
s.async = true;
s.onload = function () {
if (window.Tesseract) {
resolve(window.Tesseract);
} else {
tessPromise = null;
reject(new Error('engine'));
}
};
s.onerror = function () {
tessPromise = null;
reject(new Error('engine'));
};
document.head.appendChild(s);
setTimeout(function () {
reject(new Error('engine'));
}, 45000);
});
return tessPromise;
}该函数检查 window.Tesseract 以确定 OCR 库是否已经可用。如果可用,函数会立即返回该对象。
如果库仍在加载中,则返回现有的 tessPromise 而不是创建新的脚本请求。
否则,应用程序会创建一个脚本元素,将其源设置为 Tesseract.js 库,并将其添加到文档中。onload 和 onerror 处理程序用于检测加载是否成功或失败。
创建 OCR 工作线程
库加载完成后,应用程序会创建一个配置为识别英文文本的 Tesseract 工作线程。
以下是实际运行的 runOcr() 函数代码片段:
var T = await loadTesseract();
checkCancel();
var w = await T.createWorker('eng', 1, {
workerPath: TESS + 'worker.min.js',
corePath: TESS_CORE,
logger: function (m) {
if (!m || token !== state.loadToken || !state.busy) {
return;
}
if (/loading language/i.test(m.status)) {
setProgress(
m.progress || 0,
'Getting the English language data (first time only)…'
);
} else if (/recogniz/i.test(m.status)) {
setProgress(
(done + (m.progress || 0)) / list.length,
'Reading page ' + list[done] +
' (' + (done + 1) + ' of ' + list.length + ')…'
);
}
}
});
state.worker = w;
checkCancel();
await w.setParameters({ debug_file: '/dev/null' });createWorker() 方法使用英文语言数据初始化 OCR 引擎。worker 和 core 路径告诉 Tesseract.js 从何处加载其支持文件。
logger 用于报告语言加载和文字识别进度。应用程序使用这些信息在 OCR 运行时更新进度指示器。
从扫描页面中识别文字
应用程序会单独处理每个符合条件的扫描页面。在将页面发送给 Tesseract.js 之前,会先以更高分辨率渲染页面。
以下是 runOcr() 中实际的页面处理代码片段:
for (; done < list.length; done++) {
checkCancel();
var n = list[done],
page = await state.doc.getPage(n),
b = page.getViewport({ scale: 1 });
var c = await renderPage(
n,
Math.min(b.width * 300 / 72, 2600),
Math.min(b.height * 300 / 72, 2600)
);
checkCancel();
var png = await pngBytes(c);
c.width = 1;
var res = await w.recognize(png);
checkCancel();
if (token !== state.loadToken) {
return;
}
var cap = captionFromText(res.data && res.data.text);
if (cap && !captionFor(n)) {
state.captions[n] = cap;
var ta = ui.grid.querySelector('[data-cap="' + n + '"]');
if (ta) {
ta.value = cap;
}
}
}该函数获取每个扫描的 PDF 页面并计算其原始尺寸。然后以约 300 DPI 的分辨率渲染页面,最大尺寸限制为 2600 像素。
pngBytes() 辅助函数将渲染后的画布转换为 PNG 图像数据。Tesseract.js 通过 w.recognize(png) 接收这些数据并返回识别出的文字。
应用程序将识别出的文字传递给 captionFromText() 进行清理和缩短。如果结果有用且页面尚未添加标题,应用程序会将其保存在 state.captions 中并更新对应的标题字段。
在更新结果前,应用程序还会检查是否已取消操作并验证 PDF 加载操作是否仍然有效。
处理完成后,应用程序会显示一条消息,提示用户查看生成的标题。OCR 无法保证能正确识别每个单词。图像质量、手写体、特殊字体和页面方向可能会影响结果。
在下载故事板之前,用户应检查生成的标题。
生成最终的故事板 PDF
当用户对布局和标题满意后,应用程序可以生成最终的 PDF。
该流程使用 PDF-lib 创建新的 PDF 文档。应用程序为每张故事板画布生成一个输出页面,然后将原始 PDF 页面放置到计算出的面板位置,并添加故事板的标题、标签和说明文字。
创建 PDF 文档
实际应用中使用 exportPdf() 函数生成故事板。首先创建新的 PDF 文档,并检查原始 PDF 页面是否可以作为矢量内容嵌入。
以下是实际实现的第一部分:
async function exportPdf(snap, token) {
await engine();
var PL = window.PDFLib,
L = snap.L,
o = snap.o,
list = snap.list;
var out = await PL.PDFDocument.create(),
src = null,
embedded = {};
if (state.vector) {
try {
src = await PL.PDFDocument.load(
state.bytes.slice(0),
{ updateMetadata: false }
);
} catch (e) {
src = null;
}
}
var k = exportScale(L, 300, 14e6);
for (var s = 0; s < L.sheets; s++) {
checkCancel();
if (token !== state.loadToken) {
return;
}
setProgress(
s / L.sheets,
'Making sheet ' + (s + 1) + ' of ' + L.sheets + '…'
);
var page = out.addPage([L.W, L.H]);
var c = document.createElement('canvas');
c.width = Math.round(L.W * k);
c.height = Math.round(L.H * k);
var drawn = await drawSheet(
c.getContext('2d'),
o,
list,
L,
s,
k,
'overlay',
null
);
if (!drawn) {
return;
}该函数首先通过 engine() 等待所需的 PDF 库。然后使用 PDFDocument.create() 创建新的 PDF 文档。
snap 参数包含所选布局、选项和页面列表的快照。应用程序使用这些值确保导出符合用户选择的设置。
state.vector 检查确定原始 PDF 是否可以通过 PDF-lib 进行矢量嵌入。应用程序还会计算一个以 300 DPI 为目标的渲染比例,同时受最大像素限制约束。
循环为每个故事板画布创建一个输出 PDF 页面。同时以叠加模式调用 drawSheet(),为原始 PDF 页面上要放置的标题、面板标签和说明文字做准备。
保留原始 PDF 页面
当支持矢量嵌入时,应用程序会直接嵌入原始 PDF 页面,而不是将其转换为普通图像。
以下代码片段展示了如何处理每个选定的面板:
for (var i = 0; i < drawn.length; i++) {
checkCancel();
var d = drawn[i],
r = d.rect,
yb = L.H - r.y - r.h;
page.drawRectangle({
x: r.x,
y: yb,
width: r.w,
height: r.h,
color: PL.rgb(1, 1, 1)
});
if (src) {
var sp = src.getPage(d.n - 1);
if (!embedded[d.n]) {
var cb = sp.getCropBox();
embedded[d.n] = await out.embedPage(sp, {
left: cb.x,
bottom: cb.y,
right: cb.x + cb.width,
top: cb.y + cb.height
});
}
var em = embedded[d.n],
rot = ((sp.getRotation().angle % 360) + 360) % 360;var turned = rot === 90 || rot === 270,
sx = r.w / (turned ? em.height : em.width);
var ew = em.width * sx,
eh = em.height * sx,
at = { x: r.x, y: yb };
if (rot === 90) {
at = { x: r.x, y: yb + ew };
} else if (rot === 180) {
at = { x: r.x + ew, y: yb + eh };
} else if (rot === 270) {
at = { x: r.x + eh, y: yb };
}
page.drawPage(em, {
x: at.x,
y: at.y,
width: ew,
height: eh,
rotate: PL.degrees(-rot)
});应用程序使用页面编号获取原始PDF页面,然后通过 embedPage() 方法将该页面嵌入到新PDF文档中。
嵌入对象会缓存已嵌入的页面,因此无需重复嵌入相同的原始页面。
代码还会检查原始页面的旋转角度,并在绘制前调整其位置和尺寸。这有助于在将页面放置到故事板面板时保持正确的方向。
处理受保护的PDF
如果原始PDF无法作为矢量内容嵌入,应用程序会使用位图回退方案。
以下是实际的回退代码:
else {
var pic = await renderPage(
d.n,
r.w * k,
r.h * k
);
var jpg = await new Promise(function (res) {
pic.toBlob(function (b) {
b.arrayBuffer().then(function (a) {
res(new Uint8Array(a));
});
}, 'image/jpeg', 0.92);
});
pic.width = 1;
page.drawImage(
await out.embedJpg(jpg),
{
x: r.x,
y: yb,
width: r.w,
height: r.h
}
);
}在这种情况下,应用程序将原始PDF页面渲染到画布上,并将其转换为JPEG图像数据。PDF-lib随后会将图像嵌入到对应的故事板面板中。
当矢量嵌入不可用时(包括无法遵循常规矢量工作流程的受保护PDF),会使用此回退方案。
添加标题和保存PDF
在原始页面图像或矢量内容放置完成后,应用程序会将故事板的标题、标签、说明文字和其他绘图元素作为叠加层添加到页面上。
以下代码片段展示了如何添加叠加层并保存最终的PDF文件:
var over = await out.embedPng(await pngBytes(c));
c.width = 1;
page.drawImage(over, {
x: 0,
y: 0,
width: L.W,
height: L.H
});
await nextFrame();在所有页面处理完成后,应用程序会检查是否取消操作并准备最终的PDF文件:
checkCancel();
setProgress(1, 'Saving the PDF…');
out.setTitle(state.title || state.base + ' storyboard');
out.setCreator('AllInOneTools PDF Storyboard');
out.setProducer('AllInOneTools (pdf-lib)');
var bytes = await out.save();
if (token !== state.loadToken) {
return;
}
save(
new Blob([bytes], { type: 'application/pdf' }),
state.base + '-storyboard.pdf'
);
toast(
'Saved ' + plural(L.sheets, 'sheet', 'sheets') +
' as ' + state.base + '-storyboard.pdf.'
);embedPng() 方法将故事板叠加层添加到PDF页面上。该叠加层包含标题、面板标签、说明文字和其他视觉元素。
随后应用程序设置PDF元数据,将文档保存为字节流,并生成可下载的PDF文件。
在整个导出过程中都会使用进度更新和取消检查,这在生成包含多张分页的故事板时尤其有用。
最终生成的PDF将原始PDF页面与故事板布局和说明文字合并,可随时下载、分享或打印。
下载PNG故事板分页
不需要PDF格式的用户可以选择PNG分页格式。
应用程序会以200 DPI的分辨率将每张完整的故事板分页渲染为PNG图像。如果故事板只包含一张分页,浏览器将直接下载单个PNG文件。如果包含多张分页,应用程序会将它们打包成ZIP压缩包。
以PNG格式导出故事板
应用程序在exportJob()函数中处理PNG格式导出。首先计算渲染比例,然后依次处理每张故事板分页。
以下代码片段展示了实际的PNG导出实现:
var k = exportScale(L, 200, 16e6),
files = [];
for (var s = 0; s < L.sheets; s++) {
checkCancel();
setProgress(
s / L.sheets,
'Drawing sheet ' + (s + 1) + ' of ' + L.sheets + '…'
);
var c = document.createElement('canvas');
c.width = Math.round(L.W * k);
c.height = Math.round(L.H * k);
var ok = await drawSheet(
c.getContext('2d'),
o,
list,
L,
s,
k,
'full',
function (n, w, h) {
checkCancel();
return renderPage(n, w, h);
}
);
if (!ok) { return; }
files.push({
name: state.base + '-storyboard-sheet-' +
pad2(s + 1) + '.png',
data: await pngBytes(c)
});
c.width = 1;
}
if (files.length === 1) {
save(
new Blob([files[0].data], { type: 'image/png' }),
state.base + '-storyboard.png'
);
} else {
save(makeZip(files), state.base + '-storyboard-sheets.zip');
}
toast(
files.length === 1
? 'Saved the storyboard as a PNG.'
: 'Saved ' + files.length + ' sheets as PNG files in a ZIP.'
);应用程序使用exportScale()计算适合200 DPI的渲染比例,同时确保画布像素数不超过1600万的最大限制。
对于每张分页,应用程序会创建画布并以完整模式调用drawSheet()。这会同时绘制PDF页面预览以及故事板标题、标签、说明文字和其他选定设置。
辅助函数pngBytes()将完成的画布转换为PNG数据。每个图像会以包含分页编号的文件名添加到文件数组中。
处理完所有分页后,应用程序会检查生成的PNG文件数量。单张分页会直接以PNG格式下载,多张分页则通过makeZip()打包成ZIP压缩包。
这种格式适用于在演示文稿、消息和其他应用程序中分享故事板预览。
下载单页图片
第三种导出选项是页面图片(ZIP)。
与PNG分页选项不同,这种导出方式包含故事板所选PDF页面的独立图片。
应用程序会单独渲染每张选定页面,并将生成的PNG文件放入ZIP压缩包。
导出单个PDF页面
实际应用在exportJob()函数中处理此选项。首先创建选定页面的唯一列表,然后单独渲染每一页。
var pages = unique(list),
out = [];
for (var i = 0; i < pages.length; i++) {
checkCancel();
setProgress(
i / pages.length,
'Saving page ' + pages[i] +
' (' + (i + 1) + ' of ' + pages.length + ')…'
);
var pg = await state.doc.getPage(pages[i]),
vb = pg.getViewport({ scale: 1 }),
sc = Math.min(
2,
Math.sqrt(12e6 / (vb.width * vb.height))
);
var pc = await renderPage(
pages[i],
vb.width * sc,
vb.height * sc
);
out.push({
name: 'panel-' +
pad2(list.indexOf(pages[i]) + 1) +
'-page-' + pad2(pages[i]) + '.png',
data: await pngBytes(pc)
});
pc.width = 1;
}
save(makeZip(out), state.base + '-panels.zip');
toast(
'Saved ' +
plural(out.length, 'page picture', 'page pictures') +
' in a ZIP.'
);该函数首先调用 unique() 方法从所选列表中移除重复的页码。
随后对每一页进行单独处理。getPage() 方法获取原始 PDF 页面,getViewport() 方法获取其尺寸。
缩放比例计算将渲染比例限制为 2,同时保持渲染后的页面大小在约 1200 万像素以内。这有助于在处理大型页面时控制内存使用。
renderPage() 函数生成页面图像,而 pngBytes() 函数将画布转换为 PNG 数据。
每个图像都会以包含其面板位置和原始 PDF 页码的文件名添加到 out 数组中。这使得图片更容易识别并保持故事板的顺序。
最后,makeZip() 函数将所有生成的 PNG 图像打包成 ZIP 压缩包,浏览器会下载该文件。
当用户需要单独处理 PDF 页面图片而非完整的故事板图纸时,此选项非常有用。
性能与重要注意事项
渲染大型 PDF 和生成高分辨率图像会消耗大量浏览器内存。
应用程序通过页面预览缓存、临时画布、进度报告和取消控制来管理这些操作。
为了获得更好的效果,处理大型文档时请减少每张图纸的面板数量。使用 A3 纸张也可以在故事板包含大量面板时提供更多空间。
请记住,布局偏好会保存在设备上,但 PDF 和标题仍保留在当前浏览器标签页中。关闭标签页前请先下载您的工作成果。
示例:PDF 故事板生成器
您可以通过以下链接尝试完整应用:
PDF 故事板生成器 – AllInOneTools
上传 PDF、排列页面、添加标题、自定义故事板并下载最终结果。
结论
构建 PDF 故事板生成器将多种有用的浏览器技术整合到一个应用中。
PDF.js 负责 PDF 加载和页面渲染。Tesseract.js 为扫描页面提供可选的文本识别功能。PDF-lib 创建最终的故事板 PDF,而 HTML 画布处理预览和图像导出。
通过 JavaScript 将这些组件连接起来,我们可以创建一个实用工具,用于整理演示文稿幻灯片、漫画页面、剧本和其他 PDF 文档。
该项目还展示了基于浏览器的应用程序如何在不将用户文件上传到服务器的情况下本地处理文档。
有了完整的流程,用户可以将普通的 PDF 页面转换为更易于查看、打印和分享的有序故事板图纸。
推荐课程(来自合作伙伴,1/14)
(在新标签页中打开)
ADVERTISEMENT
- 在Coursera上 Adobe PDF基础 商务专业人士 4周,每周1小时 初级 证书 查看课程(在新标签页中打开)
- 在Udemy上 前端网页开发 现代HTML CSS JavaScript Laurence Svekis 4.5(满分5分)(6,608人评价)来自6,608条评价 12小时13分钟 初级 证书 查看课程(在新标签页中打开)
- 在Coursera上 利用Google Sheets实现更多功能 Google Cloud培训 4.6(满分5分)(1,398人评价)来自1,398条评价 5周,每周1小时 初级 证书 查看课程(在新标签页中打开)
- 在Udemy上 掌握Spring Boot中的Thymeleaf John Thompson 4.1(满分5分)(1,154人评价)来自1,154条评价 4小时49分钟 初级 证书 查看课程(在新标签页中打开)
Class Central上更多HTML & CSS课程
→
合作伙伴推荐课程(侧边栏,第2页,共14页)
- 在Udemy上 Web开发课程 HTML CSS JavaScript 学习网页设计 Laurence Svekis 4.2(满分5分)(5,748人评价)来自5,748条评价 5小时56分钟 初级 查看课程(在新标签页中打开)
- 在Udemy上 Java Spring Security Trevor Page 4.5(满分5分)(1,691人评价)来自1,691条评价 2小时54分钟 中级 证书 查看课程(在新标签页中打开)
- 在Udemy上 Autodesk Inventor完整指南 从入门到专家 Marius Brink 4.6(满分5分)(1,239人评价)来自1,239条评价 1天1小时57分钟 初级 证书 查看课程(在新标签页中打开)
- 在Coursera上 Facebook Creator Studio入门 Yasmeen Atwa 1小时37分钟 中级 证书 查看课程(在新标签页中打开)
合作伙伴推荐课程(侧边栏,第3页,共14页)
- 在DataCamp上 Google Workspace End User: Google Sheets Google Cloud 4.9(满分5分)(25人评价)来自25条评价 7小时 初级 证书 查看课程(在新标签页中打开)
- 在Coursera上 构建并分析Node.js网站 EDUCBA 2周,每周2小时 初级 证书 查看课程(在新标签页中打开)
合作伙伴推荐课程(侧边栏,第4页,共14页)
合作伙伴推荐课程(侧边栏,第5页,共14页)
合作伙伴推荐课程(侧边栏,第6页,共14页)
合作伙伴推荐课程(侧边栏,第7页,共14页)
合作伙伴推荐课程(侧边栏,第8页,共14页)
合作伙伴推荐课程(侧边栏,第9页,共14页)
合作伙伴推荐课程(侧边栏,第10页,共14页)
合作伙伴推荐课程(侧边栏,第11页,共14页)
合作伙伴推荐课程(侧边栏,第12页,共14页)
合作伙伴推荐课程(侧边栏,第13页,共14页)
合作伙伴推荐课程(侧边栏,第14页,共14页)
AllInOneTools.net创始人——打造简单、免费、无需登录的网络工具,解决日常问题。专注于实用工具、SEO、效率提升,以及公开发布有用软件。基于实际经验撰写内容,同时构建和运营AllInOneTools。
如果你读到这里,请向作者表达感谢以示支持。说声谢谢
免费学习编程。freeCodeCamp的开源课程已帮助超过40,000人成为开发者。立即开始
合作伙伴推荐课程