Add an optimizer library to score tracks

CONTRIBUTING.md

@@ -0,0 +1,51 @@
+# How to contribute.
+
+## Required tools
+
+- node.js
+- npm
+- on mac-os, you have to install xcode command line developer tools (run xcode-select --install)
+- gcloud
+- docker
+- the IDE of your choice
+
+## Project setup
+
+- run `npm install`
+- add default keys definitions
+  - `cp apps/fxc-front/src/app/keys.ts.dist apps/fxc-front/src/app/keys.ts`
+  - `cp libs/common/src/lib/keys.ts.dist libs/common/src/lib/keys.ts`
+
+### Simplistic configuration
+
+**redis server**
+
+- `cd docker; docker compose up -d redis`
+
+**pubsub**
+
+- `cd docker; docker compose up -d pubsub`
+
+**datastore**
+
+For the moment, it does not work with docker compose. But if you install the cloud-datastore-emulator, you will have a working configuration.
+
+**_Installation_**
+
+- `gcloud components install cloud-datastore-emulator`
+
+**_run the data store:_**
+
+- `gcloud beta emulators datastore start --data-dir=MY_DATA_DIR`
+
+**_before npm run dev:_**
+
+- open another shell.
+- define the required environment variables:`eval $(gcloud beta emulators datastore --data-dir=MY_DATA_DIR env-init)`
+- you can then run the application locally in this shell with `npm run dev`
+
+## Helpful commands
+
+`npx nx check` runs the build, lint, and test targets for all the projects. Nice to use before uploading a PR.
+
+`nx affected:test --all --parallel --maxParallel 10 --watch` will run the tests affected by your code changes.

apps/fxc-front/src/app/components/2d/path-element.ts

@@ -13,12 +13,13 @@ import { FaiSectors } from '../../gm/fai-sectors';
 import { addAltitude } from '../../logic/elevation';
 import { getCurrentUrl, pushCurrentState } from '../../logic/history';
 import { drawRoute } from '../../logic/messages';
-import { LEAGUES } from '../../logic/score/league/leagues';
-import { Measure } from '../../logic/score/measure';
-import { CircuitType, Score } from '../../logic/score/scorer';
+import { Score } from '../../logic/score/scorer';
 import { setDistance, setEnabled, setRoute, setScore } from '../../redux/planner-slice';
 import { RootState, store } from '../../redux/store';
 import { PlannerElement } from './planner-element';
