@macrostrat/column-views 2.4.3 → 3.0.0

package/dist/prepare-units/composite-scale.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"composite-scale.js","sources":["../../src/prepare-units/composite-scale.ts"],"sourcesContent":["import { ColumnAxisType } from \"@macrostrat/column-components\";\nimport { ensureArray, getUnitHeightRange } from \"./utils\";\nimport { ScaleContinuousNumeric, scaleLinear } from \"d3-scale\";\nimport { UnitLong } from \"@macrostrat/api-types\";\nimport { buildHybridScale } from \"./dynamic-scales\";\nimport { ExtUnit, HybridScaleType, SectionInfo } from \"./types\";\nimport type {\n  ColumnScaleOptions,\n  CompositeColumnData,\n  CompositeScaleData,\n  PackageLayoutData,\n  PackageScaleInfo,\n  PackageScaleLayoutData,\n  SectionScaleOptions,\n} from \"./types\";\n\n// Composite scale information augmented with units in each package\n\nexport function buildCompositeScaleInfo(\n  inputScales: PackageScaleInfo[],\n  unconformityHeight: number,\n): CompositeScaleData {\n  /** Finalize the heights of sections, including the heights of unconformities\n   * between them.\n   */\n\n  let totalHeight = unconformityHeight / 2;\n  let lastSectionTopHeight = 0;\n\n  const packages2: PackageScaleLayoutData[] = [];\n  for (const group of inputScales) {\n    const { domain, scale } = group;\n    const [b_age, t_age] = domain;\n    const key = `package-${b_age}-${t_age}`;\n\n    packages2.push({\n      ...createPackageScale(group, totalHeight),\n      key,\n      offset: totalHeight,\n      // Unconformity height above this particular section\n      paddingTop: totalHeight - lastSectionTopHeight,\n    });\n\n    const pixelHeight = Math.abs(scale(b_age) - scale(t_age));\n    lastSectionTopHeight = totalHeight + pixelHeight;\n    totalHeight = lastSectionTopHeight + unconformityHeight;\n  }\n  totalHeight += unconformityHeight / 2;\n  return {\n    totalHeight,\n    sections: packages2,\n  };\n}\n\nexport function finalizeSectionHeights<T extends UnitLong>(\n  sections: SectionInfoWithScale<T>[],\n  unconformityHeight: number,\n): CompositeColumnData<T> {\n  /** Finalize the heights of sections, including the heights of unconformities\n   * between them.\n   */\n\n  const sectionScales = sections.map((d) => d.scaleInfo);\n\n  const { totalHeight, sections: packages } = buildCompositeScaleInfo(\n    sectionScales,\n    unconformityHeight,\n  );\n\n  // This could perhaps be simplified.\n  const sections1: PackageLayoutData<T>[] = [];\n  for (const i in sections) {\n    const group = sections[i];\n    const scaleInfo = packages[i];\n    sections1.push({\n      ...group,\n      key: scaleInfo.key,\n      scaleInfo,\n    });\n  }\n  return {\n    totalHeight,\n    sections: sections1,\n  };\n}\n\nexport interface SectionInfoWithScale<\n  T extends UnitLong = ExtUnit,\n> extends SectionInfo<T> {\n  scaleInfo: PackageScaleInfo;\n}\n\nexport function computeSectionHeights<T extends UnitLong>(\n  sections: SectionInfo<T>[],\n  opts: ColumnScaleOptions,\n): SectionInfoWithScale<T>[] {\n  return sections.map((group) => {\n    return addScaleToSection<T>(group, opts);\n  });\n}\n\nfunction addScaleToSection<T extends UnitLong = ExtUnit>(\n  group: SectionInfo<T>,\n  opts: ColumnScaleOptions,\n): SectionInfoWithScale<T> {\n  const { t_age, b_age, t_pos, b_pos, units } = group;\n  let _range = null;\n  // if t_age and b_age are set for a group, use them to define the range...\n  if (opts.axisType == ColumnAxisType.AGE) {\n    _range = [b_age, t_age];\n  } else {\n    _range = [b_pos, t_pos];\n  }\n\n  const scaleInfo = buildSectionScale<T>(units, {\n    ...opts,\n    domain: _range,\n  });\n\n  return {\n    ...group,\n    scaleInfo,\n  };\n}\n\nfunction buildSectionScale<T extends UnitLong>(\n  data: T[],\n  opts: SectionScaleOptions,\n): PackageScaleInfo {\n  const {\n    targetUnitHeight = 20,\n    minPixelScale = 0.2,\n    axisType,\n    minSectionHeight,\n    scale,\n    hybridScale,\n  } = opts;\n  const domain = opts.domain ?? findSectionHeightRange(data, axisType);\n\n  const dAge = Math.abs(domain[0] - domain[1]);\n\n  let _pixelScale = opts.pixelScale;\n  let pixelHeight: number;\n\n  if (hybridScale != null) {\n    /** In an equidistant surfaces scale, we want to determine the heights of surfaces\n     * and then distribute units evenly between them.\n     * This is somewhat like an ordinal scale\n     */\n    if (hybridScale.type === HybridScaleType.EquidistantSurfaces) {\n      _pixelScale ??= targetUnitHeight;\n    }\n\n    return buildHybridScale(hybridScale, data, domain, {\n      pixelOffset: 0,\n      pixelScale: _pixelScale,\n    });\n  }\n\n  if (scale == null) {\n    if (_pixelScale == null) {\n      const avgAgeRange = findAverageUnitHeight(data, axisType);\n      // Get pixel height necessary to render average unit at target height\n      _pixelScale = Math.max(targetUnitHeight / avgAgeRange, minPixelScale);\n\n      // OLD METHOD that cares about overall section height vs. individual unit height\n      // 0.2 pixel per myr is the floor scale\n      //const targetHeight = targetUnitHeight * data.length;\n      // 1 pixel per myr is the floor scale\n      //_pixelScale = Math.max(targetHeight / dAge, minPixelScale);\n    }\n\n    let height = dAge * _pixelScale;\n    // If height is less than minSectionHeight, set it to minSectionHeight\n    const _minSectionHeight = minSectionHeight ?? targetUnitHeight ?? 0;\n    pixelHeight = Math.max(height, _minSectionHeight);\n    _pixelScale = pixelHeight / dAge;\n  } else {\n    // If a scale is provided, use it to compute pixel height\n    pixelHeight = Math.abs(scale(domain[0]) - scale(domain[1]));\n  }\n\n  return createPackageScale(\n    { scale, domain, pixelHeight, pixelScale: _pixelScale },\n    0,\n  );\n}\n\nexport function createPackageScale(\n  def: PackageScaleInfo,\n  offset: number = 0,\n): PackageScaleInfo {\n  /** Build a section scale */\n  // Domain should be oriented from bottom to top, but scale is oriented from top to bottom\n  const { domain, pixelScale, pixelHeight, scale, heightScale } = def;\n\n  if (scale == null && pixelScale == null) {\n    throw new Error(\"Either scale or pixelScale must be provided\");\n  }\n\n  let _scale: ScaleContinuousNumeric<number, number>;\n  if (scale == null) {\n    _scale = scaleLinear()\n      .domain([domain[1], domain[0]])\n      .range([offset, pixelHeight + offset]);\n  } else {\n    const domain0 = scale.domain();\n    const range0 = scale.range();\n    _scale = scale\n      .copy()\n      .domain(domain0)\n      .range(range0.map((d) => d + offset));\n  }\n\n  _scale.clamp();\n\n  let _heightScale = null;\n  if (heightScale != null) {\n    // Adjust height scale as well\n    const range0 = scale.range();\n    _heightScale = heightScale.copy().range(range0.map((d) => d + offset));\n    _heightScale.clamp();\n  }\n\n  return {\n    domain,\n    pixelScale,\n    pixelHeight,\n    scale: _scale,\n    // Internal details for hybrid scales. TODO: improve this\n    heightScale: _heightScale,\n  };\n}\n\nfunction findSectionHeightRange(\n  data: UnitLong[],\n  axisType: ColumnAxisType,\n): [number, number] {\n  if (axisType == null) {\n    throw new Error(\"Axis type is not set\");\n  }\n  if (axisType === ColumnAxisType.AGE) {\n    const t_age = Math.min(...data.map((d) => d.t_age));\n    const b_age = Math.max(...data.map((d) => d.b_age));\n    return [b_age, t_age];\n  } else if (\n    axisType == ColumnAxisType.DEPTH ||\n    axisType == ColumnAxisType.ORDINAL\n  ) {\n    const t_pos = Math.min(...data.map((d) => d.t_pos));\n    const b_pos = Math.max(...data.map((d) => d.b_pos));\n    return [b_pos, t_pos];\n  } else if (axisType == ColumnAxisType.HEIGHT) {\n    const t_pos = Math.max(...data.map((d) => d.t_pos));\n    const b_pos = Math.min(...data.map((d) => d.b_pos));\n    return [b_pos, t_pos];\n  }\n}\n\nfunction findAverageUnitHeight(\n  data: UnitLong[],\n  axisType: ColumnAxisType,\n): number {\n  const unitHeights = data.map((d) => {\n    const [b_pos, t_pos] = getUnitHeightRange(d, axisType);\n    return Math.abs(b_pos - t_pos);\n  });\n  return unitHeights.reduce((a, b) => a + b, 0) / unitHeights.length;\n}\n\nexport interface CompositeColumnScale {\n  (age: number): number | null;\n  copy(): CompositeColumnScale;\n  domain(): [number, number];\n  invert(pixelHeight: number): number | null;\n  clamp(clamp: boolean): void;\n}\n\nexport function createCompositeScale(\n  sections: PackageLayoutData[],\n  interpolateUnconformities: boolean = false,\n): CompositeColumnScale {\n  /** Create a scale that works across multiple packages */\n\n  const scales: ScaleContinuousNumeric<number, number>[] = [];\n\n  let lastScale: ScaleContinuousNumeric<number, number> | null = null;\n  for (const section of sections) {\n    const _scale = section.scaleInfo.scale.copy().clamp(true);\n    scales.push(_scale);\n    if (lastScale != null && interpolateUnconformities) {\n      // Add a new scale that interpolates between lastScale and _scale\n      const lastDomain = lastScale.domain();\n      const lastRange = lastScale.range();\n      const currentDomain = _scale.domain();\n      const currentRange = _scale.range();\n\n      const interpScale = scaleLinear()\n        .domain([lastDomain[lastDomain.length - 1], currentDomain[0]])\n        .range([lastRange[lastRange.length - 1], currentRange[0]])\n        .clamp(true);\n      scales.push(interpScale);\n    }\n    lastScale = _scale;\n  }\n\n  const scale: CompositeColumnScale = (age) => {\n    for (const s of scales) {\n      const domain = s.domain();\n      if (\n        domain[0] < domain[domain.length - 1] &&\n        age >= domain[0] &&\n        age <= domain[domain.length - 1]\n      ) {\n        // Age axes\n        return s(age);\n      } else if (age <= domain[0] && age >= domain[domain.length - 1]) {\n        // Normal axes like height\n        return s(age);\n      }\n    }\n    return null;\n  };\n\n  scale.copy = () => {\n    return createCompositeScale(sections, interpolateUnconformities);\n  };\n\n  scale.domain = () => {\n    /** Return the domain of the scale */\n    const vals = sections.flatMap((d) => d.scaleInfo.domain);\n    if (vals[0] < vals[vals.length - 1]) {\n      // age axes\n      return [Math.min(...vals), Math.max(...vals)];\n    }\n    // Normal axes like height\n    return [Math.max(...vals), Math.min(...vals)];\n  };\n\n  scale.invert = (pixelHeight) => {\n    /** Invert the scale to get the age at a given pixel height */\n    // Iterate through the sections to find the correct one\n    for (const scale of scales) {\n      const range = scale.range();\n      if (\n        pixelHeight > Math.min(...range) &&\n        pixelHeight <= Math.max(...range)\n      ) {\n        console.log(\"Inverting scale at pixel height\", pixelHeight);\n        return scale.invert(pixelHeight);\n      }\n    }\n    return null;\n  };\n\n  scale.clamp = (clamp: boolean) => {\n    /** Clamp all constituent scales */\n    for (const s of scales) {\n      s.clamp(clamp);\n    }\n  };\n\n  return scale;\n}\n\n/** Collapse sections separated by unconformities that are smaller than a given pixel height. */\nexport function collapseUnconformitiesByPixelHeight<T extends UnitLong>(\n  sections: SectionInfoWithScale<T>[],\n  threshold: number,\n  opts: ColumnScaleOptions,\n): SectionInfoWithScale<T>[] {\n  const newSections = [];\n  let currentSection: SectionInfoWithScale<T> | null = null;\n  for (const nextSection of sections) {\n    if (currentSection == null) {\n      currentSection = nextSection;\n      continue;\n    }\n    let heights: [number, number];\n    let pxHeights: [number, number];\n    if (opts.axisType !== ColumnAxisType.AGE) {\n      heights = [nextSection.t_pos, currentSection.b_pos];\n    } else {\n      heights = [nextSection.t_age, currentSection.b_age];\n    }\n\n    const _diff = (vals: number[]) => {\n      return Math.abs(vals[0] - vals[1]);\n    };\n\n    pxHeights = [\n      _diff(heights.map(nextSection.scaleInfo.scale)),\n      _diff(heights.map(currentSection.scaleInfo.scale)),\n    ];\n\n    const pxHeight = Math.min(...pxHeights);\n\n    if (pxHeight < threshold) {\n      let t_pos: number;\n      let b_pos: number;\n      if (\n        opts.axisType == ColumnAxisType.AGE ||\n        opts.axisType == ColumnAxisType.DEPTH\n      ) {\n        t_pos = Math.min(currentSection.t_pos, nextSection.t_pos);\n        b_pos = Math.max(currentSection.b_pos, nextSection.b_pos);\n      } else {\n        t_pos = Math.max(currentSection.t_pos, nextSection.t_pos);\n        b_pos = Math.min(currentSection.b_pos, nextSection.b_pos);\n      }\n\n      // We need to merge the sections\n      const compositeSection0: SectionInfo<T> = {\n        units: [...currentSection.units, ...nextSection.units],\n        section_id: [\n          ...ensureArray(currentSection.section_id),\n          ...ensureArray(nextSection.section_id),\n        ],\n        t_age: Math.min(currentSection.t_age, nextSection.t_age),\n        b_age: Math.max(currentSection.b_age, nextSection.b_age),\n        t_pos,\n        b_pos,\n      };\n\n      currentSection = addScaleToSection(compositeSection0, opts);\n    } else {\n      // We need to keep the section\n      newSections.push(currentSection);\n      currentSection = nextSection;\n    }\n  }\n  if (currentSection != null) {\n    newSections.push(currentSection);\n  }\n\n  return newSections;\n}\n"],"names":["scale"],"mappings":"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"}

