Placement : une personne au milieu de ses conjoints

Une personne à trois conjoints ou plus était posée au deuxième rang de la
chaîne : ses traits vers les conjoints suivants passaient derrière les
autres portraits, presque à la même hauteur, et les fratries partaient en
éventail depuis une rangée serrée. Un arbre réel de ce type (une femme,
cinq mariages, treize enfants) comptait 6 croisements et 2 traits sur un
portrait étranger.

Quand au moins trois de ses conjoints ont une famille dans l'arbre, la
personne est au milieu : ses premiers conjoints à gauche, les suivants à
droite, dans l'ordre des mariages (ou du premier enfant), chaque union
entre deux voisins. La chaîne s'écarte pour que chaque union soit
au-dessus de sa fratrie, et le trait vers un conjoint qui n'est pas à
côté d'elle passe au-dessus des portraits, un étage par portrait enjambé.

Banc : l'arbre anonymisé passe à 0 croisement et 0 trait sur un portrait
étranger ; les archétypes, desc-3, asc-23 et sept gros arbres de l'étude
du placement sont identiques. Des conjoints tous isolés restent en petit
(trois-petits-conjoints, #223).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
IliesAllaliandClaude Opus 5.5 committed 2026-11-12 14:43:41 +01:00
1 parent 0881dbf561
commit e260b9958d
3 files changed
+178 -36

No files matched your search

+48 -2
View File
@@ -27,6 +27,12 @@ import { persons as globalPersons, unions as globalUnions, filiations as globalF
// L'ordre ne dépend jamais des effectifs : rangée, année de naissance,
// identifiant. Ajouter une personne ne bouge que son foyer.
//
// Trois conjoints ou plus qui ont une famille dans l'arbre : la personne
// est au milieu, ses premiers conjoints à gauche, les suivants à droite
// (ordre des mariages, sinon du premier enfant), chaque union au-dessus
// de sa fratrie. Le trait vers un conjoint qui n'est pas à côté d'elle
// passe au-dessus des portraits (elkLayout starOf, renderers traceJump).
//
// Banc, archétypes et témoins : tools/layout-bench/.
// ============================================================
@@ -210,6 +216,40 @@ function layoutOnce(graphData, referenceId, forcedSide, familyTabs = true) {
return offsets
}
// Chaîne en étoile posée sur ses enfants : chaque union qui a des enfants au-dessus du centre de sa fratrie,
// les autres nœuds serrés à l'écart minimal, les conjoints entre deux unions centrés dans la place qui reste.
// Rend la position de la chaîne, sa largeur et l'écart de chaque nœud à son bord gauche.
const spreadStar = (chain, unionsOfChain, childBlocks, packed) => {
const want = new Map()
for (const u of unionsOfChain) {
const g = childBlocks.map((b, i) => (b.unionId === u ? [packed.xs[i] + b.chain[0], packed.xs[i] + b.chain[1]] : null)).filter(Boolean)
if (g.length) want.set(u, (Math.min(...g.map(r => r[0])) + Math.max(...g.map(r => r[1]))) / 2 - byId.get(u).width / 2)
}
const anchors = chain.map((id, i) => (want.has(id) ? i : -1)).filter(i => i >= 0)
if (!anchors.length) return null
const w = (i) => byId.get(chain[i]).width
const step = (i) => w(i) + gapAfter(chain, i) // du bord gauche du nœud i au bord gauche du suivant
const pos = new Array(chain.length)
pos[anchors[0]] = want.get(chain[anchors[0]])
for (let i = anchors[0] + 1; i < chain.length; i++) {
const min = pos[i - 1] + step(i - 1)
pos[i] = want.has(chain[i]) ? Math.max(min, want.get(chain[i])) : min
}
for (let i = anchors[0] - 1; i >= 0; i--) pos[i] = pos[i + 1] - step(i)
for (let k = 0; k < anchors.length - 1; k++) {
const a = anchors[k], b = anchors[k + 1]
if (b - a < 2) continue
const slack = pos[b] - (pos[b - 1] + step(b - 1))
for (let i = a + 1; i < b; i++) pos[i] += slack / 2
}
const left = pos[0]
return {
rowX: left,
rowW: pos[chain.length - 1] + w(chain.length - 1) - left,
offsets: new Map(chain.map((id, i) => [id, pos[i] - left])),
}
}
// La chaîne la plus haute d'une famille : on remonte de parents en parents, par le sang de la référence
// quand un membre en est (on retombe alors sur la lignée principale, déjà en cours : rien à attacher,
// la filiation sera un renvoi), sinon par le premier membre qui a des parents
@@ -520,7 +560,7 @@ function layoutOnce(graphData, referenceId, forcedSide, familyTabs = true) {
// Chaîne centrée sur la rangée de ses enfants directs (fantômes compris), décalée au plus près si une
// famille de conjoint occupe déjà cette rangée
const rowW = chainWidth(chain)
let rowW = chainWidth(chain)
let offsets = chainOffsets(chain)
const kidRowL = childBlocks.length ? Math.min(...childBlocks.map((b, i) => packed.xs[i] + b.chain[0])) : 0
const kidRowR = childBlocks.length ? Math.max(...childBlocks.map((b, i) => packed.xs[i] + b.chain[1])) : rowW
@@ -536,7 +576,13 @@ function layoutOnce(graphData, referenceId, forcedSide, familyTabs = true) {
return pool.length ? pool.reduce((best, c) => (Math.abs(c - x) < Math.abs(best - x) ? c : best)) : x
}
let rowX = (kidRowL + kidRowR) / 2 - rowW / 2
if (childBlocks.length) {
// Une personne au milieu de trois conjoints ou plus (elkLayout, starOf) : la chaîne s'écarte pour que chaque
// union soit au-dessus de sa fratrie, au lieu d'une rangée serrée d'où les fratries partaient en éventail
const starRow = childBlocks.length && unionsOfChain.some(u => byId.get(u)?._data?._hub) ? spreadStar(chain, unionsOfChain, childBlocks, packed) : null
if (starRow) {
({ rowX, rowW, offsets } = starRow)
rowX = avoidObstacles(rowX)
} else if (childBlocks.length) {
// Remariage : chaque union au plus près au-dessus de ses propres enfants. Parmi les positions qui
// alignent une union sur un bord ou le centre de son groupe, on garde celle où les lignes de fratrie
// débordent le moins au-dessus des demi-frères et demi-sœurs (égalité : la plus proche du centrage).
+87 -24
View File
@@ -357,6 +357,18 @@ export function computeLayout(graphData = null, referenceId = null) {
for (const pid of [u.partner1Id, u.partner2Id]) unionCount.set(pid, (unionCount.get(pid) || 0) + 1)
})
const isLoneSpouse = (pid) => !linkedByFiliation.has(pid) && unionCount.get(pid) === 1
// Trois conjoints ou plus qui ont une famille dans l'arbre (enfants ou parents) : la personne est au milieu de ses
// conjoints (voir starOf, phase 3). Ses conjoints isolés y prennent leur place dans l'ordre des mariages, à leur
// taille. Des conjoints tous isolés restent en petit collés à elle (archétypes trois-petits-conjoints, #223).
const STAR_MIN = 3
const familySpouses = new Map()
unions.forEach(u => {
if (!u.partner1Id || !u.partner2Id) return
for (const [pid, other] of [[u.partner1Id, u.partner2Id], [u.partner2Id, u.partner1Id]]) {
if (!isLoneSpouse(other)) familySpouses.set(pid, (familySpouses.get(pid) || 0) + 1)
}
})
const starCenters = new Set([...familySpouses].filter(([, n]) => n >= STAR_MIN).map(([pid]) => pid))
const compactPartnerOf = new Map() // conjoint isolé → partenaire
const compactUnionIds = new Map() // union de conjoint isolé → partenaire
const compactLoneOfUnion = new Map() // union de conjoint isolé → le conjoint isolé
@@ -365,7 +377,7 @@ export function computeLayout(graphData = null, referenceId = null) {
let lone = null, partner = null
if (isLoneSpouse(u.partner2Id)) { lone = u.partner2Id; partner = u.partner1Id }
else if (isLoneSpouse(u.partner1Id) && !isLoneSpouse(u.partner2Id)) { lone = u.partner1Id; partner = u.partner2Id }
if (!lone) return
if (!lone || starCenters.has(partner)) return
compactPartnerOf.set(lone, partner)
compactUnionIds.set(`u-${u.id}`, `p-${partner}`)
compactLoneOfUnion.set(`u-${u.id}`, `p-${lone}`)
@@ -484,7 +496,79 @@ export function computeLayout(graphData = null, referenceId = null) {
const sortedGens = [...genNodeKeys.keys()].sort((a, b) => a - b)
componentOrderPerGen = new Map()
function pushPersonKey(key, gen) {
if (key.startsWith('p-')) {
const person = personByElkId.get(key)
if (!person) return
const compactPartner = compactPartnerOf.get(person.id)
pushNode({
id: key, width: compactPartner ? COMPACT_W : PERSON_W, height: PERSON_H,
_type: 'person', _data: person, _generation: gen,
...(compactPartner ? { _compact: true, _compactPartner: `p-${compactPartner}` } : {}),
})
} else if (key.startsWith('unknown-')) {
pushNode({
id: key, width: UNKNOWN_W, height: UNKNOWN_H,
_type: 'unknown', _data: { label: 'Inconnu' }, _generation: gen,
})
}
}
function pushUnionKey(unionElkId, gen) {
pushNode({
id: unionElkId, width: compactUnionIds.has(unionElkId) ? 0 : UNION_W, height: UNION_H,
...(compactUnionIds.has(unionElkId) ? { _compact: true, _compactPartner: compactUnionIds.get(unionElkId), _compactLone: compactLoneOfUnion.get(unionElkId) } : {}),
_type: 'union',
_data: unionEntryByElkId.get(unionElkId) || { id: unionElkId },
_generation: gen,
})
}
// Une union se date par son mariage, sinon par son premier enfant, sinon elle vient après les autres
function unionYear(unionElkId) {
const u = unionsById.get(unionElkId.slice(2))
const own = u?.startYear ?? (u?.startDate ? parseInt(String(u.startDate).slice(0, 4), 10) : null)
if (Number.isFinite(own)) return own
const years = (childrenBySourceId.get(unionElkId) || []).map(k => personByElkId.get(k)).filter(Boolean).map(birthYear).filter(y => y != null)
return years.length ? Math.min(...years) : Number.MAX_SAFE_INTEGER
}
// Étoile : une personne et au moins trois conjoints qui n'ont qu'elle dans la rangée. Parcourue d'un bout à
// l'autre, la chaîne mettait la personne au deuxième rang et ses traits passaient derrière les conjoints suivants
// (arbre « tout emmêlé », 12/11). Ici ses premiers conjoints sont à sa gauche, les suivants à sa droite, dans
// l'ordre des mariages de gauche à droite, chaque union entre deux voisins. L'union d'un conjoint qui n'est pas à
// côté d'elle porte _jump (le nombre de portraits enjambés) : son trait passe au-dessus (renderers.js).
function starOf(component) {
const partnersIn = (key) => (adj.get(key) || []).filter(n => component.has(n.otherKey))
for (const key of component) {
if (!starCenters.has(personByElkId.get(key)?.id)) continue
const partners = partnersIn(key)
if (partners.length < STAR_MIN || partners.length !== component.size - 1) continue
if (!partners.every(({ otherKey }) => partnersIn(otherKey).length === 1)) continue
const ordered = [...partners].sort((a, b) => {
const dy = unionYear(a.unionElkId) - unionYear(b.unionElkId)
if (dy) return dy
return compareByOrderThenId(unionsById.get(a.unionElkId.slice(2)) || {}, unionsById.get(b.unionElkId.slice(2)) || {})
})
return { center: key, ordered }
}
return null
}
function pushStar({ center, ordered }, gen) {
const left = Math.floor(ordered.length / 2)
ordered.forEach(({ unionElkId }, i) => {
const entry = unionEntryByElkId.get(unionElkId)
if (entry) { entry._jump = i < left ? left - 1 - i : i - left; entry._hub = center }
})
for (let i = 0; i < left; i++) { pushPersonKey(ordered[i].otherKey, gen); pushUnionKey(ordered[i].unionElkId, gen) }
pushPersonKey(center, gen)
for (let i = left; i < ordered.length; i++) { pushUnionKey(ordered[i].unionElkId, gen); pushPersonKey(ordered[i].otherKey, gen) }
}
function traverseChain(component, gen, chainVisited) {
const star = component.size > STAR_MIN ? starOf(component) : null
if (star) { pushStar(star, gen); return }
// Choisir le point de départ (extrémité de la chaîne)
const leaves = [...component].filter(key =>
(adj.get(key) || []).filter(n => component.has(n.otherKey)).length <= 1
@@ -505,34 +589,13 @@ export function computeLayout(graphData = null, referenceId = null) {
if (chainVisited.has(key)) return
chainVisited.add(key)
if (key.startsWith('p-')) {
const person = personByElkId.get(key)
if (person) {
const compactPartner = compactPartnerOf.get(person.id)
pushNode({
id: key, width: compactPartner ? COMPACT_W : PERSON_W, height: PERSON_H,
_type: 'person', _data: person, _generation: gen,
...(compactPartner ? { _compact: true, _compactPartner: `p-${compactPartner}` } : {}),
})
}
} else if (key.startsWith('unknown-')) {
pushNode({
id: key, width: UNKNOWN_W, height: UNKNOWN_H,
_type: 'unknown', _data: { label: 'Inconnu' }, _generation: gen,
})
}
pushPersonKey(key, gen)
const neighbors = (adj.get(key) || [])
.filter(n => component.has(n.otherKey) && !chainVisited.has(n.otherKey))
for (const { unionElkId, otherKey } of neighbors) {
pushNode({
id: unionElkId, width: compactUnionIds.has(unionElkId) ? 0 : UNION_W, height: UNION_H,
...(compactUnionIds.has(unionElkId) ? { _compact: true, _compactPartner: compactUnionIds.get(unionElkId), _compactLone: compactLoneOfUnion.get(unionElkId) } : {}),
_type: 'union',
_data: unionEntryByElkId.get(unionElkId) || { id: unionElkId },
_generation: gen,
})
pushUnionKey(unionElkId, gen)
traverse(otherKey)
}
}
+43 -10
View File
@@ -149,11 +149,49 @@ export function traceSibship(ctx, sourceId, sourcePos, items, lift = 0) {
ctx.stroke()
}
// Saut : le trait de la personne au milieu de ses conjoints (elkLayout, starOf) vers l'union d'un conjoint qui
// n'est pas à côté d'elle. Il part du haut de son portrait, passe au-dessus des portraits enjambés, un étage par
// portrait, et redescend sur l'union. Le saut le plus haut part le plus près du centre : sa montée ne coupe pas
// les sauts plus bas.
const JUMP = { rise: 20, step: 12, r: 10 }
function traceJump(ctx, hubPos, hubR, jx, jy, level) {
const dir = Math.sign(jx - hubPos.cx) || 1
const off = Math.max(3, hubR * 0.7 - (level - 1) * 7)
const x0 = hubPos.cx + dir * off
const y0 = hubPos.cy - Math.sqrt(Math.max(0, hubR * hubR - off * off))
const top = hubPos.cy - hubR - JUMP.rise - (level - 1) * JUMP.step
const k = Math.min(JUMP.r, Math.abs(jx - x0) / 2)
ctx.beginPath()
ctx.moveTo(x0, y0)
ctx.lineTo(x0, top + k)
ctx.arcTo(x0, top, x0 + dir * k, top, k)
ctx.lineTo(jx - dir * k, top)
ctx.arcTo(jx, top, jx, top + k, k)
ctx.lineTo(jx, jy)
ctx.stroke()
}
// Les deux côtés d'un couple jusqu'à l'union. `progress` < 1 pendant l'entrée : le saut n'a pas d'entrée partielle,
// il est dessiné entier (l'alpha du couple le fait apparaître)
function strokeCouple(ctx, meta, points, p1Pos, p2Pos, p1R, p2R, progress) {
const { sLx, sLy, sRx, sRy, jx, jy } = points
const hubIsLeft = meta._jump > 0 && meta._hub
? (meta._hub === meta.p1Key) === (p1Pos.cx < p2Pos.cx)
: null
const hubPos = meta._hub === meta.p1Key ? p1Pos : p2Pos
const hubR = meta._hub === meta.p1Key ? p1R : p2R
if (hubIsLeft === true) traceJump(ctx, hubPos, hubR, jx, jy, meta._jump)
else drawPartialBezier(ctx, sLx, sLy, sLx + (jx - sLx) * 0.55, sLy, jx - (jx - sLx) * 0.1, jy, jx, jy, progress)
if (hubIsLeft === false) traceJump(ctx, hubPos, hubR, jx, jy, meta._jump)
else drawPartialBezier(ctx, sRx, sRy, sRx + (jx - sRx) * 0.55, sRy, jx - (jx - sRx) * 0.1, jy, jx, jy, progress)
}
// ============================================================
// Courbes de couple (Bézier)
// ============================================================
export function drawCoupleLinks(ctx, coupleBarMeta, posMap, nodeMap, nodeRandomData, entrance, entranceActive, elapsed, view = null) {
coupleBarMeta.forEach(({ elkId, p1Key, p2Key, virtual, ghost }) => {
coupleBarMeta.forEach((meta) => {
const { elkId, p1Key, p2Key, virtual, ghost } = meta
const p1Pos = posMap.get(p1Key)
const p2Pos = posMap.get(p2Key)
const unionPos = posMap.get(elkId)
@@ -188,10 +226,7 @@ export function drawCoupleLinks(ctx, coupleBarMeta, posMap, nodeMap, nodeRandomD
ctx.lineCap = 'round'
ctx.globalAlpha = coupleProgress
drawPartialBezier(ctx, sLx, sLy,
sLx + (jx - sLx) * 0.55, sLy, jx - (jx - sLx) * 0.1, jy, jx, jy, coupleProgress)
drawPartialBezier(ctx, sRx, sRy,
sRx + (jx - sRx) * 0.55, sRy, jx - (jx - sRx) * 0.1, jy, jx, jy, coupleProgress)
strokeCouple(ctx, meta, { sLx, sLy, sRx, sRy, jx, jy }, p1Pos, p2Pos, p1R, p2R, coupleProgress)
ctx.globalAlpha = 1
ctx.setLineDash([])
@@ -361,7 +396,8 @@ export function drawPathHighlight(ctx, {
)
// Re-dessiner les couples du chemin par-dessus
coupleBarMeta.forEach(({ elkId, p1Key, p2Key }) => {
coupleBarMeta.forEach((meta) => {
const { elkId, p1Key, p2Key } = meta
if (!highlightCoupleIds.has(elkId)) return
const hp = pathProgressRef.get(elkId) || 0
if (hp < 0.01) return
@@ -388,10 +424,7 @@ export function drawPathHighlight(ctx, {
ctx.lineCap = 'round'
ctx.globalAlpha = 1
drawPartialBezier(ctx, sLx, sLy,
sLx + (jx - sLx) * 0.55, sLy, jx - (jx - sLx) * 0.1, jy, jx, jy, hp)
drawPartialBezier(ctx, sRx, sRy,
sRx + (jx - sRx) * 0.55, sRy, jx - (jx - sRx) * 0.1, jy, jx, jy, hp)
strokeCouple(ctx, meta, { sLx, sLy, sRx, sRy, jx, jy }, p1Pos, p2Pos, p1R, p2R, hp)
})
// Re-dessiner les filiations du chemin par-dessus