@macrostrat/column-views 3.1.0 → 3.2.1

package/src/units/colors.ts

@@ -1,22 +1,93 @@
 import chroma from "chroma-js";
-import { UnitLong } from "@macrostrat/api-types";
+import {
+  Environment,
+  Lithology,
+  UnitLithology,
+  UnitLong,
+} from "@macrostrat/api-types";
 
 interface KeyOptions {
-  key?: string;
-  id_key?: string;
+  key?: "lith" | "environ";
+  id_key?: "lith_id" | "environ_id";
 }
 
 export function getMixedUnitColor(
   unit: UnitLong,
-  lithMap,
+  lithMap: Map<number, { color: string }>,
   inDarkMode = false,
   asBackground = true,
   keyOpts: KeyOptions = null,
 ): string | null {
   const { key = "lith", id_key = "lith_id" } = keyOpts ?? {};
   const liths = unit[key];
-  if (liths == null) {
-    return "gray";
+  const getColor = (data: UnitLithology): string | null => {
+    return lithMap?.get(data[id_key])?.color ?? null;
+  };
+
+  return getMixedColorForData(liths, getColor, {
+    inDarkMode,
+    asBackground,
+    key: id_key,
+  });
+}
+
+interface ColorBuilderOptions {
+  key?: "lith_id" | "environ_id";
+  inDarkMode?: boolean;
+  asBackground?: boolean;
+}
+
+export function flattenLithologies<
+  T extends { prop: number | null; lith_id?: number; environ_id?: number },
+>(liths: T[][], normalize: boolean = true): T[] {
+  /** Unify proportions in lithology/environment data across several units, normalizing if needed.
+   * If normalize is true, proportions are scaled to sum to 1 within each unit (with remaining proportions
+   * distributed equally among liths without specified proportions). This helps ensure that units with a
+   * few lithologies with specified proportions don't skew the color mixing.
+   *
+   * Lithologies are deduplicated based on their identifying property (lith_id or environ_id) if that is present.
+   */
+  if (liths == null || liths.length === 0) {
+    return [];
+  }
+
+  const unitCount = liths.length;
+
+  let newLiths: T[] = [];
+  for (const unitLiths of liths) {
+    let l1 = unitLiths;
+    if (normalize) {
+      l1 = addProportionsToAllData(unitLiths);
+    }
+    // Divide proportions by number of units to balance influence
+    for (const lith of l1) {
+      if (lith.prop == null || isNaN(lith.prop) || lith.prop <= 0) {
+        continue;
+      }
+      lith.prop = lith.prop / unitCount;
+    }
+    newLiths.push(...l1);
+  }
+  if (newLiths[0]?.lith_id != null) {
+    newLiths = mergeLikeData(newLiths, "lith_id");
+  } else if (newLiths[0]?.environ_id != null) {
+    newLiths = mergeLikeData(newLiths, "environ_id");
+  }
+  // Sort by proportion descending
+  newLiths.sort((a, b) => b.prop - a.prop);
+  return newLiths;
+}
+
+export function getMixedColorForData<
+  T extends UnitLithology | Lithology | Environment,
+>(
+  liths: T[] | null,
+  getColor: (val: T) => string | null,
+  options: ColorBuilderOptions = {},
+): string | null {
+  const { inDarkMode = false, asBackground = true } = options;
+  if (liths == null || liths.length === 0) {
+    return null;
   }
   const lithData = liths
     .map((d) => {
@@ -25,33 +96,19 @@ export function getMixedUnitColor(
         prop = null;
       }
       return {
-        lith_id: d[id_key],
+        ...d,
         prop,
-        color: lithMap?.get(d[id_key])?.color,
+        color: getColor?.(d) ?? d.color,
       };
     })
     .filter((d) => d.color != null);
 
-  const lithsWithProp = lithData.filter((d) => d.prop != null);
-  const lithsWithoutProp = lithData.filter((d) => d.prop == null);
-
-  const totalProp = lithsWithProp.reduce((sum, d) => sum + d.prop, 0);
-  if (totalProp < 1 && lithsWithoutProp.length > 0) {
-    const remainingProp = 1 - totalProp;
-    // Distribute remaining proportion equally among liths without prop
-    const equalProp = remainingProp / lithsWithoutProp.length;
-    lithsWithoutProp.forEach((d) => {
-      lithsWithProp.push({
-        ...d,
-        prop: equalProp,
-      });
-    });
-  }
-
-  if (lithsWithProp.length == 0) {
+  if (lithData.length == 0) {
     return null;
   }
 
+  const lithsWithProp = addProportionsToAllData(lithData);
+
   // Mix colors proportionally
   const baseColor = chroma.average(
     lithsWithProp.map((d) => d.color),
@@ -69,3 +126,58 @@ export function getMixedUnitColor(
     return baseColor.set("hsl.l", 0.9).hex();
   }
 }
+
+function addProportionsToAllData<T extends { prop?: number }>(liths: T[]): T[] {
+  /** Make sure that all lithologies/environments have a defined proportion,
+   * and that proportions sum to 1. If some liths lack a defined proportion,
+   * the remaining proportion is distributed equally among them.
+   *
+   * NOTE: This function does not normalize proportions if they already sum to more than 1.
+   */
+  const lithsWithProp = liths.filter((d) => d.prop != null);
+  const lithsWithoutProp = liths.filter((d) => d.prop == null);
+
+  const totalProp = lithsWithProp.reduce((sum, d) => sum + d.prop, 0);
+  let overallTotal = 1;
+
+  if (totalProp < overallTotal && lithsWithoutProp.length > 0) {
+    const remainingProp = overallTotal - totalProp;
+    // Distribute remaining proportion equally among liths without prop
+    const equalProp = remainingProp / lithsWithoutProp.length;
+    lithsWithoutProp.forEach((d) => {
+      lithsWithProp.push({
+        ...d,
+        prop: equalProp,
+      } as T);
+    });
+  }
+  return lithsWithProp as T[];
+}
+
+function mergeLikeData<
+  T extends { prop: number; lith_id?: number; environ_id?: number },
+>(liths: T[], key: "lith_id" | "environ_id"): T[] {
+  /** Merge lithology/environment data with the same identifying property (lith_id or environ_id),
+   * summing their proportions.
+   *
+   * TODO: handle attribute merging
+   */
+  const mergedMap: Map<number, T> = new Map();
+
+  for (const lith of liths) {
+    const id = lith[key];
+    if (id == null) continue;
+
+    if (mergedMap.has(id)) {
+      const existing = mergedMap.get(id);
+      mergedMap.set(id, {
+        ...existing,
+        prop: existing.prop + lith.prop,
+      });
+    } else {
+      mergedMap.set(id, { ...lith });
+    }
+  }
+
+  return Array.from(mergedMap.values());
+}

package/src/units/resolvers.ts

@@ -1,3 +1,6 @@
+import { Lithology, UnitLithology } from "@macrostrat/api-types";
+import { LithologyCore } from "@macrostrat/api-types/src/lithologies";
+
 const symbolIndex = {
   "dolomite-limestone": 641,
   lime_mudstone: 627,
@@ -54,6 +57,19 @@ const symbolIndex = {
   diamictite: 681,
 };
 
+export function getBestFGDCPatternForLithologyList<
+  T extends UnitLithology | Lithology,
+>(liths: T[]): { lith: T; patternID: string } | null {
+  let lithsSorted = [...liths];
+  lithsSorted.sort((a, b) => b.prop - a.prop);
+  let firstLith = lithsSorted[0];
+  let sym = symbolIndex[firstLith.name];
+  if (sym != null) {
+    return { lith: firstLith, patternID: `${sym}` };
+  }
+  return null;
+}
+
 const resolveID = (d: any) => {
   if (d.lith == null || d.lith.length == 0) {
     return null;