package/dist/prepare-units/dynamic-scales.cjs

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const d3Scale = require("d3-scale");
+const utils = require("./utils.cjs");
+const columnComponents = require("@macrostrat/column-components");
+const stratigraphyUtils = require("@macrostrat/stratigraphy-utils");
+const types = require("./types.cjs");
+function buildColumnSurfaces(units, tolerance = 1e-3) {
+  const surfaces = [];
+  for (const unit of units) {
+    surfaces.push({
+      age: unit.t_age,
+      units_below: [unit.unit_id],
+      units_above: []
+    });
+    surfaces.push({
+      age: unit.b_age,
+      units_above: [unit.unit_id],
+      units_below: []
+    });
+  }
+  const mergedSurfaces = [];
+  for (const surface of surfaces) {
+    const existingSurface = mergedSurfaces.find(
+      (s) => Math.abs(s.age - surface.age) < tolerance
+    );
+    if (existingSurface) {
+      existingSurface.units_above.push(...surface.units_above);
+      existingSurface.units_below.push(...surface.units_below);
+    } else {
+      mergedSurfaces.push(surface);
+    }
+  }
+  mergedSurfaces.sort((a, b) => a.age - b.age);
+  return mergedSurfaces.map((s, i) => ({ ...s, index: i }));
+}
+function getUnitsInAgeDomains(surfaces, units) {
+  const domainUnitInfo = [];
+  for (let i = 0; i < surfaces.length - 1; i++) {
+    const topSurface = surfaces[i];
+    const bottomSurface = surfaces[i + 1];
+    const unitsInDomain = units.filter((unit) => {
+      return unit.t_age <= topSurface.age + 1e-3 && unit.b_age >= bottomSurface.age - 1e-3;
+    });
+    domainUnitInfo.push({
+      t_age: topSurface.age,
+      b_age: bottomSurface.age,
+      units: unitsInDomain
+    });
+  }
+  return domainUnitInfo;
+}
+function proportionOfUnitInDomain(unit, t_age, b_age) {
+  const rng = utils.getUnitHeightRange(unit, columnComponents.ColumnAxisType.AGE);
+  const rng1 = [b_age, t_age];
+  const mergedRange = stratigraphyUtils.mergeAgeRanges([rng, rng1], stratigraphyUtils.MergeMode.Inner);
+  const unitHeight = Math.abs(rng[1] - rng[0]);
+  const mergedHeight = Math.abs(mergedRange[1] - mergedRange[0]);
+  return mergedHeight / unitHeight;
+}
+function buildHybridScale(def, units, domain, options = {}) {
+  const surfaces = buildColumnSurfaces(units);
+  const filteredSurfaces = surfaces.filter(
+    (s) => s.age < Math.max(...domain) && s.age > Math.min(...domain)
+  );
+  const s1 = [
+    { index: -1, age: Math.min(...domain), units_above: [], units_below: [] },
+    ...filteredSurfaces,
+    {
+      index: -1,
+      age: Math.max(...domain),
+      units_above: [],
+      units_below: []
+    }
+  ];
+  const { type, ...rest } = def;
+  if (type === types.HybridScaleType.EquidistantSurfaces) {
+    return buildScaleFromSurfacesSimple(s1, options);
+  }
+  return buildApproximateHeightScale(s1, units, { ...options, ...rest });
+}
+function getApproximateHeight(unit, method = types.HeightMethod.Maximum) {
+  const heights = [];
+  unit.min_thick;
+  if (method === types.HeightMethod.Minimum || method === types.HeightMethod.Average) {
+    const h = unit.min_thick;
+    if (h != null && !isNaN(h) && h > 0) heights.push(h);
+  }
+  if (method === types.HeightMethod.Average || method === types.HeightMethod.Maximum) {
+    const h = unit.max_thick;
+    if (h != null && !isNaN(h) && h > 0) heights.push(h);
+  }
+  if (heights.length === 0) return null;
+  if (method === types.HeightMethod.Average) {
+    return heights.reduce((sum, h) => sum + h, 0) / heights.length;
+  } else {
+    return heights[0];
+  }
+}
+function buildApproximateHeightScale(surfaces, units, options = {}) {
+  const {
+    pixelScale = 1,
+    // pixels per meter
+    pixelOffset = 0,
+    minHeight = 5,
+    heightMethod = types.HeightMethod.Maximum,
+    // Default height for when height is unknown
+    defaultHeight = 100
+  } = options;
+  const domainInfo = getUnitsInAgeDomains(surfaces, units);
+  const surfaceHeights = [];
+  const ageDomain = [];
+  let lastHeight = pixelOffset;
+  for (const domain2 of domainInfo) {
+    if (lastHeight == pixelOffset) {
+      surfaceHeights.push(lastHeight);
+      ageDomain.push(domain2.t_age);
+    }
+    const units2 = domain2.units;
+    let unitHeightInfo = [];
+    for (const unit of units2) {
+      const proportion = proportionOfUnitInDomain(
+        unit,
+        domain2.t_age,
+        domain2.b_age
+      );
+      const height = getApproximateHeight(unit, heightMethod);
+      if (height != null) {
+        unitHeightInfo.push({ unit, height: height * proportion });
+      }
+    }
+    let thisHeight = 0;
+    if (unitHeightInfo.length === 0) {
+      thisHeight = defaultHeight;
+    } else {
+      const meanHeight = unitHeightInfo.reduce((sum, d) => sum + d.height, 0) / unitHeightInfo.length;
+      if (meanHeight == 0) {
+        thisHeight = defaultHeight;
+      } else if (meanHeight < minHeight) {
+        thisHeight = minHeight;
+      } else {
+        thisHeight = meanHeight;
+      }
+    }
+    lastHeight += thisHeight;
+    surfaceHeights.push(lastHeight);
+    ageDomain.push(domain2.b_age);
+  }
+  const pixelRange = surfaceHeights.map((h) => h * pixelScale);
+  const scale = d3Scale.scaleLinear().domain(ageDomain).range(pixelRange);
+  const heightDomain = surfaceHeights.map((h) => lastHeight - h);
+  const heightScale = d3Scale.scaleLinear().domain(heightDomain).range(pixelRange);
+  const domain = [
+    ageDomain[ageDomain.length - 1],
+    ageDomain[0]
+  ];
+  return {
+    scale,
+    pixelScale: null,
+    // pixels per unit
+    domain,
+    pixelHeight: Math.abs(pixelRange[pixelRange.length - 1] - pixelRange[0]),
+    heightScale
+  };
+}
+function buildScaleFromSurfacesSimple(surfaces, options = {}) {
+  const { pixelScale = 30 } = options;
+  const domain = [
+    surfaces[surfaces.length - 1].age,
+    surfaces[0].age
+  ];
+  const surfaceHeights = surfaces.map((surface, i) => {
+    return i * pixelScale;
+  });
+  const ageDomain = surfaces.map((s) => s.age);
+  const pixelRange = surfaceHeights;
+  const scale = d3Scale.scaleLinear().domain(ageDomain).range(pixelRange);
+  return {
+    scale,
+    pixelScale: null,
+    // pixels per unit
+    domain,
+    pixelHeight: Math.abs(pixelRange[pixelRange.length - 1] - pixelRange[0])
+  };
+}
+exports.buildApproximateHeightScale = buildApproximateHeightScale;
+exports.buildColumnSurfaces = buildColumnSurfaces;
+exports.buildHybridScale = buildHybridScale;
+exports.buildScaleFromSurfacesSimple = buildScaleFromSurfacesSimple;
+//# sourceMappingURL=dynamic-scales.cjs.map

