Also draw a boundary

README.md

@@ -2,7 +2,7 @@
 
 Generate pdf with [OpenStreetMap](https://openstreetmap.org) tiles.
 
-![example output of osm2pdf with --path parameter](https://git.mrkvon.org/mrkvon/osm2pdf/raw/branch/master/example.png)
+![example output of osm2pdf with --route parameter](https://git.mrkvon.org/mrkvon/osm2pdf/raw/branch/master/example.png)
 
 ## Video
 
@@ -24,20 +24,15 @@ sudo npm install -g osm2pdf
 You need to provide a route in gpx format. You can download it on [graphhopper website](https://graphhopper.com/maps/). Find your route and click _GPX export_ button.
 
 ```bash
-osm2pdf --route --zoom=10 --input=path/to/route.gpx --output=path/to/output
+osm2pdf --route --zoom=10 --input=path/to/route.gpx --output=path/to/output --tile-server=1
 ```
 
-or if you want to also draw the path on the map
-
-```bash
-osm2pdf --path --zoom=10 --input=path/to/route.gpx --output=path/to/output --distance --distance-step=20
-```
 ### Download a map
 
 You need to provide boundaries of the area you want to download.
 
 ```bash
-osm2pdf --north=70.923 --west=-4.373 --south=55.756 --east=27.872 --zoom=9 --output=path/to/output
+osm2pdf -n=70.923 -w=-4.373 -s=55.756 -e=27.872 --zoom=9 --output=path/to/output --tile-server=2
 ```
 
 ## Help

package.json

@@ -56,11 +56,15 @@
     "typescript": "^3.7.5"
   },
   "dependencies": {
+    "@types/pdfkit": "^0.11.2",
     "axios": "^0.19.2",
+    "axios-rate-limit": "^1.3.0",
+    "chalk": "^4.1.2",
     "fs-extra": "^8.1.0",
     "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

@@ -0,0 +1,128 @@
+import minimist from 'minimist';
+import { TileServer } from './types';
+import { servers, parseUrl } from './tile-servers';
+// TODO json-schema validation of input
+
+// Generic options
+type Mode = 'help' | 'map' | 'route' | 'tiles';
+
+interface ModeConfig {
+  mode: Mode;
+}
+
+interface BaseConfig extends ModeConfig {
+  zoom: number;
+  output: string;
+  tileServer: TileServer;
+  pageSizeX: number;
+  pageSizeY: number;
+  tmp: string;
+}
+
+export interface MapConfig extends BaseConfig {
+  mode: 'map';
+  north: number;
+  west: number;
+  south: number;
+  east: number;
+}
+
+interface RouteConfig extends BaseConfig {
+  mode: 'route';
+  input: string;
+  draw: boolean;
+  distance: boolean;
+  distanceStep: number;
+}
+
+interface HelpConfig extends ModeConfig {
+  mode: 'help';
+}
+
+interface TilesConfig extends ModeConfig {
+  mode: 'tiles';
+}
+
+export default function getConfig(): MapConfig | RouteConfig | HelpConfig | TilesConfig {
+  const helpConfig: HelpConfig = { mode: 'help' };
+  const tilesConfig: TilesConfig = { mode: 'tiles' };
+
+  const argv = minimist(process.argv.slice(2));
+
+  if (argv.h || argv.help) {
+    return helpConfig;
+  }
+
+  if (argv['list-tile-servers']) {
+    return tilesConfig;
+  }
+
+  if (argv.route || argv.map) {
+    const baseConfig = {
+      zoom: argv.zoom ?? 12,
+      pageSizeX: argv.x ?? 4,
+      pageSizeY: argv.y ?? 5,
+      tileServer: getTileServer(argv['tile-server'], argv['rate-limit']),
+      tmp: argv.tmp ?? `tmp${Date.now()}`,
+    };
+
+    if (argv.route) {
+      const input = argv.input;
+      if (!input) return helpConfig;
+
+      return {
+        ...baseConfig,
+        mode: 'route',
+        input,
+        draw: !!(argv.path ?? true),
+        distance: !!(argv.distance ?? true),
+        distanceStep: argv['distance-step'] ?? 10,
+        output:
+          argv.output ||
+          `route-${input
+            .split('.')
+            .slice(0, -1)
+            .join('.')}-${baseConfig.zoom}`,
+      };
+    }
+
+    if (argv.map) {
+      const north: number = argv.n;
+      const west: number = argv.w;
+      const south: number = argv.s;
+      const east: number = argv.e;
+
+      if (
+        typeof north !== 'number' ||
+        typeof south !== 'number' ||
+        typeof east !== 'number' ||
+        typeof west !== 'number'
+      )
+        return helpConfig;
+
+      const output = argv.output ?? `map_${north}_${west}_${south}_${east}_${baseConfig.zoom}`;
+      return {
+        ...baseConfig,
+        mode: 'map',
+        north,
+        south,
+        west,
+        east,
+        output,
+      };
+    }
+  }
+
+  return helpConfig;
+}
+
+function getTileServer(server: string | number, rateLimit: number = 10): TileServer {
+  if (typeof server === 'number') {
+    return servers[server - 1];
+  } else {
+    return {
+      url: parseUrl(server),
+      rateLimit,
+    };
+  }
+}

src/download.ts

@@ -0,0 +1,72 @@
+import { Page, TileServer, Tile } from './types';
+import { getHttp } from './http';
+import fs from 'fs-extra';
+import mergeImg from 'merge-img';
+import log from './log';
+import { getFilename, fileExists } from './utils';
+
+// This is the main exported function. Provide pages, folder and server to dowload from and it fills the tmp folder with the pages
+export async function downloadPages(pages: Page[], tmp: string, tileServer: TileServer) {
+  await fs.ensureDir(tmp);
+  const http = getHttp(tileServer.rateLimit);
+  for (let i = 0, len = pages.length; i < len; i++) {
+    const filename = getFilename(tmp, i);
+    if (!(await fileExists(filename))) {
+      const page = pages[i];
+      const info = `downloading page ${i + 1}/${pages.length}`;
+      const pageTiles = await getPage(page, { http, tileServer }, info);
+      await savePage(pageTiles, filename);
+    }
+  }
+}
+
+// download a single tile
+async function getTile(
+  { x, y, zoom: z }: Tile,
+  { http, tileServer }: { http: any; tileServer: TileServer },
+): Promise<Buffer> {
+  return Buffer.from(
+    (
+      await http.get(tileServer.url({ z, x, y }), {
+        responseType: 'arraybuffer',
+        headers: {
+          'User-Agent': 'osm2pdf',
+        },
+      })
+    ).data,
+    'binary',
+  );
+}
+
+async function getPage(
+  { x, y, sx, sy, zoom }: Page,
+  { http, tileServer }: { http: any; tileServer: TileServer },
+  info: string,
+): Promise<Buffer[][]> {
+  let progress = 0;
+  log(info, `[${'.'.repeat(progress)}${' '.repeat(sx * sy - progress)}]`);
+  const rows: Promise<Buffer[]>[] = [];
+  for (let i = 0; i < sx; i++) {
+    const row: Promise<Buffer>[] = [];
+    for (let j = 0; j < sy; j++) {
+      row.push(
+        getTile({ x: x + i, y: y + j, zoom }, { http, tileServer }).then(tile => {
+          log(info, `[${'.'.repeat(++progress)}${' '.repeat(sx * sy - progress)}]`);
+          return tile;
+        }),
+      );
+    }
+    rows.push(Promise.all(row));
+  }
+  return await Promise.all(rows);
+}
+
+async function mergeTiles(tiles: Buffer[][]): Promise<any> {
+  const row = await Promise.all(tiles.map(column => mergeImg(column, { direction: true })));
+  return await mergeImg(row);
+}
+
+async function savePage(pageTiles: Buffer[][], output: string): Promise<void> {
+  const image = await mergeTiles(pageTiles);
+  await new Promise(resolve => image.write(output, resolve));
+}

src/help.ts

@@ -4,38 +4,77 @@ Export OpenStreetMap to pdf
 Usage:
 osm2pdf [options]
 
+=== Generic options (for Route and Area methods) ===
+
+--zoom          map zoom (default 12)
+--tile-server   url or number of the tile server (see also \`osm2pdf --list-tile-servers\`)
+                  find more tile servers at https://wiki.openstreetmap.org/wiki/Tile_servers
+                  please respect tile usage policies. download responsibly.
+--rate-limit    how many tiles per second can be downloaded (default 10)
+--output        name of the generated pdf file (".pdf" will be attached, existing files will be overwritten)
+-x              tiles per page horizontally (default 4)
+-y              tiles per page vertically (default 5)
+--tmp           temporary folder to save downloaded tiles to (default tmp[timestamp])
+                  if the folder doesn't exist, it will be created
+                  you can resume failed download with this option
+                  use carefully! folder will be deleted after successful download
+
+
+=== Methods ===
+
+=== Route ===
+
+Download route, given route coordinates in GPX format
+
 Options:
--h, --help                print this page
---route                   (optional) download the route
-                          you can download the GPX route file from https://graphhopper.com/maps/
-                          find the desired route and click "GPX export" (gpx button)
---path                    (optional) download the route and draw the path on it
-                          similar to --route option
---distance                (optional with --path option) write labels with distance in kilometres to path points
---distance-step           (optional with --distance option) distance between distance labels (kilometres); defaults to 10
---input <path/to/gpx>     (with --route or --path option) path to GPX route file
--n <latitude>   north
--w <longitude>  west
--s <latitude>   south
--e <longitude>  east      latitude or longitude of the desired map boundary (only when --route is not specified)
-                          downloads a map within a defined square
---zoom <level>            (optional) map zoom (number); defaults to 12; must be < 17
---sx <integer>            (optional) amount of tiles per page horizontally; defaults to 4
---sy <integer>            (optional) amount of tiles per page vertically; defaults to 5
---output <path/to/output> (optional) the desired name of the exported pdf file
+--route         execute Route method (required)
+--input         path to GPX route file (required)
+                  you can download the GPX route file e.g. from https://graphhopper.com/maps/
+                  find the desired route and click "GPX export" (gpx button)
+--no-path       don't draw path (optional)
+--no-distance   don't write labels with kilometers at the path (optional)
+--distance-step distance between distance labels (default 10 [kilometers])
 
 Examples:
-1. Provide map boundaries
+osm2pdf --route --input=path/to/some-route.gpx --output some-route-12 --zoom=12 --tile-server=2
+osm2pdf --route --input=path/to/other-route.gpx --output other-route-13 --zoom=13 --distance-step=5 --tile-server="http://{a|b}.tile.openstreetmap.fr/hot/{z}/{x}/{y}.png" --rate-limit=2
+
+
+=== Area ===
+
+Download rectangular area, given GPS boundaries
+
+Options:
+--map           execute Area method (required)
+-n              latitude of the north boundary (required)
+-s              latitude of the south boundary (required)
+-e              longitude of the east boundary (required)
+-w              longitude of the west boundary (required)
+
+Example:
+osm2pdf --map -n=50.1 -s=50 -w=14.9 -e=15 --output=some-name-15 --tile-server=3 --zoom=15
+
+
+=== List Tile Servers ===
+
+Print a list of some recommended tile servers to choose from
+
+Options:
+--list-tile-servers   (required)
+
+Example:
+osm2pdf --list-tile-servers
 
-  osm2pdf --zoom=10 -n=15.1 -s=14.9 -e=13.9 -w=13.7
 
-2. Provide a route in GPX format (can be exported at https://graphhopper.com/maps/)
-  
-  osm2pdf --path --zoom=15 --input=path/to/some_route.gpx --output=my-route --distance --distance-step=5
+=== Help ===
 
-  OR (route without highlighted path)
+Print help
+
+Options:
+-h, --help                print this page (required)
 
-  osm2pdf --route --zoom=15 --input=path/to/some_route.gpx --output=my-route
+Example:
+osm2pdf --help
 `;
 
 export default function help(): void {

src/http.ts

@@ -0,0 +1,5 @@
+import rateLimit from 'axios-rate-limit';
+import axios from 'axios';
+
+export const getHttp = (rps: number) =>
+  rps === 0 ? axios : rateLimit(axios, { maxRequests: 1, perMilliseconds: 1000 / rps });

src/map.ts

@@ -1,41 +1,216 @@
-import { lat2tile, lon2tile, getTileSize } from './osm';
-import { pages2pdf, Page, PageSize } from './pdf';
+import { lat2tile, lon2tile, getTileSize, lat2tileExact, lon2tileExact } from './osm';
+import { TileServer, Page } from './types';
+import { createPdf, PDFOptions } from './pdf';
+import { downloadPages } from './download';
+import { clearTmp, getFilename } from './utils';
+import { TILE_SIZE } from './route';
+import { MapConfig } from './config';
+import gm from 'gm';
+import log from './log';
 
-interface Boundaries {
+// main executable function
+export default async function map({
+  zoom,
+  output,
+  pageSizeX,
+  pageSizeY,
+  north,
+  west,
+  south,
+  east,
+  tileServer,
+  tmp,
+}: {
+  zoom: number;
+  output: string;
+  pageSizeX: number;
+  pageSizeY: number;
   north: number;
+  west: number;
   south: number;
   east: number;
-  west: number;
-  zoom: number;
+  tileServer: TileServer;
+  tmp: string;
+}) {
+  // collect pages
+  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, {
+    pageSizeX,
+    pageSizeY,
+    links: boundaries2links({ north, west, south, east, pageSizeX, pageSizeY, zoom }),
+  });
+  // clean up downloaded pages
+  await clearTmp(tmp);
 }
 
-// main executable function
-export default async function map(boundaries: Boundaries, pageSize: PageSize, output: string) {
-  const pages: Page[] = boundaries2pages(boundaries, pageSize);
+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),
+  };
 
-  await pages2pdf(pages, output);
-}
+  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);
 
-function boundaries2pages({ north, west, south, east, zoom }: Boundaries, { sx, sy }: PageSize) {
-  const x = lon2tile(west, zoom);
-  const y = lat2tile(north, zoom);
+    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,
+  east,
+  pageSizeX,
+  pageSizeY,
+  zoom,
+}: {
+  north: number;
+  west: number;
+  south: number;
+  east: number;
+  pageSizeX: number;
+  pageSizeY: number;
+  zoom: number;
+}): 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 / sx);
-  const pagesY = Math.ceil(height / sy);
+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 * sx,
-        y: y + py * sy,
-        sx,
-        sy,
+        x: x + px * pageSizeX,
+        y: y + py * pageSizeY,
+        sx: pageSizeX,
+        sy: pageSizeY,
         zoom,
       });
     }

