chore: move function getEllipse to a separate folder

Author: EscapedGibbon

src/roi/Roi.ts

@@ -1,6 +1,3 @@
-import { EigenvalueDecomposition } from 'ml-matrix';
-import { xVariance, xyCovariance } from 'ml-spectra-processing';
-
 import { Mask } from '../Mask';
 import {
   GetBorderPointsOptions,
@@ -9,25 +6,14 @@ import {
   getConvexHull,
   getMbr,
   Mbr,
-  FeretDiameter,
 } from '../maskAnalysis';
-import { getAngle } from '../maskAnalysis/utils/getAngle';
-import { toDegrees } from '../utils/geometry/angles';
 import { Point } from '../utils/geometry/points';
 
 import { RoiMap } from './RoiMapManager';
 import { getBorderPoints } from './getBorderPoints';
 import { getMask, GetMaskOptions } from './getMask';
+import { Ellipse, getEllipse } from './properties/getEllipse';
 
-interface Ellipse {
-  center: {
-    column: number;
-    row: number;
-  };
-  majorAxis: FeretDiameter;
-  minorAxis: FeretDiameter;
-  surface: number;
-}
 interface Border {
   connectedID: number; // refers to the roiID of the contiguous ROI
   length: number;
@@ -635,352 +621,7 @@ export class Roi {
    * @param x
    */
   computeIndex(y: number, x: number): number {
-    const roiMap = this.getMap();
+    const roiMap = this.map;
     return (y + this.origin.row) * roiMap.width + x + this.origin.column;
   }
 }
-
-
-/**
- *
- * @param roi -ROI
- * @returns object which tells how many pixels are exposed externally to how many sides
- */
-function getPerimeterInfo(roi: Roi) {
-  const roiMap = roi.getMap();
-  const data = roiMap.data;
-  let one = 0;
-  let two = 0;
-  let three = 0;
-  let four = 0;
-  let externalIDs = roi.externalBorders.map((element) => element.connectedID);
-  for (let column = 0; column < roi.width; column++) {
-    for (let row = 0; row < roi.height; row++) {
-      let target = roi.computeIndex(row, column);
-      if (data[target] === roi.id) {
-        let nbAround = 0;
-        if (column === 0) {
-          nbAround++;
-        } else if (externalIDs.includes(data[target - 1])) {
-          nbAround++;
-        }
-
-        if (column === roiMap.width - 1) {
-          nbAround++;
-        } else if (externalIDs.includes(data[target + 1])) {
-          nbAround++;
-        }
-
-        if (row === 0) {
-          nbAround++;
-        } else if (externalIDs.includes(data[target - roiMap.width])) {
-          nbAround++;
-        }
-
-        if (row === roiMap.height - 1) {
-          nbAround++;
-        } else if (externalIDs.includes(data[target + roiMap.width])) {
-          nbAround++;
-        }
-        switch (nbAround) {
-          case 1:
-            one++;
-            break;
-          case 2:
-            two++;
-            break;
-          case 3:
-            three++;
-            break;
-          case 4:
-            four++;
-            break;
-          default:
-        }
-      }
-    }
-  }
-  return { one, two, three, four };
-}
-
-/**
- *
- * @param roi - ROI
- * @returns the surface of holes in ROI
- */
-function getHolesInfo(roi: Roi) {
-  let surface = 0;
-  const data = roi.getMap().data;
-  for (let column = 1; column < roi.width - 1; column++) {
-    for (let row = 1; row < roi.height - 1; row++) {
-      let target = roi.computeIndex(row, column);
-      if (roi.internalIDs.includes(data[target]) && data[target] !== roi.id) {
-        surface++;
-      }
-    }
-  }
-  return {
-    number: roi.internalIDs.length - 1,
-    surface,
-  };
-}
-/**
- * Calculates internal IDs of the ROI
- *
- * @param roi
- * @returns internalIDs
- */
-function getInternalIDs(roi: Roi) {
-  let internal = [roi.id];
-  let roiMap = roi.getMap();
-  let data = roiMap.data;
-
-  if (roi.height > 2) {
-    for (let column = 0; column < roi.width; column++) {
-      let target = roi.computeIndex(0, column);
-      if (internal.includes(data[target])) {
-        let id = data[target + roiMap.width];
-        if (!internal.includes(id) && !roi.boxIDs.includes(id)) {
-          internal.push(id);
-        }
-      }
-    }
-  }
-
-  let array = new Array(4);
-  for (let column = 1; column < roi.width - 1; column++) {
-    for (let row = 1; row < roi.height - 1; row++) {
-      let target = roi.computeIndex(row, column);
-      if (internal.includes(data[target])) {
-        // we check if one of the neighbour is not yet in
-
-        array[0] = data[target - 1];
-        array[1] = data[target + 1];
-        array[2] = data[target - roiMap.width];
-        array[3] = data[target + roiMap.width];
-
-        for (let i = 0; i < 4; i++) {
-          let id = array[i];
-          if (!internal.includes(id) && !roi.boxIDs.includes(id)) {
-            internal.push(id);
-          }
-        }
-      }
-    }
-  }
-
-  return internal;
-}
-
-function getBoxIDs(roi: Roi): number[] {
-  let surroundingIDs = new Set<number>(); // allows to get a unique list without indexOf
-
-  const roiMap = roi.getMap();
-  const data = roiMap.data;
-
-  // we check the first line and the last line
-  for (let row of [0, roi.height - 1]) {
-    for (let column = 0; column < roi.width; column++) {
-      let target = roi.computeIndex(row, column);
-      if (
-        column - roi.origin.column > 0 &&
-        data[target] === roi.id &&
-        data[target - 1] !== roi.id
-      ) {
-        let value = data[target - 1];
-        surroundingIDs.add(value);
-      }
-      if (
-        roiMap.width - column - roi.origin.column > 1 &&
-        data[target] === roi.id &&
-        data[target + 1] !== roi.id
-      ) {
-        let value = data[target + 1];
-        surroundingIDs.add(value);
-      }
-    }
-  }
-
-  // we check the first column and the last column
-  for (let column of [0, roi.width - 1]) {
-    for (let row = 0; row < roi.height; row++) {
-      let target = roi.computeIndex(row, column);
-      if (
-        row - roi.origin.row > 0 &&
-        data[target] === roi.id &&
-        data[target - roiMap.width] !== roi.id
-      ) {
-        let value = data[target - roiMap.width];
-        surroundingIDs.add(value);
-      }
-      if (
-        roiMap.height - row - roi.origin.row > 1 &&
-        data[target] === roi.id &&
-        data[target + roiMap.width] !== roi.id
-      ) {
-        let value = data[target + roiMap.width];
-        surroundingIDs.add(value);
-      }
-    }
-  }
-
-  return Array.from(surroundingIDs); // the selection takes the whole rectangle
-}
-
-/**
- *
- * @param roi - ROI
- * @returns borders' length and their IDs
- */
-function getBorders(roi: Roi): Border[] {
-  const roiMap = roi.getMap();
-  const data = roiMap.data;
-  let surroudingIDs = new Set<number>(); // allows to get a unique list without indexOf
-  let surroundingBorders = new Map();
-  let visitedData = new Set();
-  let dx = [+1, 0, -1, 0];
-  let dy = [0, +1, 0, -1];
-
-  for (
-    let column = roi.origin.column;
-    column <= roi.origin.column + roi.width;
-    column++
-  ) {
-    for (let row = roi.origin.row; row <= roi.origin.row + roi.height; row++) {
-      let target = column + row * roiMap.width;
-      if (data[target] === roi.id) {
-        for (let dir = 0; dir < 4; dir++) {
-          let newX = column + dx[dir];
-          let newY = row + dy[dir];
-          if (
-            newX >= 0 &&
-            newY >= 0 &&
-            newX < roiMap.width &&
-            newY < roiMap.height
-          ) {
-            let neighbour = newX + newY * roiMap.width;
-
-            if (data[neighbour] !== roi.id && !visitedData.has(neighbour)) {
-              visitedData.add(neighbour);
-              surroudingIDs.add(data[neighbour]);
-              let surroundingBorder = surroundingBorders.get(data[neighbour]);
-              if (!surroundingBorder) {
-                surroundingBorders.set(data[neighbour], 1);
-              } else {
-                surroundingBorders.set(data[neighbour], ++surroundingBorder);
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  let id: number[] = Array.from(surroudingIDs);
-  return id.map((id) => {
-    return {
-      connectedID: id,
-      length: surroundingBorders.get(id),
-    };
-  });
-}
-
-function getEllipse(roi: Roi, scale: number): Ellipse {
-  const nbSD = 2;
-
-  let xCenter = roi.centroid.column;
-  let yCenter = roi.centroid.row;
-
-  let xCentered = roi.points.map((point: number[]) => point[0] - xCenter);
-  let yCentered = roi.points.map((point: number[]) => point[1] - yCenter);
-
-  let centeredXVariance = xVariance(xCentered, { unbiased: false });
-  let centeredYVariance = xVariance(yCentered, { unbiased: false });
-
-  let centeredCovariance = xyCovariance(
-    {
-      x: xCentered,
-      y: yCentered,
-    },
-    { unbiased: false },
-  );
-
-  //spectral decomposition of the sample covariance matrix
-  let sampleCovarianceMatrix = [
-    [centeredXVariance, centeredCovariance],
-    [centeredCovariance, centeredYVariance],
-  ];
-  let e = new EigenvalueDecomposition(sampleCovarianceMatrix);
-  let eigenvalues = e.realEigenvalues;
-  let vectors = e.eigenvectorMatrix;
-
-  let radiusMajor: number;
-  let radiusMinor: number;
-  let vectorMajor: number[];
-  let vectorMinor: number[];
-
-  if (eigenvalues[0] > eigenvalues[1]) {
-    radiusMajor = Math.sqrt(eigenvalues[0] * nbSD);
-    radiusMinor = Math.sqrt(eigenvalues[1] * nbSD);
-    vectorMajor = vectors.getColumn(0);
-    vectorMinor = vectors.getColumn(1);
-  } else if (eigenvalues[0] < eigenvalues[1]) {
-    radiusMajor = Math.sqrt(eigenvalues[1] * nbSD);
-    radiusMinor = Math.sqrt(eigenvalues[0] * nbSD);
-    vectorMajor = vectors.getColumn(1);
-    vectorMinor = vectors.getColumn(0);
-  } else {
-    // order here does not matter
-    radiusMajor = Math.sqrt(eigenvalues[1] * nbSD);
-    radiusMinor = Math.sqrt(eigenvalues[0] * nbSD);
-    vectorMajor = vectors.getColumn(1);
-    vectorMinor = vectors.getColumn(0);
-  }
-
-  radiusMajor *= scale;
-  radiusMinor *= scale;
-  let majorAxisPoint1 = {
-    column: xCenter + radiusMajor * vectorMajor[0],
-    row: yCenter + radiusMajor * vectorMajor[1],
-  };
-  let majorAxisPoint2 = {
-    column: xCenter - radiusMajor * vectorMajor[0],
-    row: yCenter - radiusMajor * vectorMajor[1],
-  };
-  let minorAxisPoint1 = {
-    column: xCenter + radiusMinor * vectorMinor[0],
-    row: yCenter + radiusMinor * vectorMinor[1],
-  };
-  let minorAxisPoint2 = {
-    column: xCenter - radiusMinor * vectorMinor[0],
-    row: yCenter - radiusMinor * vectorMinor[1],
-  };
-
-  const majorLength = Math.sqrt(
-    (majorAxisPoint1.column - majorAxisPoint2.column) ** 2 +
-      (majorAxisPoint1.row - majorAxisPoint2.row) ** 2,
-  );
-  const minorLength = Math.sqrt(
-    (minorAxisPoint1.column - majorAxisPoint2.column) ** 2 +
-      (minorAxisPoint1.row - minorAxisPoint2.row) ** 2,
-  );
-
-  let ellipseSurface = (((minorLength / 2) * majorLength) / 2) * Math.PI;
-  return {
-    center: {
-      column: xCenter,
-      row: yCenter,
-    },
-    majorAxis: {
-      points: [majorAxisPoint1, majorAxisPoint2],
-      length: majorLength,
-      angle: toDegrees(getAngle(majorAxisPoint1, majorAxisPoint2)),
-    },
-    minorAxis: {
-      points: [minorAxisPoint1, minorAxisPoint1],
-      length: minorLength,
-      angle: toDegrees(getAngle(minorAxisPoint1, minorAxisPoint2)),
-    },
-    surface: ellipseSurface,
-  };
-}
-