package/dist/prepare-units/dynamic-scales.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"dynamic-scales.cjs","sources":["../../src/prepare-units/dynamic-scales.ts"],"sourcesContent":["import type { UnitLong } from \"@macrostrat/api-types\";\nimport { scaleLinear } from \"d3-scale\";\nimport { getUnitHeightRange } from \"./utils\";\nimport { ColumnAxisType } from \"@macrostrat/column-components\";\nimport { mergeAgeRanges, MergeMode } from \"@macrostrat/stratigraphy-utils\";\nimport type {\n  ApproxHeightScaleOptions,\n  ExtUnit,\n  HybridScaleDefinition,\n  HybridScaleOptions,\n  PackageScaleInfo,\n} from \"./types\";\nimport { HybridScaleType, HeightMethod } from \"./types\";\n\ninterface BaseSurface {\n  index: number;\n  age: number;\n  units_below: number[];\n  units_above: number[];\n}\n\nexport function buildColumnSurfaces<T extends UnitLong>(\n  units: T[],\n  tolerance: number = 0.001,\n): BaseSurface[] {\n  /** Compute age surfaces for a column based on unit tops and bottoms */\n  const surfaces: Omit<BaseSurface, \"index\">[] = [];\n  for (const unit of units) {\n    // Top surface\n    surfaces.push({\n      age: unit.t_age,\n      units_below: [unit.unit_id],\n      units_above: [],\n    });\n    // Bottom surface\n    surfaces.push({\n      age: unit.b_age,\n      units_above: [unit.unit_id],\n      units_below: [],\n    });\n  }\n\n  // Merge duplicate surfaces (same age)\n  const mergedSurfaces: Omit<BaseSurface, \"index\">[] = [];\n  for (const surface of surfaces) {\n    const existingSurface = mergedSurfaces.find(\n      (s) => Math.abs(s.age - surface.age) < tolerance,\n    );\n    if (existingSurface) {\n      existingSurface.units_above.push(...surface.units_above);\n      existingSurface.units_below.push(...surface.units_below);\n    } else {\n      mergedSurfaces.push(surface);\n    }\n  }\n\n  // Sort surfaces by age (ascending)\n  mergedSurfaces.sort((a, b) => a.age - b.age);\n\n  return mergedSurfaces.map((s, i) => ({ ...s, index: i }));\n}\n\ninterface AgeDomainUnitInfo {\n  t_age: number;\n  b_age: number;\n  units: ExtUnit[];\n}\n\nfunction getUnitsInAgeDomains(\n  surfaces: BaseSurface[],\n  units: ExtUnit[],\n): AgeDomainUnitInfo[] {\n  // Get unit IDs represented between the same surface, and the proportion of their total height represented\n  const domainUnitInfo: AgeDomainUnitInfo[] = [];\n  for (let i = 0; i < surfaces.length - 1; i++) {\n    const topSurface = surfaces[i];\n    const bottomSurface = surfaces[i + 1];\n    const unitsInDomain = units.filter((unit) => {\n      return (\n        unit.t_age <= topSurface.age + 0.001 &&\n        unit.b_age >= bottomSurface.age - 0.001\n      );\n    });\n    domainUnitInfo.push({\n      t_age: topSurface.age,\n      b_age: bottomSurface.age,\n      units: unitsInDomain,\n    });\n  }\n  return domainUnitInfo;\n}\n\nfunction proportionOfUnitInDomain(\n  unit: ExtUnit,\n  t_age: number,\n  b_age: number,\n): number {\n  // Compute the proportion of a unit's height that lies within the given age domain\n\n  const rng = getUnitHeightRange(unit, ColumnAxisType.AGE);\n  const rng1: [number, number] = [b_age, t_age];\n  // Compute overlap\n\n  const mergedRange = mergeAgeRanges([rng, rng1], MergeMode.Inner);\n\n  const unitHeight = Math.abs(rng[1] - rng[0]);\n  const mergedHeight = Math.abs(mergedRange[1] - mergedRange[0]);\n\n  return mergedHeight / unitHeight;\n}\n\nexport function buildHybridScale<T extends UnitLong>(\n  def: HybridScaleDefinition,\n  units: T[],\n  domain: [number, number],\n  options: HybridScaleOptions = {},\n): PackageScaleInfo {\n  const surfaces = buildColumnSurfaces(units);\n\n  const filteredSurfaces = surfaces.filter(\n    (s) => s.age < Math.max(...domain) && s.age > Math.min(...domain),\n  );\n\n  const s1 = [\n    { index: -1, age: Math.min(...domain), units_above: [], units_below: [] },\n    ...filteredSurfaces,\n    {\n      index: -1,\n      age: Math.max(...domain),\n      units_above: [],\n      units_below: [],\n    },\n  ];\n\n  const { type, ...rest } = def;\n\n  if (type === HybridScaleType.EquidistantSurfaces) {\n    return buildScaleFromSurfacesSimple(s1, options);\n  }\n\n  return buildApproximateHeightScale(s1, units, { ...options, ...rest });\n}\n\nfunction getApproximateHeight(\n  unit: ExtUnit,\n  method: HeightMethod = HeightMethod.Maximum,\n): number | null {\n  // Get approximate height of a unit based on specified method\n  const heights = [];\n  let minHeight = unit.min_thick;\n  if (method === HeightMethod.Minimum || method === HeightMethod.Average) {\n    const h = unit.min_thick;\n    if (h != null && !isNaN(h) && h > 0) heights.push(h);\n  }\n  if (method === HeightMethod.Average || method === HeightMethod.Maximum) {\n    const h = unit.max_thick;\n    if (h != null && !isNaN(h) && h > 0) heights.push(h);\n  }\n\n  if (heights.length === 0) return null;\n\n  if (method === HeightMethod.Average) {\n    return heights.reduce((sum, h) => sum + h, 0) / heights.length;\n  } else {\n    return heights[0];\n  }\n}\n\nexport function buildApproximateHeightScale(\n  surfaces: BaseSurface[],\n  units: UnitLong[],\n  options: HybridScaleOptions & ApproxHeightScaleOptions = {},\n): PackageScaleInfo {\n  /** Build a variable age scale that places age surfaces equally far apart in height space.\n   * It is presumed that gaps are already removed from the unit set provided.\n   * */\n\n  const {\n    pixelScale = 1, // pixels per meter\n    pixelOffset = 0,\n    minHeight = 5,\n    heightMethod = HeightMethod.Maximum,\n    // Default height for when height is unknown\n    defaultHeight = 100,\n  } = options;\n\n  // Get units associated with each surface\n  // Note: we could hoist this if it proved useful for other scale types\n  const domainInfo = getUnitsInAgeDomains(surfaces, units as ExtUnit[]);\n\n  // Compute the height in pixels for each surface\n\n  const surfaceHeights = [];\n  const ageDomain = [];\n  let lastHeight = pixelOffset;\n\n  for (const domain of domainInfo) {\n    if (lastHeight == pixelOffset) {\n      surfaceHeights.push(lastHeight);\n      ageDomain.push(domain.t_age);\n    }\n\n    // Approximate height based on units in this domain\n    const units = domain.units;\n    let unitHeightInfo: { unit: ExtUnit; height: number }[] = [];\n\n    for (const unit of units) {\n      const proportion = proportionOfUnitInDomain(\n        unit,\n        domain.t_age,\n        domain.b_age,\n      );\n      const height = getApproximateHeight(unit, heightMethod);\n      if (height != null) {\n        unitHeightInfo.push({ unit, height: height * proportion });\n      }\n    }\n\n    let thisHeight = 0;\n    if (unitHeightInfo.length === 0) {\n      thisHeight = defaultHeight; // Default height if no units with height info\n    } else {\n      // Normalize weights (take the mean)\n\n      const meanHeight =\n        unitHeightInfo.reduce((sum, d) => sum + d.height, 0) /\n        unitHeightInfo.length;\n\n      if (meanHeight == 0) {\n        thisHeight = defaultHeight; // Arbitrary height for zero-height intervals\n      } else if (meanHeight < minHeight) {\n        thisHeight = minHeight; // Minimum height\n      } else {\n        thisHeight = meanHeight;\n      }\n    }\n\n    lastHeight += thisHeight;\n    surfaceHeights.push(lastHeight);\n    ageDomain.push(domain.b_age);\n  }\n\n  // Build a piecewise linear scale mapping age to pixel height\n  const pixelRange = surfaceHeights.map((h) => h * pixelScale);\n\n  const scale = scaleLinear().domain(ageDomain).range(pixelRange);\n\n  const heightDomain = surfaceHeights.map((h) => lastHeight - h);\n\n  const heightScale = scaleLinear().domain(heightDomain).range(pixelRange);\n\n  const domain: [number, number] = [\n    ageDomain[ageDomain.length - 1],\n    ageDomain[0],\n  ];\n\n  return {\n    scale,\n    pixelScale: null, // pixels per unit\n    domain,\n    pixelHeight: Math.abs(pixelRange[pixelRange.length - 1] - pixelRange[0]),\n    heightScale,\n  };\n}\n\nexport function buildScaleFromSurfacesSimple(\n  surfaces: BaseSurface[],\n  options: HybridScaleOptions = {},\n): PackageScaleInfo {\n  /** Build a variable age scale that places age surfaces equally far apart in height space.\n   * It is presumed that gaps are already removed from the unit set provided.\n   * */\n\n  const { pixelScale = 30 } = options;\n\n  const domain: [number, number] = [\n    surfaces[surfaces.length - 1].age,\n    surfaces[0].age,\n  ];\n  // Compute the height in pixels for each surface\n\n  const surfaceHeights = surfaces.map((surface, i) => {\n    return i * pixelScale;\n  });\n\n  // Build a piecewise linear scale mapping age to pixel height\n  const ageDomain = surfaces.map((s) => s.age);\n  const pixelRange = surfaceHeights;\n\n  const scale = scaleLinear().domain(ageDomain).range(pixelRange);\n\n  return {\n    scale,\n    pixelScale: null, // pixels per unit\n    domain,\n    pixelHeight: Math.abs(pixelRange[pixelRange.length - 1] - pixelRange[0]),\n  };\n}\n"],"names":["getUnitHeightRange","ColumnAxisType","mergeAgeRanges","MergeMode","HybridScaleType","HeightMethod","domain","units","scaleLinear"],"mappings":"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"}

