@macrostrat/column-views 3.9.0 → 3.11.0

package/src/units/colors.ts

@@ -1,183 +0,0 @@
-import chroma from "chroma-js";
-import {
-  Environment,
-  Lithology,
-  UnitLithology,
-  UnitLong,
-} from "@macrostrat/api-types";
-
-interface KeyOptions {
-  key?: "lith" | "environ";
-  id_key?: "lith_id" | "environ_id";
-}
-
-export function getMixedUnitColor(
-  unit: UnitLong,
-  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];
-  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) => {
-      let prop = d.prop;
-      if (prop == null || isNaN(prop) || prop <= 0) {
-        prop = null;
-      }
-      return {
-        ...d,
-        prop,
-        color: getColor?.(d) ?? d.color,
-      };
-    })
-    .filter((d) => d.color != null);
-
-  if (lithData.length == 0) {
-    return null;
-  }
-
-  const lithsWithProp = addProportionsToAllData(lithData);
-
-  // Mix colors proportionally
-  const baseColor = chroma.average(
-    lithsWithProp.map((d) => d.color),
-    "lrgb",
-    lithsWithProp.map((d) => d.prop),
-  );
-
-  if (!asBackground) {
-    return baseColor.hex();
-  }
-
-  if (inDarkMode) {
-    return baseColor.set("hsl.l", 0.2).hex();
-  } else {
-    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,141 +0,0 @@
-import { Lithology, UnitLithology } from "@macrostrat/api-types";
-import { LithologyCore } from "@macrostrat/api-types/src/lithologies";
-
-const symbolIndex = {
-  "dolomite-limestone": 641,
-  lime_mudstone: 627,
-  sandstone: 607,
-  "quartz arenite": 607,
-  litharenite: 608,
-  sand: 608,
-  siltstone: 616,
-  silt: 616,
-  siliciclastic: 615,
-  mud: 620,
-  "dolomitic siltstone": 616,
-  shale: 620,
-  limestone: 627,
-  dolomite: 642,
-  conglomerate: 602,
-  carbonate: 627,
-  "dolomite-mudstone": 642,
-  dolostone: 642,
-  mudstone: 620,
-  slate: 703,
-  "sandy-dolomite": 645,
-  quartzite: 702,
-  halite: 668,
-  gypsum: 667,
-  evaporite: 667,
-  claystone: 620,
-  anhydrite: 667,
-  gabbro: 720,
-  basalt: 717,
-  diabase: 717,
-  rhyolite: 722,
-  andesite: 723,
-  till: 681,
-  loess: 684,
-  "calcareous ooze": 653,
-  "siliceous ooze": 653,
-  chalk: 626,
-  gravel: 601,
-  plutonic: 721,
-  granite: 719,
-  clay: 660,
-  syenite: 722,
-  tuff: 711,
-  volcanic: 725,
-  metamorphic: 707,
-  volcaniclastic: 714,
-  migmatite: 709,
-  gneiss: 708,
-  tonalite: 727,
-  granodiorite: 725,
-  monzonite: 723,
-  argillite: 624,
-  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;
-  }
-  let liths = [...d.lith];
-  let environs = d.environ.map((d) => d.name).join(" ");
-  liths.sort((a, b) => b.prop - a.prop);
-
-  //console.log(d, d.unit_name, liths.map(d => d.name), environs)
-
-  let sym = null;
-
-  // overrides for IODP columns
-  if (d.unit_name == "clay") {
-    return "650";
-  }
-  if (d.unit_name == "calcareous clay") {
-    return "651";
-  }
-
-  for (const k of liths) {
-    if (k.name == "sandstone") {
-      // Special cases for sandstone
-      if (environs.includes("dune")) {
-        return "609";
-      }
-      if (environs.includes("marine")) {
-        return "608";
-      }
-      if (environs.includes("shore")) {
-        return "611";
-      }
-      if (environs.includes("loess")) {
-        return "686";
-      }
-    }
-
-    if (k.name == "conglomerate") {
-      // Special cases for sandstone
-      if (environs.includes("fluvial")) {
-        return "603";
-      }
-    }
-
-    if (k.name.includes("tuff")) {
-      return "711";
-    }
-    sym = symbolIndex[k.name];
-    if (sym != null) {
-      return sym;
-    }
-
-    if (k.type == "volcanic") {
-      return "725";
-    }
-  }
-  return sym;
-};
-
-const patternScale = {
-  "609": 1.5,
-  "603": 1.5,
-};
-
-const scalePattern = (id) => {
-  return patternScale[`${id}`] ?? 1;
-};
-
-export { resolveID, scalePattern };