big refactor, first working version

merge --path and --route options (also in code)
implement server selecting
refactor config and parameter providing
implement rate limiting

package.json

@@ -57,6 +57,7 @@
   },
   "dependencies": {
     "axios": "^0.19.2",
+    "axios-rate-limit": "^1.3.0",
     "fs-extra": "^8.1.0",
     "gm": "^1.23.1",
     "haversine": "^1.1.1",

src/config.ts

@@ -0,0 +1,110 @@
+import minimist from 'minimist';
+import { TileServer } from './types';
+// 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;
+}
+
+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;
+  }
+
+  const zoom = argv.zoom ?? 12;
+  const pageSizeX = argv.x ?? 4;
+  const pageSizeY = argv.y ?? 5;
+  const tileServer = getTileServer(argv['tile-server'], argv['rate-limit']);
+
+  const baseConfig = { zoom, pageSizeX, pageSizeY, tileServer };
+
+  if (argv.route) {
+    const input = argv.input;
+    if (!input) return helpConfig;
+
+    return {
+      ...baseConfig,
+      mode: 'route',
+      input,
+      draw: argv.path ?? true,
+      distance: !!argv.distance,
+      distanceStep: argv['distance-step'] ?? 10,
+      output: argv.output || 'route',
+    };
+  }
+
+  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}_${zoom}`;
+    return {
+      ...baseConfig,
+      mode: 'map',
+      north,
+      south,
+      west,
+      east,
+      output,
+    };
+  }
+
+  return helpConfig;
+}
+
+function getTileServer(server: string | number, rateLimit: number = 10): TileServer {
+  return {
+    url: ({ x, y, z }) => `${server}/${z}/${x}/${y}.png`,
+    rateLimit: rateLimit ?? 5,
+  };
+}

src/download.ts

@@ -0,0 +1,61 @@
+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 } 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 page = pages[i];
+    log('page', `${i + 1}/${pages.length}`);
+    const pageTiles = await getPage(page, { http, tileServer });
+    await savePage(pageTiles, getFilename(tmp, i));
+  }
+}
+
+// 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 },
+): 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 }, { http, tileServer }));
+    }
+    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/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,29 +1,66 @@
 import { lat2tile, lon2tile, getTileSize } from './osm';
-import { pages2pdf, Page, PageSize } from './pdf';
+import { TileServer, Page } from './types';
+import { createPdf } from './pdf';
+import { downloadPages } from './download';
+import { clearTmp } from './utils';
 
-interface Boundaries {
+// main executable function
+export default async function map({
+  zoom,
+  output,
+  pageSizeX,
+  pageSizeY,
+  north,
+  west,
+  south,
+  east,
+  tileServer,
+}: {
+  zoom: number;
+  output: string;
+  pageSizeX: number;
+  pageSizeY: number;
   north: number;
+  west: number;
   south: number;
   east: number;
-  west: number;
-  zoom: number;
-}
-
-// main executable function
-export default async function map(boundaries: Boundaries, pageSize: PageSize, output: string) {
-  const pages: Page[] = boundaries2pages(boundaries, pageSize);
-
-  await pages2pdf(pages, output);
+  tileServer: TileServer;
+}) {
+  // collect pages
+  const pages: Page[] = boundaries2pages({ north, west, south, east, pageSizeX, pageSizeY, zoom });
+  // download pages
+  const tmp = `tmp${Date.now()}`;
+  await downloadPages(pages, tmp, tileServer);
+  // create pdf
+  await createPdf(output, tmp);
+  // clean up downloaded pages
+  await clearTmp(tmp);
 }
 
-function boundaries2pages({ north, west, south, east, zoom }: Boundaries, { sx, sy }: PageSize) {
+function boundaries2pages({
+  north,
+  west,
+  south,
+  east,
+  pageSizeX,
+  pageSizeY,
+  zoom,
+}: {
+  north: number;
+  west: number;
+  south: number;
+  east: number;
+  pageSizeX: number;
+  pageSizeY: number;
+  zoom: number;
+}) {
   const x = lon2tile(west, zoom);
   const y = lat2tile(north, zoom);
 
   const { width, height } = getTileSize({ north, west, south, east, zoom });
 
-  const pagesX = Math.ceil(width / sx);
-  const pagesY = Math.ceil(height / sy);
+  const pagesX = Math.ceil(width / pageSizeX);
+  const pagesY = Math.ceil(height / pageSizeY);
 
   console.log('size', pagesX, 'x', pagesY, 'pages'); // tslint:disable-line:no-console
 
@@ -32,10 +69,10 @@ function boundaries2pages({ north, west, south, east, zoom }: Boundaries, { sx,
   for (let py = 0; py < pagesY; py++) {
     for (let px = 0; px < pagesX; 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,14 @@
-import axios from 'axios';
-import mergeImg from 'merge-img';
 import gm from 'gm';
-import fs from 'fs-extra';
-import { pad } from './utils';
 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 }));
-    }
-    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));
-}
-
-export async function createPdf(name: string, tmp: string) {
+export async function createPdf(output: string, tmp: string) {
+  log('Creating pdf');
   await new Promise((resolve, reject) => {
-    gm(`${tmp}/*.png`).write(`${name}.pdf`, err => {
+    gm(`${tmp}/*.png`).write(`${output}.pdf`, err => {
       if (!err) return resolve();
       if (err) return reject(err);
     });
   });
-}
-
-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,236 @@
-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 interface Coordinate {
-  lat: number;
-  lon: number;
-  ele: number;
-}
+const TILE_SIZE = 256;
 
-interface StringCoordinate {
-  lat: string;
-  lon: string;
+interface TileWithDistance extends Tile {
+  distance: number;
 }
 
-interface Route {
-  gpx: {
-    trk: {
-      trkseg: {
-        trkpt: {
-          $: StringCoordinate;
-          ele: string[];
-        }[];
-      }[];
-    }[];
-  };
+type Path = TileWithDistance[];
+
+interface DrawablePoint {
+  x: number;
+  y: number;
+  distance: number;
 }
 
-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 }));
+type DrawablePath = DrawablePoint[];
+
+export default async function path({
+  zoom,
+  input,
+  output,
+  pageSizeX,
+  pageSizeY,
+  draw,
+  distance,
+  distanceStep,
+  tileServer,
+}: {
+  zoom: number;
+  input: string;
+  output: string;
+  pageSizeX: number;
+  pageSizeY: number;
+  draw: boolean;
+  distance: boolean;
+  distanceStep: number;
+  tileServer: TileServer;
+}) {
+  // 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
+  const tmp = `tmp${Date.now()}`;
+  await downloadPages(pages, tmp, tileServer);
+
+  // draw path on pages
+  if (draw) {
+    for (let i = 0, len = pages.length; i < len; ++i) {
+      // draw paths
+      log(`${i + 1}/${pages.length} drawing`);
+      const page = pages[i];
+      await drawPath(page, drawablePath, distance ? distanceStep : -1, getFilename(tmp, i));
+    }
+  }
+
+  // make pdf from pages
+  await createPdf(output, tmp);
+  await clearTmp(tmp);
 }
 
-// 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,
-    };
+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,
+  }));
 
-    const found = tiles.findIndex(({ x, y }) => x === tile.x && y === tile.y);
-    if (found === -1) tiles.push(tile);
-  });
+  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;
+      }
 
-  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,37 @@
 // 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';
 
 (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}`,
-    );
+  try {
+    const config = getConfig();
+
+    switch (config.mode) {
+      case 'tiles': {
+        return listTileServers();
+      }
+      case 'map': {
+        const { zoom, output, pageSizeX, pageSizeY, north, west, south, east, tileServer } = config;
+        return map({ zoom, output, pageSizeX, pageSizeY, north, west, south, east, tileServer });
+      }
+      case 'route': {
+        const { zoom, input, output, pageSizeX, pageSizeY, draw, distance, distanceStep, tileServer } = config;
+        return route({ zoom, input, output, pageSizeX, pageSizeY, draw, distance, distanceStep, tileServer });
+      }
+      default:
+        return help();
+    }
+  } catch (e) {
+    // tslint:disable-next-line:no-console
+    console.log(JSON.stringify(e));
+    // tslint:disable-next-line:no-console
+    console.log(JSON.stringify(e));
+    // tslint:disable-next-line:no-console
+    console.error(e);
   }
 })();

src/tile-servers.ts

@@ -0,0 +1,19 @@
+import { TileServer } from './types';
+
+// const tileServer = 'http://a.tile.stamen.com/toner';
+// const tileServer = 'https://a.tile.openstreetmap.de'
+// const tileServer = 'https://tile.openstreetmap.org';
+// const tileServer = 'https://tiles.wmflabs.org/bw-mapnik/'
+// const tileServer = 'https://c.tile.openstreetmap.fr/osmfr'
+//
+
+export const servers: TileServer[] = [
+  {
+    url: ({ z, x, y }) => `https://a.tile.opentopomap.org/${z}/${x}/${y}.png`,
+    rateLimit: 1,
+  },
+];
+
+export default function listTileServers() {
+  return 'tile servers listing TODO';
+}

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,11 @@
+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`;

yarn.lock

@@ -643,6 +643,11 @@ aws4@^1.8.0:
   resolved "https://registry.yarnpkg.com/aws4/-/aws4-1.9.1.tgz#7e33d8f7d449b3f673cd72deb9abdc552dbe528e"
   integrity sha512-wMHVg2EOHaMRxbzgFJ9gtjOOCrI80OHLG14rxi28XwOW8ux6IiEbRCGGGqCtdAIg4FQCbW20k9RsT4y3gJlFug==
 
+axios-rate-limit@^1.3.0:
+  version "1.3.0"
+  resolved "https://registry.yarnpkg.com/axios-rate-limit/-/axios-rate-limit-1.3.0.tgz#03241d24c231c47432dab6e8234cfde819253c2e"
+  integrity sha512-cKR5wTbU/CeeyF1xVl5hl6FlYsmzDVqxlN4rGtfO5x7J83UxKDckudsW0yW21/ZJRcO0Qrfm3fUFbhEbWTLayw==
+
 axios@*, axios@^0.19.2:
   version "0.19.2"
   resolved "https://registry.yarnpkg.com/axios/-/axios-0.19.2.tgz#3ea36c5d8818d0d5f8a8a97a6d36b86cdc00cb27"