From e260b9958df970aa47d7524b63010f394efab329 Mon Sep 17 00:00:00 2001 From: IliesAllali Date: Thu, 12 Nov 2026 14:24:18 +0100 Subject: [PATCH] Placement : une personne au milieu de ses conjoints MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 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 --- frontend/src/components/galaxy/blockLayout.js | 50 +++++++- frontend/src/components/galaxy/elkLayout.js | 111 ++++++++++++++---- frontend/src/components/galaxy/renderers.js | 53 +++++++-- 3 files changed, 178 insertions(+), 36 deletions(-) diff --git a/frontend/src/components/galaxy/blockLayout.js b/frontend/src/components/galaxy/blockLayout.js index 88cd589..83ad739 100644 --- a/frontend/src/components/galaxy/blockLayout.js +++ b/frontend/src/components/galaxy/blockLayout.js @@ -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). diff --git a/frontend/src/components/galaxy/elkLayout.js b/frontend/src/components/galaxy/elkLayout.js index 242cb52..c6a1daf 100644 --- a/frontend/src/components/galaxy/elkLayout.js +++ b/frontend/src/components/galaxy/elkLayout.js @@ -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) } } diff --git a/frontend/src/components/galaxy/renderers.js b/frontend/src/components/galaxy/renderers.js index 668c9e0..cd23213 100644 --- a/frontend/src/components/galaxy/renderers.js +++ b/frontend/src/components/galaxy/renderers.js @@ -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