@datagrok/peptides 1.0.0 → 1.1.0

package/src/utils/cell-renderer.ts

@@ -1,8 +1,9 @@
-import {ChemPalette} from './chem-palette';
+import {SeqPaletteBase} from '@datagrok-libraries/bio/src/seq-palettes';
 import * as DG from 'datagrok-api/dg';
 
 import * as C from './constants';
-import {getSeparator} from './misc';
+import {getPalleteByType} from './misc';
+import * as types from './types';
 
 /**
  * A function to expand column size based on its contents.
@@ -16,10 +17,8 @@ import {getSeparator} from './misc';
  * @param {number} [maxSize=650] Maximum column width.
  * @param {number} [timeout=500] Timeout value.
  */
-export function expandColumn(
-  col: DG.Column, grid: DG.Grid, cellRenderSize: (cellVal: string) => number,
-  textSizeMult = 10, minSize = 30, maxSize = 650, timeout = 500,
-): void {
+export function expandColumn(col: DG.Column, grid: DG.Grid, cellRenderSize: (cellVal: string) => number,
+  textSizeMult = 10, minSize = 30, maxSize = 650, timeout = 500): void {
   let maxLen = 0;
   col.categories.forEach((ent: string) => {
     const len = cellRenderSize(ent);
@@ -40,11 +39,10 @@ export function expandColumn(
  * @param {(DG.Grid | null)} [grid=null] Grid that contains the col column.
  * @param {boolean} [grouping=false] Is grouping enabled.
  */
-export function setAARRenderer(col: DG.Column, grid: DG.Grid | null = null, grouping = false): void {
-  col.semType = C.SEM_TYPES.AMINO_ACIDS;
-  col.setTag('cell.renderer', C.SEM_TYPES.AMINO_ACIDS);
-  if (grouping)
-    col.setTag('groups', `${grouping}`);
+export function setAARRenderer(col: DG.Column, alphabet: string, grid?: DG.Grid): void {
+  col.semType = C.SEM_TYPES.MONOMER;
+  col.setTag('cell.renderer', C.SEM_TYPES.MONOMER);
+  col.tags[C.TAGS.ALPHABET] = alphabet;
 
   if (grid)
     expandColumn(col, grid, (ent) => measureAAR(ent));
@@ -63,266 +61,146 @@ export function measureAAR(s: string): number {
   return end == beg ? s.length : s.length - (end - beg) + 1;
 }
 
-/**
- * A function that prints a string aligned to left or centered.
- *
- * @param {number} x x coordinate.
- * @param {number} y y coordinate.
- * @param {number} w Width.
- * @param {number} h Height.
- * @param {CanvasRenderingContext2D} g Canvas rendering context.
- * @param {string} s String to print.
- * @param {string} [color=ChemPalette.undefinedColor] String color.
- * @param {number} [pivot=0] Pirvot.
- * @param {boolean} [left=false] Is left aligned.
- * @param {boolean} [hideMod=false] Hide amino acid redidue modifications.
- * @param {number} [transparencyRate=0.0] Transparency rate where 1.0 is fully transparent
- * @return {number} x coordinate to start printing at.
- */
-function printLeftOrCentered(
-  x: number, y: number, w: number, h: number,
-  g: CanvasRenderingContext2D, s: string, color = ChemPalette.undefinedColor,
-  pivot: number = 0, left = false, hideMod = false, transparencyRate: number = 1.0,
-): number {
-  g.textAlign = 'start';
-  let colorPart = pivot == -1 ? s.substring(0) : s.substring(0, pivot);
-  if (colorPart.length == 1)
-    colorPart = colorPart.toUpperCase();
-
-  if (colorPart.length >= 3) {
-    if (colorPart.substring(0, 3) in ChemPalette.AAFullNames)
-      colorPart = ChemPalette.AAFullNames[s.substring(0, 3)] + colorPart.substring(3);
-    else if (colorPart.substring(1, 4) in ChemPalette.AAFullNames)
-      colorPart = colorPart[0] + ChemPalette.AAFullNames[s.substring(1, 4)] + colorPart.substring(4);
-  }
-  let grayPart = pivot == -1 ? '' : s.substring(pivot);
-  if (hideMod) {
-    let end = colorPart.lastIndexOf(')');
-    let beg = colorPart.indexOf('(');
-    if (beg > -1 && end > -1 && end - beg > 2)
-      colorPart = colorPart.substring(0, beg) + '(+)' + colorPart.substring(end + 1);
-
-
-    end = grayPart.lastIndexOf(')');
-    beg = grayPart.indexOf('(');
-    if (beg > -1 && end > -1 && end - beg > 2)
-      grayPart = grayPart.substring(0, beg) + '(+)' + grayPart.substring(end + 1);
-  }
-  const textSize = g.measureText(colorPart + grayPart);
-  const indent = 5;
-
-  const colorTextSize = g.measureText(colorPart);
-  const dy = (textSize.fontBoundingBoxAscent + textSize.fontBoundingBoxDescent) / 2;
-
-  function draw(dx1: number, dx2: number): void {
-    g.fillStyle = color;
-    g.globalAlpha = transparencyRate;
-    g.fillText(colorPart, x + dx1, y + dy);
-    g.fillStyle = ChemPalette.undefinedColor;
-    g.fillText(grayPart, x + dx2, y + dy);
-  }
-
-
-  if (left || textSize.width > w) {
-    draw(indent, indent + colorTextSize.width);
-    return x + colorTextSize.width + g.measureText(grayPart).width;
-  } else {
-    const dx = (w - textSize.width) / 2;
-    draw(dx, dx + colorTextSize.width);
-    return x + dx + colorTextSize.width;
+export function renderSARCell(canvasContext: CanvasRenderingContext2D, currentAAR: string, currentPosition: string,
+  statsDf: DG.DataFrame, twoColorMode: boolean, mdCol: DG.Column<number>, bound: DG.Rect, cellValue: number,
+  currentSelection: types.SelectionObject, substitutionsInfo: types.SubstitutionsInfo | null): void {
+  const queryAAR = `${C.COLUMNS_NAMES.AMINO_ACID_RESIDUE} = ${currentAAR}`;
+  const query = `${queryAAR} and ${C.COLUMNS_NAMES.POSITION} = ${currentPosition}`;
+  const pVal: number = statsDf
+    .groupBy([C.COLUMNS_NAMES.P_VALUE])
+    .where(query)
+    .aggregate()
+    .get(C.COLUMNS_NAMES.P_VALUE, 0);
+
+  let coef: string;
+  const variant = cellValue < 0;
+  if (pVal < 0.01)
+    coef = variant && twoColorMode ? '#FF7900' : '#299617';
+  else if (pVal < 0.05)
+    coef = variant && twoColorMode ? '#FFA500' : '#32CD32';
+  else if (pVal < 0.1)
+    coef = variant && twoColorMode ? '#FBCEB1' : '#98FF98';
+  else
+    coef = DG.Color.toHtml(DG.Color.lightLightGray);
+
+
+  const chooseMin = (): number => twoColorMode ? 0 : mdCol.min;
+  const chooseMax = (): number => twoColorMode ? Math.max(Math.abs(mdCol.min), mdCol.max) : mdCol.max;
+  const chooseCurrent = (): any => twoColorMode ? Math.abs(cellValue) : cellValue;
+
+  const rCoef = (chooseCurrent() - chooseMin()) / (chooseMax() - chooseMin());
+
+  const maxRadius = 0.9 * (bound.width > bound.height ? bound.height : bound.width) / 2;
+  const radius = Math.floor(maxRadius * rCoef);
+
+  const midX = bound.x + bound.width / 2;
+  const midY = bound.y + bound.height / 2;
+  canvasContext.beginPath();
+  canvasContext.fillStyle = coef;
+  canvasContext.arc(midX, midY, radius < 3 ? 3 : radius, 0, Math.PI * 2, true);
+  canvasContext.closePath();
+
+  canvasContext.fill();
+  if (substitutionsInfo) {
+    canvasContext.textBaseline = 'middle';
+    canvasContext.textAlign = 'center';
+    canvasContext.fillStyle = DG.Color.toHtml(DG.Color.getContrastColor(DG.Color.fromHtml(coef)));
+    canvasContext.font = '13px Roboto, Roboto Local, sans-serif';
+    let substValue = 0;
+    substitutionsInfo.get(currentAAR)?.get(currentPosition)?.forEach((idxs) => substValue += idxs.length);
+    if (substValue && substValue != 0)
+      canvasContext.fillText(substValue.toString(), midX, midY);
   }
-}
-
-export class AminoAcidsCellRenderer extends DG.GridCellRenderer {
-  chemPalette: ChemPalette | null;
-
-  get name(): string {return 'aminoAcidsCR';}
-
-  get cellType(): string {return C.SEM_TYPES.AMINO_ACIDS;}
-
-  get defaultHeight(): number {return 15;}
-
-  get defaultWidth(): number {return 30;}
-
-  constructor() {
-    super();
-    this.chemPalette = null;
-  }
-
-  /**
-     * Cell renderer function.
-     *
-     * @param {CanvasRenderingContext2D} g Canvas rendering context.
-     * @param {number} x x coordinate on the canvas.
-     * @param {number} y y coordinate on the canvas.
-     * @param {number} w width of the cell.
-     * @param {number} h height of the cell.
-     * @param {DG.GridCell} gridCell Grid cell.
-     * @param {DG.GridCellStyle} cellStyle Cell style.
-     */
-  render(
-    g: CanvasRenderingContext2D, x: number, y: number, w: number, h: number, gridCell: DG.GridCell,
-    cellStyle: DG.GridCellStyle): void {
-    y -= 2;
-    g.save();
-    g.beginPath();
-    g.rect(x, y, w, h);
-    g.clip();
-    g.font = `12px monospace`;
-    g.textBaseline = 'top';
-    const s: string = gridCell.cell.value ? gridCell.cell.value : '-';
-    let [color, outerS, innerS, pivot] = ChemPalette.getColorAAPivot(s);
-    if (innerS)
-      outerS = s;
 
-    printLeftOrCentered(x, y, w, h, g, outerS, color, pivot, false, true);
-    g.restore();
+  //TODO: frame based on currentSelection
+  const aarSelection = currentSelection[currentPosition];
+  if (aarSelection && aarSelection.includes(currentAAR)) {
+    canvasContext.strokeStyle = '#000';
+    canvasContext.lineWidth = 1;
+    canvasContext.strokeRect(bound.x + 1, bound.y + 1, bound.width - 1, bound.height - 1);
   }
 }
 
-export class AlignedSequenceCellRenderer extends DG.GridCellRenderer {
-  get name(): string {return 'alignedSequenceCR';}
-
-  get cellType(): string {return C.SEM_TYPES.ALIGNED_SEQUENCE;}
-
-  get defaultHeight(): number {return 30;}
-
-  get defaultWidth(): number {return 230;}
-
-  /**
-   * Cell renderer function.
-   *
-   * @param {CanvasRenderingContext2D} g Canvas rendering context.
-   * @param {number} x x coordinate on the canvas.
-   * @param {number} y y coordinate on the canvas.
-   * @param {number} w width of the cell.
-   * @param {number} h height of the cell.
-   * @param {DG.GridCell} gridCell Grid cell.
-   * @param {DG.GridCellStyle} cellStyle Cell style.
-   * @memberof AlignedSequenceCellRenderer
-   */
-  render(
-    g: CanvasRenderingContext2D, x: number, y: number, w: number, h: number, gridCell: DG.GridCell,
-    cellStyle: DG.GridCellStyle,
-  ): void {
-    const grid = gridCell.grid;
-    const cell = gridCell.cell;
-    w = grid ? Math.min(grid.canvas.width - x, w) : g.canvas.width - x;
-    g.save();
-    g.beginPath();
-    g.rect(x, y, w, h);
-    g.clip();
-    g.font = '12px monospace';
-    g.textBaseline = 'top';
-    const s: string = cell.value ?? '';
+export function renderBarchart(ctx: CanvasRenderingContext2D, col: DG.Column, monomerColStats: types.MonomerColStats,
+  bounds: DG.Rect, max: number): types.BarCoordinates {
+  let sum = col.length - (monomerColStats['-']?.count ?? 0);
+  const colorPalette = getPalleteByType(col.tags[C.TAGS.ALPHABET]);
+  const name = col.name;
+  const colNameSize = ctx.measureText(name);
+  const margin = 0.2;
+  const innerMargin = 0.02;
+  const selectLineRatio = 0.1;
+  const fontSize = 11;
+
+  const xMargin = bounds.x + bounds.width * margin;
+  const yMargin = bounds.y + bounds.height * margin / 4;
+  const wMargin = bounds.width - bounds.width * margin * 2;
+  const hMargin = bounds.height - bounds.height * margin;
+  const barWidth = 10;
+  ctx.fillStyle = 'black';
+  ctx.textBaseline = 'top';
+  ctx.font = `${hMargin * margin / 2}px`;
+  ctx.fillText(name, xMargin + (wMargin - colNameSize.width) / 2, yMargin + hMargin + hMargin * margin / 4);
+
+
+  const barCoordinates: types.BarCoordinates = {};
+
+  const xStart = xMargin + (wMargin - barWidth) / 2;
+  for (const [monomer, monomerStats] of Object.entries(monomerColStats)) {
+    if (monomer == '-')
+      continue;
+
+    const count = monomerStats.count;
+    const sBarHeight = hMargin * count / max;
+    const gapSize = sBarHeight * innerMargin;
+    const verticalShift = (max - sum) / max;
+    const textSize = ctx.measureText(monomer);
+    const subBarHeight = sBarHeight - gapSize;
+    const yStart = yMargin + hMargin * verticalShift + gapSize / 2;
+    barCoordinates[monomer] = new DG.Rect(xStart, yStart, barWidth, subBarHeight);
+
+    const color = colorPalette.get(monomer);
+    ctx.strokeStyle = color;
+    ctx.fillStyle = color;
+
+    if (textSize.width <= subBarHeight) {
+      if (color != SeqPaletteBase.undefinedColor)
+        ctx.fillRect(xStart, yStart, barWidth, subBarHeight);
+      else {
+        ctx.strokeRect(xStart + 0.5, yStart, barWidth - 1, subBarHeight);
+        barCoordinates[monomer].x -= 0.5;
+        barCoordinates[monomer].width -= 1;
+      }
 
-    //TODO: can this be replaced/merged with splitSequence?
-    const subParts = s.split(getSeparator(cell.column));
-    const [text, simplified] = processSequence(subParts);
-    const textSize = g.measureText(text.join(''));
-    let x1 = Math.max(x, x + (w - textSize.width) / 2);
+      const leftMargin = (wMargin - (monomer.length > 1 ? fontSize : textSize.width - 8)) / 2;
+      const absX = xMargin + leftMargin;
+      const absY = yStart + subBarHeight / 2 + (monomer.length == 1 ? 4 : 0);
+      const origTransform = ctx.getTransform();
 
-    subParts.forEach((amino, index) => {
-      let [color, outerAmino,, pivot] = ChemPalette.getColorAAPivot(amino);
-      g.fillStyle = ChemPalette.undefinedColor;
-      if (index + 1 < subParts.length) {
-        const gap = simplified ? '' : ' ';
-        outerAmino += `${outerAmino ? '' : '-'}${gap}`;
+      if (monomer.length > 1) {
+        ctx.translate(absX, absY);
+        ctx.rotate(Math.PI / 2);
+        ctx.translate(-absX, -absY);
       }
-      x1 = printLeftOrCentered(x1, y, w, h, g, outerAmino, color, pivot, true);
-    });
 
-    g.restore();
+      ctx.fillStyle = 'black';
+      ctx.font = `${fontSize}px monospace`;
+      ctx.textAlign = 'center';
+      ctx.textBaseline = 'bottom';
+      ctx.fillText(monomer, absX, absY);
+      ctx.setTransform(origTransform);
+    } else
+      ctx.fillRect(xStart, yStart, barWidth, subBarHeight);
+
+    const selectedCount = monomerStats.selected;
+    if (selectedCount) {
+      ctx.fillStyle = 'rgb(255,165,0)';
+      ctx.fillRect(xStart - wMargin * selectLineRatio * 2, yStart,
+        barWidth * selectLineRatio, hMargin * selectedCount / max - gapSize);
+    }
+
+    sum -= count;
   }
-}
-
-export function processSequence(subParts: string[]): [string[], boolean] {
-  const simplified = !subParts.some((amino, index) =>
-    amino.length > 1 &&
-    index != 0 &&
-    index != subParts.length - 1);
-
-  const text: string[] = [];
-  const gap = simplified ? '' : ' ';
-  subParts.forEach((amino: string, index) => {
-    if (index < subParts.length)
-      amino += `${amino ? '' : '-'}${gap}`;
-
-    text.push(amino);
-  });
-  return [text, simplified];
-}
 
-export class AlignedSequenceDifferenceCellRenderer extends DG.GridCellRenderer {
-  get name(): string {return 'alignedSequenceDifferenceCR';}
-
-  get cellType(): string {return C.SEM_TYPES.ALIGNED_SEQUENCE_DIFFERENCE;}
-
-  get defaultHeight(): number {return 30;}
-
-  get defaultWidth(): number {return 230;}
-
-  /**
-   * Cell renderer function.
-   *
-   * @param {CanvasRenderingContext2D} g Canvas rendering context.
-   * @param {number} x x coordinate on the canvas.
-   * @param {number} y y coordinate on the canvas.
-   * @param {number} w width of the cell.
-   * @param {number} h height of the cell.
-   * @param {DG.GridCell} gridCell Grid cell.
-   * @param {DG.GridCellStyle} cellStyle Cell style.
-   * @memberof AlignedSequenceDifferenceCellRenderer
-   */
-  render(
-    g: CanvasRenderingContext2D, x: number, y: number, w: number, h: number, gridCell: DG.GridCell,
-    cellStyle: DG.GridCellStyle): void {
-    const grid = gridCell.grid;
-    const cell = gridCell.cell;
-
-    w = grid ? Math.min(grid.canvas.width - x, w) : g.canvas.width - x;
-    g.save();
-    g.beginPath();
-    g.rect(x, y, w, h);
-    g.clip();
-    g.font = '12px monospace';
-    g.textBaseline = 'top';
-    const s: string = cell.value ?? '';
-
-    //TODO: can this be replaced/merged with splitSequence?
-    const [s1, s2] = s.split('#');
-    const separator = getSeparator(gridCell.tableColumn!);
-    const subParts1 = s1.split(separator);
-    const subParts2 = s2.split(separator);
-    const [text] = processSequence(subParts1);
-    const textSize = g.measureText(text.join(''));
-    let updatedX = Math.max(x, x + (w - (textSize.width + subParts1.length * 4)) / 2);
-    // 28 is the height of the two substitutions on top of each other + space
-    const updatedY = Math.max(y, y + (h - 28) / 2);
-
-    let amino2;
-    let updatedAmino1: string;
-    let updatedAmino2: string;
-    subParts1.forEach((amino1: string, index) => {
-      amino2 = subParts2[index];
-      const [color1, amino1Outer, amino1Inner, pivot1] = ChemPalette.getColorAAPivot(amino1);
-      const [color2, amino2Outer, amino2Inner, pivot2] = ChemPalette.getColorAAPivot(amino2);
-
-      updatedAmino1 = amino1Outer + (amino1Inner !== '' ? '(' + amino1Inner + ')' : '');
-      updatedAmino1 = updatedAmino1 === '' ? '-' : updatedAmino1;
-
-      if (amino1 != amino2) {
-        updatedAmino2 = amino2Outer + (amino2Inner !== '' ? '(' + amino2Inner + ')' : '');
-        updatedAmino2 = updatedAmino2 === '' ? '-' : updatedAmino2;
-
-        const vShift = 7;
-        const subX0 = printLeftOrCentered(updatedX, updatedY - vShift, w, h, g, updatedAmino1, color1, pivot1, true);
-        const subX1 = printLeftOrCentered(updatedX, updatedY + vShift, w, h, g, updatedAmino2, color2, pivot2, true);
-        updatedX = Math.max(subX1, subX0);
-      } else
-        updatedX = printLeftOrCentered(updatedX, updatedY, w, h, g, updatedAmino1, color1, pivot1, true, true, 0.5);
-      updatedX += 4;
-    });
-    g.restore();
-  }
+  return barCoordinates;
 }

package/src/utils/constants.ts

@@ -7,6 +7,8 @@ export enum COLUMNS_NAMES {
   POSITION = 'Pos',
   P_VALUE = 'pValue',
   MEAN_DIFFERENCE = 'Mean difference',
+  COUNT = 'Count',
+  RATIO = 'Ratio',
 }
 
 export enum CATEGORIES {
@@ -17,14 +19,15 @@ export enum CATEGORIES {
 export enum TAGS {
   AAR = 'AAR',
   POSITION = 'Pos',
-  SEPARATOR = 'monomer-separator',
+  SEPARATOR = 'separator',
   SELECTION = 'selection',
+  ALPHABET = 'alphabet',
 }
 
 export enum SEM_TYPES {
-  AMINO_ACIDS = 'aminoAcids',
-  ALIGNED_SEQUENCE = 'alignedSequence',
-  ALIGNED_SEQUENCE_DIFFERENCE = 'alignedSequenceDifference',
+  MONOMER = 'Monomer',
+  MACROMOLECULE = 'Macromolecule',
+  MACROMOLECULE_DIFFERENCE = 'MacromoleculeDifference',
   ACTIVITY = 'activity',
   ACTIVITY_SCALED = 'activityScaled',
 }

package/src/utils/filtering-statistics.ts

@@ -2,61 +2,29 @@ import * as DG from 'datagrok-api/dg';
 
 import {tTest} from '@datagrok-libraries/statistics/src/tests';
 
-/** Column statistics helper. */
-export class FilteringStatistics {
-  private data?: Float32Array;
-  private stats: Stats = {
-    count: 0,
-    pValue: 1.,
-    meanDifference: 0.,
-  };
-
-  /**
-   * Creates an instance of FilteringStatistics.
-   * @param {Float32Array} [data] Numeric values to consider.
-   */
-  constructor(data?: Float32Array) {this.data = data;}
-
-  /**
-   * Sets values to make statistical analysis.
-   * @param {Float32Array} data Those values.
-   */
-  setData(data: Float32Array): void {this.data = data;}
-
-  /**
-   * Sets bit mask to split population into two groups.
-   * @param {DG.BitSet} mask The mask to perform splitting.
-   */
-  setMask(mask: DG.BitSet): void {
-    if (!this.data)
-      return;
-    const selected = this.data.filter((_, i) => mask.get(i));
-    const rest = this.data.filter((_, i) => !mask.get(i));
-    this.stats = this.calcStats(selected, rest);
-  }
-
-  /**
-   * Calculates simple statistics on two samples.
-   * @param {Float32Array} selected First sample.
-   * @param {Float32Array} rest Second sample.
-   * @return {Stats} Statistics.
-   */
-  calcStats(selected: Float32Array, rest: Float32Array): Stats {
-    const testResult = tTest(selected, rest);
-    const currentMeanDiff = testResult['Mean difference']!;
-    return {
-      count: selected.length,
-      pValue: testResult[currentMeanDiff >= 0 ? 'p-value more' : 'p-value less'],
-      meanDifference: currentMeanDiff,
-    };
-  }
-
-  /** Returns calculated statistics. */
-  get result(): Stats {return this.stats;}
-}
-
 export type Stats = {
   count: number,
   pValue: number,
   meanDifference: number,
+  ratio: number,
 };
+
+type StatsData = Float32Array | Float64Array | Int32Array | Uint32Array | number[];
+
+export function getStats(data: StatsData, mask: DG.BitSet): Stats {
+  const selected = new Float32Array(mask.trueCount);
+  const rest = new Float32Array(mask.falseCount);
+  let selectedIndex = 0;
+  let restIndex = 0;
+  data.forEach((v, i) => mask.get(i) ? selected[selectedIndex++] = v : rest[restIndex++] = v);
+
+  const testResult = tTest(selected, rest);
+  const currentMeanDiff = testResult['Mean difference']!;
+  const realCount = selected.length || data.length;
+  return {
+    count: realCount,
+    pValue: testResult[currentMeanDiff >= 0 ? 'p-value more' : 'p-value less'],
+    meanDifference: currentMeanDiff,
+    ratio: realCount / data.length,
+  };
+}

package/src/utils/misc.ts

@@ -1,24 +1,24 @@
 import * as DG from 'datagrok-api/dg';
-
 import * as C from './constants';
+import * as type from './types';
 
-export function stringToBool(str: string): boolean {
-  return str === 'true' ? true : false;
-}
+import {AminoacidsPalettes} from '@datagrok-libraries/bio/src/aminoacids';
+import {NucleotidesPalettes} from '@datagrok-libraries/bio/src/nucleotides';
+import {UnknownSeqPalettes} from '@datagrok-libraries/bio/src/unknown';
+import {SeqPalette} from '@datagrok-libraries/bio/src/seq-palettes';
 
-export function getSeparator(col: DG.Column<string>): string {
-  const separator = col.tags[C.TAGS.SEPARATOR];
-  if (separator)
-    return separator as string;
-
-  const defaultSeparators = ['.', '-', ' '];
-  const categories = col.categories;
-  const catLen = categories.length;
-  for (const potentialSeparator of defaultSeparators) {
-    if (categories.filter((sequence) => sequence.includes(potentialSeparator)).length == catLen)
-      return potentialSeparator;
+export function getPalleteByType(paletteType: string): SeqPalette {
+  switch (paletteType) {
+  case 'PT':
+    return AminoacidsPalettes.GrokGroups;
+  case 'NT':
+  case 'DNA':
+  case 'RNA':
+    return NucleotidesPalettes.Chromatogram;
+    // other
+  default:
+    return UnknownSeqPalettes.Color;
   }
-  return separator as string ?? '';
 }
 
 export function getTypedArrayConstructor(
@@ -27,3 +27,67 @@ export function getTypedArrayConstructor(
     maxNum < 65536 ? Uint16Array :
       Uint32Array;
 }
+
+export function getSeparator(col: DG.Column<string>): string {
+  return col.getTag(C.TAGS.SEPARATOR) ?? '';
+}
+
+export function scaleActivity(
+  activityScaling: string, df: DG.DataFrame, originalActivityName?: string, cloneBitset = false,
+): [DG.DataFrame, string] {
+  let currentActivityColName = originalActivityName ?? C.COLUMNS_NAMES.ACTIVITY;
+  const flag = df.columns.names().includes(currentActivityColName) &&
+    currentActivityColName === originalActivityName;
+  currentActivityColName = flag ? currentActivityColName : C.COLUMNS_NAMES.ACTIVITY;
+  const tempDf = df.clone(cloneBitset ? df.filter : null, [currentActivityColName]);
+
+  let formula = (v: number): number => v;
+  let newColName = 'activity';
+  switch (activityScaling) {
+  case 'none':
+    break;
+  case 'lg':
+    formula = (v: number): number => Math.log10(v);
+    newColName = `Log10(${newColName})`;
+    break;
+  case '-lg':
+    formula = (v: number): number => -Math.log10(v);
+    newColName = `-Log10(${newColName})`;
+    break;
+  default:
+    throw new Error(`ScalingError: method \`${activityScaling}\` is not available.`);
+  }
+
+  const asCol = tempDf.columns.addNewFloat(C.COLUMNS_NAMES.ACTIVITY_SCALED);
+  const activityCol = df.getCol(currentActivityColName);
+  asCol.init((i) => formula(activityCol.get(i)));
+  df.tags['scaling'] = activityScaling;
+
+  return [tempDf, newColName];
+}
+
+export function calculateBarsData(columns: DG.Column<string>[], selection: DG.BitSet): type.MonomerDfStats {
+  const dfStats: type.MonomerDfStats = {};
+  const columnsLen = columns.length;
+
+  for (let colIndex = 0; colIndex < columnsLen; colIndex++) {
+    const col = columns[colIndex];
+    dfStats[col.name] = calculateSingleBarData(col, selection);
+  }
+
+  return dfStats;
+}
+
+export function calculateSingleBarData(col: DG.Column<string>, selection: DG.BitSet): type.MonomerColStats {
+  const colLen = col.length;
+  const colStats: type.MonomerColStats = {};
+  col.categories.forEach((monomer) => colStats[monomer] = {count: 0, selected: 0});
+
+  for (let rowIndex = 0; rowIndex < colLen; rowIndex++) {
+    const monomerStats = colStats[col.get(rowIndex)!];
+    monomerStats.count += 1;
+    monomerStats.selected += +selection.get(rowIndex);
+  }
+
+  return colStats;
+}