package/dist/prepare-units/dynamic-scales.d.ts

@@ -0,0 +1,13 @@
+import { UnitLong } from '@macrostrat/api-types';
+import { ApproxHeightScaleOptions, HybridScaleDefinition, HybridScaleOptions, PackageScaleInfo } from './types';
+interface BaseSurface {
+    index: number;
+    age: number;
+    units_below: number[];
+    units_above: number[];
+}
+export declare function buildColumnSurfaces<T extends UnitLong>(units: T[], tolerance?: number): BaseSurface[];
+export declare function buildHybridScale<T extends UnitLong>(def: HybridScaleDefinition, units: T[], domain: [number, number], options?: HybridScaleOptions): PackageScaleInfo;
+export declare function buildApproximateHeightScale(surfaces: BaseSurface[], units: UnitLong[], options?: HybridScaleOptions & ApproxHeightScaleOptions): PackageScaleInfo;
+export declare function buildScaleFromSurfacesSimple(surfaces: BaseSurface[], options?: HybridScaleOptions): PackageScaleInfo;
+export {};

package/dist/prepare-units/dynamic-scales.js

@@ -0,0 +1,190 @@
+import { scaleLinear } from "d3-scale";
+import { getUnitHeightRange } from "./utils.js";
+import { ColumnAxisType } from "@macrostrat/column-components";
+import { mergeAgeRanges, MergeMode } from "@macrostrat/stratigraphy-utils";
+import { HybridScaleType, HeightMethod } from "./types.js";
+function buildColumnSurfaces(units, tolerance = 1e-3) {
+  const surfaces = [];
+  for (const unit of units) {
+    surfaces.push({
+      age: unit.t_age,
+      units_below: [unit.unit_id],
+      units_above: []
+    });
+    surfaces.push({
+      age: unit.b_age,
+      units_above: [unit.unit_id],
+      units_below: []
+    });
+  }
+  const mergedSurfaces = [];
+  for (const surface of surfaces) {
+    const existingSurface = mergedSurfaces.find(
+      (s) => Math.abs(s.age - surface.age) < tolerance
+    );
+    if (existingSurface) {
+      existingSurface.units_above.push(...surface.units_above);
+      existingSurface.units_below.push(...surface.units_below);
+    } else {
+      mergedSurfaces.push(surface);
+    }
+  }
+  mergedSurfaces.sort((a, b) => a.age - b.age);
+  return mergedSurfaces.map((s, i) => ({ ...s, index: i }));
+}
+function getUnitsInAgeDomains(surfaces, units) {
+  const domainUnitInfo = [];
+  for (let i = 0; i < surfaces.length - 1; i++) {
+    const topSurface = surfaces[i];
+    const bottomSurface = surfaces[i + 1];
+    const unitsInDomain = units.filter((unit) => {
+      return unit.t_age <= topSurface.age + 1e-3 && unit.b_age >= bottomSurface.age - 1e-3;
+    });
+    domainUnitInfo.push({
+      t_age: topSurface.age,
+      b_age: bottomSurface.age,
+      units: unitsInDomain
+    });
+  }
+  return domainUnitInfo;
+}
+function proportionOfUnitInDomain(unit, t_age, b_age) {
+  const rng = getUnitHeightRange(unit, ColumnAxisType.AGE);
+  const rng1 = [b_age, t_age];
+  const mergedRange = mergeAgeRanges([rng, rng1], MergeMode.Inner);
+  const unitHeight = Math.abs(rng[1] - rng[0]);
+  const mergedHeight = Math.abs(mergedRange[1] - mergedRange[0]);
+  return mergedHeight / unitHeight;
+}
+function buildHybridScale(def, units, domain, options = {}) {
+  const surfaces = buildColumnSurfaces(units);
+  const filteredSurfaces = surfaces.filter(
+    (s) => s.age < Math.max(...domain) && s.age > Math.min(...domain)
+  );
+  const s1 = [
+    { index: -1, age: Math.min(...domain), units_above: [], units_below: [] },
+    ...filteredSurfaces,
+    {
+      index: -1,
+      age: Math.max(...domain),
+      units_above: [],
+      units_below: []
+    }
+  ];
+  const { type, ...rest } = def;
+  if (type === HybridScaleType.EquidistantSurfaces) {
+    return buildScaleFromSurfacesSimple(s1, options);
+  }
+  return buildApproximateHeightScale(s1, units, { ...options, ...rest });
+}
+function getApproximateHeight(unit, method = HeightMethod.Maximum) {
+  const heights = [];
+  unit.min_thick;
+  if (method === HeightMethod.Minimum || method === HeightMethod.Average) {
+    const h = unit.min_thick;
+    if (h != null && !isNaN(h) && h > 0) heights.push(h);
+  }
+  if (method === HeightMethod.Average || method === HeightMethod.Maximum) {
+    const h = unit.max_thick;
+    if (h != null && !isNaN(h) && h > 0) heights.push(h);
+  }
+  if (heights.length === 0) return null;
+  if (method === HeightMethod.Average) {
+    return heights.reduce((sum, h) => sum + h, 0) / heights.length;
+  } else {
+    return heights[0];
+  }
+}
+function buildApproximateHeightScale(surfaces, units, options = {}) {
+  const {
+    pixelScale = 1,
+    // pixels per meter
+    pixelOffset = 0,
+    minHeight = 5,
+    heightMethod = HeightMethod.Maximum,
+    // Default height for when height is unknown
+    defaultHeight = 100
+  } = options;
+  const domainInfo = getUnitsInAgeDomains(surfaces, units);
+  const surfaceHeights = [];
+  const ageDomain = [];
+  let lastHeight = pixelOffset;
+  for (const domain2 of domainInfo) {
+    if (lastHeight == pixelOffset) {
+      surfaceHeights.push(lastHeight);
+      ageDomain.push(domain2.t_age);
+    }
+    const units2 = domain2.units;
+    let unitHeightInfo = [];
+    for (const unit of units2) {
+      const proportion = proportionOfUnitInDomain(
+        unit,
+        domain2.t_age,
+        domain2.b_age
+      );
+      const height = getApproximateHeight(unit, heightMethod);
+      if (height != null) {
+        unitHeightInfo.push({ unit, height: height * proportion });
+      }
+    }
+    let thisHeight = 0;
+    if (unitHeightInfo.length === 0) {
+      thisHeight = defaultHeight;
+    } else {
+      const meanHeight = unitHeightInfo.reduce((sum, d) => sum + d.height, 0) / unitHeightInfo.length;
+      if (meanHeight == 0) {
+        thisHeight = defaultHeight;
+      } else if (meanHeight < minHeight) {
+        thisHeight = minHeight;
+      } else {
+        thisHeight = meanHeight;
+      }
+    }
+    lastHeight += thisHeight;
+    surfaceHeights.push(lastHeight);
+    ageDomain.push(domain2.b_age);
+  }
+  const pixelRange = surfaceHeights.map((h) => h * pixelScale);
+  const scale = scaleLinear().domain(ageDomain).range(pixelRange);
+  const heightDomain = surfaceHeights.map((h) => lastHeight - h);
+  const heightScale = scaleLinear().domain(heightDomain).range(pixelRange);
+  const domain = [
+    ageDomain[ageDomain.length - 1],
+    ageDomain[0]
+  ];
+  return {
+    scale,
+    pixelScale: null,
+    // pixels per unit
+    domain,
+    pixelHeight: Math.abs(pixelRange[pixelRange.length - 1] - pixelRange[0]),
+    heightScale
+  };
+}
+function buildScaleFromSurfacesSimple(surfaces, options = {}) {
+  const { pixelScale = 30 } = options;
+  const domain = [
+    surfaces[surfaces.length - 1].age,
+    surfaces[0].age
+  ];
+  const surfaceHeights = surfaces.map((surface, i) => {
+    return i * pixelScale;
+  });
+  const ageDomain = surfaces.map((s) => s.age);
+  const pixelRange = surfaceHeights;
+  const scale = scaleLinear().domain(ageDomain).range(pixelRange);
+  return {
+    scale,
+    pixelScale: null,
+    // pixels per unit
+    domain,
+    pixelHeight: Math.abs(pixelRange[pixelRange.length - 1] - pixelRange[0])
+  };
+}
+export {
+  buildApproximateHeightScale,
+  buildColumnSurfaces,
+  buildHybridScale,
+  buildScaleFromSurfacesSimple
+};
+//# sourceMappingURL=dynamic-scales.js.map

