refactor(exareme2): Refactoring PCA Algorithm

api/src/engine/connectors/exareme/handlers/algorithms/PCA.handler.spec.ts

@@ -2,6 +2,7 @@ import { Experiment } from '../../../../models/experiment/experiment.model';
 import { HeatMapResult } from '../../../../models/result/heat-map-result.model';
 import handlers from '..';
 import { BarChartResult } from '../../../../models/result/bar-chart-result.model';
+import { Domain } from '../../../../models/domain.model';
 
 const createExperiment = (): Experiment => ({
   id: 'dummy-id',
@@ -24,6 +25,16 @@ const createExperiment = (): Experiment => ({
   results: [],
 });
 
+const domain: Domain = {
+  id: 'dummy-id',
+  groups: [],
+  rootGroup: {
+    id: 'dummy-id',
+  },
+  datasets: [{ id: 'desd-synthdata', label: 'Dead Synthdata' }],
+  variables: [],
+};
+
 const data = [
   {
     n_obs: 920,
@@ -80,7 +91,7 @@ const data = [
 describe('PCA result handler', () => {
   it('Test PCA handler with regular data (no edge cases)', () => {
     const exp = createExperiment();
-    handlers(exp, data, null);
+    handlers(exp, data, domain);
     expect(exp.results.length).toBeGreaterThanOrEqual(2);
 
     exp.results.forEach((result) => {

api/src/engine/connectors/exareme/handlers/algorithms/PCA.handler.ts

+import { Variable } from 'src/engine/models/variable.model';
 import { Domain } from '../../../../models/domain.model';
 import { Experiment } from '../../../../models/experiment/experiment.model';
 import { BarChartResult } from '../../../../models/result/bar-chart-result.model';
@@ -18,18 +19,13 @@ export default class PCAHandler extends BaseHandler {
     );
   }
 
-  handle(exp: Experiment, data: any, domain?: Domain): void {
-    if (!this.canHandle(exp.algorithm.name, data))
-      return this.next?.handle(exp, data, domain);
-
-    const extractedData = data[0];
-
-    const barChar: BarChartResult = {
+  private getBarChartResult(data: any): BarChartResult {
+    const barChart: BarChartResult = {
       name: 'Eigen values',
-      barValues: extractedData['eigenvalues'],
+      barValues: data['eigenvalues'],
       xAxis: {
         label: 'Dimensions',
-        categories: exp.variables.map((_, i) => i + 1).map(String),
+        categories: data['eigenvalues'].map((_: unknown, i: number) => i + 1),
       },
       hasConnectedBars: true,
       yAxis: {
@@ -37,17 +33,18 @@ export default class PCAHandler extends BaseHandler {
       },
     };
 
-    if (barChar.barValues && barChar.barValues.length > 0)
-      exp.results.push(barChar);
+    return barChart;
+  }
 
-    const matrix = extractedData['eigenvectors'] as number[][];
+  private getHeatMapResult(data: any, variables: Variable[]): HeatMapResult {
+    const matrix = data['eigenvectors'] as number[][];
 
     const heatMapChart: HeatMapResult = {
       name: 'Eigen vectors',
       matrix,
       heatMapStyle: HeatMapStyle.BUBBLE,
       yAxis: {
-        categories: exp.variables,
+        categories: variables.map((v) => v.label ?? v.id),
       },
       xAxis: {
         categories: [...Array(matrix.length).keys()]
@@ -62,8 +59,27 @@ export default class PCAHandler extends BaseHandler {
       );
     }
 
+    return heatMapChart;
+  }
+
+  handle(exp: Experiment, data: any, domain: Domain): void {
+    if (!this.canHandle(exp.algorithm.name, data))
+      return this.next?.handle(exp, data, domain);
+
+    const extractedData = data[0];
+
+    const variables =
+      exp.variables
+        ?.map((v) => domain.variables.find((v2) => v2.id === v) ?? { id: v })
+        .filter((v) => v) ?? [];
+
+    const barChart = this.getBarChartResult(extractedData);
+    if (barChart.barValues && barChart.barValues.length > 0)
+      exp.results.push(barChart);
+
+    const heatMapChart = this.getHeatMapResult(extractedData, variables);
     if (heatMapChart.matrix) exp.results.push(heatMapChart);
 
-    this.next?.handle(exp, data);
+    this.next?.handle(exp, data, domain);
   }
 }