src/parse-route.ts

@@ -0,0 +1,35 @@
+import xml2js from 'xml2js';
+import fs from 'fs-extra';
+import { promisify } from 'util';
+
+const parseString = promisify(xml2js.parseString);
+
+export interface Coordinate {
+  lat: number;
+  lon: number;
+  ele: number;
+}
+
+interface StringCoordinate {
+  lat: string;
+  lon: string;
+}
+
+interface Route {
+  gpx: {
+    trk: {
+      trkseg: {
+        trkpt: {
+          $: StringCoordinate;
+          ele: string[];
+        }[];
+      }[];
+    }[];
+  };
+}
+
+export async function parseRoute(file: string): Promise<Coordinate[]> {
+  const xml = (await fs.readFile(file)).toString();
+  const raw = (await parseString(xml)) as Route;
+  return raw.gpx.trk[0].trkseg[0].trkpt.map(({ $: { lat, lon }, ele: [ele] }) => ({ lat: +lat, lon: +lon, ele: +ele }));
+}

src/path.ts

@@ -1,232 +0,0 @@
-import fs from 'fs-extra';
-import { lat2tileExact, lon2tileExact } from './osm';
-import { Tile, Page, PageSize, savePage, createPdf, clearTemporary } from './pdf';
-import { pad } from './utils';
-import gm from 'gm';
-import * as vector from './vector';
-import { parseRoute, Coordinate } from './route';
-import log from './log';
-import * as nodePath from 'path';
-import haversine from 'haversine';
-
-const TILE_SIZE = 256;
-
-interface TileWithDistance extends Tile {
-  distance: number;
-}
-
-type Path = TileWithDistance[];
-
-interface DrawablePoint {
-  x: number;
-  y: number;
-  distance: number;
-}
-
-type DrawablePath = DrawablePoint[];
-
-export default async function path(
-  { zoom, input }: { zoom: number; input: string },
-  { sx, sy }: PageSize,
-  distanceStep: number,
-  output: string,
-) {
-  // get route
-  const route = await parseRoute(input);
-  // convert gps points to tile points
-  const tileRoute = getTileRouteWithDistance(route, zoom);
-  // convert tile points to pixel points of path
-  const drawablePath = getDrawablePath(tileRoute);
-  // collect the pages in abstract form
-  const pages = collectPages(tileRoute, sx, sy);
-
-  // download the tiles and connect them to pages
-  const tmp = `tmp${Date.now()}`;
-  await fs.ensureDir(tmp);
-  for (let i = 0, len = pages.length; i < len; ++i) {
-    const page = pages[i];
-    // tslint:disable-next-line:no-shadowed-variable
-    const { x, y, sx, sy, zoom } = page;
-    const filename = `${tmp}/${pad(i)}.png`;
-    // save page
-    log(`${i + 1}/${pages.length} downloading`);
-    await savePage({ x, y, sx, sy, zoom }, filename);
-    // draw paths
-    log(`${i + 1}/${pages.length} drawing`);
-    await drawPath(page, drawablePath, distanceStep, filename);
-  }
-  // make pdf from pages
-  log(`Creating pdf`);
-  await createPdf(output, tmp);
-  await clearTemporary(tmp);
-  log('');
-  // tslint:disable-next-line:no-console
-  console.log(`Finished! Your map was saved to ${output}.pdf`);
-}
-
-function getDrawablePath(tilePath: Path): DrawablePath {
-  const drawablePath: DrawablePath = [];
-  // tslint:disable-next-line:no-shadowed-variable
-  const path = tilePath.map(point => ({
-    x: point.x * TILE_SIZE,
-    y: point.y * TILE_SIZE,
-  }));
-
-  if (path.length <= 1) {
-    path.forEach(point => {
-      drawablePath.push({
-        x: point.x,
-        y: point.y,
-        distance: 0,
-      });
-    });
-  } else {
-    let lastPoint: vector.Vector | null;
-
-    // tslint:disable-next-line:no-shadowed-variable
-    path.forEach((point, i, path) => {
-      let direction;
-      if (i === 0) {
-        direction = vector.normal(vector.unit(vector.diff(path[i + 1], path[i])));
-      } else if (i === path.length - 1) {
-        direction = vector.normal(vector.unit(vector.diff(path[i], path[i - 1])));
-      } else {
-        direction = vector.normal(
-          vector.unit(
-            vector.sum(vector.unit(vector.diff(path[i], path[i - 1])), vector.unit(vector.diff(path[i + 1], path[i]))),
-          ),
-        );
-      }
-      const newPoint = vector.sum(point, vector.times(10, direction));
-      // don't draw a point if it's too close to the last drawn point
-      if (!lastPoint || vector.size(vector.diff(newPoint, lastPoint)) > 30) {
-        drawablePath.push({
-          x: newPoint.x,
-          y: newPoint.y,
-          distance: tilePath[i].distance,
-        });
-
-        lastPoint = newPoint;
-      }
-
-      // make sure the very last point is displayed
-      if (i === path.length - 1) {
-        // not too close!
-        drawablePath.pop();
-        drawablePath.push({
-          x: newPoint.x,
-          y: newPoint.y,
-          distance: tilePath[i].distance,
-        });
-      }
-    });
-  }
-
-  return drawablePath;
-}
-
-async function drawPath(page: Page, drawablePath: DrawablePath, distanceStep: number, filename: string) {
-  await new Promise((resolve, reject) => {
-    const control = gm(filename);
-
-    // tslint:disable-next-line:no-shadowed-variable
-    const path = drawablePath.map(({ x, y, distance }) => ({
-      x: x - page.x * TILE_SIZE,
-      y: y - page.y * TILE_SIZE,
-      distance,
-    }));
-
-    // draw points
-    control.stroke('red', 2).fill('#000f');
-    path.forEach(({ x, y }) => {
-      control.drawCircle(x, y, x + 3, y + 3);
-    });
-
-    // draw distance labels
-    if (distanceStep > -1) {
-      control
-        .stroke('none')
-        .fill('black')
-        .font(nodePath.resolve(__dirname, 'fonts/OpenSans/OpenSans-Bold.ttf'), 12);
-
-      let nextDistance = 0;
-      // tslint:disable-next-line:no-shadowed-variable
-      path.forEach(({ x, y, distance }, i, path) => {
-        if (distance >= nextDistance * distanceStep || i === path.length - 1) {
-          control.drawText(x + 7, y + 6, distance.toFixed(1));
-          ++nextDistance;
-        }
-      });
-    }
-
-    // draw it
-    control.write(filename, err => {
-      if (err) return reject(err);
-      else return resolve();
-    });
-  });
-}
-
-function collectPages(tileRoute: Path, sx: number, sy: number): Page[] {
-  const pages: Page[] = [];
-  const pageDict: { [id: string]: boolean } = {};
-
-  for (const tile of tileRoute) {
-    const pageX = Math.floor(tile.x / sx) * sx;
-    const pageY = Math.floor(tile.y / sy) * sy;
-
-    const id = `${pageX}-${pageY}`;
-    if (!pageDict[id]) {
-      pageDict[id] = true;
-      pages.push({
-        x: pageX,
-        y: pageY,
-        sx,
-        sy,
-        zoom: tile.zoom,
-      });
-    }
-  }
-
-  return pages;
-}
-/*
-function getTileRoute(route: Coordinate[], zoom: number): Tile[] {
-  return route.map(({ lat, lon }) => ({
-    x: lon2tileExact(lon, zoom),
-    y: lat2tileExact(lat, zoom),
-    zoom,
-  }));
-  }
-  */
-
-function getTileRouteWithDistance(route: Coordinate[], zoom: number): Path {
-  const output: Path = [];
-  let distance = 0;
-
-  for (let i = 0, len = route.length; i < len; ++i) {
-    if (i > 0) {
-      distance +=
-        (haversine(
-          {
-            latitude: route[i].lat,
-            longitude: route[i].lon,
-          },
-          {
-            latitude: route[i - 1].lat,
-            longitude: route[i - 1].lon,
-          },
-        ) **
-          2 +
-          (route[i].ele / 1000 - route[i - 1].ele / 1000) ** 2) **
-        0.5;
-    }
-    output.push({
-      x: lon2tileExact(route[i].lon, zoom),
-      y: lat2tileExact(route[i].lat, zoom),
-      zoom,
-      distance,
-    });
-  }
-  return output;
-}

