| import { colorFamily, hueFromRgb } from './color'; |
| import { recombineProfiles } from './breeder'; |
| import { bloomScoreFromPalette, generatePhenotype } from './phenotype'; |
| import { canAttempt } from './state'; |
| import type { |
| BloomPredictionSummary, |
| ColorPattern, |
| CrossPrediction, |
| DistributionSummary, |
| GermplasmRecord, |
| LabPayload, |
| Rgb, |
| SeedProfile, |
| TraitVariable, |
| } from './types'; |
|
|
| export const TRAIT_VARIABLES: TraitVariable[] = [ |
| { key: 'THC', label: 'THC', unit: '%', min: 0, max: 35, scale: 'numeric' }, |
| { key: 'CBD', label: 'CBD', unit: '%', min: 0, max: 20, scale: 'numeric' }, |
| { key: 'Yield', label: 'Yield', unit: 'g', min: 30, max: 140, scale: 'numeric' }, |
| { key: 'GrowTime', label: 'Grow Time', unit: 'd', min: 40, max: 80, scale: 'numeric' }, |
| { key: 'BudHue', label: 'Bud Hue', unit: 'deg', min: 0, max: 360, scale: 'circular' }, |
| { key: 'LeafHue', label: 'Leaf Hue', unit: 'deg', min: 0, max: 360, scale: 'circular' }, |
| { key: 'Stability', label: 'Stability', unit: '', min: 0, max: 1, scale: 'numeric' }, |
| { key: 'Volatility', label: 'Volatility', unit: '', min: 0, max: 1, scale: 'numeric' }, |
| { key: 'Bloom', label: 'Bloom', unit: '', min: 0, max: 100, scale: 'numeric' }, |
| ]; |
|
|
| function generation(seed: SeedProfile, byId: Map<string, SeedProfile>, cache: Map<string, number>): number { |
| const cached = cache.get(seed.seedId); |
| if (cached !== undefined) return cached; |
| const parentGenerations = seed.lineage |
| .map((parentId) => (parentId ? byId.get(parentId) : undefined)) |
| .filter((parent): parent is SeedProfile => Boolean(parent)) |
| .map((parent) => generation(parent, byId, cache)); |
| const value = parentGenerations.length ? Math.max(...parentGenerations) + 1 : 0; |
| cache.set(seed.seedId, value); |
| return value; |
| } |
|
|
| function pedigree(seed: SeedProfile, byId: Map<string, SeedProfile>): string { |
| const [parentOneId, parentTwoId] = seed.lineage; |
| const parentOne = parentOneId ? byId.get(parentOneId) : undefined; |
| const parentTwo = parentTwoId ? byId.get(parentTwoId) : undefined; |
| if (parentOne && parentTwo) return `${parentOne.strainName} / ${parentTwo.strainName}`; |
| if (parentOne) return `${parentOne.strainName} (clone)`; |
| return 'founder'; |
| } |
|
|
| function meanStability(seed: SeedProfile): number { |
| const values = Object.values(seed.stabilities).filter((value) => Number.isFinite(value)); |
| return values.length ? Math.round((values.reduce((sum, value) => sum + value, 0) / values.length) * 1000) / 1000 : 0; |
| } |
|
|
| export function germplasmRecords(seeds: SeedProfile[]): GermplasmRecord[] { |
| const byId = new Map(seeds.map((seed) => [seed.seedId, seed])); |
| const cache = new Map<string, number>(); |
| return seeds.map((seed) => { |
| const budHue = hueFromRgb(seed.budColor); |
| const leafHue = hueFromRgb(seed.leafColor); |
| const stability = meanStability(seed); |
| const budBloom = bloomScoreFromPalette(seed.budPalette, seed.budPattern); |
| const leafBloom = bloomScoreFromPalette(seed.leafPalette, seed.leafPattern); |
| return { |
| germplasmDbId: seed.seedId, |
| germplasmName: seed.strainName, |
| germplasmType: seed.type, |
| generation: generation(seed, byId, cache), |
| pedigree: pedigree(seed, byId), |
| parents: seed.lineage, |
| isStarter: seed.isStarter, |
| stage: seed.growthStage, |
| THC: seed.thc, |
| CBD: seed.cbd, |
| Yield: seed.yield, |
| GrowTime: seed.growTime, |
| BudHue: budHue, |
| LeafHue: leafHue, |
| Stability: stability, |
| Volatility: Math.round((1 - stability) * 1000) / 1000, |
| Bloom: budBloom.score, |
| budColor: seed.budColor, |
| leafColor: seed.leafColor, |
| budPalette: seed.budPalette, |
| leafPalette: seed.leafPalette, |
| budPattern: seed.budPattern, |
| leafPattern: seed.leafPattern, |
| budBloom, |
| leafBloom, |
| budFamily: colorFamily(budHue), |
| alleles: seed.alleles, |
| attemptsUsed: seed.attemptsUsed, |
| maxAttempts: seed.maxAttempts, |
| canAttempt: canAttempt(seed), |
| }; |
| }); |
| } |
|
|
| function countFacet(records: GermplasmRecord[], key: keyof GermplasmRecord): Record<string, number> { |
| const counts: Record<string, number> = {}; |
| for (const record of records) { |
| const value = String(record[key]); |
| counts[value] = (counts[value] ?? 0) + 1; |
| } |
| return Object.fromEntries(Object.entries(counts).sort(([left], [right]) => left.localeCompare(right))); |
| } |
|
|
| export function facets(records: GermplasmRecord[]): Record<string, Record<string, number>> { |
| return { |
| germplasmType: countFacet(records, 'germplasmType'), |
| generation: countFacet(records, 'generation'), |
| stage: countFacet(records, 'stage'), |
| budFamily: countFacet(records, 'budFamily'), |
| budPattern: countFacet(records, 'budPattern'), |
| }; |
| } |
|
|
| export function labPayload(seeds: SeedProfile[]): LabPayload { |
| const records = germplasmRecords(seeds); |
| return { |
| variables: TRAIT_VARIABLES, |
| records, |
| facets: facets(records), |
| count: records.length, |
| }; |
| } |
|
|
| function downsample<T>(values: T[], cap: number): T[] { |
| if (values.length <= cap) return values; |
| const step = values.length / cap; |
| const out: T[] = []; |
| for (let index = 0; index < cap; index += 1) out.push(values[Math.floor(index * step)] as T); |
| return out; |
| } |
|
|
| function summarize(values: number[], keepValues = true, cap = 80): DistributionSummary { |
| const sorted = [...values].sort((left, right) => left - right); |
| const total = sorted.reduce((sum, value) => sum + value, 0); |
| return { |
| min: sorted[0] ?? 0, |
| max: sorted[sorted.length - 1] ?? 0, |
| mean: sorted.length ? Math.round((total / sorted.length) * 100) / 100 : 0, |
| median: sorted[Math.floor(sorted.length / 2)] ?? 0, |
| values: keepValues ? downsample(values, cap) : [], |
| }; |
| } |
|
|
| function incrementPattern(target: Record<ColorPattern, number>, pattern: ColorPattern): void { |
| target[pattern] = (target[pattern] ?? 0) + 1; |
| } |
|
|
| function bloomHint(summary: { score: DistributionSummary; volatility: DistributionSummary; colorCount: DistributionSummary; maxColors: number; patterns: Record<ColorPattern, number> }): string { |
| const topPattern = Object.entries(summary.patterns).sort((left, right) => right[1] - left[1])[0]?.[0] ?? 'solid'; |
| if (summary.maxColors >= 5 || summary.score.max >= 82) return `wild bloom lane: up to ${summary.maxColors} colors, ${topPattern} dominant`; |
| if (summary.colorCount.mean >= 3.2 || summary.score.mean >= 64) return `bloom-positive: ${topPattern} bias, mean ${summary.colorCount.mean.toFixed(1)} colors`; |
| if (summary.volatility.mean >= 0.42) return `volatile but unproven: color spread needs a lucky roll`; |
| return `stable expression: safer traits, lower bloom odds`; |
| } |
|
|
| function bloomSummary(scores: number[], volatilities: number[], colorCounts: number[], patterns: Record<ColorPattern, number>, keepValues = true): BloomPredictionSummary { |
| const summary = { |
| score: summarize(scores, keepValues), |
| volatility: summarize(volatilities, keepValues), |
| colorCount: summarize(colorCounts, keepValues), |
| maxColors: Math.max(0, ...colorCounts), |
| patterns, |
| hint: '', |
| }; |
| return { ...summary, hint: bloomHint(summary) }; |
| } |
|
|
| export function predictCross(parentOne: SeedProfile, parentTwo: SeedProfile, sampleCount = 200, summaryOnly = false): CrossPrediction { |
| const n = Math.max(20, Math.min(1000, sampleCount)); |
| const thc: number[] = []; |
| const cbd: number[] = []; |
| const yieldValues: number[] = []; |
| const growTime: number[] = []; |
| const budCloud: Rgb[] = []; |
| const leafCloud: Rgb[] = []; |
| const budBloomScores: number[] = []; |
| const leafBloomScores: number[] = []; |
| const budColorCounts: number[] = []; |
| const leafColorCounts: number[] = []; |
| const budVolatility: number[] = []; |
| const leafVolatility: number[] = []; |
| const budPatterns: Record<ColorPattern, number> = { solid: 0, speckled: 0, split: 0, mosaic: 0, rimmed: 0, polycolor: 0 }; |
| const leafPatterns: Record<ColorPattern, number> = { solid: 0, speckled: 0, split: 0, mosaic: 0, rimmed: 0, polycolor: 0 }; |
|
|
| for (let index = 0; index < n; index += 1) { |
| const { alleles, stabilities } = recombineProfiles(parentOne, parentTwo); |
| const phenotype = generatePhenotype(alleles, stabilities); |
| thc.push(Math.round(phenotype.thc * 100) / 100); |
| cbd.push(Math.round(phenotype.cbd * 100) / 100); |
| yieldValues.push(Math.round(phenotype.yield * 10) / 10); |
| growTime.push(Math.round(phenotype.growTime * 10) / 10); |
| const budBloom = bloomScoreFromPalette(phenotype.budPaletteRgb, phenotype.budPattern); |
| const leafBloom = bloomScoreFromPalette(phenotype.leafPaletteRgb, phenotype.leafPattern); |
| budCloud.push(phenotype.budColorRgb); |
| leafCloud.push(phenotype.leafColorRgb); |
| budBloomScores.push(budBloom.score); |
| leafBloomScores.push(leafBloom.score); |
| budColorCounts.push(budBloom.colorCount); |
| leafColorCounts.push(leafBloom.colorCount); |
| budVolatility.push(Math.round((1 - stabilities.BudColor) * 1000) / 1000); |
| leafVolatility.push(Math.round((1 - stabilities.LeafColor) * 1000) / 1000); |
| incrementPattern(budPatterns, phenotype.budPattern); |
| incrementPattern(leafPatterns, phenotype.leafPattern); |
| } |
|
|
| const keepValues = !summaryOnly; |
| return { |
| n, |
| parents: [parentOne.strainName, parentTwo.strainName], |
| THC: summarize(thc, keepValues), |
| CBD: summarize(cbd, keepValues), |
| Yield: summarize(yieldValues, keepValues), |
| GrowTime: summarize(growTime, keepValues), |
| budCloud: summaryOnly ? [] : downsample(budCloud, 80), |
| leafCloud: summaryOnly ? [] : downsample(leafCloud, 80), |
| budBloom: bloomSummary(budBloomScores, budVolatility, budColorCounts, budPatterns, keepValues), |
| leafBloom: bloomSummary(leafBloomScores, leafVolatility, leafColorCounts, leafPatterns, keepValues), |
| }; |
| } |
|
|
| function safeLabel(name: string): string { |
| return name.replaceAll(',', '_').replaceAll('(', '[').replaceAll(')', ']').replaceAll(':', '-'); |
| } |
|
|
| export function toNewick(seeds: SeedProfile[]): string { |
| const byId = new Map(seeds.map((seed) => [seed.seedId, seed])); |
| const children = new Map<string, string[]>(); |
| const hasParent = new Set<string>(); |
|
|
| for (const seed of seeds) { |
| for (const parentId of seed.lineage) { |
| if (parentId && byId.has(parentId)) { |
| children.set(parentId, [...(children.get(parentId) ?? []), seed.seedId]); |
| hasParent.add(seed.seedId); |
| } |
| } |
| } |
|
|
| const seen = new Set<string>(); |
| const render = (nodeId: string): string => { |
| const node = byId.get(nodeId); |
| if (!node) return ''; |
| const kids = (children.get(nodeId) ?? []).filter((kid) => !seen.has(kid)); |
| for (const kid of kids) seen.add(kid); |
| const label = `${safeLabel(node.strainName)}#${node.seedId.slice(0, 6)}`; |
| if (!kids.length) return label; |
| return `(${kids.map(render).join(',')})${label}`; |
| }; |
|
|
| const roots = seeds.map((seed) => seed.seedId).filter((seedId) => !hasParent.has(seedId)); |
| return `(${roots.filter((root) => !seen.has(root)).map(render).join(',')});`; |
| } |
|
|
|
|
|
|