+import { CircuitType, getOptimizer } from '@flyxc/optimizer';
+import { getScoringRuleName } from '../../logic/score/league/leagues';
+import type { LeagueCode } from '../../logic/score/league/leagues';
 
 // Route color by circuit type.
 const ROUTE_STROKE_COLORS = {
@@ -44,7 +45,7 @@ export class PathElement extends connect(store)(LitElement) {
   @state()
   private enabled = false;
   @state()
-  private league = 'xc';
+  private league: LeagueCode = 'xc';
   @state()
   private encodedRoute = '';
   @state()
@@ -191,18 +192,14 @@ export class PathElement extends connect(store)(LitElement) {
 
   // Optimize the route and draw the optimize lines and sectors.
   private optimize(): void {
-    if (!this.line || this.line.getPath().getLength() < 2) {
+    const { line } = this;
+    if (!line || line.getPath().getLength() < 2 || this.doNotSyncState) {
       return;
     }
-    const line = this.line;
     store.dispatch(setDistance(google.maps.geometry.spherical.computeLength(line.getPath())));
 
     const points = this.getPathPoints();
-    const measure = new Measure(points);
-    const scores = LEAGUES[this.league].score(measure);
-
-    scores.sort((score1, score2) => score2.points - score1.points);
-    const score = scores[0];
+    const score = this.computeScore(points);
     store.dispatch(setScore(score));
 
     let optimizedPath = score.indexes.map((index) => new google.maps.LatLng(points[index].lat, points[index].lon));
@@ -212,9 +209,8 @@ export class PathElement extends connect(store)(LitElement) {
       optimizedPath = [optimizedPath[1], optimizedPath[2]];
     }
 
-    if (!this.optimizedLine) {
-      this, (this.optimizedLine = new google.maps.Polyline());
-    }
+    this.optimizedLine ??= new google.maps.Polyline();
+
     this.optimizedLine.setOptions({
       map: this.map,
       path: optimizedPath,
@@ -229,10 +225,10 @@ export class PathElement extends connect(store)(LitElement) {
       this.closingSector.addListener('rightclick', (e) => this.appendToPath(e.latLng));
     }
 
-    if (score.closingRadius) {
+    if (score.closingRadiusM) {
       const center = points[score.indexes[0]];
       this.closingSector.center = center;
-      this.closingSector.radius = score.closingRadius;
+      this.closingSector.radius = score.closingRadiusM;
       this.closingSector.update();
       this.closingSector.setMap(this.map);
     } else {
@@ -254,12 +250,28 @@ export class PathElement extends connect(store)(LitElement) {
     this.postScoreToHost(score);
   }
 
+  private computeScore(points: LatLon[]): Score {
+    // TODO: limit the processing time ?
+    const result = getOptimizer(
+      { track: { points: points.map((point, i) => ({ ...point, alt: 0, timeSec: i * 60 })) } },
+      getScoringRuleName(this.league),
+    ).next().value;
+    return new Score({
+      circuit: result.circuit,
+      distanceM: result.lengthKm * 1000,
+      multiplier: result.multiplier,
+      closingRadiusM: result.closingRadiusM ? result.closingRadiusM * 1000 : null,
+      indexes: result.solutionIndices,
+      points: result.score,
+    });
+  }
+
   // Sends a message to the iframe host with the changes.
   private postScoreToHost(score: Score) {
     let kms = '';
     let circuit = '';
-    if (score.distance && window.parent) {
-      kms = (score.distance / 1000).toFixed(1);
+    if (score.distanceM && window.parent) {
+      kms = (score.distanceM / 1000).toFixed(1);
       circuit = CIRCUIT_SHORT_NAME[score.circuit];
       if (score.circuit == CircuitType.OpenDistance) {
         circuit += score.indexes.length - 2;

apps/fxc-front/src/app/components/2d/planner-element.ts

@@ -139,7 +139,7 @@ export class PlannerElement extends connect(store)(LitElement) {
         <div>
           <div>${this.score.circuit}</div>
           <div class="large">
-            ${unsafeHTML(units.formatUnit(this.score.distance / 1000, this.units.distance, undefined, 'unit'))}
+            ${unsafeHTML(units.formatUnit(this.score.distanceM / 1000, this.units.distance, undefined, 'unit'))}
           </div>
         </div>
         <div class="collapsible">

apps/fxc-front/src/app/components/ui/about-modal.ts

@@ -20,7 +20,8 @@ export class AboutModal extends LitElement {
           <a href="https://github.com/mmomtchev" target="_blank">Momtchil Momtchev</a>,
           <a href="https://github.com/osmeras" target="_blank">Stanislav Ošmera</a>,
           <a href="https://github.com/tris" target="_blank">Tristan Horn</a>,
-          <a href="https://github.com/spasutto" target="_blank">Sylvain Pasutto</a>
+          <a href="https://github.com/spasutto" target="_blank">Sylvain Pasutto</a>,
+          <a href="https://github.com/flyingtof" target="_blank">flyingtof</a>
         </p>
 
         <p>

apps/fxc-front/src/app/components/ui/main-menu.ts

@@ -628,18 +628,18 @@ export class TrackItems extends connect(store)(LitElement) {
     (this.renderRoot.querySelector('#track') as HTMLInputElement)?.click();
   }
 
-  private async handleUpload(e: Event): Promise<void> {
+  private async handleUpload(e: Event & { target: HTMLInputElement }): Promise<void> {
     if (e.target) {
-      const el = e.target as HTMLInputElement;
-      if (el.files?.length) {
+      const input = e.target;
+      if (input.files?.length) {
         const files: File[] = [];
-        for (let i = 0; i < el.files.length; i++) {
-          files.push(el.files[i]);
+        for (let i = 0; i < input.files.length; i++) {
+          files.push(input.files[i]);
         }
         const ids = await uploadTracks(files);
         pushCurrentState();
         addUrlParamValues(ParamNames.groupId, ids);
-        el.value = '';
+        input.value = '';
       }
     }
   }

apps/fxc-front/src/app/components/ui/pref-modal.ts

@@ -4,11 +4,11 @@ import { connect } from 'pwa-helpers';
 
 import { modalController } from '@ionic/core/components';
 
-import { LEAGUES } from '../../logic/score/league/leagues';
 import * as units from '../../logic/units';
 import { setLeague } from '../../redux/planner-slice';
 import { RootState, store } from '../../redux/store';
 import { setAltitudeUnit, setDistanceUnit, setSpeedUnit, setVarioUnit } from '../../redux/units-slice';
+import { LEAGUE_CODES, LEAGUES } from '../../logic/score/league/leagues';
 
 @customElement('pref-modal')
 export class PrefModal extends connect(store)(LitElement) {
@@ -21,7 +21,7 @@ export class PrefModal extends connect(store)(LitElement) {
 
   constructor() {
     super();
-    Object.getOwnPropertyNames(LEAGUES).forEach((value) => {
+    LEAGUE_CODES.forEach((value) => {
       this.leagues.push({ value, name: LEAGUES[value].name });
     });
     this.leagues.sort((a, b) => (a < b ? -1 : 1));

apps/fxc-front/src/app/logic/score/league/leagues.ts

@@ -1,22 +1,46 @@
-import { League } from '../league';
-import { CzechEurope, CzechLocal, CzechOutEurope } from './czech';
-import { FrCfd } from './frcfd';
-import { Leonardo } from './leonardo';
-import { UKXCLClub, UKXCLInternational, UKXCLNational } from './ukxcl';
-import { WXC } from './wxc';
-import { NorwayLeague, XContest, XContestPPG } from './xcontest';
+import { ScoringRuleName } from '@flyxc/optimizer';
 
-export const LEAGUES: { [name: string]: League } = {
-  czl: new CzechLocal(),
-  cze: new CzechEurope(),
-  czo: new CzechOutEurope(),
-  fr: new FrCfd(),
-  leo: new Leonardo(),
-  nor: new NorwayLeague(),
-  ukc: new UKXCLClub(),
-  uki: new UKXCLInternational(),
-  ukn: new UKXCLNational(),
-  xc: new XContest(),
-  xcppg: new XContestPPG(),
-  wxc: new WXC(),
+export const LEAGUE_CODES = [
+  'czl',
+  'cze',
+  'czo',
+  'fr',
+  'leo',
+  'nor',
+  'ukc',
+  'uki',
+  'ukn',
+  'xc',
+  'xcppg',
+  'wxc',
+] as const;
+
+export type LeagueCode = (typeof LEAGUE_CODES)[number];
+
+interface LeagueDetails {
+  name: string;
+  ruleName: ScoringRuleName;
+}
+
+export const LEAGUES: Readonly<Record<LeagueCode, LeagueDetails>> = {
+  czl: { name: 'Czech (ČPP local)', ruleName: 'CzechLocal' },
+  cze: { name: 'Czech (ČPP Europe)', ruleName: 'CzechEurope' },
+  czo: { name: 'Czech (ČPP outside Europe)', ruleName: 'CzechOutsideEurope' },
+  fr: { name: 'France (CFD)', ruleName: 'FFVL' },
+  leo: { name: 'Leonardo', ruleName: 'Leonardo' },
+  nor: { name: 'Norway (Distanseligaen)', ruleName: 'Norway' },
+  ukc: { name: 'UK (XC League, Club)', ruleName: 'UKClub' },
+  uki: { name: 'UK (XC League, International)', ruleName: 'UKInternational' },
+  ukn: { name: 'UK (XC League, National)', ruleName: 'UKNational' },
+  xc: { name: 'XContest', ruleName: 'XContest' },
+  xcppg: { name: 'XContest PPG', ruleName: 'XContestPPG' },
+  wxc: { name: 'World XC Online Contest', ruleName: 'WorldXC' },
 };
+
+export function getScoringRuleName(leagueCode: LeagueCode): ScoringRuleName {
+  const ruleName = LEAGUES[leagueCode]?.ruleName;
+  if (ruleName == null) {
+    throw new Error('Unkown league code "${leagueCode}"');
+  }
+  return ruleName;
+}