mobility-toolbox-js 2.0.0-beta.8 → 2.0.1-beta.13

package/api/RoutingAPI.js

@@ -0,0 +1,15 @@
+import HttpAPI from "../common/api/HttpAPI";
+class RoutingAPI extends HttpAPI {
+  constructor(options = {}) {
+    super({
+      url: "https://api.geops.io/routing/v1/",
+      ...options
+    });
+  }
+  route(params, abortController = new AbortController()) {
+    return this.fetch("", params, {
+      signal: abortController.signal
+    });
+  }
+}
+export default RoutingAPI;

package/api/RoutingAPI.test.js

@@ -0,0 +1,25 @@
+import fetch from "jest-fetch-mock";
+import RoutingAPI from "./RoutingAPI";
+let api;
+describe("RoutingAPI", () => {
+  beforeEach(() => {
+    global.fetch = fetch;
+    fetch.resetMocks();
+    api = new RoutingAPI({ apiKey: "apiKey" });
+  });
+  describe("#route", () => {
+    test("should success", (done) => {
+      fetch.mockResponseOnce(JSON.stringify(global.fetchRouteResponse));
+      return api.route({
+        mot: "bus",
+        via: "47.3739194713294,8.538274823394632|47.37595378493421,8.537490375951839"
+      }).then((featureCollection) => {
+        expect(fetch.mock.calls[0][0]).toEqual("https://api.geops.io/routing/v1/?key=apiKey&mot=bus&via=47.3739194713294%2C8.538274823394632%7C47.37595378493421%2C8.537490375951839");
+        expect(featureCollection.features[0].geometry.type).toEqual("LineString");
+        expect(featureCollection.features[0].properties.lines).toBeDefined();
+        expect(featureCollection.features[0].properties.station_to).toBeDefined();
+        done();
+      });
+    });
+  });
+});

package/api/StopsAPI.js

@@ -0,0 +1,12 @@
+import HttpAPI from "../common/api/HttpAPI";
+class StopsAPI extends HttpAPI {
+  constructor(options = {}) {
+    super({ url: "https://api.geops.io/stops/v1/", ...options });
+  }
+  search(params, abortController = {}) {
+    return this.fetch("", params, {
+      signal: abortController.signal
+    });
+  }
+}
+export default StopsAPI;

package/api/StopsAPI.test.js

@@ -0,0 +1,22 @@
+import fetch from "jest-fetch-mock";
+import StopsAPI from "./StopsAPI";
+let api;
+describe("StopsAPI", () => {
+  beforeEach(() => {
+    global.fetch = fetch;
+    fetch.resetMocks();
+    api = new StopsAPI({ apiKey: "apiKey" });
+  });
+  describe("#search", () => {
+    test("should success", (done) => {
+      fetch.mockResponseOnce(JSON.stringify(global.stopsSearchResponse));
+      return api.search({
+        q: "Bern"
+      }).then((featureCollection) => {
+        expect(fetch.mock.calls[0][0]).toEqual("https://api.geops.io/stops/v1/?key=apiKey&q=Bern");
+        expect(featureCollection.features[0].properties.name).toEqual("Bern");
+        done();
+      });
+    });
+  });
+});

package/api/TralisAPI.js

