@rasifix/orienteering-utils 1.0.6 → 2.0.0

package/{lib/anonymizer.js → src/utils/anonymizer.ts}

@@ -1,9 +1,12 @@
+import { Competition } from "../model/competition";
+import { Sex } from "../model/runner";
+
 const names = [
     'Gustavson', 'Hendrikson', 'Meyer', 'Marlovic', 'Torres', 'Huber',
     'Wüst', 'Zürcher', 'Berner', 'Rufer', 'Gutmann', 'Hübscher',
     'Schneller', 'Widemar', 'Rohrer', 'Kunz', 'Kinzle', 'Steinle',
     'Allemann', 'Röhrig', 'Meyer', 'Uhlmann', 'Garaio', 'Regazoni',
-    'Maudet', 'Zoja'
+    'Maudet', 'Zoja', 'Scheller', 'Beckenbauer', 'Würsten'
 ];
 
 const firstNames = {
@@ -16,17 +19,17 @@ const firstNames = {
     ],
     m: [
         'Albert', 'Bruno', 'Chris', 'Dirk', 'David', 'Erwin', 'Francesco',
-        'Fritz', 'Gianni', 'Gustav', 'Hans', 'Ian', 'Jan', 'Karl', 'Lars',
+        'Fritz', 'Gianni', 'Gustav', 'Hans', 'Henrik', 'Ian', 'Jan', 'Karl', 'Lars',
         'Martin', 'Marco', 'Markus', 'Nico', 'Nino', 'Otto', 'Olav',
         'Patric', 'Pablo', 'Quentin', 'Ralf', 'Rudolf', 'Simon', 'Steve',
-        'Thomas', 'Tim', 'Urs', 'Udo'
+        'Thomas', 'Tim', 'Urs', 'Udo', 'Zan'
     ]
 };
 
 const cities = [
-    'Aarberg', 'Bern', 'Colombier', 'Diemerswil', 'Elm', 'Fribourg',
-    'Goldiwil', 'Heimiswil', 'Illiswil', 'Konolfingen', 'Lausanne',
-    'Lugano', 'Martigny', 'Neuchatel', 'Orbe', 'Zürich'
+    'Aarberg', 'Bern', 'Burgdorf', 'Colombier', 'Diemerswil', 'Domdidier', 'Elm', 'Flawil', 'Fribourg',
+    'Goldiwil', 'Heimiswil', 'Hergiswil', 'Illiswil', 'Konolfingen', 'Lausanne', 'Locarno',
+    'Lugano', 'Martigny', 'Neuchatel', 'Orbe', 'Uzwil', 'Zürich'
 ];
 
 const clubs = {
@@ -34,39 +37,35 @@ const clubs = {
     names: ['Bernstein', 'Erdmannlistein', 'Blanc', 'Piz Balü', 'Bartli und Most', 'Aare', 'Reuss' ]
 };
 
-function random(arr) {
-    if (arr.lenght === 0) {
-        return null;
-    }
+function random(arr: string[]):string {
     const idx = Math.floor(Math.random() * (arr.length - 1));
     return arr[idx];
 }
 
-function randInt(from, to) {
+function randInt(from: number, to: number) {
     return from + Math.round(Math.random() * (to - from));
 }
 
-module.exports.anonymize = function(event) {
-    event.categories.forEach(category => {
+export function anonymize(competition: Competition) {
+    competition.categories.forEach(category => {
         category.runners.forEach(runner => {
             runner.name = random(names);
 
-            if (runner.sex === 'M' || runner.sex === 'm') {
-                runner.firstName = random(firstNames.m);
-                runner.sex = 'M';
-            } else {
+            if (!runner.sex || runner.sex === 'f') {
                 runner.firstName = random(firstNames.f);
-                runner.sex = 'F';
+                runner.sex = Sex.female;
+            } else {
+                runner.firstName = random(firstNames.m);
+                runner.sex = Sex.male;
             }
 
             runner.fullName = runner.firstName + ' ' + runner.name;
 
             runner.city = random(cities);
             runner.club = random(clubs.prefixes) + ' ' + random(clubs.names);
-            runner.yearOfBirth = randInt(1925, 2010);
+            runner.yearOfBirth = '' + randInt(1925, 2010);
             runner.nation = 'SUI';
-            runner.ecard = Math.round(Math.random() * 1000000);
         });
     });
-    return event;
+    return competition;
 };

package/src/utils/ranking.ts

@@ -0,0 +1,535 @@
+import { Runner } from "../model/runner";
+import { Split } from "../model/split";
+import { parseTime, formatTime } from "../time";
+
+function invalidTime(time:number|undefined) {
+  return time === undefined || time < 0;
+}
+
+function validTime(time:number|undefined) {
+  return !invalidTime(time);
+}
+
+function sum(a1: number, a2: number) {
+  return a1 + a2;
+}
+
+export interface Course {
+  code: string;
+  runners: number[]
+}
+
+export interface RunnerLegs {
+  [key: string]: RunnerLeg;
+}
+
+export interface RunnerLeg {
+  runners: RunnerLegEntry[];
+  code: string;
+  idealSplit?: number;
+  fastestSplit?: number;
+  spread: [number, number];
+  weight?: number;
+}
+
+export interface RunnerLegEntry {
+  id: number;
+  fullName: string;
+  time: number;
+  split: number;
+  splitBehind?: number;
+  splitRank: number;
+  performanceIndex?: number;
+  overallRank?: number;
+  overallBehind?: string;
+  idealBehind?: string;
+  leg?: string;
+  position?: number;
+}
+
+
+/**
+ * Assigns the following property to every valid leg of a runner.
+ *
+ * - splitBehind: how much time behind the faster runner
+ * - splitRank: rank on corresponding leg
+ * - leg: code of leg
+ *
+ * @param {RankingRunner[]} runners
+ * @param {RunnerLegs} legs
+ */
+function assignLegInfoToSplits(runners: RankingRunner[], legs: RunnerLegs): void {
+  runners.forEach((runner) => {
+    runner.splits
+      .filter((s) => validTime(s.splitTime))
+      .forEach((split) => {
+        let leg = legs[split.legCode];
+
+        if (!leg) {
+          throw "leg with code " + split.leg + " not defined!";
+        }
+
+        split.legCode = leg.code;
+
+        let legRunner = leg.runners.find((r) => r.id === runner.id);
+
+        if (legRunner) {
+          split.leg.idealBehind = leg.idealSplit && legRunner.split - leg.idealSplit;
+          split.leg.behind = legRunner.splitBehind;
+          split.leg.rank = legRunner.splitRank;
+          split.performanceIndex = legRunner.performanceIndex;
+        }
+        split.weight = leg.weight;
+      });
+  });
+}
+
+function rank(runners: RankingRunner[]) {
+  runners.forEach((runner, idx) => {
+    if (idx === 0) {
+      runner.rank = 1;
+    } else {
+      let prev = runners[idx - 1];
+      if (prev.time === runner.time) {
+        runner.rank = prev.rank;
+      } else if (parseTime(runner.time)) {
+        runner.rank = idx + 1;
+      }
+    }
+  });
+}
+
+interface RankingRunner {
+  // the unique identifier of this runner
+  id: number; 
+
+  // the overall rank of this runner
+  rank?: number;
+
+  // the full name of this runner
+  fullName: string; 
+
+  // the overall time of this runner
+  time?: string; 
+
+  // the year of birth of this runner
+  yearOfBirth?: string; 
+
+  // the city of this runner
+  city?: string; 
+
+  // the club of this runner
+  club?: string; 
+
+  // the splits of this runner
+  splits: RankingSplit[];
+}
+
+interface RankingSplit {
+
+  // the control code of this leg
+  code: string; 
+
+  // the leg identifier for this leg (from-to)
+  legCode: string;
+
+  // the punch time from the start of the race
+  time?: number;
+
+  // the split time for this leg
+  splitTime?: number;
+
+  overall: RankingInfo;
+
+  leg: SplitInfo;
+
+  // the performance index for this runner on this leg
+  performanceIndex: number | undefined;
+
+  // defines the start position of this leg as a percentage
+  position: number;
+
+  // defines the percentage of the overall time this leg represents
+  weight: number | undefined; 
+}
+
+interface RankingInfo {
+  rank?: number;
+  behind?: number;
+  idealBehind?: number;
+}
+
+interface SplitInfo extends RankingInfo {
+  performanceIndex?: number;
+}
+
+export function parseRanking(runners: Runner[]) {
+  const courses = defineCourses(runners);
+
+  // prepare the result by defining the runners and their splits
+  const rankingRunners = defineRunners(runners);
+
+  // prepare auxiliary data about the legs needed to calculate ideal times, weights, ...
+  const legs = defineLegs(rankingRunners);
+
+  // calculate the ideal time [s]
+  const idealTime = Object.keys(legs)
+    .map((code) => legs[code].idealSplit)
+    .filter((time) => time !== undefined)
+    .reduce(sum);
+
+  console.log("ideal time: ", idealTime);
+
+  // each leg's weight is calculated regarding as a ratio of the ideal split time to the ideal time
+  Object.keys(legs).forEach((code) => {
+    let leg = legs[code];
+    if (leg.idealSplit && idealTime > 0) {
+      leg.weight = leg.idealSplit / idealTime;
+    }
+  });
+
+  // now assing the leg information (such as idealTime, weight, ...) to the individual splits of the runners
+  assignLegInfoToSplits(rankingRunners, legs);
+
+  rankingRunners.forEach((runner) => {
+    let behind = 0;
+    let weightSum = 0;
+    runner.splits.forEach((split) => {
+      behind += split.leg.idealBehind!;
+      split.overall = {
+        behind: behind
+      };
+      split.position = weightSum + split.weight!;
+
+      if (split.weight) {
+        weightSum += split.weight;
+      }
+    });
+  });
+
+  // function of function calculating the time at an arbitrary position for a given runner
+  let timeFn =
+    (runner: RankingRunner) =>
+    (pos: number): number | undefined => {
+      if (pos === 0) {
+        return 0;
+      } else if (isNaN(pos)) {  
+        return undefined;
+      } else if (pos >= 1) {
+        if (!parseTime(runner.time)) {
+          return undefined;
+        }
+        return parseTime(runner.time)!;
+      }
+
+      let idx = 0;
+      let weightSum = 0;
+      let prevTime = 0;
+      for (idx = 0; idx < runner.splits.length; idx++) {
+        let split = runner.splits[idx];
+        if (weightSum + split.weight! >= pos) {
+          break;
+        }
+        weightSum += split.weight!;
+        prevTime = split.time!
+      }
+
+      let prev = idx === 0 ? { position: 0, time: 0 } : runner.splits[idx - 1];
+      let next = runner.splits[idx];
+
+      if (
+        prev === undefined ||
+        next === undefined ||
+        invalidTime(prev.time) ||
+        invalidTime(next.splitTime)
+      ) {
+        return undefined;
+      }
+
+      return prevTime! + ((pos - prev.position) / next.weight!) * next.splitTime!;
+    };
+
+  // function returning the times at a given position for all runners
+  const memo = new Map<number, { id: number, time: number | undefined}[]>();
+  const timesAtPosition = (pos: number): { id: number, time: number | undefined}[] => {
+    if (memo.has(pos)) {
+      return memo.get(pos)!;
+    }
+    const result = rankingRunners.map((runner) => {
+      return { id: runner.id, time: timeFn(runner)(pos) };
+    });
+    memo.set(pos, result);
+    return result;
+  };
+
+  rankingRunners.forEach((runner) => {
+    runner.splits.forEach((split) => {
+      const times = timesAtPosition(split.position)
+        .filter((entry) => entry.time && entry.time > 0)
+        .map((entry) => {
+          return { id: entry.id, time: entry.time! };
+        });
+      times.sort((t1, t2) => t1.time - t2.time);
+
+      if (!split.position || isNaN(split.position)) {
+        return;
+      }
+
+      if (!times || times.length === 0) {
+        console.log(
+          "no times at position ",
+          split.position,
+          split.weight,
+          " for runner ",
+          runner.fullName,
+          runner.time,
+          times.length
+        );
+        return;
+      }
+
+      let rank = 1;
+
+      const lastTime = times[0].time;
+      for (let idx = 0; idx < times.length; idx++) {
+        const entry = times[idx];
+
+        if (lastTime < entry.time) {
+          rank++;
+        }
+
+        if (runner.id === entry.id) {
+          const idealSplitTime = times.slice(0, 5).reduce((sum, t) => sum + t.time!, 0) / Math.min(5, times.length);
+          const fastestTime = times[0].time;
+          split.overall.rank = rank;
+          split.overall.behind = entry.time - fastestTime;
+          split.overall.idealBehind = Math.round(entry.time - idealSplitTime);
+          break;
+        }
+      }
+    });
+  });
+
+  // calculate the overall rank
+  rank(rankingRunners);
+
+  console.log(rankingRunners[0].fullName, rankingRunners[0].splits[rankingRunners[0].splits.length - 1]);
+
+  Object.values(legs).forEach((leg) => {
+    const ideal = leg.idealSplit!;
+    const min = leg.runners.filter((runner) => !isNaN(runner.split) && runner.split !== undefined).map((runner) => runner.split).reduce((min, split) => Math.min(min, split - ideal), Number.MAX_VALUE);
+    const max = leg.runners.filter((runner) => !isNaN(runner.split) && runner.split !== undefined).map((runner) => runner.split).reduce((max, split) => Math.max(max, split - ideal), Number.MIN_VALUE);
+    leg.spread = [min, max];
+  });
+
+  console.log("leg runner", legs[Object.keys(legs)[1]].runners[1]);
+
+  return {
+    courses,
+    runners: rankingRunners,
+    legs: Object.values(legs).map((leg) => ({
+      code: leg.code,
+      spread: leg.spread,
+      idealSplit: leg.idealSplit,
+      fastestSplit: leg.fastestSplit,
+      weight: leg.weight,
+    })),
+  };
+}
+
+/**
+ * Define the sources ran by the given runners. If all runner ran the same
+ * course, then only one course will be defined.
+ * 
+ * @param runners the list of runners
+ * @returns the defined courses
+ */
+function defineCourses(runners: Runner[]): Course[] {
+  let courses:{[key:string]: Course} = {};
+  runners.filter((runner) => validTime(parseTime(runner.time))).forEach((runner) => {
+    let course = "St," + runner.splits.map((split) => split.code).join(",");
+    if (!courses[course]) {
+      courses[course] = {
+        code: course,
+        runners: [runner.id],
+      };
+    } else {
+      courses[course].runners.push(runner.id);
+    }
+  });
+  return Object.keys(courses).map((key) => courses[key]);
+}
+
+function defineRunners(runners:Runner[]): RankingRunner[] {
+  return runners.filter((runner) => runner.splits.length > 0 && runner.splits.every((split) => split.code)).map((runner) => {
+    const lastSplit = defineRunnerLegSplit({ code: "Zi", time: runner.time }, runner.splits.length, runner);
+    return {
+      id: runner.id,
+      rank: undefined,
+      fullName: runner.fullName,
+      time: runner.time,
+      yearOfBirth: runner.yearOfBirth,
+      city: runner.city,
+      club: runner.club,
+      splits: runner.splits.map((split, idx) => defineRunnerLegSplit(split, idx, runner)).concat([lastSplit]),
+    };
+  });
+}
+
+function defineRunnerLegSplit(split: {
+  code: string;
+  time: string | undefined;
+}, idx: number, runner: Runner): RankingSplit {
+  var splitTime: number | undefined = undefined;
+  if (split.time === "-") {
+    splitTime = undefined;
+  } else if (idx === 0) {
+    splitTime = parseTime(split.time) ? parseTime(split.time)! : undefined;
+  } else {
+    let current = parseTime(split.time);
+    let previous = parseTime(runner.splits[idx - 1].time);
+    if (!current || !previous) {
+      splitTime = undefined;
+    } else {
+      splitTime = current - previous;
+    }
+  }
+
+  return {
+    code: split.code,
+    legCode: legCode(runner.splits, idx),
+    time: parseTime(split.time),
+    splitTime: splitTime,
+    leg: {
+      rank: undefined,
+      behind: 0,
+      idealBehind: undefined
+    },
+    overall: {
+      rank: undefined,
+      behind: 0,
+      idealBehind: undefined
+    },
+    performanceIndex: undefined,
+    position: 0,
+    weight: undefined
+  };
+}
+
+function legCode(splits: Split[], idx: number) {
+  if (idx === 0) {
+    return "St-" + splits[0].code;
+  } else if (idx === splits.length) {
+    return splits[idx - 1].code + "-Zi";
+  } else {
+    return splits[idx - 1].code + "-" + splits[idx].code;
+  }
+}
+
+function defineLegs(runners: RankingRunner[]) {
+  const legs = Array.from(runners
+    .map((runner) => 
+      runner.splits.map((split, idx) => {
+        let from = idx === 0 ? "St" : runner.splits[idx - 1].code;
+        let to = split.code;
+        let code = from + "-" + to;
+        return code;
+      })
+    ).reduce((a, b) => a.concat(b), [])
+    .reduce((a, b) => a.add(b), new Set<string>())).reduce((obj, code) => {
+      obj[code] = {
+        code: code,
+        runners: [],
+        spread: [0, 0],
+      };
+      return obj;
+  }, {} as RunnerLegs);
+  
+  runners.forEach((runner) => {
+    runner.splits
+      //.filter((s) => validTime(s.time))
+      .forEach((split, idx) => {
+        const from = idx === 0 ? "St" : runner.splits[idx - 1].code;
+        const to = split.code;
+        const code = from + "-" + to;
+
+        const current = legs[code];
+        if (validTime(split.time)) {
+          current.runners.push({
+            id: runner.id,
+            fullName: runner.fullName,
+            splitRank: 0,
+            time: split.time!,
+            split: idx === 0
+              ? split.time!
+              : split.time! - runner.splits[idx - 1].time!,
+          });
+        }
+      });
+  });
+
+  defineLegProperties(legs);
+
+  return legs;
+}
+
+/**
+ * Define properties of each leg. After this method the leg structure will be enhanced as follows:
+ *
+ * - runners are sorted per split time per leg
+ * - each leg has a property 'idealSplit' (ideal split time of this leg)
+ * - each leg has a property 'fastestSplit'
+ * - each runner entry of a leg is enhanced with 'splitBehind' and 'splitRank'
+ *
+ * @param {*} legs leg data structre (only split is relevant)
+ */
+function defineLegProperties(legs: RunnerLegs) {
+  Object.keys(legs).forEach((code) => {
+    let leg = legs[code];
+    leg.runners.sort(function (r1, r2) {
+      return r1.split - r2.split;
+    });
+
+    // calculate the ideal time: take up to 5 fastest on that leg
+    let selected = leg.runners
+      .slice(0, Math.min(leg.runners.length, 5))
+      .map((runner) => runner.split);
+
+    // only if there are valid splits for this leg
+    if (selected.length > 0) {
+      leg.idealSplit = Math.round(selected.reduce(sum) / selected.length);
+
+      if (leg.idealSplit < 0) {
+        throw new Error("invalid ideal split calculated for leg " + code);
+      }
+    }
+
+    // only if there are valid splits for this leg
+    if (leg.runners.length > 0) {
+      const fastestSplit = leg.runners[0].split;
+      leg.fastestSplit = fastestSplit;
+      leg.runners[0].splitBehind = 0;
+      leg.runners.slice(1).forEach((runner) => {
+        runner.splitBehind = runner.split - fastestSplit;
+      });
+
+      leg.runners[0].splitRank = 1;
+
+      leg.runners.forEach((runner, idx, arr) => {
+        if (idx > 0) {
+          if (runner.split === arr[idx - 1].split) {
+            runner.splitRank = arr[idx - 1].splitRank;
+          } else {
+            runner.splitRank = idx + 1;
+          }
+        }
+
+        if (leg.idealSplit) {
+          runner.performanceIndex = Math.round(((1.0 * leg.idealSplit) / runner.split) * 100);
+        } else {
+          console.log("cannot calculate performance index for runner ", runner.fullName, " on leg ", code);
+        }
+      });
+    }
+  });
+}

package/test/kraemer-test.ts

@@ -0,0 +1,78 @@
+import { readFileSync } from "fs";
+import * as path from "path";
+import * as chai from "chai";
+import { KraemerFormater } from "../src/formats/kraemer";
+import { Split } from "../src/model/split";
+
+chai.should();
+
+const csvPath = path.join(__dirname, "kraemer.csv");
+const words = readFileSync(csvPath, "utf-8");
+
+describe("kraemer", function () {
+  let event: any;
+
+  before(function () {
+    event = new KraemerFormater().parse(words);
+  });
+
+  describe("#parse()", function () {
+    it("should return parsed event", function () {
+      event.should.be.an("object");
+    });
+
+    it("should be named Anonymous Event", function () {
+      event.name.should.be.an("string");
+      event.name.should.equal("Anonymous Event");
+    });
+
+    it("should have a map name", function () {
+      event.map.should.be.an("string");
+      event.map.should.equal("Unknown Map");
+    });
+
+    it("should have an event date", function () {
+      event.date.should.equal("");
+    });
+
+    it("should have a start time", function () {
+      event.startTime.should.equal("");
+    });
+
+    it("should have 3 categories", function () {
+      event.categories.length.should.equal(3);
+    });
+
+    describe("category K", function () {
+      let category: any;
+
+      before(function () {
+        category = event.categories.find((cat: any) => cat.name === "K");
+      });
+
+      it("should have a category K with 58 runners", function () {
+        category.should.be.an("object");
+        category.name.should.equal("K");
+        category.runners.length.should.equal(38);
+      });
+
+      it("should have a runner named Lena Torres at rank 1", function () {
+        const runner = category.runners[0];
+        runner.fullName.should.equal("Lena Torres");
+        runner.yearOfBirth.should.equal("1933");
+        runner.city.should.equal("Flawil");
+        runner.club.should.equal("OL Piz Balü");
+      });
+
+      it("Lena Torres should have a 14 splits", function () {
+        const runner = category.runners[0];
+        runner.splits.length.should.equal(14);
+      });
+
+      it("Lena Torres should have a 14 splits with the given split times", function () {
+        const runner = category.runners[0];
+        runner.splits.map((s: any) => s.time).join(",").should.equal("3:30,5:55,7:05,8:07,9:15,11:30,13:39,15:08,17:21,19:17,20:58,25:43,27:31,29:26");
+      });
+    });
+  });
+});