Files
faunosteo/packages/anatomy/src/render/compose.ts
T

197 lines
6.1 KiB
TypeScript

import type { AnatomicalSheetDocumentInput } from '@faunosteo/domain'
import {
createLayerElement,
SVG_NS,
type MinimalDocument,
type MinimalElement,
type MinimalNode,
} from './dom'
import { renderAnnotationLayer, viewBoxOf, type LayerElement } from './layer'
/**
* Composes the drawing of one view: the parsed asset framed on the view's
* box plus the annotation layer rendered from the document. With a
* `highlight`, the layer keeps only the selected annotations, styled for
* print (legacy picture: accent fill, halo on the main view, no data
* attributes). Works on any DOM Level 2 implementation (a Node parser or
* the browser DOM): the caller parses and serialises.
*/
export const HALO_FILTER_ID = 'osteo-halo'
export const HIGHLIGHT_FILL = '#b85a3f'
export const HIGHLIGHT_FILL_OPACITY = '0.85'
/** DOM Level 2 surface the composer needs on the `<svg>` root. */
export interface ComposeElement extends MinimalElement {
readonly ownerDocument: MinimalDocument | null
readonly firstChild: MinimalNode | null
getAttribute(name: string): string | null
removeAttribute(name: string): void
insertBefore(node: MinimalNode, reference: MinimalNode | null): unknown
getElementsByTagName(tag: string): ComposeElementList
}
export interface ComposeElementList {
readonly length: number
item(index: number): ComposeElement | null
}
export interface ComposeHighlight {
/** Annotation ids kept on the layer; every other marker is dropped. */
annotationIds: ReadonlySet<string>
/** Wrap the kept markers in the `osteo-halo` filter (main view). */
halo: boolean
}
export interface ComposeInput<Root extends ComposeElement = ComposeElement> {
root: Root
document: AnatomicalSheetDocumentInput
viewId: string
highlight?: ComposeHighlight
}
/** Frames `root` on the view, appends the layer `<g>` last, returns `root`. */
export function composeViewSvg<Root extends ComposeElement>(
input: ComposeInput<Root>,
): Root {
const { root, document, viewId, highlight } = input
const view = document.views.find((v) => v.id === viewId)
if (!view) throw new Error(`unknown view "${viewId}"`)
const box = viewBoxOf(view)
if (box) root.setAttribute('viewBox', box)
root.removeAttribute('width')
root.removeAttribute('height')
if (highlight?.halo) ensureHaloFilter(root)
const rendered = renderAnnotationLayer({ document, viewId })
const layer = highlight ? highlightLayer(rendered, highlight) : rendered
root.appendChild(createLayerElement(documentOf(root), layer))
return root
}
/** Typed nullable by the DOM; an element taken from a parsed document has one. */
function documentOf(root: ComposeElement): MinimalDocument {
if (!root.ownerDocument) throw new Error('root has no owner document')
return root.ownerDocument
}
/**
* The layer reduced to the selected annotations (both elements of a point),
* each with the accent fill and, when asked, the halo filter. No `data-*`
* attribute survives: the result is a picture, not an interactive layer.
*/
export function highlightLayer(
layer: LayerElement,
highlight: ComposeHighlight,
): LayerElement {
const children = layer.children
.filter((child) =>
highlight.annotationIds.has(child.attrs['data-anno-id'] ?? ''),
)
.map((child) => highlightElement(child, highlight.halo))
return { ...layer, attrs: withoutDataAttrs(layer.attrs), children }
}
function highlightElement(node: LayerElement, halo: boolean): LayerElement {
const attrs: Record<string, string> = {
...withoutDataAttrs(node.attrs),
fill: HIGHLIGHT_FILL,
'fill-opacity': HIGHLIGHT_FILL_OPACITY,
}
if (halo) attrs.filter = `url(#${HALO_FILTER_ID})`
return { ...node, attrs }
}
function withoutDataAttrs(
attrs: Record<string, string>,
): Record<string, string> {
return Object.fromEntries(
Object.entries(attrs).filter(([name]) => !name.startsWith('data-')),
)
}
/**
* Adds the Gaussian-blur "halo" filter so the highlighted markers stay
* visible on the whole-animal view once rasterised at print scale. One
* filter per root: a second call finds it and leaves the tree alone.
*/
function ensureHaloFilter(root: ComposeElement): void {
if (hasElementWithId(root, 'filter', HALO_FILTER_ID)) return
const defs = root.getElementsByTagName('defs').item(0) ?? createDefs(root)
defs.appendChild(haloFilter(documentOf(root)))
}
function hasElementWithId(
root: ComposeElement,
tag: string,
id: string,
): boolean {
const list = root.getElementsByTagName(tag)
for (let i = 0; i < list.length; i++) {
if (list.item(i)?.getAttribute('id') === id) return true
}
return false
}
/** `<defs>` as the first child: the asset's own filters sit at the root. */
function createDefs(root: ComposeElement): MinimalElement {
const defs = documentOf(root).createElementNS(SVG_NS, 'defs')
root.insertBefore(defs, root.firstChild)
return defs
}
function svgElement(
doc: MinimalDocument,
tag: string,
attrs: Record<string, string>,
): MinimalElement {
const element = doc.createElementNS(SVG_NS, tag)
for (const [name, value] of Object.entries(attrs)) {
element.setAttribute(name, value)
}
return element
}
function haloFilter(doc: MinimalDocument): MinimalElement {
const filter = svgElement(doc, 'filter', {
id: HALO_FILTER_ID,
x: '-100%',
y: '-100%',
width: '300%',
height: '300%',
filterUnits: 'userSpaceOnUse',
})
filter.appendChild(gaussianBlur(doc, '18', 'haloWide'))
filter.appendChild(gaussianBlur(doc, '8', 'haloTight'))
filter.appendChild(haloMerge(doc))
return filter
}
function gaussianBlur(
doc: MinimalDocument,
stdDeviation: string,
result: string,
): MinimalElement {
return svgElement(doc, 'feGaussianBlur', {
in: 'SourceGraphic',
stdDeviation,
result,
})
}
/** Three wide blurs, two tight ones, then the marker itself on top. */
function haloMerge(doc: MinimalDocument): MinimalElement {
const merge = svgElement(doc, 'feMerge', {})
const inputs = [
'haloWide',
'haloWide',
'haloWide',
'haloTight',
'haloTight',
'SourceGraphic',
]
for (const input of inputs) {
merge.appendChild(svgElement(doc, 'feMergeNode', { in: input }))
}
return merge
}