mirror of
https://github.com/IliesAllali/parenthese.git
synced 2026-11-16 16:33:28 +00:00
Merge pull request #234 from IliesAllali/feat/conjoints-au-milieu
Placement : une personne au milieu de ses conjoints
This commit is contained in:
5 files changed
+197
-36
No files matched your search
@@ -0,0 +1,5 @@
|
||||
C1────•────────────C2────────────•───────────────A───────────────•─────────────C3───────────────•───C4────•───C5
|
||||
│ │ │ │
|
||||
┬────────┼────────┬ ┬────────┼────────┬ ┬────────┬────┴───┬────────┬ ┬────────┼────────┬
|
||||
│ │ │ │ │ │ │ │ │ │ │ │ │
|
||||
1a 1b 1c 2a 2b 2c 3a 3b 3c 3d 4a 4b 4c
|
||||
@@ -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).
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -83,6 +83,20 @@ export const archetypes = [
|
||||
filiations: [L('G', 'u')],
|
||||
},
|
||||
},
|
||||
{
|
||||
slug: 'cinq-conjoints',
|
||||
note: 'A a eu cinq conjoints, quatre avec des enfants, le dernier sans. Unions toutes au même ordre (saisie à la main) : elles se rangent par le premier enfant. A au milieu, chaque union au-dessus de sa fratrie, sauts au-dessus des portraits.',
|
||||
reference: 'A',
|
||||
graph: (() => {
|
||||
const persons = [P('A', { birthDate: '1917' }), P('C1'), P('C2'), P('C3'), P('C4'), P('C5')]
|
||||
// créées dans le désordre : l'ordre vient des enfants, pas des identifiants
|
||||
const unions = [U('u3', 'A', 'C3'), U('u1', 'A', 'C1'), U('u5', 'A', 'C5'), U('u4', 'A', 'C4'), U('u2', 'A', 'C2')]
|
||||
const filiations = []
|
||||
const kids = { u1: [1935, 1937, 1938], u2: [1942, 1943, 1946], u3: [1948, 1949, 1951, 1953], u4: [1957, 1958, 1960] }
|
||||
for (const [u, years] of Object.entries(kids)) years.forEach((y, i) => { const id = `${u.slice(1)}${String.fromCharCode(97 + i)}`; persons.push(P(id, { birthDate: String(y) })); filiations.push(L(id, u, i + 1)) })
|
||||
return { persons, unions, filiations }
|
||||
})(),
|
||||
},
|
||||
{
|
||||
slug: 'fratrie-12',
|
||||
note: 'Douze enfants, chacun marié, les six premiers avec deux enfants, les autres avec un. La ligne de fratrie est longue, c est normal.',
|
||||
|
||||
Reference in new issue
Block a user