src/pdf.ts

@@ -1,86 +1,47 @@
-import axios from 'axios';
-import mergeImg from 'merge-img';
-import gm from 'gm';
-import fs from 'fs-extra';
-import { pad } from './utils';
+import PDFDocument from 'pdfkit';
 import log from './log';
-
-export interface Tile {
-  x: number;
-  y: number;
-  zoom: number;
-}
-
-export interface PageSize {
-  sx: number;
-  sy: number;
-}
-
-export interface Page extends Tile, PageSize {}
-
-async function getTile({ x, y, zoom }: Tile): Promise<Buffer> {
-  return Buffer.from(
-    (
-      await axios.get(`https://tile.openstreetmap.org/${zoom}/${x}/${y}.png`, {
-        responseType: 'arraybuffer',
-      })
-    ).data,
-    'binary',
-  );
-}
-
-export async function getPage({ x, y, sx, sy, zoom }: Page): Promise<Buffer[][]> {
-  const rows: Promise<Buffer[]>[] = [];
-  for (let i = 0; i < sx; i++) {
-    const row: Promise<Buffer>[] = [];
-    for (let j = 0; j < sy; j++) {
-      row.push(getTile({ x: x + i, y: y + j, zoom }));
+import fs from 'fs-extra';
+import path from 'path';
+
+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');
+  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));
     }