@@ -0,0 +1,359 @@
+import WebSocketAPI from "../common/api/WebSocketAPI";
+import {
+  getModeSuffix,
+  cleanStopTime,
+  compareDepartures
+} from "./TralisAPIUtils";
+export const TralisModes = {
+  RAW: "raw",
+  TOPOGRAPHIC: "topographic",
+  SCHEMATIC: "schematic"
+};
+class TralisAPI {
+  constructor(options = {}) {
+    this.defineProperties(options);
+    this.subscribedStationUic = null;
+    this.departureUpdateTimeout = null;
+    this.maxDepartureAge = 30;
+    this.extraGeoms = {};
+    this.prefix = options.prefix || "";
+    this.onOpen = this.onOpen.bind(this);
+  }
+  defineProperties(options) {
+    let opt = options;
+    if (typeof options === "string") {
+      opt = { url: options };
+    }
+    const { apiKey } = opt;
+    let { url, projection, bbox, buffer = [100, 100] } = opt;
+    const wsApi = new WebSocketAPI();
+    if (apiKey) {
+      url = `${url || "wss://api.geops.io/tracker-ws/v1/"}?key=${apiKey}`;
+    }
+    Object.defineProperties(this, {
+      url: {
+        get: () => url,
+        set: (newUrl) => {
+          url = newUrl;
+          this.open();
+        }
+      },
+      projection: {
+        get: () => projection,
+        set: (newProjection) => {
+          if (newProjection !== projection) {
+            projection = newProjection;
+            if (this.wsApi) {
+              this.wsApi.send(`PROJECTION ${projection}`);
+            }
+          }
+        }
+      },
+      bbox: {
+        get: () => bbox,
+        set: (newBbox) => {
+          if (JSON.stringify(newBbox) !== JSON.stringify(bbox)) {
+            bbox = newBbox;
+            if (this.wsApi) {
+              this.wsApi.send(`BBOX ${bbox.join(" ")}`);
+            }
+          }
+        }
+      },
+      buffer: {
+        get: () => buffer,
+        set: (newBuffer) => {
+          if (JSON.stringify(newBuffer) !== JSON.stringify(buffer)) {
+            buffer = newBuffer;
+            if (this.wsApi) {
+              this.wsApi.send(`BUFFER ${buffer.join(" ")}`);
+            }
+          }
+        }
+      },
+      wsApi: {
+        value: wsApi,
+        writable: true
+      },
+      pingIntervalMs: {
+        value: options.pingIntervalMs || 1e4,
+        writable: true
+      },
+      reconnectTimeoutMs: {
+        value: options.pingIntervalMs || 100,
+        writable: true
+      }
+    });
+  }
+  open() {
+    this.close();
+    this.wsApi.connect(this.url, this.onOpen);
+    this.wsApi.websocket.onclose = () => {
+      this.onClose();
+    };
+  }
+  close() {
+    this.wsApi.close();
+  }
+  reset() {
+    this.wsApi.send("RESET");
+  }
+  onOpen() {
+    if (this.projection) {
+      this.wsApi.send(`PROJECTION ${this.projection}`);
+    }
+    if (this.bbox) {
+      this.wsApi.send(`BBOX ${this.bbox.join(" ")}`);
+    }
+    if (this.buffer) {
+      this.wsApi.send(`BUFFER ${this.buffer.join(" ")}`);
+    }
+    if (this.pingIntervalMs) {
+      window.clearInterval(this.pingInterval);
+      this.pingInterval = setInterval(() => {
+        this.wsApi.send("PING");
+      }, this.pingIntervalMs);
+    }
+  }
+  onClose() {
+    window.clearTimeout(this.pingInterval);
+    window.clearTimeout(this.reconnectTimeout);
+    if (this.reconnectTimeoutMs) {
+      this.reconnectTimeout = window.setTimeout(() => this.open(), this.reconnectTimeoutMs);
+    }
+  }
+  subscribe(channel, onSuccess, onError, quiet = false) {
+    this.wsApi.subscribe({ channel }, onSuccess, onError, quiet);
+  }
+  unsubscribe(channel, suffix, cb) {
+    this.wsApi.unsubscribe(`${channel}${getModeSuffix(TralisModes.SCHEMATIC, TralisModes)}${suffix}`, cb);
+    this.wsApi.unsubscribe(`${channel}${getModeSuffix(TralisModes.TOPOGRAPHIC, TralisModes)}${suffix || ""}`, cb);
+  }
+  filterDepartures(depObject, sortByMinArrivalTime = false) {
+    const departures = Object.keys(depObject).map((k) => depObject[k]);
+    departures.sort((a, b) => compareDepartures(a, b, sortByMinArrivalTime));
+    let future = new Date();
+    future.setMinutes(future.getMinutes() + this.maxDepartureAge);
+    future = future.getTime();
+    let past = new Date();
+    past.setMinutes(past.getMinutes() - this.maxDepartureAge);
+    past = past.getTime();
+    const departureArray = [];
+    const platformsBoarding = [];
+    let previousDeparture = null;
+    for (let i = departures.length - 1; i >= 0; i -= 1) {
+      const d = departures[i];
+      const t = new Date(d.time).getTime();
+      if (t > past && t < future) {
+        if (d.state === "BOARDING") {
+          if (platformsBoarding.indexOf(d.platform) === -1) {
+            platformsBoarding.push(d.platform);
+          } else {
+            d.state = "HIDDEN";
+          }
+        }
+        if (previousDeparture && d.to[0] === previousDeparture.to[0] && Math.abs(t - previousDeparture.time) < 1e3 && d.line.name === previousDeparture.line.name) {
+          d.state = "HIDDEN";
+        }
+        if (/(STOP_CANCELLED|JOURNEY_CANCELLED)/.test(d.state)) {
+          d.cancelled = true;
+        }
+        previousDeparture = d;
+        previousDeparture.time = t;
+        departureArray.unshift(d);
+      }
+    }
+    return departureArray;
+  }
+  subscribeDepartures(stationId, sortByMinArrivalTime, onMessage) {
+    window.clearTimeout(this.departureUpdateTimeout);
+    this.unsubscribeDepartures();
+    this.subscribedStationUic = stationId;
+    const channel = stationId ? `timetable_${stationId}` : null;
+    const departureObject = {};
+    this.subscribe(channel, (data) => {
+      if (data.source === channel) {
+        const content = data.content || {};
+        const tDiff = new Date(content.timestamp).getTime() - Date.now();
+        content.timediff = tDiff;
+        departureObject[content.call_id] = content;
+        window.clearTimeout(this.departureUpdateTimeout);
+        this.departureUpdateTimeout = window.setTimeout(() => {
+          const departures = this.filterDepartures(departureObject, sortByMinArrivalTime || false);
+          onMessage(departures);
+        }, 100);
+      }
+    }, () => {
+      onMessage([]);
+    });
+  }
+  unsubscribeDepartures(cb) {
+    if (this.subscribedStationUic) {
+      this.unsubscribe(`timetable_${this.subscribedStationUic}`, "", cb);
+      this.subscribedStationUic = null;
+    }
+  }
+  subscribeDisruptions(onMessage) {
+    this.subscribe(`${this.prefix}newsticker`, (data) => {
+      onMessage(data.content);
+    });
+  }
+  unsubscribeDisruptions(cb) {
+    this.unsubscribe(`${this.prefix}newsticker`, "", cb);
+  }
+  getStation(uic, mode) {
+    const params = {
+      channel: `station${getModeSuffix(mode, TralisModes)}`,
+      args: uic
+    };
+    return new Promise((resolve, reject) => {
+      this.wsApi.get(params, (data) => {
+        if (data.content) {
+          resolve(data.content);
+        } else {
+          reject();
+        }
+      });
+    });
+  }
+  getStations(mode) {
+    const stations = [];
+    const params = {
+      channel: `station${getModeSuffix(mode, TralisModes)}`
+    };
+    window.clearTimeout(this.stationUpdateTimeout);
+    return new Promise((resolve, reject) => {
+      this.wsApi.get(params, (data) => {
+        if (data.content) {
+          stations.push(data.content);
+          window.clearTimeout(this.stationUpdateTimeout);
+          this.stationUpdateTimeout = window.setTimeout(() => {
+            resolve(stations);
+          }, 50);
+        } else {
+          reject(data.content);
+        }
+      });
+    });
+  }
+  subscribeStations(mode, onMessage) {
+    this.unsubscribeStations();
+    this.subscribe(`station${getModeSuffix(mode, TralisModes)}`, (data) => {
+      if (data.content) {
+        onMessage(data.content);
+      }
+    });
+  }
+  unsubscribeStations(cb) {
+    window.clearTimeout(this.stationUpdateTimeout);
+    this.unsubscribe("station", "", cb);
+  }
+  subscribeExtraGeoms(onMessage) {
+    this.subscribe("extra_geoms", (data) => {
+      const extraGeom = data.content;
+      if (extraGeom) {
+        const { ref } = extraGeom.properties;
+        if (extraGeom.type === "Feature") {
+          this.extraGeoms[ref] = extraGeom;
+        } else {
+          delete this.extraGeoms[ref];
+        }
+        onMessage(Object.keys(this.extraGeoms).map((key) => this.extraGeoms[key]));
+      }
+    });
+  }
+  unsubscribeExtraGeoms(cb) {
+    this.unsubscribe("extra_geoms", "", cb);
+  }
+  subscribeTrajectory(mode, onMessage, quiet = false) {
+    this.unsubscribeTrajectory(onMessage);
+    this.subscribe(`trajectory${getModeSuffix(mode, TralisModes)}`, onMessage, null, quiet);
+  }
+  unsubscribeTrajectory(cb) {
+    this.unsubscribe(`trajectory`, "", cb);
+  }
+  subscribeDeletedVehicles(mode, onMessage, quiet = false) {
+    this.unsubscribeDeletedVehicles(onMessage);
+    this.subscribe(`deleted_vehicles${getModeSuffix(mode, TralisModes)}`, onMessage, null, quiet);
+  }
+  unsubscribeDeletedVehicles(cb) {
+    this.unsubscribe("deleted_vehicles", "", cb);
+  }
+  getFullTrajectory(id, mode, generalizationLevel) {
+    const channel = [`full_trajectory${getModeSuffix(mode, TralisModes)}`];
+    if (id) {
+      channel.push(id);
+    }
+    if ((!mode || mode === TralisModes.TOPOGRAPHIC) && generalizationLevel) {
+      channel.push(`gen${generalizationLevel}`);
+    }
+    const params = {
+      channel: channel.join("_")
+    };
+    return new Promise((resolve) => {
+      this.wsApi.get(params, (data) => {
+        if (data.content) {
+          resolve(data.content);
+        }
+      });
+    });
+  }
+  getFullTrajectories(ids, mode, generalizationLevel) {
+    const promises = ids.map((id) => this.getFullTrajectory(id, mode, generalizationLevel));
+    return Promise.all(promises);
+  }
+  subscribeFullTrajectory(id, mode) {
+    this.unsubscribeFullTrajectory(id);
+    this.subscribe(`full_trajectory${getModeSuffix(mode, TralisModes)}_${id}`, (data) => {
+      console.log("subscribe full_trajectory", data);
+    }, (err) => {
+      console.log("subscribe full_trajectory error", err);
+    });
+  }
+  unsubscribeFullTrajectory(id, cb) {
+    this.unsubscribe("full_trajectory", `_${id}`, cb);
+  }
+  getStopSequence(id) {
+    const params = {
+      channel: `stopsequence_${id}`
+    };
+    return new Promise((resolve, reject) => {
+      this.wsApi.get(params, (data) => {
+        if (data.content && data.content.length) {
+          const content = data.content.map((stopSequence) => cleanStopTime(stopSequence));
+          resolve(content);
+        }
+        resolve([]);
+      }, (err) => {
+        reject(err);
+      });
+    });
+  }
+  getStopSequences(ids) {
+    const promises = ids.map((id) => this.getStopSequence(id));
+    return Promise.all(promises);
+  }
+  subscribeStopSequence(id, onMessage) {
+    window.clearTimeout(this.fullTrajectoryUpdateTimeout);
+    this.unsubscribeStopSequence(id);
+    this.subscribe(`stopsequence_${id}`, (data) => {
+      if (data.content && data.content.length) {
+        const content = data.content.map((stopSequence) => cleanStopTime(stopSequence));
+        onMessage(content);
+      }
+    }, (err) => {
+      console.log("subscribe stopsequence error", err);
+    });
+  }
+  unsubscribeStopSequence(id, cb) {
+    this.unsubscribe(`stopsequence`, `_${id}`, cb);
+  }
+  subscribeHealthCheck(onMessage) {
+    this.unsubscribeHealthCheck();
+    this.subscribe("healthcheck", onMessage);
+  }
+  unsubscribeHealthCheck() {
+    this.unsubscribe("healthcheck");
+  }
+}
+export default TralisAPI;

