compileprofile-spacetests 0.2.1 → 0.4.0

package/src/gonogo.ts

@@ -1,76 +1,149 @@
-interface GonogoResultsStructure {
-  n: number;
-  avg_rt: number;
-  avg_acc: number;
-  performance: number;
-}
+import { GonogoResultsStructure, CommonResults, GonogoSpecialResults } from './common-interfaces';
+const BEST_SCORE = 300;
+const WORST_SCORE = 5000;
 
 const gonogo_calculate_results = (data: any[]): GonogoResultsStructure => {
   const trials = gonogo_extract_trials(data);
   const results = gonogo_results(trials);
   return results;
-} 
+}
+
+// Which stimulus is "go" in each block of the runner:
+// 1 astronaut, 2 alien, 3 rocket, 4 anything but the rocket (the UFOs).
+const should_go_for = (block_number: number, stimulus: string): boolean => {
+  switch (block_number) {
+    case 1: return stimulus == "astronaut_trans_1.png";
+    case 2: return stimulus == "alien_trans_1.png";
+    case 3: return stimulus == "rocket_trans_1.png";
+    case 4: return stimulus != "rocket_trans_1.png";
+    default: return false;
+  }
+}
 
 const gonogo_extract_trials = (obj: any[]): any[] => {
-  // GONOGO_IMAGE_PATH <- "https://unyavwofnmwihnpvkjji.supabase.co/storage/v1/object/public/test-stimuli/gonogo/"
-  let trials = obj.filter((o: any) => 'image' in o && o.image !== undefined);
-  trials.forEach((o: any) => {
-    // image is in format <stimulus>_trans_<number>.png
-    // extract the stimulus and number
-
-    // "image": "https://unyavwofnmwihnpvkjji.supabase.co/storage/v1/object/public/test-stimuli/gonogo/aliens/astronaut_trans_1.png",
-    // i need to extract the iamge name from the url
-    const match = o.image.match(/([^/]+)_(\d+)\.png$/);
-    if (match) {
-      o.stimulus = match[0];
-      o.stimulustype = match[1];
-      o.image_number = match[2];
-    } else {
+  const trials: any[] = [];
+  obj.filter((o: any) => 'image' in o && o.image !== undefined && o.image !== null).forEach((o: any) => {
+    // image is in format <stimulus>_trans_<number>.png, e.g.
+    // ".../test-stimuli/gonogo/aliens/astronaut_trans_1.png"
+    const match = String(o.image).match(/([^/]+)_(\d+)\.png$/);
+    if (!match) {
+      // Without a recognisable stimulus the trial cannot be scored, so leave it out
+      // instead of counting it as neither correct nor incorrect.
       console.warn('Image format did not match expected pattern:', o.image);
       return;
     }
-    o.should_go = false;
-    o.did_go = o.response !== null;
-    switch (o.block_number) {
-      case 1:
-        o.should_go = o.stimulus == "astronaut_trans_1.png";
-        break;
-      case 2:
-        o.should_go = o.stimulus == "alien_trans_1.png";
-        break;
-      case 3:
-        o.should_go = o.stimulus == "rocket_trans_1.png";
-        break;
-      case 4:
-        // should go in all cases where the goal is NOT the rocket
-        o.should_go = !(o.stimulus == "rocket_trans_1.png");
-        break;
-      default:
-        o.should_go = false;
-        break;
-    }
-    o.correct = o.should_go == o.did_go;
-  })
+    // Copy, so the caller's data is not modified.
+    const trial = { ...o };
+    trial.stimulus = match[0];
+    trial.stimulustype = match[1];
+    trial.image_number = match[2];
+    // Prefer a go/no-go flag recorded by the runner; otherwise derive it from block and image.
+    trial.should_go = typeof o.should_go === 'boolean' ? o.should_go : should_go_for(o.block_number, trial.stimulus);
+    trial.did_go = o.response !== null && o.response !== undefined;
+    trial.correct = trial.should_go == trial.did_go;
+    trials.push(trial);
+  });
   return trials;
 }
 
+const has_rt = (o: any): boolean => o.did_go === true && typeof o.rt === 'number' && !isNaN(o.rt);
+
+// Mean of the values; 0 for an empty list, so callers always get a number.
+const mean = (values: number[]): number => values.length > 0 ? values.reduce((a, b) => a + b, 0) / values.length : 0;
+
+// Mean RT over the trials that have a response; trials without one have no RT and are not averaged in as 0.
+const mean_rt = (trials: any[]): number => mean(trials.filter(has_rt).map((o: any) => o.rt));
+
+const proportion = (trials: any[], pred: (o: any) => boolean): number =>
+  trials.length > 0 ? trials.filter(pred).length / trials.length : 0;
+
+// Hit rate and correct-rejection rate weighted equally. When a set has no go (or no no-go)
+// trials, the other rate is used alone.
+const balanced_accuracy = (go_trials: any[], nogo_trials: any[]): number => {
+  const rates: number[] = [];
+  if (go_trials.length > 0) rates.push(proportion(go_trials, (o) => o.correct === true));
+  if (nogo_trials.length > 0) rates.push(proportion(nogo_trials, (o) => o.correct === true));
+  return mean(rates);
+}
+
+// Score 0-100 from the hit RT and the balanced accuracy: RT / (acc^5), clamped to 300-5000 ms.
+// Without any hit there is no RT to score, so the score is 0. (Previously an RT of 0 was
+// clamped to the best value, so a participant who never responded scored 100.)
+const calculate_performance_score = (hit_rt: number, acc: number): number => {
+  if (!(hit_rt > 0)) {
+    return 0;
+  }
+  let performance = hit_rt / (Math.pow(acc, 5) + 0.001);
+  performance = Math.min(Math.max(performance, BEST_SCORE), WORST_SCORE);
+  const performance_score = (1 - ((performance - BEST_SCORE) / (WORST_SCORE - BEST_SCORE))) * 100;
+  return performance_score;
+}
+
 const gonogo_results = (data: any[]): GonogoResultsStructure => {
   // throw error if obj is empty
   if (data.length === 0) {
     throw new Error("No trials found");
   }
-  let results = {
-    n: data.length,
-    avg_rt: data.reduce((a, b) => a + b.rt, 0) / data.length,
-    avg_acc: data.reduce((a, b) => a + b.correct, 0) / data.length,
-    performance: NaN
+
+  const correct_trials = data.filter((o: any) => o.correct === true);
+  const incorrect_trials = data.filter((o: any) => o.correct === false);
+
+  const go_trials = data.filter((o: any) => o.should_go === true);
+  const nogo_trials = data.filter((o: any) => o.should_go === false);
+
+  // A response is correct on go trials (hit) and incorrect on no-go trials (false alarm).
+  // Correct no-go trials and missed go trials have no response, so no RT.
+  const hit_rt = mean_rt(go_trials);
+  const balanced_acc = balanced_accuracy(go_trials, nogo_trials);
+
+  const common: CommonResults = {
+    n_trials: data.length,
+    n_correct_trials: correct_trials.length,
+    n_incorrect_trials: incorrect_trials.length,
+    avg_rt_total: mean_rt(data),
+    avg_rt_correct: mean_rt(correct_trials),
+    avg_rt_incorrect: mean_rt(incorrect_trials),
+    performance_score: calculate_performance_score(hit_rt, balanced_acc)
+  };
+
+  // Group by block for special results
+  const by_block = Object.values(data.reduce((acc: any, trial: any) => {
+    const key = trial.block_number || 'unknown';
+    if (!acc[key]) acc[key] = { block: key, trials: [] };
+    acc[key].trials.push(trial);
+    return acc;
+  }, {})).map((group: any) => {
+    const block_go = group.trials.filter((o: any) => o.should_go === true);
+    const block_nogo = group.trials.filter((o: any) => o.should_go === false);
+    group.avg_rt = mean_rt(block_go);
+    group.avg_acc = proportion(group.trials, (o) => o.correct === true);
+    group.hit_rate = proportion(block_go, (o) => o.correct === true);
+    group.correct_rejection_rate = proportion(block_nogo, (o) => o.correct === true);
+    group.balanced_acc = balanced_accuracy(block_go, block_nogo);
+    return group;
+  });
+
+  const special: GonogoSpecialResults = {
+    balanced_acc,
+    by_block,
+    go_trials: {
+      n: go_trials.length,
+      avg_rt: hit_rt,
+      avg_acc: proportion(go_trials, (o) => o.correct === true),
+      n_omissions: go_trials.filter((o: any) => o.did_go === false).length,
+    },
+    nogo_trials: {
+      n: nogo_trials.length,
+      avg_rt: mean_rt(nogo_trials),
+      avg_acc: proportion(nogo_trials, (o) => o.correct === true),
+      n_commissions: nogo_trials.filter((o: any) => o.did_go === true).length,
+    }
+  };
+
+  return {
+    common,
+    special
   };
-  const best_score = 300;
-  const worst_score = 5000;
-  let performance = results.avg_rt / (Math.pow(results.avg_acc, 5) + 0.001);
-  performance = Math.min(Math.max(performance, best_score), worst_score);
-  results.performance = (1 - ((performance - best_score) / (worst_score - best_score))) * 100; 
-  return results;
 }
 
-export { GonogoResultsStructure, gonogo_calculate_results, gonogo_extract_trials, gonogo_results };
+export { GonogoResultsStructure, gonogo_calculate_results, gonogo_extract_trials, gonogo_results };

package/src/index.ts

@@ -1,7 +1,14 @@
-import { NbackResultsStructure, nback_calculate_results } from './nback';
-import { SpatialResultsStructure, spatial_calculate_results } from './spatial-cognition';
-import { GonogoResultsStructure, gonogo_calculate_results } from './gonogo';
-import { EmotionResultsStructure, emotion_calculate_results } from './emotions';
+import { nback_calculate_results } from './nback';
+import { spatial_calculate_results } from './spatial-cognition';
+import { gonogo_calculate_results } from './gonogo';
+import { emotion_calculate_results } from './emotions';
+import {
+  NbackResultsStructure,
+  SpatialResultsStructure,
+  GonogoResultsStructure,
+  EmotionResultsStructure,
+  CommonResults
+} from './common-interfaces';
 
 const NbackResults = (obj: any[]): NbackResultsStructure => {
   return nback_calculate_results(obj);
@@ -19,5 +26,14 @@ const EmotionResults = (obj: any[]): EmotionResultsStructure => {
   return emotion_calculate_results(obj);
 }
 
-export { NbackResults, SpatialCognitionResults, 
-  EmotionResults, GonogoResults };
+export {
+  NbackResults,
+  SpatialCognitionResults,
+  EmotionResults,
+  GonogoResults,
+  NbackResultsStructure,
+  SpatialResultsStructure,
+  GonogoResultsStructure,
+  EmotionResultsStructure,
+  CommonResults
+};

package/src/nback.ts

@@ -1,53 +1,182 @@
+import { NbackResultsStructure, CommonResults, NbackSpecialResults,
+  NbackGroupResults, NbackBlockResults, NbackLevelResults } from './common-interfaces';
+
 // from the passed json extract those objects that have field is_target
+// Version 1 trials have no n_back field and get exactly the original result. Version 2 trials
+// (n_back, block, block_index on each trial) also get special.by_block and special.by_nback.
 const nback_calculate_results = (obj: any[]): NbackResultsStructure => {
   const trials = nback_extract_trials(obj);
-  return nback_results(trials);
+  const results = nback_results(trials);
+  if (nback_is_versioned(trials)) {
+    results.special.by_block = nback_results_by_block(trials);
+    results.special.by_nback = nback_results_by_nback(trials);
+  }
+  return results;
 }
 
+const nback_is_versioned = (trials: any[]): boolean =>
+  trials.some((t: any) => t.n_back !== undefined && t.n_back !== null);
+
 const nback_extract_trials = (obj: any[]): any[] => {
   const trials = obj.filter((o: any) => 'is_target' in o);
   return trials;
 }
 
-interface NbackTrialResultsStructure {
-  n: number;
-  avg_rt: number;
-  avg_acc: number;
-}
-
-interface NbackResultsStructure {
-  total_trials: NbackTrialResultsStructure;
-  target_trials: NbackTrialResultsStructure;
-  non_target_trials: NbackTrialResultsStructure;
-  performance: number;
-}
-
-const nback_results = (trials: any[]): NbackResultsStructure  => {
+const nback_results = (trials: any[]): NbackResultsStructure => {
   const target_trials = trials.filter((o: any) => o.is_target);
   const non_target_trials = trials.filter((o: any) => !o.is_target);
+  const correct_trials = trials.filter((o: any) => o.correct === true);
+  const incorrect_trials = trials.filter((o: any) => o.correct === false);
 
-  let results = {
-    total_trials: {
-      n: trials.length,
-      avg_rt: trials.reduce((a, b) => a + b.rt, 0)/trials.length,
-      avg_acc: trials.reduce((a, b) => a + b.correct, 0)/trials.length,
-    },
+  const total_rt = trials.reduce((a, b) => a + (b.rt || 0), 0);
+  const correct_rt = correct_trials.reduce((a, b) => a + (b.rt || 0), 0);
+  const incorrect_rt = incorrect_trials.reduce((a, b) => a + (b.rt || 0), 0);
+
+  const responded_trials = trials.filter((o: any) => o.response !== null);
+  const correct_responded_trials = responded_trials.filter((o: any) => o.correct === true);
+  const incorrect_responded_trials = responded_trials.filter((o: any) => o.correct === false);
+
+  const common: CommonResults = {
+    n_trials: trials.length,
+    n_correct_trials: correct_trials.length,
+    n_incorrect_trials: incorrect_trials.length,
+    avg_rt_total: trials.length > 0 ? total_rt / responded_trials.length : 0,
+    avg_rt_correct: correct_trials.length > 0 ? correct_rt / correct_responded_trials.length : 0,
+    avg_rt_incorrect: incorrect_trials.length > 0 ? incorrect_rt / incorrect_responded_trials.length : 0,
+    performance_score: trials.length > 0 ? correct_trials.length * 100 / trials.length : 0
+  };
+
+  const special: NbackSpecialResults = {
     target_trials: {
       n: target_trials.length,
-      avg_rt: target_trials.reduce((a, b) => a + b.rt, 0)/target_trials.length,
-      avg_acc: target_trials.reduce((a, b) => a + b.correct, 0)/target_trials.length,
+      avg_rt: target_trials.length > 0 ? target_trials.reduce((a, b) => a + (b.rt || 0), 0) / target_trials.length : 0,
+      avg_acc: target_trials.length > 0 ? target_trials.reduce((a, b) => a + (b.correct ? 1 : 0), 0) * 100 / target_trials.length : 0,
     },
     non_target_trials: {
       n: non_target_trials.length,
-      avg_rt: non_target_trials.reduce((a, b) => a + b.rt, 0)/non_target_trials.length,
-      avg_acc: non_target_trials.reduce((a, b) => a + b.correct, 0)/non_target_trials.length,
-    },
-    performance: NaN
-  }
-  results.performance = results.total_trials.avg_acc;
+      avg_rt: non_target_trials.length > 0 ? non_target_trials.reduce((a, b) => a + (b.rt || 0), 0) / non_target_trials.length : 0,
+      avg_acc: non_target_trials.length > 0 ? non_target_trials.reduce((a, b) => a + (b.correct ? 1 : 0), 0) * 100 / non_target_trials.length : 0,
+    }
+  };
+
+  const results: NbackResultsStructure = {
+    common,
+    special
+  };
+
   console.log(results);
   return results;
 }
 
-export { nback_extract_trials, nback_results, 
-  nback_calculate_results, NbackResultsStructure };
+// Standard normal CDF (Marsaglia 2004, Taylor series; absolute error ~1e-15 for |x| < 8)
+const normal_cdf = (x: number): number => {
+  let sum = x, term = x, prev = 0;
+  const x2 = x * x;
+  for (let i = 3; sum !== prev; i += 2) {
+    prev = sum;
+    term *= x2 / i;
+    sum = prev + term;
+  }
+  return 0.5 + sum * Math.exp(-0.5 * x2 - 0.91893853320467274178);
+}
+
+// Inverse of the standard normal CDF: Acklam's rational approximation, polished with one
+// Halley step against normal_cdf, as Acklam recommends. Accurate to ~1e-12 for 1e-10 < p < 1 - 1e-10.
+const inverse_normal = (p: number): number => {
+  if (p <= 0) return -Infinity;
+  if (p >= 1) return Infinity;
+  const x = acklam_inverse_normal(p);
+  const e = normal_cdf(x) - p;
+  const u = e * Math.sqrt(2 * Math.PI) * Math.exp(x * x / 2);
+  return x - u / (1 + x * u / 2);
+}
+
+const acklam_inverse_normal = (p: number): number => {
+  const a = [-3.969683028665376e+01, 2.209460984245205e+02, -2.759285104469687e+02,
+    1.383577518672690e+02, -3.066479806614716e+01, 2.506628277459239e+00];
+  const b = [-5.447609879822406e+01, 1.615858368580409e+02, -1.556989798598866e+02,
+    6.680131188771972e+01, -1.328068155288572e+01];
+  const c = [-7.784894002430293e-03, -3.223964580411365e-01, -2.400758277161838e+00,
+    -2.549671010322563e+00, 4.374664141464968e+00, 2.938163982698783e+00];
+  const d = [7.784695709041462e-03, 3.224671290700398e-01, 2.445134137142996e+00,
+    3.754408661907416e+00];
+  const p_low = 0.02425;
+  if (p < p_low) {
+    const q = Math.sqrt(-2 * Math.log(p));
+    return (((((c[0] * q + c[1]) * q + c[2]) * q + c[3]) * q + c[4]) * q + c[5]) /
+      ((((d[0] * q + d[1]) * q + d[2]) * q + d[3]) * q + 1);
+  }
+  if (p > 1 - p_low) return -acklam_inverse_normal(1 - p);
+  const q = p - 0.5;
+  const r = q * q;
+  return (((((a[0] * r + a[1]) * r + a[2]) * r + a[3]) * r + a[4]) * r + a[5]) * q /
+    (((((b[0] * r + b[1]) * r + b[2]) * r + b[3]) * r + b[4]) * r + 1);
+}
+
+const mean_or_null = (xs: number[]): number | null =>
+  xs.length > 0 ? xs.reduce((s, x) => s + x, 0) / xs.length : null;
+
+const responded = (t: any): boolean => t.response !== null && t.response !== undefined;
+
+// d' uses the log-linear correction (Hautus 1995), so it stays finite at 0 % or 100 % rates
+const nback_group_results = (trials: any[]): NbackGroupResults => {
+  const targets = trials.filter((t: any) => t.is_target);
+  const non_targets = trials.filter((t: any) => !t.is_target);
+  const hits = targets.filter(responded);
+  const false_alarms = non_targets.filter(responded);
+  const lures = non_targets.filter((t: any) => t.is_lure === true);
+  const lure_false_alarms = lures.filter(responded).length;
+  const n_correct = trials.filter((t: any) => t.correct === true).length;
+  const rts = (ts: any[]) => ts.map((t: any) => t.rt).filter((rt: any) => typeof rt === 'number');
+
+  return {
+    n_trials: trials.length,
+    n_correct_trials: n_correct,
+    performance_score: trials.length > 0 ? n_correct * 100 / trials.length : 0,
+    n_targets: targets.length,
+    n_non_targets: non_targets.length,
+    hits: hits.length,
+    misses: targets.length - hits.length,
+    false_alarms: false_alarms.length,
+    correct_rejections: non_targets.length - false_alarms.length,
+    hit_rate: targets.length > 0 ? hits.length / targets.length : null,
+    false_alarm_rate: non_targets.length > 0 ? false_alarms.length / non_targets.length : null,
+    d_prime: targets.length > 0 && non_targets.length > 0
+      ? inverse_normal((hits.length + 0.5) / (targets.length + 1))
+        - inverse_normal((false_alarms.length + 0.5) / (non_targets.length + 1))
+      : null,
+    n_lures: lures.length,
+    lure_false_alarms,
+    lure_false_alarm_rate: lures.length > 0 ? lure_false_alarms / lures.length : null,
+    avg_rt_hits: mean_or_null(rts(hits)),
+    avg_rt_false_alarms: mean_or_null(rts(false_alarms)),
+  };
+}
+
+const nback_results_by_block = (trials: any[]): NbackBlockResults[] => {
+  const blocks = new Map<number, any[]>();
+  for (const t of trials) {
+    if (!blocks.has(t.block_index)) blocks.set(t.block_index, []);
+    blocks.get(t.block_index)!.push(t);
+  }
+  return Array.from(blocks.entries())
+    .sort(([a], [b]) => a - b)
+    .map(([block_index, ts]) => ({
+      block: ts[0].block,
+      block_index,
+      n_back: ts[0].n_back,
+      ...nback_group_results(ts),
+    }));
+}
+
+const nback_results_by_nback = (trials: any[]): NbackLevelResults[] => {
+  const levels = Array.from(new Set(trials.map((t: any) => t.n_back as number))).sort((a, b) => a - b);
+  return levels.map(n_back => ({
+    n_back,
+    ...nback_group_results(trials.filter((t: any) => t.n_back === n_back)),
+  }));
+}
+
+export { nback_extract_trials, nback_results, nback_calculate_results,
+  nback_group_results, nback_results_by_block, nback_results_by_nback,
+  inverse_normal, NbackResultsStructure };

package/src/spatial-cognition.ts

@@ -1,15 +1,20 @@
-interface SpatialResultsStructure {
-  n: number;
-  avg_rt: number;
-  avg_acc: number;
-  performance: number;
-}
+import { SpatialResultsStructure, CommonResults, SpatialSpecialResults } from './common-interfaces';
+
+const BEST_SCORE = 1000;
+const WORST_SCORE = 10000;
 
 const spatial_calculate_results = (obj: any[]): SpatialResultsStructure => {
   const trials = spatial_extract_trials(obj);
   return spatial_results(trials);
 }
 
+const calculate_performance_score = (avg_rt: number, avg_acc: number): number => {
+  let performance = avg_rt / (avg_acc + 0.001);
+  performance = Math.min(Math.max(performance, BEST_SCORE), WORST_SCORE);
+  const performance_score = (1 - ((performance - BEST_SCORE) / (WORST_SCORE - BEST_SCORE))) * 100;
+  return performance_score;
+}
+
 const spatial_extract_trials = (obj: any[]) => {
   let trials = obj.filter((o: any) => 'stimulus' in o && 
     o.stimulus.startsWith("<img src="));
@@ -18,21 +23,72 @@ const spatial_extract_trials = (obj: any[]) => {
 }
 
 const spatial_results = (obj: any[]): SpatialResultsStructure => {
-  const results = {
-    n: obj.length,
-    avg_rt: obj.reduce((a, b) => a + b.rt, 0) / obj.length,
-    avg_acc: obj.reduce((a, b) => a + b.correct, 0) / obj.length,
-    performance: NaN
-  }
-  const best_score = 1000;
-  const worst_score = 10000;
-  // results.avg_acc to the power of 5
-  //let performance = results.avg_rt / (Math.pow(results.avg_acc, 5) + 0.001);
-  let performance = results.avg_rt / (results.avg_acc + 0.001);
-  performance = Math.min(Math.max(performance, best_score), worst_score);
-  // convert to 0-100 where 100 is the best (200)
-  results.performance = (1 - ((performance - best_score) / (worst_score - best_score))) * 100; 
-  return results;
+  const correct_trials = obj.filter((o: any) => o.correct === 1 || o.correct === true);
+  const incorrect_trials = obj.filter((o: any) => o.correct === 0 || o.correct === false);
+
+  const total_rt = obj.reduce((a, b) => a + (b.rt || 0), 0);
+  const correct_rt = correct_trials.reduce((a, b) => a + (b.rt || 0), 0);
+  const incorrect_rt = incorrect_trials.reduce((a, b) => a + (b.rt || 0), 0);
+
+  const avg_rt = obj.length > 0 ? total_rt / obj.length : 0;
+  const avg_acc = obj.length > 0 ? correct_trials.length / obj.length : 0;
+
+  const performance_score = calculate_performance_score(avg_rt, avg_acc);
+
+  const common: CommonResults = {
+    n_trials: obj.length,
+    n_correct_trials: correct_trials.length,
+    n_incorrect_trials: incorrect_trials.length,
+    avg_rt_total: avg_rt,
+    avg_rt_correct: correct_trials.length > 0 ? correct_rt / correct_trials.length : 0,
+    avg_rt_incorrect: incorrect_trials.length > 0 ? incorrect_rt / incorrect_trials.length : 0,
+    performance_score
+  };
+
+  // Group by distance, angle, and rotation for special results
+  const by_distance = Object.values(obj.reduce((acc: any, trial: any) => {
+    const key = trial.distance || 'unknown';
+    if (!acc[key]) acc[key] = { distance: key, trials: [], avg_rt: 0, avg_acc: 0 };
+    acc[key].trials.push(trial);
+    return acc;
+  }, {})).map((group: any) => {
+    group.avg_rt = group.trials.reduce((a: number, b: any) => a + (b.rt || 0), 0) / group.trials.length;
+    group.avg_acc = group.trials.reduce((a: number, b: any) => a + (b.correct ? 1 : 0), 0) / group.trials.length;
+    return group;
+  });
+
+  const by_angle = Object.values(obj.reduce((acc: any, trial: any) => {
+    const key = trial.angle || 'unknown';
+    if (!acc[key]) acc[key] = { angle: key, trials: [], avg_rt: 0, avg_acc: 0 };
+    acc[key].trials.push(trial);
+    return acc;
+  }, {})).map((group: any) => {
+    group.avg_rt = group.trials.reduce((a: number, b: any) => a + (b.rt || 0), 0) / group.trials.length;
+    group.avg_acc = group.trials.reduce((a: number, b: any) => a + (b.correct ? 1 : 0), 0) / group.trials.length;
+    return group;
+  });
+
+  const by_rotation = Object.values(obj.reduce((acc: any, trial: any) => {
+    const key = trial.rotation || 'unknown';
+    if (!acc[key]) acc[key] = { rotation: key, trials: [], avg_rt: 0, avg_acc: 0 };
+    acc[key].trials.push(trial);
+    return acc;
+  }, {})).map((group: any) => {
+    group.avg_rt = group.trials.reduce((a: number, b: any) => a + (b.rt || 0), 0) / group.trials.length;
+    group.avg_acc = group.trials.reduce((a: number, b: any) => a + (b.correct ? 1 : 0), 0) / group.trials.length;
+    return group;
+  });
+
+  const special: SpatialSpecialResults = {
+    by_distance,
+    by_angle,
+    by_rotation
+  };
+
+  return {
+    common,
+    special
+  };
 }
 
 const spatial_extract_image_info = (obj: any[]) => {