-    rows.push(Promise.all(row));
-  }
-  return await Promise.all(rows);
-}
-
-async function mergeTiles(tiles: Buffer[][]): Promise<any> {
-  const row = await Promise.all(tiles.map(column => mergeImg(column, { direction: true })));
-  return await mergeImg(row);
-}
-
-export async function savePage(page: Page, output: string): Promise<void> {
-  const pageTiles = await getPage(page);
-  const image = await mergeTiles(pageTiles);
-  await new Promise(resolve => image.write(output, resolve));
-}
+    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();
 
-export async function createPdf(name: string, tmp: string) {
-  await new Promise((resolve, reject) => {
-    gm(`${tmp}/*.png`).write(`${name}.pdf`, err => {
-      if (!err) return resolve();
-      if (err) return reject(err);
-    });
+    stream.on('finish', resolve);
+    stream.on('error', reject);
   });
-}
-
-export async function clearTemporary(tmp: string) {
-  await fs.remove(tmp);
-}
-
-export async function pages2pdf(pages: Page[], name: string): Promise<void> {
-  const tmp = `tmp${Date.now()}`;
-  await fs.ensureDir(tmp);
-
-  for (let i = 0, len = pages.length; i < len; i++) {
-    const page = pages[i];
-    log('page', `${i + 1}/${pages.length}`);
-    const pageTiles = await getPage(page);
-    const image = await mergeTiles(pageTiles);
-
-    await new Promise(resolve => image.write(`${tmp}/${pad(i)}.png`, resolve));
-  }
-
-  await createPdf(name, tmp);
-  await clearTemporary(tmp);
-
-  log();
-  console.log(`Finished! Your map was saved to ${name}.pdf`); // tslint:disable-line:no-console
+  // eslint-disable-next-line: no-console
+  log(`Your map was saved to ${output}.pdf\n`);
 }