package/api/TralisAPI.test.js

@@ -0,0 +1,67 @@
+import { TralisAPI, TralisModes } from ".";
+describe("TralisAPI", () => {
+  let tralisAPI;
+  let get;
+  beforeEach(() => {
+    get = jest.fn((params, cb) => {
+      cb({ content: "content" });
+    });
+    tralisAPI = new TralisAPI();
+    tralisAPI.wsApi = {
+      get
+    };
+  });
+  describe("#getFullTrajectory() calls fullTrajectory channel", () => {
+    test("without parameters", (done) => {
+      tralisAPI.getFullTrajectory().then(() => {
+        expect(get.mock.calls.length).toBe(1);
+        expect(get.mock.calls[0][0]).toEqual({
+          channel: "full_trajectory"
+        });
+        done();
+      });
+    });
+    [null, TralisModes.TOPOGRAPHIC].forEach((mode) => {
+      describe(`using mode ${mode}`, () => {
+        test("using id", (done) => {
+          tralisAPI.getFullTrajectory("foo", mode).then(() => {
+            expect(get.mock.calls.length).toBe(1);
+            expect(get.mock.calls[0][0]).toEqual({
+              channel: "full_trajectory_foo"
+            });
+            done();
+          });
+        });
+        test("using id and generalizationLevel param", (done) => {
+          tralisAPI.getFullTrajectory("foo", mode, 5).then(() => {
+            expect(get.mock.calls.length).toBe(1);
+            expect(get.mock.calls[0][0]).toEqual({
+              channel: "full_trajectory_foo_gen5"
+            });
+            done();
+          });
+        });
+      });
+    });
+    describe("using schematic mode ", () => {
+      test("using id", (done) => {
+        tralisAPI.getFullTrajectory("foo", TralisModes.SCHEMATIC).then(() => {
+          expect(get.mock.calls.length).toBe(1);
+          expect(get.mock.calls[0][0]).toEqual({
+            channel: "full_trajectory_schematic_foo"
+          });
+          done();
+        });
+      });
+      test("doesn't use generalizationLevel param", (done) => {
+        tralisAPI.getFullTrajectory("foo", TralisModes.SCHEMATIC, 10).then(() => {
+          expect(get.mock.calls.length).toBe(1);
+          expect(get.mock.calls[0][0]).toEqual({
+            channel: "full_trajectory_schematic_foo"
+          });
+          done();
+        });
+      });
+    });
+  });
+});

