Add links to surrounding pages in --map option

Also draw a boundary

package.json

@@ -56,6 +56,7 @@
     "typescript": "^3.7.5"
   },
   "dependencies": {
+    "@types/pdfkit": "^0.11.2",
     "axios": "^0.19.2",
     "axios-rate-limit": "^1.3.0",
     "chalk": "^4.1.2",
@@ -63,6 +64,7 @@
     "gm": "^1.23.1",
     "haversine": "^1.1.1",
     "merge-img": "^2.1.3",
-    "minimist": "^1.2.0"
+    "minimist": "^1.2.0",
+    "pdfkit": "^0.12.3"
   }
 }

src/config.ts

@@ -19,7 +19,7 @@ interface BaseConfig extends ModeConfig {
   tmp: string;
 }
 
-interface MapConfig extends BaseConfig {
+export interface MapConfig extends BaseConfig {
   mode: 'map';
   north: number;
   west: number;

src/map.ts

@@ -1,8 +1,12 @@
-import { lat2tile, lon2tile, getTileSize } from './osm';
+import { lat2tile, lon2tile, getTileSize, lat2tileExact, lon2tileExact } from './osm';
 import { TileServer, Page } from './types';
-import { createPdf } from './pdf';
+import { createPdf, PDFOptions } from './pdf';
 import { downloadPages } from './download';
-import { clearTmp } from './utils';
+import { clearTmp, getFilename } from './utils';
+import { TILE_SIZE } from './route';
+import { MapConfig } from './config';
+import gm from 'gm';
+import log from './log';
 
 // main executable function
 export default async function map({
@@ -32,13 +36,72 @@ export default async function map({
   const pages: Page[] = boundaries2pages({ north, west, south, east, pageSizeX, pageSizeY, zoom });
   // download pages
   await downloadPages(pages, tmp, tileServer);
+  // draw boundary
+  await drawBoundary(pages, { north, west, south, east, zoom, tmp, pageSizeX, pageSizeY });
   // create pdf
-  await createPdf(output, tmp);
+  await createPdf(output, tmp, {
+    pageSizeX,
+    pageSizeY,
+    links: boundaries2links({ north, west, south, east, pageSizeX, pageSizeY, zoom }),
+  });
   // clean up downloaded pages
   await clearTmp(tmp);
 }
 
-function boundaries2pages({
+const drawBoundary = async (
+  pages: Page[],
+  {
+    north,
+    west,
+    south,
+    east,
+    zoom,
+    tmp,
+    pageSizeX,
+    pageSizeY,
+  }: Pick<MapConfig, 'north' | 'west' | 'south' | 'east' | 'zoom' | 'tmp' | 'pageSizeX' | 'pageSizeY'>,
+): Promise<void> => {
+  const tileBoundary = {
+    north: lat2tileExact(north, zoom),
+    south: lat2tileExact(south, zoom),
+    east: lon2tileExact(east, zoom),
+    west: lon2tileExact(west, zoom),
+  };
+
+  for (let i = 0, len = pages.length; i < len; ++i) {
+    log(`drawing boundary ${i + 1}/${len}`);
+    const page = pages[i];
+    const filename = getFilename(tmp, i);
+    const control = gm(filename);
+
+    const pixelBoundary = {
+      north: (tileBoundary.north - page.y) * TILE_SIZE,
+      south: (tileBoundary.south - page.y) * TILE_SIZE,
+      east: (tileBoundary.east - page.x) * TILE_SIZE,
+      west: (tileBoundary.west - page.x) * TILE_SIZE,
+    };
+
+    // draw boundary
+    const maxWidth = Math.max(pageSizeX, pageSizeY) * TILE_SIZE;
+    control.stroke('#000a', maxWidth).fill('#000f');
+    control.drawRectangle(
+      pixelBoundary.west - maxWidth / 2,
+      pixelBoundary.north - maxWidth / 2,
+      pixelBoundary.east + maxWidth / 2,
+      pixelBoundary.south + maxWidth / 2,
+    );
+
+    await new Promise<void>((resolve, reject) => {
+      // draw it
+      control.write(filename, err => {
+        if (err) return reject(err);
+        else return resolve();
+      });
+    });
+  }
+};
+
+const boundaries2links = ({
   north,
   west,
   south,
@@ -54,21 +117,95 @@ function boundaries2pages({
   pageSizeX: number;
   pageSizeY: number;
   zoom: number;
-}) {
-  const x = lon2tile(west, zoom);
-  const y = lat2tile(north, zoom);
+}): PDFOptions['links'] => {
+  const { width, height } = boundaries2size({ north, west, south, east, pageSizeX, pageSizeY, zoom });
 
+  const links: PDFOptions['links'] = [];
+  const pageSize = { width: pageSizeX * TILE_SIZE, height: pageSizeY * TILE_SIZE };
+  const breakPoints = {
+    x: [0, 0.25 * pageSize.width, 0.75 * pageSize.width, pageSize.width],
+    y: [0, 0.25 * pageSize.height, 0.75 * pageSize.height, pageSize.height],
+  };
+  for (let i = 0, len = width * height; i < len; ++i) {
+    const linksForPage: PDFOptions['links'][number] = [];
+    for (const yi of [-1, 0, 1]) {
+      for (const xi of [-1, 0, 1]) {
+        const url = i + yi * width + xi;
+        const x = breakPoints.x[xi + 1];
+        const y = breakPoints.y[yi + 1];
+        const w = breakPoints.x[xi + 2] - breakPoints.x[xi + 1];
+        const h = breakPoints.y[yi + 2] - breakPoints.y[yi + 1];
+        if (
+          url >= 0 &&
+          url < len &&
+          // we don't want to link to page itself
+          url !== i &&
+          // we don't want to go beyond left and right edges
+          url % width === (i % width) + xi &&
+          // we don't want to go beyond top and bottom edges
+          Math.floor(url / width) % height === (Math.floor(i / width) % height) + yi
+        ) {
+          linksForPage.push({ x, y, width: w, height: h, url });
+        }
+      }
+    }
+    links.push(linksForPage);
+  }
+  return links;
+};
+
+const boundaries2size = ({
+  north,
+  west,
+  south,
+  east,
+  pageSizeX,
+  pageSizeY,
+  zoom,
+}: {
+  north: number;
+  west: number;
+  south: number;
+  east: number;
+  pageSizeX: number;
+  pageSizeY: number;
+  zoom: number;
+}): { width: number; height: number } => {
   const { width, height } = getTileSize({ north, west, south, east, zoom });
+  return {
+    width: Math.ceil(width / pageSizeX),
+    height: Math.ceil(height / pageSizeY),
+  };
+};
 
-  const pagesX = Math.ceil(width / pageSizeX);
-  const pagesY = Math.ceil(height / pageSizeY);
+function boundaries2pages({
+  north,
+  west,
+  south,
+  east,
+  pageSizeX,
+  pageSizeY,
+  zoom,
+}: {
+  north: number;
+  west: number;
+  south: number;
+  east: number;
+  pageSizeX: number;
+  pageSizeY: number;
+  zoom: number;
+}) {
+  const { width, height } = boundaries2size({ north, west, south, east, zoom, pageSizeX, pageSizeY });
 
-  console.log('size', pagesX, 'x', pagesY, 'pages'); // tslint:disable-line:no-console
+  console.log('size', width, 'x', height, 'pages'); // tslint:disable-line:no-console
 
   const pages: Page[] = [];
 
-  for (let py = 0; py < pagesY; py++) {
-    for (let px = 0; px < pagesX; px++) {
+  const x = lon2tile(west, zoom);
+  const y = lat2tile(north, zoom);
+
+  for (let py = 0; py < height; py++) {
+    for (let px = 0; px < width; px++) {
       pages.push({
         x: x + px * pageSizeX,
         y: y + py * pageSizeY,

src/pdf.ts

@@ -1,13 +1,46 @@
-import gm from 'gm';
+import PDFDocument from 'pdfkit';
 import log from './log';
+import fs from 'fs-extra';
+import path from 'path';
 
-export async function createPdf(output: string, tmp: string) {
+export interface PDFOptions {
+  pageSizeX: number;
+  pageSizeY: number;
+  links: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    url: string | number;
+  }[][];
+}
+
+export async function createPdf(output: string, tmp: string, { pageSizeX, pageSizeY, links }: PDFOptions) {
   log('Creating pdf');
-  await new Promise((resolve, reject) => {
-    gm(`${tmp}/*.png`).write(`${output}.pdf`, err => {
-      if (!err) return resolve();
-      if (err) return reject(err);
-    });
+  const files = await fs.readdir(tmp);
+  await new Promise<void>((resolve, reject) => {
+    const doc = new PDFDocument({ margin: 0, size: [256 * pageSizeX, 256 * pageSizeY], bufferPages: true });
+    const stream = doc.pipe(fs.createWriteStream(`${output}.pdf`));
+    let first = true;
+    for (const file of files) {
+      if (!first) {
+        doc.addPage();
+      } else {
+        first = !first;
+      }
+      doc.image(path.join(tmp, file));
+    }
+    for (let i = 0, len = links.length; i < len; ++i) {
+      doc.switchToPage(i);
+      for (const link of links[i]) {
+        const { x, y, width, height, url } = link;
+        doc.link(x, y, width, height, url as string);
+      }
+    }
+    doc.end();
+
+    stream.on('finish', resolve);
+    stream.on('error', reject);
   });
   // eslint-disable-next-line: no-console
   log(`Your map was saved to ${output}.pdf\n`);

src/route.ts

@@ -10,7 +10,7 @@ import { Tile, Page, TileServer } from './types';
 import { downloadPages } from './download';
 import { Coordinate, parseRoute } from './parse-route';
 
-const TILE_SIZE = 256;
+export const TILE_SIZE = 256;
 
 interface TileWithDistance extends Tile {
   distance: number;
@@ -74,7 +74,12 @@ export default async function path({
   }
 
   // make pdf from pages
-  await createPdf(output, tmp);
+  const options = {
+    pageSizeX,
+    pageSizeY,
+    links: [],
+  };
+  await createPdf(output, tmp, options);
   await clearTmp(tmp);
 }