src/route.ts

@@ -1,90 +1,242 @@
-import xml2js from 'xml2js';
-import fs from 'fs-extra';
-import { promisify } from 'util';
-import { lat2tile, lon2tile } from './osm';
-import { pages2pdf, Tile, Page, PageSize } from './pdf';
-
-const parseString = promisify(xml2js.parseString);
-
-export default async function route(
-  { zoom, input }: { zoom: number; input: string },
-  pageSize: PageSize,
-  output: string,
-) {
-  // get route
-  // tslint:disable-next-line:no-shadowed-variable
-  const route = await parseRoute(input);
-  // get tile for each route point
-  const tiles = route2tiles(route, zoom);
-  const pages = tiles2pages(tiles, pageSize);
-  await pages2pdf(pages, output);
-}
+import { lat2tileExact, lon2tileExact } from './osm';
+import { createPdf } from './pdf';
+import { clearTmp, getFilename } from './utils';
+import gm from 'gm';
+import * as vector from './vector';
+import log from './log';
+import * as nodePath from 'path';
+import haversine from 'haversine';
+import { Tile, Page, TileServer } from './types';
+import { downloadPages } from './download';
+import { Coordinate, parseRoute } from './parse-route';
+
+export const TILE_SIZE = 256;
 
-export interface Coordinate {
-  lat: number;
-  lon: number;
-  ele: number;
+interface TileWithDistance extends Tile {
+  distance: number;
 }
 
-interface StringCoordinate {
-  lat: string;
-  lon: string;
+type Path = TileWithDistance[];
+
+interface DrawablePoint {
+  x: number;
+  y: number;
+  distance: number;
 }
 
-interface Route {
-  gpx: {
-    trk: {
-      trkseg: {
-        trkpt: {
-          $: StringCoordinate;
-          ele: string[];
-        }[];
-      }[];
-    }[];
+type DrawablePath = DrawablePoint[];
+
+export default async function path({
+  zoom,
+  input,
+  output,
+  pageSizeX,
+  pageSizeY,
+  draw,
+  distance,
+  distanceStep,
+  tileServer,
+  tmp,
+}: {
+  zoom: number;
+  input: string;
+  output: string;
+  pageSizeX: number;
+  pageSizeY: number;
+  draw: boolean;
+  distance: boolean;
+  distanceStep: number;
+  tileServer: TileServer;
+  tmp: string;
+}) {
+  // collect pages:
+  //
+  // get route
+  const route = await parseRoute(input);
+  // convert gps points to tile points
+  const tileRoute = getTileRouteWithDistance(route, zoom);
+  // convert tile points to pixel points of path
+  const drawablePath = getDrawablePath(tileRoute);
+  // collect the pages in abstract form
+  const pages = collectPages(tileRoute, pageSizeX, pageSizeY);
+
+  // download the tiles and connect them to pages
+  await downloadPages(pages, tmp, tileServer);
+
+  // draw path on pages
+  if (draw) {
+    for (let i = 0, len = pages.length; i < len; ++i) {
+      // draw paths
+      log(`drawing page ${i + 1}/${pages.length}`);
+      const page = pages[i];
+      await drawPath(page, drawablePath, distance ? distanceStep : -1, getFilename(tmp, i));
+    }
+  }
+
+  // make pdf from pages
+  const options = {
+    pageSizeX,
+    pageSizeY,
+    links: [],
   };
+  await createPdf(output, tmp, options);
+  await clearTmp(tmp);
 }
 
-export async function parseRoute(file: string): Promise<Coordinate[]> {
-  const xml = (await fs.readFile(file)).toString();
-  const raw = (await parseString(xml)) as Route;
-  return raw.gpx.trk[0].trkseg[0].trkpt.map(({ $: { lat, lon }, ele: [ele] }) => ({ lat: +lat, lon: +lon, ele: +ele }));
-}
+function getDrawablePath(tilePath: Path): DrawablePath {
+  const drawablePath: DrawablePath = [];
+  // tslint:disable-next-line:no-shadowed-variable
+  const path = tilePath.map(point => ({
+    x: point.x * TILE_SIZE,
+    y: point.y * TILE_SIZE,
+  }));
 
-// tslint:disable-next-line:no-shadowed-variable
-function route2tiles(route: Coordinate[], zoom: number): Tile[] {
-  const tiles: Tile[] = [];
-  // add tile for each route point
-  route.forEach(({ lat, lon }) => {
-    const tile: Tile = {
-      x: lon2tile(+lon, zoom),
-      y: lat2tile(+lat, zoom),
-      zoom,
-    };
+  if (path.length <= 1) {
+    path.forEach(point => {
+      drawablePath.push({
+        x: point.x,
+        y: point.y,
+        distance: 0,
+      });
+    });
+  } else {
+    let lastPoint: vector.Vector | null;
 
-    const found = tiles.findIndex(({ x, y }) => x === tile.x && y === tile.y);
-    if (found === -1) tiles.push(tile);
-  });
+    // tslint:disable-next-line:no-shadowed-variable
+    path.forEach((point, i, path) => {
+      let direction;
+      if (i === 0) {
+        direction = vector.normal(vector.unit(vector.diff(path[i + 1], path[i])));
+      } else if (i === path.length - 1) {
+        direction = vector.normal(vector.unit(vector.diff(path[i], path[i - 1])));
+      } else {
+        direction = vector.normal(
+          vector.unit(
+            vector.sum(vector.unit(vector.diff(path[i], path[i - 1])), vector.unit(vector.diff(path[i + 1], path[i]))),
+          ),
+        );
+      }
+      const newPoint = vector.sum(point, vector.times(10, direction));
+      // don't draw a point if it's too close to the last drawn point
+      if (!lastPoint || vector.size(vector.diff(newPoint, lastPoint)) > 30) {
+        drawablePath.push({
+          x: newPoint.x,
+          y: newPoint.y,
+          distance: tilePath[i].distance,
+        });
+
+        lastPoint = newPoint;
+      }
 
-  return tiles;
+      // make sure the very last point is displayed
+      if (i === path.length - 1) {
+        // not too close!
+        drawablePath.pop();
+        drawablePath.push({
+          x: newPoint.x,
+          y: newPoint.y,
+          distance: tilePath[i].distance,
+        });
+      }
+    });
+  }
+
+  return drawablePath;
 }
 
-function tiles2pages(tiles: Tile[], { sx, sy }: PageSize): Page[] {
-  const pages: Page[] = [];
-  tiles.forEach(({ x, y, zoom }) => {
-    const page: Page = {
-      x: Math.floor(x / sx) * sx,
-      y: Math.floor(y / sy) * sy,
-      sx,
-      sy,
-      zoom,
-    };
+async function drawPath(page: Page, drawablePath: DrawablePath, distanceStep: number, filename: string) {
+  await new Promise((resolve, reject) => {
+    const control = gm(filename);
 
     // tslint:disable-next-line:no-shadowed-variable
-    const found = pages.findIndex(({ x, y }) => x === page.x && y === page.y);
-    if (found === -1) {
-      pages.push(page);
+    const path = drawablePath.map(({ x, y, distance }) => ({
+      x: x - page.x * TILE_SIZE,
+      y: y - page.y * TILE_SIZE,
+      distance,
+    }));
+
+    // draw points
+    control.stroke('red', 2).fill('#000f');
+    path.forEach(({ x, y }) => {
+      control.drawCircle(x, y, x + 3, y + 3);
+    });
+
+    // draw distance labels
+    if (distanceStep > -1) {
+      control
+        .stroke('none')
+        .fill('black')
+        .font(nodePath.resolve(__dirname, 'fonts/OpenSans/OpenSans-Bold.ttf'), 12);
+
+      let nextDistance = 0;
+      // tslint:disable-next-line:no-shadowed-variable
+      path.forEach(({ x, y, distance }, i, path) => {
+        if (distance >= nextDistance * distanceStep || i === path.length - 1) {
+          control.drawText(x + 7, y + 6, distance.toFixed(1));
+          ++nextDistance;
+        }
+      });
     }
+
+    // draw it
+    control.write(filename, err => {
+      if (err) return reject(err);
+      else return resolve();
+    });
   });
+}
+
+function collectPages(tileRoute: Path, sx: number, sy: number): Page[] {
+  const pages: Page[] = [];
+  const pageDict: { [id: string]: boolean } = {};
+
+  for (const tile of tileRoute) {
+    const pageX = Math.floor(tile.x / sx) * sx;
+    const pageY = Math.floor(tile.y / sy) * sy;
+
+    const id = `${pageX}-${pageY}`;
+    if (!pageDict[id]) {
+      pageDict[id] = true;
+      pages.push({
+        x: pageX,
+        y: pageY,
+        sx,
+        sy,
+        zoom: tile.zoom,
+      });
+    }
+  }
 
   return pages;
 }
+
+function getTileRouteWithDistance(route: Coordinate[], zoom: number): Path {
+  const output: Path = [];
+  let distance = 0;
+
+  for (let i = 0, len = route.length; i < len; ++i) {
+    if (i > 0) {
+      distance +=
+        (haversine(
+          {
+            latitude: route[i].lat,
+            longitude: route[i].lon,
+          },
+          {
+            latitude: route[i - 1].lat,
+            longitude: route[i - 1].lon,
+          },
+        ) **
+          2 +
+          (route[i].ele / 1000 - route[i - 1].ele / 1000) ** 2) **
+        0.5;
+    }
+    output.push({
+      x: lon2tileExact(route[i].lon, zoom),
+      y: lat2tileExact(route[i].lat, zoom),
+      zoom,
+      distance,
+    });
+  }
+  return output;
+}

src/run.ts

@@ -8,61 +8,46 @@
 // otherwise download a map (default)
 // e.g. --zoom=15 --north= --south= --east= --west= --output=map --sx=4 --sy=5
 //
-
-import minimist from 'minimist';
+import getConfig from './config';
 import map from './map';
 import route from './route';
-import path from './path';
 import help from './help';
+import { listTileServers } from './tile-servers';
+import chalk from 'chalk';
 
 (async () => {
-  const argv = minimist(process.argv.slice(2));
-
-  if (argv.h || argv.help) {
-    help();
-    return;
-  }
-
-  const zoom = argv.zoom ?? 12;
-
-  if (zoom >= 17) {
-    const SORRY =
-      'Sorry, OSM Tile Usage Policy (https://operations.osmfoundation.org/policies/tiles/) forbids downloading tiles with zoom 17 and higher.';
-    console.log(SORRY); // tslint:disable-line:no-console
-    return;
-  }
-
-  const sx = argv.sx ?? 4;
-  const sy = argv.sy ?? 5;
-  const output = argv.output;
-
-  if (argv.path) {
-    const input = argv.input;
-
-    const distanceStep = argv.distance ? argv['distance-step'] ?? 10 : -1;
-
-    if (!input) return help();
-
-    await path({ zoom, input }, { sx, sy }, distanceStep, output || 'path');
-  } else if (argv.route) {
-    const input = argv.input;
-
-    if (!input) return help();
-
-    await route({ zoom, input }, { sx, sy }, output || 'route');
-  } else {
-    const north = argv.n ?? argv.north;
-    const west = argv.w ?? argv.west;
-    const south = argv.s ?? argv.south;
-    const east = argv.e ?? argv.east;
-
-    if (typeof north !== 'number' || typeof south !== 'number' || typeof east !== 'number' || typeof west !== 'number')
-      return help();
-
-    await map(
-      { zoom, north, west, south, east },
-      { sx, sy },
-      output || `map_${north}_${west}_${south}_${east}_${zoom}`,
-    );
+  let config;
+  try {
+    config = getConfig();
+
+    switch (config.mode) {
+      case 'tiles': {
+        listTileServers();
+        return;
+      }
+      case 'map': {
+        await map(config);
+        return;
+      }
+      case 'route': {
+        await route(config);
+        return;
+      }
+      default:
+        help();
+        return;
+    }
+  } catch (e) {
+    // tslint:disable-next-line:no-console
+    console.log(JSON.stringify(e));
+    // tslint:disable-next-line:no-console
+    console.error(e);
+    if (config && 'tmp' in config) {
+      console.log(
+        chalk.red(
+          `\n\n************************\n\nError: ${e.message}\n\nYour download failed. You can resume it by adding "--tmp ${config.tmp}" to your command.\n\n************************\n`,
+        ),
+      );
+    }
   }
 })();

src/tile-servers.ts

@@ -0,0 +1,96 @@
+import { TileServer } from './types';
+import { random } from './utils';
+import log from './log';
+
+export const parseUrl = (a: string) => {
+  const r = /^(?<base>.+?)\$?{(?<v1>[xyz]{1})}(?<s1>.+?)\$?{(?<v2>[xyz]{1})}(?<s2>.+?)\$?{(?<v3>[xyz]{1})}(?<end>.*)$/gm;
+  const {
+    groups: { base, v1, s1, v2, s2, v3, end },
+  } = r.exec(a) as { groups: { [name: string]: string } };
+  const r2 = /(?<base1>.*)({(?<servers>[a-z0-9|]+)})(?<base2>.*)/gm;
+  const {
+    groups: { base1, servers, base2 },
+  } = (r2.exec(base) ?? { groups: { base1: base, servers: '', base2: '' } }) as { groups: { [name: string]: string } };
+
+  return ({ x, y, z }: { x: number; y: number; z: number }) =>
+    `${base1}${random(servers.split('|'))}${base2}${v1 === 'x' ? x : v1 === 'y' ? y : z}${s1}${
+      v2 === 'x' ? x : v2 === 'y' ? y : z
+    }${s2}${v3 === 'x' ? x : v3 === 'y' ? y : z}${end}`;
+};
+
+export const rawServers = [
+  {
+    name: 'German fork of the Standard tile layer: openstreetmap.de',
+    url: 'https://{a|b|c}.tile.openstreetmap.de/{z}/{x}/{y}.png',
+    rateLimit: 5,
+  },
+  {
+    name: 'OSM France',
+    url: 'https://{a|b|c}.tile.openstreetmap.fr/osmfr/{z}/{x}/{y}.png',
+    rateLimit: 1,
+  },
+  {
+    name: 'Humanitarian map style',
+    url: 'http://{a|b}.tile.openstreetmap.fr/hot/${z}/${x}/${y}.png',
+    rateLimit: 1,
+  },
+  {
+    name: 'OpenTopoMap',
+    url: 'https://{a|b|c}.tile.opentopomap.org/{z}/{x}/{y}.png',
+    rateLimit: 2,
+  },
+  {
+    name: 'Stamen Toner Black & White map',
+    url: 'http://a.tile.stamen.com/toner/{z}/{x}/{y}.png',
+    rateLimit: 5,
+  },
+  {
+    name: 'mapnik map grayscale',
+    url: 'https://tiles.wmflabs.org/bw-mapnik/{z}/{x}/{y}.png',
+    rateLimit: 5,
+  },
+  {
+    name: 'mapnik map without labels',
+    url: 'https://tiles.wmflabs.org/osm-no-labels/${z}/${x}/${y}.png',
+    rateLimit: 5,
+  },
+  {
+    name: 'wmflabs Hike & Bike - Hiking map',
+    url: 'https://tiles.wmflabs.org/hikebike/${z}/${x}/${y}.png',
+    rateLimit: 1,
+  },
+  {
+    name: 'Mapy.cz Base',
+    url: 'https://m{1|2|3|4}.mapserver.mapy.cz/base-m/{z}-{x}-{y}',
+    rateLimit: 10,
+  },
+  {
+    name: 'Mapy.cz Turistic',
+    url: 'https://m{1|2|3|4}.mapserver.mapy.cz/turist-m/{z}-{x}-{y}',
+    rateLimit: 10,
+  },
+  {
+    name: 'CyclOSM: OpenStreetMap-based bicycle map',
+    url: 'https://{a|b|c}.tile-cyclosm.openstreetmap.fr/cyclosm/{z}/{x}/{y}.png',
+    rateLimit: 1,
+  },
+];
+
+export const servers: TileServer[] = rawServers.map(({ url, rateLimit }) => ({
+  url: parseUrl(url),
+  rateLimit,
+}));
+
+export function listTileServers() {
+  const output: string[] = [];
+
+  output.push('');
+  rawServers.forEach(({ name, url }, index) => {
+    output.push(`${index + 1}. ${name}`);
+    output.push(url);
+    output.push('');
+  });
+  output.push('');
+
+  return log(output.join('\n'));
+}

src/types.ts

@@ -0,0 +1,19 @@
+type GetUrl = (coordinates: { z: number; x: number; y: number }) => string;
+
+export type TileServer = {
+  url: GetUrl;
+  rateLimit: number;
+};
+
+export interface Tile {
+  x: number;
+  y: number;
+  zoom: number;
+}
+
+export interface PageSize {
+  sx: number;
+  sy: number;
+}
+
+export interface Page extends Tile, PageSize {}

src/utils.ts

@@ -1,3 +1,24 @@
+import fs from 'fs-extra';
+
 export function pad(num: number, decimals = 5): string {
   return ('0'.repeat(decimals) + num).slice(-decimals);
 }
+
+export async function clearTmp(tmp: string) {
+  await fs.remove(tmp);
+}
+
+export const getFilename = (tmp: string, i: number) => `${tmp}/${pad(i)}.png`;
+
+export function random<T>(input: Array<T>): T {
+  return input[Math.floor(Math.random() * input.length)];
+}
+
+export const fileExists = async (file: string): Promise<boolean> => {
+  try {
+    await fs.access(file, fs.constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+};