package/{src/api/tralis → api}/TralisAPIUtils.js

@@ -1,38 +1,19 @@
-/**
- * Get the websocket channel suffix, depending on the current mode.
- * @param {String} mode Mode 'topographic' ou 'schematic'.
- * @private
- */
-export const getModeSuffix = (mode, modes) =>
-  mode === modes.SCHEMATIC ? '_schematic' : '';
-
-/**
- * Compare two given departures for sort alogithm,
- * @param {Object} a First departure.
- * @param {Object} b Second departure.
- * @private
- */
+export const getModeSuffix = (mode, modes) => mode === modes.SCHEMATIC ? "_schematic" : "";
 export const compareDepartures = (a, b, sortByMinArrivalTime = false) => {
-  // First LEAVING and HIDDEN, then BOARDING and then sorted by time.
-  const topStates = ['HIDDEN', 'LEAVING', 'BOARDING'];
+  const topStates = ["HIDDEN", "LEAVING", "BOARDING"];
   const aTop = a.has_fzo && topStates.indexOf(a.state) > -1;
   const bTop = b.has_fzo && topStates.indexOf(b.state) > -1;
-
   if (aTop || bTop) {
     if (aTop !== bTop) {
       return aTop ? -1 : 1;
     }
-
     if (a.state !== b.state) {
-      // one is leaving
       return topStates.indexOf(a.state) - topStates.indexOf(b.state);
     }
   }
-
   let aDuration = null;
   let bDuration = null;
   const now = Date.now();
-
   if (sortByMinArrivalTime) {
     aDuration = new Date(a.min_arrival_time || a.time).getTime() - now;
     bDuration = new Date(b.min_arrival_time || b.time).getTime() - now;
@@ -40,34 +21,23 @@ export const compareDepartures = (a, b, sortByMinArrivalTime = false) => {
     aDuration = new Date(a.time).getTime() - now;
     bDuration = new Date(b.time).getTime() - now;
   }
-
   return aDuration - bDuration;
 };
-
-/**
- * Remove the delay from arrivalTime and departureTime
- * @private
- */
 export const cleanStopTime = (content) => {
   if (!content) {
     return;
   }
   content.stations.forEach((station) => {
-    // eslint-disable-next-line no-param-reassign
     station.arrivalTimeWithDelay = station.arrivalTime;
     if (station.departureTime) {
-      // eslint-disable-next-line no-param-reassign
       station.departureTimeWithDelay = station.departureTime;
     }
     if (station.arrivalDelay) {
-      // eslint-disable-next-line no-param-reassign
       station.arrivalTime -= station.arrivalDelay;
       if (station.departureTime) {
-        // eslint-disable-next-line no-param-reassign
         station.departureTime -= station.arrivalDelay;
       }
     }
   });
-  // eslint-disable-next-line consistent-return
   return content;
 };

package/api/index.js

@@ -0,0 +1,3 @@
+export { default as RoutingAPI } from "./RoutingAPI";
+export { default as StopsAPI } from "./StopsAPI";
+export { default as TralisAPI, TralisModes } from "./TralisAPI";

package/common/Tracker.js

@@ -0,0 +1,93 @@
+import { compose, apply, create } from "ol/transform";
+import getVehiclePosition from "./utils/getVehiclePosition";
+export default class Tracker {
+  constructor(options) {
+    this.style = options.style;
+    this.canvas = options.canvas || document.createElement("canvas");
+  }
+  renderTrajectories(trajectories, viewState, options) {
+    const {
+      time = Date.now(),
+      size = [],
+      center,
+      resolution,
+      rotation = 0,
+      pixelRatio
+    } = viewState;
+    const {
+      noInterpolate = false,
+      hoverVehicleId,
+      selectedVehicleId
+    } = options;
+    const { canvas } = this;
+    const context = canvas.getContext("2d");
+    context.clearRect(0, 0, canvas.width, canvas.height);
+    const [width, height] = size;
+    if (width && height && (canvas.width !== width || canvas.height !== height)) {
+      [canvas.width, canvas.height] = [width * pixelRatio, height * pixelRatio];
+    }
+    const coordinateToPixelTransform = compose(create(), size[0] / 2, size[1] / 2, 1 / resolution, -1 / resolution, -rotation, -center[0], -center[1]);
+    if (canvas.style) {
+      canvas.style.width = `${canvas.width / pixelRatio}px`;
+      canvas.style.height = `${canvas.height / pixelRatio}px`;
+    }
+    let hoverVehicleImg;
+    let hoverVehiclePx;
+    let hoverVehicleWidth;
+    let hoverVehicleHeight;
+    let selectedVehicleImg;
+    let selectedVehiclePx;
+    let selectedVehicleWidth;
+    let selectedVehicleHeight;
+    let nbRendered = 0;
+    for (let i = trajectories.length - 1; i >= 0; i -= 1) {
+      const trajectory = trajectories[i];
+      const { train_id: id, timeOffset } = trajectory.properties;
+      const { coord, rotation: rotationIcon } = getVehiclePosition(time - (timeOffset || 0), trajectory, noInterpolate);
+      trajectories[i].properties.coordinate = coord;
+      trajectories[i].properties.rotation = rotationIcon;
+      if (!coord) {
+        continue;
+      }
+      let px = apply(coordinateToPixelTransform, [...coord]);
+      if (!px) {
+        continue;
+      }
+      px = px.map((p) => p * pixelRatio);
+      if (px[0] < 0 || px[0] > canvas.width || px[1] < 0 || px[1] > canvas.height) {
+        continue;
+      }
+      const vehicleImg = this.style(trajectory, viewState, options);
+      if (!vehicleImg) {
+        continue;
+      }
+      nbRendered += 1;
+      const imgWidth = vehicleImg.width;
+      const imgHeight = vehicleImg.height;
+      if (hoverVehicleId !== id && selectedVehicleId !== id) {
+        context.drawImage(vehicleImg, px[0] - imgWidth / 2, px[1] - imgHeight / 2, imgWidth, imgHeight);
+      }
+      if (hoverVehicleId && hoverVehicleId === id) {
+        hoverVehicleImg = vehicleImg;
+        hoverVehiclePx = px;
+        hoverVehicleWidth = imgWidth;
+        hoverVehicleHeight = imgHeight;
+      }
+      if (selectedVehicleId && selectedVehicleId === id) {
+        selectedVehicleImg = vehicleImg;
+        selectedVehiclePx = px;
+        selectedVehicleWidth = imgWidth;
+        selectedVehicleHeight = imgHeight;
+      }
+    }
+    if (selectedVehicleImg) {
+      context.drawImage(selectedVehicleImg, selectedVehiclePx[0] - selectedVehicleWidth / 2, selectedVehiclePx[1] - selectedVehicleHeight / 2, selectedVehicleWidth, selectedVehicleHeight);
+    }
+    if (hoverVehicleImg) {
+      context.drawImage(hoverVehicleImg, hoverVehiclePx[0] - hoverVehicleWidth / 2, hoverVehiclePx[1] - hoverVehicleHeight / 2, hoverVehicleWidth, hoverVehicleHeight);
+    }
+    return {
+      nbTrajectoriesRendered: nbRendered
+    };
+  }
+}