package/dist/prepare-units/dynamic-scales.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dynamic-scales.js","sources":["../../src/prepare-units/dynamic-scales.ts"],"sourcesContent":["import type { UnitLong } from \"@macrostrat/api-types\";\nimport { scaleLinear } from \"d3-scale\";\nimport { getUnitHeightRange } from \"./utils\";\nimport { ColumnAxisType } from \"@macrostrat/column-components\";\nimport { mergeAgeRanges, MergeMode } from \"@macrostrat/stratigraphy-utils\";\nimport type {\n  ApproxHeightScaleOptions,\n  ExtUnit,\n  HybridScaleDefinition,\n  HybridScaleOptions,\n  PackageScaleInfo,\n} from \"./types\";\nimport { HybridScaleType, HeightMethod } from \"./types\";\n\ninterface BaseSurface {\n  index: number;\n  age: number;\n  units_below: number[];\n  units_above: number[];\n}\n\nexport function buildColumnSurfaces<T extends UnitLong>(\n  units: T[],\n  tolerance: number = 0.001,\n): BaseSurface[] {\n  /** Compute age surfaces for a column based on unit tops and bottoms */\n  const surfaces: Omit<BaseSurface, \"index\">[] = [];\n  for (const unit of units) {\n    // Top surface\n    surfaces.push({\n      age: unit.t_age,\n      units_below: [unit.unit_id],\n      units_above: [],\n    });\n    // Bottom surface\n    surfaces.push({\n      age: unit.b_age,\n      units_above: [unit.unit_id],\n      units_below: [],\n    });\n  }\n\n  // Merge duplicate surfaces (same age)\n  const mergedSurfaces: Omit<BaseSurface, \"index\">[] = [];\n  for (const surface of surfaces) {\n    const existingSurface = mergedSurfaces.find(\n      (s) => Math.abs(s.age - surface.age) < tolerance,\n    );\n    if (existingSurface) {\n      existingSurface.units_above.push(...surface.units_above);\n      existingSurface.units_below.push(...surface.units_below);\n    } else {\n      mergedSurfaces.push(surface);\n    }\n  }\n\n  // Sort surfaces by age (ascending)\n  mergedSurfaces.sort((a, b) => a.age - b.age);\n\n  return mergedSurfaces.map((s, i) => ({ ...s, index: i }));\n}\n\ninterface AgeDomainUnitInfo {\n  t_age: number;\n  b_age: number;\n  units: ExtUnit[];\n}\n\nfunction getUnitsInAgeDomains(\n  surfaces: BaseSurface[],\n  units: ExtUnit[],\n): AgeDomainUnitInfo[] {\n  // Get unit IDs represented between the same surface, and the proportion of their total height represented\n  const domainUnitInfo: AgeDomainUnitInfo[] = [];\n  for (let i = 0; i < surfaces.length - 1; i++) {\n    const topSurface = surfaces[i];\n    const bottomSurface = surfaces[i + 1];\n    const unitsInDomain = units.filter((unit) => {\n      return (\n        unit.t_age <= topSurface.age + 0.001 &&\n        unit.b_age >= bottomSurface.age - 0.001\n      );\n    });\n    domainUnitInfo.push({\n      t_age: topSurface.age,\n      b_age: bottomSurface.age,\n      units: unitsInDomain,\n    });\n  }\n  return domainUnitInfo;\n}\n\nfunction proportionOfUnitInDomain(\n  unit: ExtUnit,\n  t_age: number,\n  b_age: number,\n): number {\n  // Compute the proportion of a unit's height that lies within the given age domain\n\n  const rng = getUnitHeightRange(unit, ColumnAxisType.AGE);\n  const rng1: [number, number] = [b_age, t_age];\n  // Compute overlap\n\n  const mergedRange = mergeAgeRanges([rng, rng1], MergeMode.Inner);\n\n  const unitHeight = Math.abs(rng[1] - rng[0]);\n  const mergedHeight = Math.abs(mergedRange[1] - mergedRange[0]);\n\n  return mergedHeight / unitHeight;\n}\n\nexport function buildHybridScale<T extends UnitLong>(\n  def: HybridScaleDefinition,\n  units: T[],\n  domain: [number, number],\n  options: HybridScaleOptions = {},\n): PackageScaleInfo {\n  const surfaces = buildColumnSurfaces(units);\n\n  const filteredSurfaces = surfaces.filter(\n    (s) => s.age < Math.max(...domain) && s.age > Math.min(...domain),\n  );\n\n  const s1 = [\n    { index: -1, age: Math.min(...domain), units_above: [], units_below: [] },\n    ...filteredSurfaces,\n    {\n      index: -1,\n      age: Math.max(...domain),\n      units_above: [],\n      units_below: [],\n    },\n  ];\n\n  const { type, ...rest } = def;\n\n  if (type === HybridScaleType.EquidistantSurfaces) {\n    return buildScaleFromSurfacesSimple(s1, options);\n  }\n\n  return buildApproximateHeightScale(s1, units, { ...options, ...rest });\n}\n\nfunction getApproximateHeight(\n  unit: ExtUnit,\n  method: HeightMethod = HeightMethod.Maximum,\n): number | null {\n  // Get approximate height of a unit based on specified method\n  const heights = [];\n  let minHeight = unit.min_thick;\n  if (method === HeightMethod.Minimum || method === HeightMethod.Average) {\n    const h = unit.min_thick;\n    if (h != null && !isNaN(h) && h > 0) heights.push(h);\n  }\n  if (method === HeightMethod.Average || method === HeightMethod.Maximum) {\n    const h = unit.max_thick;\n    if (h != null && !isNaN(h) && h > 0) heights.push(h);\n  }\n\n  if (heights.length === 0) return null;\n\n  if (method === HeightMethod.Average) {\n    return heights.reduce((sum, h) => sum + h, 0) / heights.length;\n  } else {\n    return heights[0];\n  }\n}\n\nexport function buildApproximateHeightScale(\n  surfaces: BaseSurface[],\n  units: UnitLong[],\n  options: HybridScaleOptions & ApproxHeightScaleOptions = {},\n): PackageScaleInfo {\n  /** Build a variable age scale that places age surfaces equally far apart in height space.\n   * It is presumed that gaps are already removed from the unit set provided.\n   * */\n\n  const {\n    pixelScale = 1, // pixels per meter\n    pixelOffset = 0,\n    minHeight = 5,\n    heightMethod = HeightMethod.Maximum,\n    // Default height for when height is unknown\n    defaultHeight = 100,\n  } = options;\n\n  // Get units associated with each surface\n  // Note: we could hoist this if it proved useful for other scale types\n  const domainInfo = getUnitsInAgeDomains(surfaces, units as ExtUnit[]);\n\n  // Compute the height in pixels for each surface\n\n  const surfaceHeights = [];\n  const ageDomain = [];\n  let lastHeight = pixelOffset;\n\n  for (const domain of domainInfo) {\n    if (lastHeight == pixelOffset) {\n      surfaceHeights.push(lastHeight);\n      ageDomain.push(domain.t_age);\n    }\n\n    // Approximate height based on units in this domain\n    const units = domain.units;\n    let unitHeightInfo: { unit: ExtUnit; height: number }[] = [];\n\n    for (const unit of units) {\n      const proportion = proportionOfUnitInDomain(\n        unit,\n        domain.t_age,\n        domain.b_age,\n      );\n      const height = getApproximateHeight(unit, heightMethod);\n      if (height != null) {\n        unitHeightInfo.push({ unit, height: height * proportion });\n      }\n    }\n\n    let thisHeight = 0;\n    if (unitHeightInfo.length === 0) {\n      thisHeight = defaultHeight; // Default height if no units with height info\n    } else {\n      // Normalize weights (take the mean)\n\n      const meanHeight =\n        unitHeightInfo.reduce((sum, d) => sum + d.height, 0) /\n        unitHeightInfo.length;\n\n      if (meanHeight == 0) {\n        thisHeight = defaultHeight; // Arbitrary height for zero-height intervals\n      } else if (meanHeight < minHeight) {\n        thisHeight = minHeight; // Minimum height\n      } else {\n        thisHeight = meanHeight;\n      }\n    }\n\n    lastHeight += thisHeight;\n    surfaceHeights.push(lastHeight);\n    ageDomain.push(domain.b_age);\n  }\n\n  // Build a piecewise linear scale mapping age to pixel height\n  const pixelRange = surfaceHeights.map((h) => h * pixelScale);\n\n  const scale = scaleLinear().domain(ageDomain).range(pixelRange);\n\n  const heightDomain = surfaceHeights.map((h) => lastHeight - h);\n\n  const heightScale = scaleLinear().domain(heightDomain).range(pixelRange);\n\n  const domain: [number, number] = [\n    ageDomain[ageDomain.length - 1],\n    ageDomain[0],\n  ];\n\n  return {\n    scale,\n    pixelScale: null, // pixels per unit\n    domain,\n    pixelHeight: Math.abs(pixelRange[pixelRange.length - 1] - pixelRange[0]),\n    heightScale,\n  };\n}\n\nexport function buildScaleFromSurfacesSimple(\n  surfaces: BaseSurface[],\n  options: HybridScaleOptions = {},\n): PackageScaleInfo {\n  /** Build a variable age scale that places age surfaces equally far apart in height space.\n   * It is presumed that gaps are already removed from the unit set provided.\n   * */\n\n  const { pixelScale = 30 } = options;\n\n  const domain: [number, number] = [\n    surfaces[surfaces.length - 1].age,\n    surfaces[0].age,\n  ];\n  // Compute the height in pixels for each surface\n\n  const surfaceHeights = surfaces.map((surface, i) => {\n    return i * pixelScale;\n  });\n\n  // Build a piecewise linear scale mapping age to pixel height\n  const ageDomain = surfaces.map((s) => s.age);\n  const pixelRange = surfaceHeights;\n\n  const scale = scaleLinear().domain(ageDomain).range(pixelRange);\n\n  return {\n    scale,\n    pixelScale: null, // pixels per unit\n    domain,\n    pixelHeight: Math.abs(pixelRange[pixelRange.length - 1] - pixelRange[0]),\n  };\n}\n"],"names":["domain","units"],"mappings":";;;;;AAqBO,SAAS,oBACd,OACA,YAAoB,MACL;AAEf,QAAM,WAAyC,CAAA;AAC/C,aAAW,QAAQ,OAAO;AAExB,aAAS,KAAK;AAAA,MACZ,KAAK,KAAK;AAAA,MACV,aAAa,CAAC,KAAK,OAAO;AAAA,MAC1B,aAAa,CAAA;AAAA,IAAC,CACf;AAED,aAAS,KAAK;AAAA,MACZ,KAAK,KAAK;AAAA,MACV,aAAa,CAAC,KAAK,OAAO;AAAA,MAC1B,aAAa,CAAA;AAAA,IAAC,CACf;AAAA,EACH;AAGA,QAAM,iBAA+C,CAAA;AACrD,aAAW,WAAW,UAAU;AAC9B,UAAM,kBAAkB,eAAe;AAAA,MACrC,CAAC,MAAM,KAAK,IAAI,EAAE,MAAM,QAAQ,GAAG,IAAI;AAAA,IAAA;AAEzC,QAAI,iBAAiB;AACnB,sBAAgB,YAAY,KAAK,GAAG,QAAQ,WAAW;AACvD,sBAAgB,YAAY,KAAK,GAAG,QAAQ,WAAW;AAAA,IACzD,OAAO;AACL,qBAAe,KAAK,OAAO;AAAA,IAC7B;AAAA,EACF;AAGA,iBAAe,KAAK,CAAC,GAAG,MAAM,EAAE,MAAM,EAAE,GAAG;AAE3C,SAAO,eAAe,IAAI,CAAC,GAAG,OAAO,EAAE,GAAG,GAAG,OAAO,EAAA,EAAI;AAC1D;AAQA,SAAS,qBACP,UACA,OACqB;AAErB,QAAM,iBAAsC,CAAA;AAC5C,WAAS,IAAI,GAAG,IAAI,SAAS,SAAS,GAAG,KAAK;AAC5C,UAAM,aAAa,SAAS,CAAC;AAC7B,UAAM,gBAAgB,SAAS,IAAI,CAAC;AACpC,UAAM,gBAAgB,MAAM,OAAO,CAAC,SAAS;AAC3C,aACE,KAAK,SAAS,WAAW,MAAM,QAC/B,KAAK,SAAS,cAAc,MAAM;AAAA,IAEtC,CAAC;AACD,mBAAe,KAAK;AAAA,MAClB,OAAO,WAAW;AAAA,MAClB,OAAO,cAAc;AAAA,MACrB,OAAO;AAAA,IAAA,CACR;AAAA,EACH;AACA,SAAO;AACT;AAEA,SAAS,yBACP,MACA,OACA,OACQ;AAGR,QAAM,MAAM,mBAAmB,MAAM,eAAe,GAAG;AACvD,QAAM,OAAyB,CAAC,OAAO,KAAK;AAG5C,QAAM,cAAc,eAAe,CAAC,KAAK,IAAI,GAAG,UAAU,KAAK;AAE/D,QAAM,aAAa,KAAK,IAAI,IAAI,CAAC,IAAI,IAAI,CAAC,CAAC;AAC3C,QAAM,eAAe,KAAK,IAAI,YAAY,CAAC,IAAI,YAAY,CAAC,CAAC;AAE7D,SAAO,eAAe;AACxB;AAEO,SAAS,iBACd,KACA,OACA,QACA,UAA8B,CAAA,GACZ;AAClB,QAAM,WAAW,oBAAoB,KAAK;AAE1C,QAAM,mBAAmB,SAAS;AAAA,IAChC,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,GAAG,MAAM,KAAK,EAAE,MAAM,KAAK,IAAI,GAAG,MAAM;AAAA,EAAA;AAGlE,QAAM,KAAK;AAAA,IACT,EAAE,OAAO,IAAI,KAAK,KAAK,IAAI,GAAG,MAAM,GAAG,aAAa,IAAI,aAAa,CAAA,EAAC;AAAA,IACtE,GAAG;AAAA,IACH;AAAA,MACE,OAAO;AAAA,MACP,KAAK,KAAK,IAAI,GAAG,MAAM;AAAA,MACvB,aAAa,CAAA;AAAA,MACb,aAAa,CAAA;AAAA,IAAC;AAAA,EAChB;AAGF,QAAM,EAAE,MAAM,GAAG,KAAA,IAAS;AAE1B,MAAI,SAAS,gBAAgB,qBAAqB;AAChD,WAAO,6BAA6B,IAAI,OAAO;AAAA,EACjD;AAEA,SAAO,4BAA4B,IAAI,OAAO,EAAE,GAAG,SAAS,GAAG,MAAM;AACvE;AAEA,SAAS,qBACP,MACA,SAAuB,aAAa,SACrB;AAEf,QAAM,UAAU,CAAA;AACA,OAAK;AACrB,MAAI,WAAW,aAAa,WAAW,WAAW,aAAa,SAAS;AACtE,UAAM,IAAI,KAAK;AACf,QAAI,KAAK,QAAQ,CAAC,MAAM,CAAC,KAAK,IAAI,EAAG,SAAQ,KAAK,CAAC;AAAA,EACrD;AACA,MAAI,WAAW,aAAa,WAAW,WAAW,aAAa,SAAS;AACtE,UAAM,IAAI,KAAK;AACf,QAAI,KAAK,QAAQ,CAAC,MAAM,CAAC,KAAK,IAAI,EAAG,SAAQ,KAAK,CAAC;AAAA,EACrD;AAEA,MAAI,QAAQ,WAAW,EAAG,QAAO;AAEjC,MAAI,WAAW,aAAa,SAAS;AACnC,WAAO,QAAQ,OAAO,CAAC,KAAK,MAAM,MAAM,GAAG,CAAC,IAAI,QAAQ;AAAA,EAC1D,OAAO;AACL,WAAO,QAAQ,CAAC;AAAA,EAClB;AACF;AAEO,SAAS,4BACd,UACA,OACA,UAAyD,CAAA,GACvC;AAKlB,QAAM;AAAA,IACJ,aAAa;AAAA;AAAA,IACb,cAAc;AAAA,IACd,YAAY;AAAA,IACZ,eAAe,aAAa;AAAA;AAAA,IAE5B,gBAAgB;AAAA,EAAA,IACd;AAIJ,QAAM,aAAa,qBAAqB,UAAU,KAAkB;AAIpE,QAAM,iBAAiB,CAAA;AACvB,QAAM,YAAY,CAAA;AAClB,MAAI,aAAa;AAEjB,aAAWA,WAAU,YAAY;AAC/B,QAAI,cAAc,aAAa;AAC7B,qBAAe,KAAK,UAAU;AAC9B,gBAAU,KAAKA,QAAO,KAAK;AAAA,IAC7B;AAGA,UAAMC,SAAQD,QAAO;AACrB,QAAI,iBAAsD,CAAA;AAE1D,eAAW,QAAQC,QAAO;AACxB,YAAM,aAAa;AAAA,QACjB;AAAA,QACAD,QAAO;AAAA,QACPA,QAAO;AAAA,MAAA;AAET,YAAM,SAAS,qBAAqB,MAAM,YAAY;AACtD,UAAI,UAAU,MAAM;AAClB,uBAAe,KAAK,EAAE,MAAM,QAAQ,SAAS,YAAY;AAAA,MAC3D;AAAA,IACF;AAEA,QAAI,aAAa;AACjB,QAAI,eAAe,WAAW,GAAG;AAC/B,mBAAa;AAAA,IACf,OAAO;AAGL,YAAM,aACJ,eAAe,OAAO,CAAC,KAAK,MAAM,MAAM,EAAE,QAAQ,CAAC,IACnD,eAAe;AAEjB,UAAI,cAAc,GAAG;AACnB,qBAAa;AAAA,MACf,WAAW,aAAa,WAAW;AACjC,qBAAa;AAAA,MACf,OAAO;AACL,qBAAa;AAAA,MACf;AAAA,IACF;AAEA,kBAAc;AACd,mBAAe,KAAK,UAAU;AAC9B,cAAU,KAAKA,QAAO,KAAK;AAAA,EAC7B;AAGA,QAAM,aAAa,eAAe,IAAI,CAAC,MAAM,IAAI,UAAU;AAE3D,QAAM,QAAQ,cAAc,OAAO,SAAS,EAAE,MAAM,UAAU;AAE9D,QAAM,eAAe,eAAe,IAAI,CAAC,MAAM,aAAa,CAAC;AAE7D,QAAM,cAAc,cAAc,OAAO,YAAY,EAAE,MAAM,UAAU;AAEvE,QAAM,SAA2B;AAAA,IAC/B,UAAU,UAAU,SAAS,CAAC;AAAA,IAC9B,UAAU,CAAC;AAAA,EAAA;AAGb,SAAO;AAAA,IACL;AAAA,IACA,YAAY;AAAA;AAAA,IACZ;AAAA,IACA,aAAa,KAAK,IAAI,WAAW,WAAW,SAAS,CAAC,IAAI,WAAW,CAAC,CAAC;AAAA,IACvE;AAAA,EAAA;AAEJ;AAEO,SAAS,6BACd,UACA,UAA8B,IACZ;AAKlB,QAAM,EAAE,aAAa,GAAA,IAAO;AAE5B,QAAM,SAA2B;AAAA,IAC/B,SAAS,SAAS,SAAS,CAAC,EAAE;AAAA,IAC9B,SAAS,CAAC,EAAE;AAAA,EAAA;AAId,QAAM,iBAAiB,SAAS,IAAI,CAAC,SAAS,MAAM;AAClD,WAAO,IAAI;AAAA,EACb,CAAC;AAGD,QAAM,YAAY,SAAS,IAAI,CAAC,MAAM,EAAE,GAAG;AAC3C,QAAM,aAAa;AAEnB,QAAM,QAAQ,cAAc,OAAO,SAAS,EAAE,MAAM,UAAU;AAE9D,SAAO;AAAA,IACL;AAAA,IACA,YAAY;AAAA;AAAA,IACZ;AAAA,IACA,aAAa,KAAK,IAAI,WAAW,WAAW,SAAS,CAAC,IAAI,WAAW,CAAC,CAAC;AAAA,EAAA;AAE3E;"}