← Indice Il modello dei falegnami

Il modello dei falegnami

I falegnami hanno mandato sette tavole SketchUp della parete. È la stessa stanza e la stessa idea della nostra parete, ma divisa nei mobili che costruiranno davvero, con molto dettaglio in più. Qui è ridisegnata da codice in models/falegnami.nim, accanto alla nostra, che resta com'è. Nel visore 3D è il modello di default (la nostra idea ha il suo Visore 3D - Idea); il pulsante Pannello estraibile toglie il pannellino tra i gradini (senza, i gradini si ridistribuiscono).

Le loro misure sono in mm, qui in cm. Quelle scritte sulle tavole sono riportate così come sono; quelle che mancano le ho misurate in scala sul prospetto (rilevate) o ipotizzate: sono elencate in fondo.

Le tavole dei falegnami

Le sette tavole come le hanno mandate, una accanto all'altra: si scorrono di lato con il dito, con la rotella o trascinando, oppure con le frecce. Toccandone una si apre a tutta grandezza.

Il fronte senza ante
1. Il fronte senza antele aperture nel pannello frontale, con le loro misure
Il fronte con ante e ribalte
2. Il fronte con ante e ribaltein prospettiva: ante, cassetti, ribalte e il pannellino aperto
Il prospetto
3. Il prospettoil fronte di faccia: i quattro pannelli 1125 × 1568, la fascia e le spalle
I mobili senza il fronte
4. I mobili senza il frontevani alti, cassone del letto con la libreria, mobili bassi
La libreria
5. La libreriamensole fisse, il gavone sotto, il taglio per i cavi
I tre vani alti
6. I tre vani altile scatole 681 × 409, profonde 775 (622 quella sopra la risega)
I mobili bassi
7. I mobili bassiA con le mensole mobili, B con i gradini, C dei cassetti, D con l'appenderia

Le tavole rifatte dal nostro modello

Le stesse sette tavole, disegnate dal modello qui sotto, in proiezione e con le stesse quote: servono a vedere se ci siamo persi dei pezzi e se le misure tornano. Ogni misura è confrontata con quella scritta sulla loro tavola: nera se torna, rossa se è diversa (tra parentesi la loro), blu se sulla loro tavola non c'è e l'abbiamo dedotta (per esempio la larghezza del pannello che copre la risega). Toccandone una si apre a tutta pagina.

14 64.3 8 64.3 8 64.3 13.9 11.9 156.7 68.2 13.9 71.5 6 25 6 46.2 8 46.2 13.9 265.3 32.6 21.7 135.3 121.9 (122) 62.4 14 91 214.6 12 15.8 4 15.8 4 14.3 7 14.3 4 15.8 212.6 13 27 6 27 6 27 213.6
1. Il fronte senza anteil pannello frontale con le aperture: quelle dei vani, la nicchia, le ante, i gradini, i cassetti
30 67 67.9 3 38.1
2. Il fronte con ante e ribaltela loro è il fronte in prospettiva con il pannellino tirato fuori (670): qui la sezione nei gradini, con il mobile B (300) e il pannellino fuori; il resto delle misure è nella 3
12 15 53.3 (53) 4 68.3 4 68.3 11.9 11.9 156.7 68.2 11.9 75.5 4 25 4 50.2 4 50.2 11.9 5.9 112.5 112.5 5.9 156.8 156.8 6 135.3 121.9 6.1 36.6 19.7 12 95 212.6 12 29 4 29 4 29 212.6
3. Il prospettoil fronte com'è chiuso, con le ante (è anche la tavola 2, in prospettiva)
156.8 156.8 6 109 150 40.9 19.7 1.8 193 2 40 5.9 112.5 112.5 5.9 3.6 77.5
4. I mobili senza il frontetutti i mobili, senza il fronte e senza ante (quelle sono nella 3): cassone, libreria, vani alti, mobili bassi; sotto, la pianta a 200
63.5 1.8 59.9 1.8 150 32 1.8 27.2 1.8 27.2 (27.7) 1.8 27.2 (27.4) 1.8 27.2 1.8 27 41.8 15.8
5. La libreriavista dal lato (la loro la guarda dal letto, qui è specchiata: il fronte è a sinistra); sotto la pianta a 200 con la profondità degli scaffali e il pannello della risega. Il triangolo fuori e il taglio per i cavi non ci sono
68.1 4.2 68.1 4.2 68.1 40.9 1.9 37.1 1.9 77.5 62.2
6. I tre vani altitre scatole in melaminico appoggiate sul cassone; sotto la pianta con le profondità (775, quella sopra la risega 622)
75.3 2.3 28.6 2.3 50 4.2 50 1.9 46.2 1.9 4.2 1.9 46.2 1.9 109 11.8 1.9 29.9 1.9 29.9 (29.8) 1.9 29.9 1.9 77.5 30 62.2
7. I mobili bassiA con due ripiani mobili, B dei gradini (in multistrato), C dei cassetti, D con l'appenderia; sotto la pianta con le profondità
import cadero, parete, falegnami
let f = falegnami()
let m = modello(f)
let p = rilievo()
echo m.parts.len, " parti, ", fmtNum(f.larghezza), " × ", fmtNum(f.altezza), " × ", fmtNum(f.profondita), " cm"
100 parti, 236.8 × 319.6 × 81.1 cm

Come è diviso

Dietro i vani alti e i mobili bassi c'è una schiena sottile (0.8, ipotesi: non è segnata sulle tavole), grigia; quella dei gradini è color legno e si apre all'altezza della fessura, perché il pannellino chiuso passi dietro.

Le scatole grigie dei disegni le leggo come melaminico da 19 mm (500 fuori, 462 dentro), le parti color legno come multistrato da 18 (la libreria: 635 fuori, 599 dentro). Nel visore il melaminico è grigio.

La tavola

let svgTavola = tavola(f, m)
12 95 28.3 121.9 6.1 36.6 13.7 6 156.8 156.8 6 12 15 53.3 4 68.3 4 68.3 11.9 11.9 156.7 68.2 11.9 75.5 4 25 4 50.2 4 50.2 11.9 5.9 112.5 112.5 5.9 109 1.8 146.4 1.8 0 40.9 19.7 33.8 29.1 29.1 29 29.1 3.6 77.5 1.8 193 2 40 3.6 77.5

Prospetto, sezione laterale a x = 150 (dentro la nicchia, si vedono i cassetti di C) e pianta a 130 cm da terra, sopra il piano letto. Senza il pannellino il prospetto dei gradini cambia così: niente fessura, lo spazio tra i gradini diventa 4.75 invece di 4.

let senza = falegnami().senzaPannello
var foglio = initSheet()
let fronte = View(kind: vFront)
foglio.draw(fronte, modello(senza))
for q in quote(senza):
  if q.view == vFront: foglio.draw(fronte, q)
12 95 28.3 121.9 6.1 36.6 13.7 6 156.8 156.8 6 12 15 53.3 4 68.3 4 68.3 11.9 11.9 156.7 68.2 11.9 75.5 4 25 4 50.2 4 50.2 11.9 5.9 112.5 112.5 5.9

L'altezza della nicchia, dalla base del letto

Sulle tavole non c'è una quota della nicchia misurata dal letto: va calcolata sommando le altezze dei mobili. I mobili bassi sono alti 109, il piano del cassone (18 mm) ci sta sopra, dentro il cassone ci sono 150 cm, poi il cielo.

let righe = @[
  ("cima dei mobili bassi", f.hBassi),
  ("piano letto (cima del piano del cassone)", f.pianoLetto),
  ("cima del materasso (" & fmtNum(f.materasso.altezza) & ")", f.pianoLetto + f.materasso.altezza),
  ("piano del comodino (gavone 32 + 1.8)", f.pianoComodino),
  ("bordo basso dell'apertura (dedotto: alto a filo del cielo)", f.nicchiaZ),
  ("bordo alto dell'apertura (+ 121.9)", f.nicchiaZ + f.nicchiaH),
  ("sotto del cielo del cassone (cassone alto 150 fuori, come la libreria)", f.cieloNicchia),
  ("fondo dei vani alti (sul cielo del cassone)", f.fondoVani),
  ("cima del fronte (2 × 156.8 + 6)", f.altezza)]
for (nome, z) in righe:
  echo fmtNum(z).align(6), "  ", nome
echo ""
echo "dal piano letto: apertura da ", fmtNum(f.nicchiaZ - f.pianoLetto), " a ",
  fmtNum(f.nicchiaZ + f.nicchiaH - f.pianoLetto), ", cielo a ", fmtNum(f.hNicchia)
echo "sopra il materasso: fronte ", fmtNum(f.bordo), ", testata ", fmtNum(f.schienale)
   109  cima dei mobili bassi
 110.8  piano letto (cima del piano del cassone)
 127.8  cima del materasso (17)
 142.8  piano del comodino (gavone 32 + 1.8)
 135.3  bordo basso dell'apertura (dedotto: alto a filo del cielo)
 257.2  bordo alto dell'apertura (+ 121.9)
 257.2  sotto del cielo del cassone (cassone alto 150 fuori, come la libreria)
   259  fondo dei vani alti (sul cielo del cassone)
 319.6  cima del fronte (2 × 156.8 + 6)

dal piano letto: apertura da 24.5 a 146.4, cielo a 150
sopra il materasso: fronte 7.5, testata 15

Lo stesso conto disegnato, con solo il frontale, il cassone del letto, il materasso e la libreria (prospetto e sezione laterale a x = 100; in blu le misure dedotte, in nero le loro). Partendo dal basso:

Il bordo alto dell'apertura coincide quindi con il sotto del cielo. È quello che viene prendendo il 150 come misura esterna e il 121.9 dalle loro tavole. Se il 150 fosse interno, l'apertura partirebbe da 137, ma il cassone finirebbe 3.6 più in alto della libreria. Il frontale porta ancora i fori dei vani e delle ante, per questo si vedono anche quelli.

Nel prospetto la libreria, che sta dietro al frontale, è tratteggiata, insieme al pannello da 1.8 che copre la risega alla sua sinistra. La catena in alto dà la distanza fra il bordo destro della nicchia e la libreria.

let svgNicchia = disegnoNicchia(f)
11.9 156.7 26.4 1.8 40 109 1.8 17 7.5 121.9 1.8 54.6 150 150 1.8 17 7.5 121.9 1.8 146.4

Confronto con la nostra parete

Le stesse misure nei due modelli (la nostra con i parametri di oggi).

let confronto = @[
  ("altezza del mobile", p.altezza, f.altezza),
  ("profondità (ante comprese)", p.profondita, f.profondita),
  ("piano letto da terra", p.pianoLetto, f.pianoLetto),
  ("nicchia dentro, dal piano letto", p.altezze.nicchia, f.hNicchia),
  ("apertura: bordo basso da terra", p.nicchiaZ, f.nicchiaZ),
  ("apertura: altezza", p.nicchiaH, f.nicchiaH),
  ("apertura: larghezza", p.nicchiaL, f.nicchiaL),
  ("fronte sopra il materasso (bordo)", p.bordo, f.bordo),
  ("testata sopra il piano letto", p.altezze.testata, f.pianoComodino - f.pianoLetto),
  ("testata sopra il materasso", p.schienale, f.schienale),
  ("profondità del comodino", p.profComodino, f.comodino),
  ("profondità degli scaffali", p.libreria.profScaffali, f.scaffali),
  ("ribalte: altezza", p.alta.altezzaRibalta, f.ribaltaH),
  ("ribalte: larghezza", p.alta.larghezzaRibalta, f.ribaltaL),
  ("ante in basso: da terra", p.bassa.zoccolo, f.zBassi),
  ("ante in basso: altezza", p.bassa.altezzaAnte, f.altezzaAnte),
  ("anta grande (A)", p.bassa.antaGrande, f.antaA),
  ("gradini: larghezza", p.bassa.gradini, f.aperturaGradini),
  ("cassetti: larghezza", p.bassa.cassetti, f.cassetti),
  ("anta stretta (D)", p.bassa.antaStretta, f.antaD)]
echo "misura".alignLeft(36), "nostra".align(8), "loro".align(8)
for (nome, a, b) in confronto:
  let segno = if abs(a - b) > 0.5: "  ←" else: ""
  echo nome.alignLeft(36), fmtNum(a).align(8), fmtNum(b).align(8), segno
misura                                nostra    loro
altezza del mobile                       316   319.6  ←
profondità (ante comprese)               80    81.1  ←
piano letto da terra                     104   110.8  ←
nicchia dentro, dal piano letto        159.2     150  ←
apertura: bordo basso da terra           131   135.3  ←
apertura: altezza                        122   121.9
apertura: larghezza                    165.5   156.7  ←
fronte sopra il materasso (bordo)         10     7.5  ←
testata sopra il piano letto              58      32  ←
testata sopra il materasso                41      15  ←
profondità del comodino                38.8      38  ←
profondità degli scaffali              26.5      27
ribalte: altezza                          43    36.6  ←
ribalte: larghezza                        68    68.3
ante in basso: da terra                    6      12  ←
ante in basso: altezza                    95      95
anta grande (A)                           71    75.5  ←
gradini: larghezza                        29      25  ←
cassetti: larghezza                       52    50.2  ←
anta stretta (D)                        38.5    50.2  ←

Le differenze grandi: la testata (loro 32 sopra il piano letto, noi avevamo deciso 58), il fronte più alto della stanza, le ribalte più basse e le ante in basso più larghe e su uno zoccolo più alto. La nicchia dentro è più bassa (150 contro 159), ma l'apertura è quasi uguale.

Cose che non tornano

Dai controlli del modello:

for c in controlli(f, m): echo "- ", c
- il fronte è alto 319.6 (2 × 156.8 + 6): la stanza è alta 316
- ante, fronte e mobili profondi 77.5 fanno 81.1 cm: oltre gli 80 della stanza (a 80 c'è la cornice della porta)
- il fronte sopra il materasso è alto 7.5 cm: meno di 16 (il nostro bordo)
- la testata (il gavone) sporge 15 cm sopra il materasso: meno di 40 (noi avevamo deciso testata 58, cioè 41 sopra il materasso)
- gli scaffali (27) sono più corti del piano del comodino (38), come scritto; nel disegno sembrano uguali
- la libreria appoggia sul mobile D, che finisce a 224.8: per gli ultimi 12.1 cm sotto non c'è niente
- il pannellino (67) è più lungo del mobile dei gradini (30): chiuso sporge dietro di 37 cm, nello spazio libero; lì serve una guida che lo regga
- il fondo dei vani alti sta 4.4 cm sotto il bordo dell'apertura delle ribalte: dentro c'è uno scalino
- fronte spalla sx, fronte spalla dx 319.6 x 5.9: non sta in una lastra 300 x 150

Letture e ipotesi da verificare

Distinta

for r in bom(m):
  if r.kind in {kPanel, kFront, kBox}:
    echo $r.count & " × " & fmtNum(r.dims[0]) & " × " & fmtNum(r.dims[1]) & " × " &
      fmtNum(r.dims[2]) & "  " & r.name
4 × 156.8 × 112.5 × 1.8  fronte basso sx, fronte basso dx, fronte alto sx, fronte alto dx
1 × 225 × 6 × 1.8  fronte fascia
2 × 319.6 × 5.9 × 1.8  fronte spalla sx, fronte spalla dx
1 × 95 × 75.5 × 1.8  anta A
1 × 95 × 50.2 × 1.8  anta D
3 × 50.2 × 29 × 1.8  frontale cassetto
1 × 36.6 × 15 × 1.8  ribalta, parte fissa
1 × 53 × 36.6 × 1.8  ribalta
2 × 68.3 × 36.6 × 1.8  ribalta
4 × 109 × 77.5 × 1.9  fianco mobile A, fianco mobile C
2 × 76.7 × 71.5 × 1.9  fondo mobile A, cielo mobile A
1 × 97.2 × 71.5 × 0.8  schiena mobile A
2 × 74.7 × 71.5 × 1.9  ripiano mobile A
2 × 109 × 30 × 1.8  fianco mobile B
7 × 29.2 × 25 × 1.8  cielo mobile B, piano gradino, piano sotto la fessura
1 × 57.7 × 25 × 0.8  schiena mobile B
1 × 38.1 × 25 × 0.8  schiena mobile B
1 × 67 × 24.6 × 1.8  pannellino estraibile
2 × 76.7 × 46.2 × 1.9  fondo mobile C, cielo mobile C
2 × 97.2 × 46.2 × 0.8  schiena mobile C, schiena mobile D
3 × 68.2 × 40 × 1.8  fondo cassetto
6 × 70 × 23 × 1.8  fianco cassetto
3 × 40 × 23 × 1.8  schiena cassetto
2 × 109 × 62.2 × 1.9  fianco mobile D
2 × 61.4 × 46.2 × 1.9  fondo mobile D, cielo mobile D
2 × 194.8 × 77.5 × 1.8  piano letto, cielo cassone
1 × 146.4 × 77.5 × 1.8  fianco cassone
2 × 150 × 38.2 × 1.8  fianco libreria
1 × 150 × 63.5 × 1.8  schiena libreria
1 × 59.9 × 36.4 × 1.8  fondo gavone
1 × 59.9 × 32 × 1.8  frontale gavone
2 × 59.9 × 38.2 × 1.8  cielo libreria, piano comodino
1 × 150 × 15.8 × 1.8  pannello risega
3 × 59.9 × 27 × 1.8  scaffale
2 × 29.8 × 23.6 × 1  coperchio gavone
4 × 77.5 × 40.9 × 1.9  fianco vano alto 1, fianco vano alto 2
4 × 76.7 × 64.3 × 1.9  fondo vano alto 1, cielo vano alto 1, fondo vano alto 2, cielo vano alto 2
3 × 64.3 × 40.9 × 0.8  schiena vano alto 1, schiena vano alto 2, schiena vano alto 3
2 × 62.2 × 40.9 × 1.9  fianco vano alto 3
2 × 64.3 × 61.4 × 1.9  fondo vano alto 3, cielo vano alto 3

Le modifiche che vorremmo

Rispetto al loro disegno torna più o meno tutto, ma alcune cose le vorremmo fatte in modo diverso. La prima è già decisa: non vogliamo il pannellino estraibile. Poi ci sono tre richieste (Pietro, 4 novembre):

  1. Testata più alta: il gavone sotto il comodino passa da 32 a 58 dal piano letto (la nostra testata), con uno scaffale in meno.
  2. Pannello della risega più stretto: da quasi 16 a 10. La risega è profonda 7; nella tavola 5 forse serve un listello, ma a 10 dovremmo arrivare.
  3. Aperture dei vani alti più alte: con 32.6 potrebbe non starci una scatola IKEA da mettere e togliere.

Sono modifiche indipendenti, come il pannellino: in falegnami.nim sono testataAlta, risegaStretta e vaniAlti, e conModifiche le accende una per una. Nel visore ci sono quattro pulsanti, tutti spenti all'inizio: Tavolino (il pannellino estraibile), Testata alta, Risega stretta, Vani alti. Qui sotto il modello rivisto è quello con le prime due accese e senza pannellino (rivisto); la terza si aggiunge sopra.

let fr = f.rivisto
let fv = fr.vaniAlti
let cambi = @[
  ("pannellino estraibile", (if f.pannello: "sì" else: "no"), "no", "no"),
  ("testata: piano comodino dal piano letto", fmtNum(f.pianoComodino - f.pianoLetto),
    fmtNum(fr.pianoComodino - fr.pianoLetto), fmtNum(fv.pianoComodino - fv.pianoLetto)),
  ("testata sopra il materasso", fmtNum(f.schienale), fmtNum(fr.schienale), fmtNum(fv.schienale)),
  ("scaffali", $f.nScaffali, $fr.nScaffali, $fv.nScaffali),
  ("vano tra due scaffali (netto)", fmtNum(f.zScaffali[0] - f.pianoComodino),
    fmtNum(fr.zScaffali[0] - fr.pianoComodino), fmtNum(fv.zScaffali[0] - fv.pianoComodino)),
  ("profondità della libreria", fmtNum(f.profLibreria), fmtNum(fr.profLibreria), fmtNum(fv.profLibreria)),
  ("pannello della risega", fmtNum(f.pannelloRisega), fmtNum(fr.pannelloRisega), fmtNum(fv.pannelloRisega)),
  ("dietro della libreria / risega", fmtNum(f.yMobili + f.profLibreria) & " / " & fmtNum(f.yMuro - f.muro.risegaProf),
    fmtNum(fr.yMobili + fr.profLibreria) & " / " & fmtNum(fr.yMuro - fr.muro.risegaProf),
    fmtNum(fv.yMobili + fv.profLibreria) & " / " & fmtNum(fv.yMuro - fv.muro.risegaProf)),
  ("pannelli del fronte (alti)", fmtNum(f.pannelloH), fmtNum(fr.pannelloH), fmtNum(fv.pannelloH)),
  ("altezza del fronte", fmtNum(f.altezza), fmtNum(fr.altezza), fmtNum(fv.altezza)),
  ("vani alti: scatole alte", fmtNum(f.vanoH), fmtNum(fr.vanoH), fmtNum(fv.vanoH)),
  ("ribalte alte", fmtNum(f.ribaltaH), fmtNum(fr.ribaltaH), fmtNum(fv.ribaltaH)),
  ("apertura dei vani alti", fmtNum(f.ribaltaH - 2 * f.sormonto), fmtNum(fr.ribaltaH - 2 * fr.sormonto),
    fmtNum(fv.ribaltaH - 2 * fv.sormonto))]
echo "".alignLeft(42), "loro".align(14), "rivisto".align(14), "+ vani alti".align(14)
for (nome, a, b, c) in cambi:
  echo nome.alignLeft(42), a.align(14), b.align(14), c.align(14)
                                                    loro       rivisto   + vani alti
pannellino estraibile                                sì            no            no
testata: piano comodino dal piano letto               32            58            58
testata sopra il materasso                            15            41            41
scaffali                                               3             2             2
vano tra due scaffali (netto)                       27.2          28.3          28.3
profondità della libreria                          63.5          69.3          69.3
pannello della risega                               15.8            10            10
dietro della libreria / risega               67.1 / 74.1   72.9 / 74.1   72.9 / 74.1
pannelli del fronte (alti)                         156.8         156.8         156.8
altezza del fronte                                 319.6         319.6         319.6
vani alti: scatole alte                             40.9          40.9            50
ribalte alte                                        36.6          36.6          45.7
apertura dei vani alti                              32.6          32.6          41.7

1 e 2: testata e pannello della risega

La tavola del modello rivisto:

let svgRivisto = tavola(fr, modello(fr))
12 95 28.3 121.9 6.1 36.6 13.7 6 156.8 156.8 6 12 15 53.3 4 68.3 4 68.3 11.9 11.9 156.7 68.2 11.9 75.5 4 25 4 50.2 4 50.2 11.9 5.9 112.5 112.5 5.9 109 1.8 146.4 1.8 0 40.9 19.7 59.8 30.1 30.1 30.1 3.6 77.5 1.8 193 2 40 3.6 77.5

3: aprire di più i vani alti

Oggi l'apertura è alta 32.6: la ribalta è alta 36.6 e copre l'apertura di 2 cm sopra e 2 sotto. Una scatola IKEA DRÖNA, quella dei Kallax, è larga 33, profonda 38 e alta 33 (verificato sul sito IKEA), quindi oggi non passerebbe. Per la proposta teniamo il loro fronte da 319.6 come giusto e prendiamo un'apertura di 41.7 (Pietro), la misura che lascia margine anche se il soffitto fosse davvero a 316.

Cosa ci limita:

La proposta: le ribalte partono da dove partono oggi (263.3) e crescono verso l'alto.

Cosa andrebbe verificato:

Prima la zona alta di oggi (nel modello rivisto, che lì non cambia), poi la proposta. Prospetto e sezione nel vano di mezzo, con la ribalta chiusa di fianco:

let svgVaniOggi = disegnoVaniAlti(fr)
let svgVaniProposta = disegnoVaniAlti(fv)

Oggi: apertura 32.6

1.8 6.3 32.6 15.7 6 36.6 156.8 6 1.9 4.4 32.6 0.1 1.9 40.9 16.1

Proposta: apertura 41.7

1.8 6.3 41.7 6.6 6 45.7 156.8 6 1.9 4.4 41.7 0.1 1.9 50 7

I controlli del modello con la proposta:

for r in controlli(fv, modello(fv)): echo "- ", r
- il fronte è alto 319.6 (2 × 156.8 + 6): la stanza è alta 316
- ante, fronte e mobili profondi 77.5 fanno 81.1 cm: oltre gli 80 della stanza (a 80 c'è la cornice della porta)
- il fronte sopra il materasso è alto 7.5 cm: meno di 16 (il nostro bordo)
- gli scaffali (27) sono più corti del piano del comodino (38), come scritto; nel disegno sembrano uguali
- la libreria appoggia sul mobile D, che finisce a 224.8: per gli ultimi 12.1 cm sotto non c'è niente
- il fondo dei vani alti sta 4.4 cm sotto il bordo dell'apertura delle ribalte: dentro c'è uno scalino
- fronte spalla sx, fronte spalla dx 319.6 x 5.9: non sta in una lastra 300 x 150
## Il modello dei falegnami (-> docs/modello_falegnami.html): le loro tavole
## ridisegnate da codice, il confronto con la nostra parete, i calcoli della
## nicchia, i mobili uno per uno e le cose da chiedere.
import nimib, tema
import std/[os, strutils]
import falegnami, falegnami_tavole

nbInit(theme = useTema)
nb.title = "Il modello dei falegnami"

nbText: """
# Il modello dei falegnami

I falegnami hanno mandato sette tavole SketchUp della parete. È la stessa stanza
e la stessa idea della [nostra parete](parete_nicchia.html), ma divisa nei mobili
che costruiranno davvero, con molto dettaglio in più. Qui è ridisegnata da codice
in `models/falegnami.nim`, accanto alla nostra, che resta com'è. Nel
[visore 3D](visore3d.html) è il modello di default (la nostra idea ha il suo
[Visore 3D - Idea](visore3d_idea.html)); il pulsante **Pannello estraibile**
toglie il pannellino tra i gradini (senza, i gradini si ridistribuiscono).

Le loro misure sono in mm, qui in cm. Quelle scritte sulle tavole sono riportate
così come sono; quelle che mancano le ho misurate in scala sul prospetto
(rilevate) o ipotizzate: sono elencate in fondo.
"""

nbText: """
## Le tavole dei falegnami

Le sette tavole come le hanno mandate, una accanto all'altra: si scorrono di lato
con il dito, con la rotella o trascinando, oppure con le frecce. Toccandone una si
apre a tutta grandezza.
"""

# le immagini stanno in docsrc/falegnami/ e si copiano accanto alla pagina
let tavole = [
  ("Il fronte senza ante", "le aperture nel pannello frontale, con le loro misure"),
  ("Il fronte con ante e ribalte", "in prospettiva: ante, cassetti, ribalte e il pannellino aperto"),
  ("Il prospetto", "il fronte di faccia: i quattro pannelli 1125 × 1568, la fascia e le spalle"),
  ("I mobili senza il fronte", "vani alti, cassone del letto con la libreria, mobili bassi"),
  ("La libreria", "mensole fisse, il gavone sotto, il taglio per i cavi"),
  ("I tre vani alti", "le scatole 681 × 409, profonde 775 (622 quella sopra la risega)"),
  ("I mobili bassi", "A con le mensole mobili, B con i gradini, C dei cassetti, D con l'appenderia")]
let cartella = $nb.doc.homeDir / "falegnami"
createDir(cartella)
var schede = ""
for i, (titolo, nota) in tavole:
  let f = "tavola-" & $(i + 1) & ".jpg"
  copyFile(currentSourcePath().parentDir / "falegnami" / f, cartella / f)
  schede.add "<figure><a href=\"falegnami/" & f & "\" target=\"_blank\" draggable=\"false\"><img src=\"falegnami/" & f &
    "\" alt=\"" & titolo & "\" loading=\"lazy\" draggable=\"false\"></a><figcaption><b>" & $(i + 1) & ". " &
    titolo & "</b><span>" & nota & "</span></figcaption></figure>\n"

nbRawHtml: """
<style>
.galleria { position: relative; margin: 1em 0 1.5em; }
.galleria .striscia { display: flex; gap: 14px; overflow-x: auto; scroll-snap-type: x mandatory;
  overscroll-behavior-x: contain; padding-bottom: 10px; cursor: grab; scrollbar-width: thin; }
.galleria .striscia.trascina { cursor: grabbing; scroll-snap-type: none; }
.galleria figure { flex: 0 0 min(86%, 560px); margin: 0; scroll-snap-align: start;
  background: #fff; border: 1px solid var(--line, #ccc); border-radius: 8px; overflow: hidden; }
.galleria img { display: block; width: 100%; height: 420px; object-fit: contain; background: #fff;
  user-select: none; -webkit-user-drag: none; }
.galleria figcaption { padding: 8px 12px 10px; font-size: 14px; background: var(--panel, #f6f6f6);
  border-top: 1px solid var(--line, #ccc); color: var(--fg, #222); }
.galleria figcaption b { display: block; }
.galleria figcaption span { color: var(--muted, #666); }
.galleria .freccia { position: absolute; top: 190px; width: 40px; height: 40px; border-radius: 50%;
  border: 1px solid var(--line, #ccc); background: var(--panel, #fff); color: var(--fg, #222);
  font-size: 20px; line-height: 1; cursor: pointer; opacity: 0.92; }
.galleria .indietro { left: 6px; } .galleria .avanti { right: 6px; }
.galleria .freccia[hidden] { display: none; }
@media (max-width: 600px) { .galleria img { height: 300px; }
  .galleria .freccia { top: 135px; width: 32px; height: 32px; font-size: 17px; opacity: 0.8; } }
</style>
<div class="galleria">
  <div class="striscia" tabindex="0" aria-label="Le sette tavole dei falegnami">
""" & schede & """
  </div>
  <button class="freccia indietro" type="button" aria-label="Tavola precedente">‹</button>
  <button class="freccia avanti" type="button" aria-label="Tavola successiva">›</button>
</div>
<script>
// la galleria: frecce, rotella verticale che scorre di lato, trascinamento con il mouse
// (con il dito scorre da sola); un trascinamento non apre l'immagine
window.attivaGalleria = g => {
  const s = g.querySelector('.striscia');
  const passo = () => s.querySelector('figure').offsetWidth + 14;
  g.querySelector('.indietro').onclick = () => s.scrollBy({left: -passo(), behavior: 'smooth'});
  g.querySelector('.avanti').onclick = () => s.scrollBy({left: passo(), behavior: 'smooth'});
  s.addEventListener('wheel', e => {
    if (Math.abs(e.deltaY) > Math.abs(e.deltaX) && s.scrollWidth > s.clientWidth) {
      const fine = s.scrollLeft + s.clientWidth >= s.scrollWidth - 2;
      if ((e.deltaY > 0 && !fine) || (e.deltaY < 0 && s.scrollLeft > 0)) {
        e.preventDefault(); s.scrollLeft += e.deltaY;
      }
    }
  }, {passive: false});
  let x0 = 0, l0 = 0, giu = false, mosso = false;
  s.addEventListener('pointerdown', e => {
    if (e.pointerType !== 'mouse') return;
    giu = true; mosso = false; x0 = e.clientX; l0 = s.scrollLeft;
  });
  window.addEventListener('pointermove', e => {
    if (!giu) return;
    if (Math.abs(e.clientX - x0) > 5) { mosso = true; s.classList.add('trascina'); }
    if (mosso) s.scrollLeft = l0 - (e.clientX - x0);
  });
  window.addEventListener('pointerup', () => {
    if (!giu) return;
    giu = false; s.classList.remove('trascina');
  });
  s.addEventListener('dragstart', e => e.preventDefault());
  s.addEventListener('click', e => { if (mosso) { e.preventDefault(); mosso = false; } }, true);
  const frecce = () => {   // la freccia non serve all'inizio e alla fine
    g.querySelector('.indietro').hidden = s.scrollLeft < 4;
    g.querySelector('.avanti').hidden = s.scrollLeft + s.clientWidth >= s.scrollWidth - 4;
  };
  s.addEventListener('scroll', frecce, {passive: true});
  frecce();
  s.addEventListener('keydown', e => {
    if (e.key === 'ArrowRight') { s.scrollBy({left: passo(), behavior: 'smooth'}); e.preventDefault(); }
    if (e.key === 'ArrowLeft') { s.scrollBy({left: -passo(), behavior: 'smooth'}); e.preventDefault(); }
  });
};
document.querySelectorAll('.galleria').forEach(attivaGalleria);
</script>
"""

nbText: """
## Le tavole rifatte dal nostro modello

Le stesse sette tavole, disegnate dal modello qui sotto, in proiezione e con le
stesse quote: servono a vedere se ci siamo persi dei pezzi e se le misure tornano.
Ogni misura è confrontata con quella scritta sulla loro tavola:
<span style="color:#1a1a1a">**nera**</span> se torna,
<span style="color:#d0312d">**rossa**</span> se è diversa (tra parentesi la loro),
<span style="color:#1f6fd1">**blu**</span> se sulla loro tavola non c'è e l'abbiamo
dedotta (per esempio la larghezza del pannello che copre la risega). Toccandone una si
apre a tutta pagina.
"""

var rifatte = ""
for i, t in tavoleRifatte(falegnami()):
  rifatte.add "<figure><div class=\"disegno\" role=\"button\" tabindex=\"0\">" & t.svg &
    "</div><figcaption><b>" & $(i + 1) & ". " & t.nome & "</b><span>" & t.nota & "</span></figcaption></figure>\n"

nbRawHtml: """
<style>
.galleria .disegno { height: 420px; background: #fff; cursor: zoom-in; overflow: hidden; }
.galleria .disegno svg { width: 100% !important; height: 100% !important; max-width: none !important; display: block; }
@media (max-width: 600px) { .galleria .disegno { height: 300px; } }
.ingrandita { position: fixed; inset: 0; z-index: 50; background: #fff; overflow: auto; cursor: zoom-out; }
.ingrandita svg { width: max(100%, 1100px); height: auto !important; max-width: none !important; display: block; }
</style>
<div class="galleria">
  <div class="striscia" tabindex="0" aria-label="Le sette tavole rifatte dal modello">
""" & rifatte & """
  </div>
  <button class="freccia indietro" type="button" aria-label="Tavola precedente">‹</button>
  <button class="freccia avanti" type="button" aria-label="Tavola successiva">›</button>
</div>
<script>
// la seconda galleria: stesso comportamento; toccando un disegno lo si vede a tutta pagina
(() => {
  const g = document.querySelectorAll('.galleria');
  const ultima = g[g.length - 1];
  attivaGalleria(ultima);
  ultima.querySelectorAll('.disegno').forEach(d => d.addEventListener('click', () => {
    if (ultima.querySelector('.striscia').classList.contains('trascina')) return;
    const o = document.createElement('div');
    o.className = 'ingrandita';
    o.innerHTML = d.innerHTML;
    o.addEventListener('click', () => o.remove());
    document.body.appendChild(o);
  }));
})();
</script>
"""

nbCode:
  import cadero, parete, falegnami
  let f = falegnami()
  let m = modello(f)
  let p = rilievo()
  echo m.parts.len, " parti, ", fmtNum(f.larghezza), " × ", fmtNum(f.altezza), " × ", fmtNum(f.profondita), " cm"

nbText: """
## Come è diviso

- **Il fronte**: quattro pannelli da 112.5 × 156.8, una fascia alta 6 in cima e due
  spalle larghe 5.9 contro i muri. La nicchia e il vano alto di mezzo passano da
  un pannello all'altro: nei pezzi diventano tacche del bordo, non fori.
- **Tre vani alti** 68.1 × 40.9, scatole aperte davanti con la ribalta. Quella di
  sinistra è tagliata a 15 cm: il pezzo a sinistra resta fisso, si apre solo la
  parte destra, così la ribalta non sbatte contro il condizionatore.
- **Il cassone del letto**: piano, cielo e un fianco a sinistra, dentro 193, alto 150 fuori come la libreria (146.4 dentro),
  profondo 77.5. Piano e cielo non passano sotto e sopra la libreria (non è
  chiaro dalle tavole: l'ho assunto).
- **La libreria** in testa al letto, un mobile a sé: 63.5 di profondità, alta 150,
  aperta verso il letto, con il gavone sotto (frontale 32), il piano del comodino
  profondo 38 con l'apertura e i due coperchi, tre scaffali profondi 27. Alla sua
  sinistra, guardandola dal letto, il pannello che copre la risega: alto 150, in
  piano con l'apertura della libreria, largo dal fianco dietro fino al muro (15.8,
  dedotto: sulla tavola non c'è la misura). Riempie anche lo spazio tra cassone e
  libreria, dove avanzano solo 0.2 cm.
- **Quattro mobili bassi** alti 109: A con due ripiani mobili (75.3), B con i
  gradini in multistrato (28.6, profondo 30), C con tre cassetti (50), D con l'appenderia (50,
  profondo solo 62.2 per stare davanti alla risega).

Dietro i vani alti e i mobili bassi c'è una schiena sottile (0.8, ipotesi: non è
segnata sulle tavole), grigia; quella dei gradini è color legno e si apre all'altezza
della fessura, perché il pannellino chiuso passi dietro.

Le scatole grigie dei disegni le leggo come melaminico da 19 mm (500 fuori, 462
dentro), le parti color legno come multistrato da 18 (la libreria: 635 fuori,
599 dentro). Nel visore il melaminico è grigio.
"""

nbText: "## La tavola"
nbCode:
  let svgTavola = tavola(f, m)
nbRawHtml: svgTavola

nbText: """
Prospetto, sezione laterale a x = 150 (dentro la nicchia, si vedono i cassetti di
C) e pianta a 130 cm da terra, sopra il piano letto. Senza il pannellino il
prospetto dei gradini cambia così: niente fessura, lo spazio tra i gradini diventa
4.75 invece di 4.
"""

nbCode:
  let senza = falegnami().senzaPannello
  var foglio = initSheet()
  let fronte = View(kind: vFront)
  foglio.draw(fronte, modello(senza))
  for q in quote(senza):
    if q.view == vFront: foglio.draw(fronte, q)
nbRawHtml: foglio.render()

nbText: """
## L'altezza della nicchia, dalla base del letto

Sulle tavole non c'è una quota della nicchia misurata dal letto: va calcolata
sommando le altezze dei mobili. I mobili bassi sono alti 109, il piano del
cassone (18 mm) ci sta sopra, dentro il cassone ci sono 150 cm, poi il cielo.
"""

nbCode:
  let righe = @[
    ("cima dei mobili bassi", f.hBassi),
    ("piano letto (cima del piano del cassone)", f.pianoLetto),
    ("cima del materasso (" & fmtNum(f.materasso.altezza) & ")", f.pianoLetto + f.materasso.altezza),
    ("piano del comodino (gavone 32 + 1.8)", f.pianoComodino),
    ("bordo basso dell'apertura (dedotto: alto a filo del cielo)", f.nicchiaZ),
    ("bordo alto dell'apertura (+ 121.9)", f.nicchiaZ + f.nicchiaH),
    ("sotto del cielo del cassone (cassone alto 150 fuori, come la libreria)", f.cieloNicchia),
    ("fondo dei vani alti (sul cielo del cassone)", f.fondoVani),
    ("cima del fronte (2 × 156.8 + 6)", f.altezza)]
  for (nome, z) in righe:
    echo fmtNum(z).align(6), "  ", nome
  echo ""
  echo "dal piano letto: apertura da ", fmtNum(f.nicchiaZ - f.pianoLetto), " a ",
    fmtNum(f.nicchiaZ + f.nicchiaH - f.pianoLetto), ", cielo a ", fmtNum(f.hNicchia)
  echo "sopra il materasso: fronte ", fmtNum(f.bordo), ", testata ", fmtNum(f.schienale)

nbText: """
Lo stesso conto disegnato, con solo il frontale, il cassone del letto, il
materasso e la libreria (prospetto e sezione laterale a x = 100; in blu le misure
dedotte, in nero le loro). Partendo dal basso:

- mobili bassi 109, sopra il piano del cassone da 1.8: la base del letto è a 110.8;
- materasso 17, e sopra resta un bordo di 7.5 fino all'apertura;
- l'apertura della nicchia è alta 121.9 e arriva fino al sotto del cielo del
  cassone (257.2);
- il cielo è da 1.8: il cassone è alto 146.4 dentro e 150 fuori, come la libreria.

Il bordo alto dell'apertura coincide quindi con il sotto del cielo. È quello che
viene prendendo il 150 come misura esterna e il 121.9 dalle loro tavole. Se il 150
fosse interno, l'apertura partirebbe da 137, ma il cassone finirebbe 3.6 più in
alto della libreria. Il frontale porta ancora i fori dei vani e delle ante, per
questo si vedono anche quelli.

Nel prospetto la libreria, che sta dietro al frontale, è tratteggiata, insieme al
pannello da 1.8 che copre la risega alla sua sinistra. La catena in alto dà la
distanza fra il bordo destro della nicchia e la libreria.
"""

nbCode:
  let svgNicchia = disegnoNicchia(f)
nbRawHtml: "<div class=\"disegno-nicchia\">" & svgNicchia & "</div>"

nbText: """
## Confronto con la nostra parete

Le stesse misure nei due modelli (la nostra con i parametri di oggi).
"""

nbCode:
  let confronto = @[
    ("altezza del mobile", p.altezza, f.altezza),
    ("profondità (ante comprese)", p.profondita, f.profondita),
    ("piano letto da terra", p.pianoLetto, f.pianoLetto),
    ("nicchia dentro, dal piano letto", p.altezze.nicchia, f.hNicchia),
    ("apertura: bordo basso da terra", p.nicchiaZ, f.nicchiaZ),
    ("apertura: altezza", p.nicchiaH, f.nicchiaH),
    ("apertura: larghezza", p.nicchiaL, f.nicchiaL),
    ("fronte sopra il materasso (bordo)", p.bordo, f.bordo),
    ("testata sopra il piano letto", p.altezze.testata, f.pianoComodino - f.pianoLetto),
    ("testata sopra il materasso", p.schienale, f.schienale),
    ("profondità del comodino", p.profComodino, f.comodino),
    ("profondità degli scaffali", p.libreria.profScaffali, f.scaffali),
    ("ribalte: altezza", p.alta.altezzaRibalta, f.ribaltaH),
    ("ribalte: larghezza", p.alta.larghezzaRibalta, f.ribaltaL),
    ("ante in basso: da terra", p.bassa.zoccolo, f.zBassi),
    ("ante in basso: altezza", p.bassa.altezzaAnte, f.altezzaAnte),
    ("anta grande (A)", p.bassa.antaGrande, f.antaA),
    ("gradini: larghezza", p.bassa.gradini, f.aperturaGradini),
    ("cassetti: larghezza", p.bassa.cassetti, f.cassetti),
    ("anta stretta (D)", p.bassa.antaStretta, f.antaD)]
  echo "misura".alignLeft(36), "nostra".align(8), "loro".align(8)
  for (nome, a, b) in confronto:
    let segno = if abs(a - b) > 0.5: "  ←" else: ""
    echo nome.alignLeft(36), fmtNum(a).align(8), fmtNum(b).align(8), segno

nbText: """
Le differenze grandi: la testata (loro 32 sopra il piano letto, noi avevamo
deciso 58), il fronte più alto della stanza, le ribalte più basse e le ante in
basso più larghe e su uno zoccolo più alto. La nicchia dentro è più bassa (150
contro 159), ma l'apertura è quasi uguale.

## Cose che non tornano

Dai controlli del modello:
"""

nbCode:
  for c in controlli(f, m): echo "- ", c

nbText: """
## Letture e ipotesi da verificare

- **Altezza**: 60 + 1568 + 1568 fa 319.6, la stanza è 316. Forse hanno rimisurato;
  da chiedere.
- <strong>Profondità</strong>: con le ante davanti al fronte (le ante 755 coprono aperture da 715)
  e i mobili da 775 dietro, si arriva a 81.1. Se invece le ante stanno a filo nel
  fronte, si arriva a 79.3 e torna con gli 80: da chiedere.
  Nel visore e nelle tavole il muro è disegnato a 81.1, dietro i mobili, perché si
  vedano le schiene.
- **622**: lo leggo come la profondità dei mobili davanti alla risega (il vano alto
  di destra e il mobile D); 775 per gli altri.
- **300** sul mobile dei gradini è la sua profondità (Pietro): il mobile B è profondo
  30. Il pannellino lungo 67 chiuso rientra nello spazio libero dietro, sotto il
  cassone: lì serve una guida che lo regga.
- **Il triangolo** fuori dalla libreria, a 277 da uno scaffale, e il taglio per il
  passaggio dei cavi: non li ho disegnati. La scatola delle prese non c'è nelle tavole.
- **Vani alti e ribalte.** Le ribalte stanno dove le mette il fronte, le scatole
  dove le mettono i mobili, e le due catene di misure non tornano tra loro. Le
  scatole (Pietro: solo scatole, appoggiate sul cassone) stanno sopra mobili bassi e
  cassone: 109 + 150 = 259, più 40.9, quindi da 259 a 299.9. Sul prospetto le
  ribalte si leggono da 270 a 306.6, cioè 11 cm più in alto delle scatole e 6.7 sopra
  la loro cima. Pietro: la cima della ribalta deve essere più o meno a filo di quella
  della scatola, quindi le ribalte ora partono da 263.3 (dedotto). Restano due cose:
  il dentro della scatola sta 4.4 sotto il bordo dell'apertura (vedi i controlli) e
  sopra le ribalte, fino alla fascia, resta una striscia di fronte di 13.7 (sul
  prospetto sembra più bassa). Il motivo è che il fronte è alto 319.6 mentre i
  mobili impilati arrivano a 299.9: da chiedere ai falegnami.
- **Libreria**: appoggia sui mobili bassi; a destra del mobile D restano 12 cm
  senza niente sotto.
- **Cassone alto 150 fuori**, come la libreria (Pietro: mobili bassi tutti a 109,
  libreria e nicchia alte uguali): dentro resta 146.4, e la cima del cielo è a filo
  della libreria (259). Perché l'apertura da 121.9 non salga oltre il cielo, il suo
  bordo basso è a 135.3 (dedotto; in scala sul prospetto si legge circa 137).
  Materasso largo 77 (Pietro).
- **Rilevate in scala**: spazio tra i frontali (4, torna con tutte le larghezze), zoccolo dei
  mobili (11.8), raggi (nicchia 5, aperture 3, frontali 2), fori maniglia (3) a 6
  cm dagli spigoli.

## Distinta
"""

nbCode:
  for r in bom(m):
    if r.kind in {kPanel, kFront, kBox}:
      echo $r.count & " × " & fmtNum(r.dims[0]) & " × " & fmtNum(r.dims[1]) & " × " &
        fmtNum(r.dims[2]) & "  " & r.name

nbText: """
## Le modifiche che vorremmo

Rispetto al loro disegno torna più o meno tutto, ma alcune cose le vorremmo fatte
in modo diverso. La prima è già decisa: non vogliamo il pannellino estraibile.
Poi ci sono tre richieste (Pietro, 4 novembre):

1. **Testata più alta**: il gavone sotto il comodino passa da 32 a 58 dal piano
   letto (la nostra testata), con uno scaffale in meno.
2. **Pannello della risega più stretto**: da quasi 16 a 10. La risega è profonda
   7; nella tavola 5 forse serve un listello, ma a 10 dovremmo arrivare.
3. **Aperture dei vani alti più alte**: con 32.6 potrebbe non starci una scatola
   IKEA da mettere e togliere.

Sono modifiche indipendenti, come il pannellino: in `falegnami.nim` sono
`testataAlta`, `risegaStretta` e `vaniAlti`, e `conModifiche` le accende una per una.
Nel [visore](visore3d.html) ci sono quattro pulsanti, tutti spenti all'inizio:
*Tavolino* (il pannellino estraibile), *Testata alta*, *Risega stretta*, *Vani alti*.
Qui sotto il **modello rivisto** è quello con le prime due accese e senza pannellino
(`rivisto`); la terza si aggiunge sopra.
"""

nbCode:
  let fr = f.rivisto
  let fv = fr.vaniAlti
  let cambi = @[
    ("pannellino estraibile", (if f.pannello: "sì" else: "no"), "no", "no"),
    ("testata: piano comodino dal piano letto", fmtNum(f.pianoComodino - f.pianoLetto),
      fmtNum(fr.pianoComodino - fr.pianoLetto), fmtNum(fv.pianoComodino - fv.pianoLetto)),
    ("testata sopra il materasso", fmtNum(f.schienale), fmtNum(fr.schienale), fmtNum(fv.schienale)),
    ("scaffali", $f.nScaffali, $fr.nScaffali, $fv.nScaffali),
    ("vano tra due scaffali (netto)", fmtNum(f.zScaffali[0] - f.pianoComodino),
      fmtNum(fr.zScaffali[0] - fr.pianoComodino), fmtNum(fv.zScaffali[0] - fv.pianoComodino)),
    ("profondità della libreria", fmtNum(f.profLibreria), fmtNum(fr.profLibreria), fmtNum(fv.profLibreria)),
    ("pannello della risega", fmtNum(f.pannelloRisega), fmtNum(fr.pannelloRisega), fmtNum(fv.pannelloRisega)),
    ("dietro della libreria / risega", fmtNum(f.yMobili + f.profLibreria) & " / " & fmtNum(f.yMuro - f.muro.risegaProf),
      fmtNum(fr.yMobili + fr.profLibreria) & " / " & fmtNum(fr.yMuro - fr.muro.risegaProf),
      fmtNum(fv.yMobili + fv.profLibreria) & " / " & fmtNum(fv.yMuro - fv.muro.risegaProf)),
    ("pannelli del fronte (alti)", fmtNum(f.pannelloH), fmtNum(fr.pannelloH), fmtNum(fv.pannelloH)),
    ("altezza del fronte", fmtNum(f.altezza), fmtNum(fr.altezza), fmtNum(fv.altezza)),
    ("vani alti: scatole alte", fmtNum(f.vanoH), fmtNum(fr.vanoH), fmtNum(fv.vanoH)),
    ("ribalte alte", fmtNum(f.ribaltaH), fmtNum(fr.ribaltaH), fmtNum(fv.ribaltaH)),
    ("apertura dei vani alti", fmtNum(f.ribaltaH - 2 * f.sormonto), fmtNum(fr.ribaltaH - 2 * fr.sormonto),
      fmtNum(fv.ribaltaH - 2 * fv.sormonto))]
  echo "".alignLeft(42), "loro".align(14), "rivisto".align(14), "+ vani alti".align(14)
  for (nome, a, b, c) in cambi:
    echo nome.alignLeft(42), a.align(14), b.align(14), c.align(14)

nbText: """
### 1 e 2: testata e pannello della risega

- **Testata**: il frontale del gavone, verso il letto, sale a 58 e il piano del
  comodino va a 168.8 da terra (41 sopra il materasso, come nella nostra parete).
  Con due scaffali al posto di tre, fra un piano e l'altro restano 28.3 netti
  (passo 30.1): meno dei 31 che ci aspettavamo, perché sopra il comodino ci sono
  88.4 cm (fino al sotto del cielo della libreria) e due scaffali da 1.8. Il gavone
  diventa molto più alto (56 dentro): da vedere se serve un ripiano anche lì.
- **Pannello della risega**: va dal fianco dietro della libreria al dietro del
  mobile, quindi per farlo largo 10 la libreria diventa più profonda (da 63.5 a
  69.3). Il suo dietro arriva a 72.9 e la risega comincia a 74.1 (con il muro
  disegnato a 81.1, dove arrivano i loro mobili): restano 1.2 cm. Con il muro vero a
  80 la risega comincia a 73 e il margine scende a 0.1, quindi 10 è circa il minimo
  senza toccare la risega. Il listello della tavola 5, se serve, va fra la
  libreria e la risega. Gli scaffali restano profondi 27; il piano del comodino e
  l'apertura del gavone diventano più profondi con la libreria.

La tavola del modello rivisto:
"""

nbCode:
  let svgRivisto = tavola(fr, modello(fr))
nbRawHtml: svgRivisto

nbText: """
### 3: aprire di più i vani alti

Oggi l'apertura è alta 32.6: la ribalta è alta 36.6 e copre l'apertura di 2 cm sopra
e 2 sotto. Una scatola IKEA DRÖNA, quella dei Kallax, è larga 33, profonda 38 e
alta 33 (verificato sul sito IKEA), quindi oggi non passerebbe. Per la proposta teniamo il loro fronte da
319.6 come giusto e prendiamo un'apertura di **41.7** (Pietro), la misura che lascia
margine anche se il soffitto fosse davvero a 316.

Cosa ci limita:

- **Sotto**: le scatole dei vani appoggiano sul cielo del cassone, a 259. Il cassone è
  alto 150 come la libreria e l'apertura della nicchia arriva fino al suo cielo. Per
  abbassare i vani bisognerebbe abbassare cassone e libreria, cioè la nicchia o la
  base del letto: non serve.
- **Sopra**: il fronte arriva a 313.6 sotto la fascia, e le ribalte di oggi finiscono a
  299.9. Sopra c'è posto: tenendo 3 cm di fronte sotto la fascia, l'apertura potrebbe
  arrivare fino a 45.3.

La proposta: le ribalte partono da dove partono oggi (263.3) e crescono verso l'alto.

- **Ribalta** alta 45.7 invece di 36.6, quindi +9.1; l'anta resta 4 cm più alta
  dell'apertura, come oggi.
- **Scatole** alte 50 invece di 40.9, con la cima sempre a filo della ribalta (309):
  restano 7 cm sotto il soffitto da 316 che abbiamo misurato, per montarle.
- **Apertura** 41.7 (+9.1): una DRÖNA da 33 passa con quasi 9 cm di gioco. In
  larghezza ne entra una per vano (dentro 64.3, due farebbero 66); in profondità due
  una dietro l'altra (76 su 76.7) nei due vani a sinistra, una sola nel vano sopra la
  risega (62.2).
- **Sotto non cambia niente**: nicchia, cassone, libreria e mobili bassi restano dove
  sono. Nel fronte cambiano solo i tre fori alti, e la striscia di fronte sopra le
  ribalte scende da 13.7 a 4.6 (più la fascia da 6).

Cosa andrebbe verificato:

- **Il limite**: tenendo 3 cm di fronte sotto la fascia si arriverebbe a 45.3; 41.7
  lascia margine sul soffitto.
- **Lo scalino dentro (il fondo della scatola è 4.4 sotto il bordo dell'apertura) va
  scavalcato sollevando la scatola.
- **Ribalte più grandi**: 45.7 × 68.3 pesano di più (compassi o pistoni più forti) e
  aperte sporgono 45.7 in avanti.
- **Il condizionatore**: la prima ribalta, più alta di 9.1, quando si apre sporge di
  più: va controllato con la posizione vera.
- **Un'alternativa che non tocca le scatole**: far crescere l'apertura verso il basso
  invece che verso l'alto. Le scatole di oggi dentro hanno 37.1: l'apertura arriverebbe
  al massimo a 37.1 (meno di 41.7) e lo scalino sparirebbe. Però la ribalta partirebbe da
  258.9, e fra la nicchia e le ribalte resterebbero 1.7 cm di fronte invece di 6.1.

Prima la zona alta di oggi (nel modello rivisto, che lì non cambia), poi la proposta.
Prospetto e sezione nel vano di mezzo, con la ribalta chiusa di fianco:
"""

nbCode:
  let svgVaniOggi = disegnoVaniAlti(fr)
  let svgVaniProposta = disegnoVaniAlti(fv)
nbRawHtml: "<p><b>Oggi</b>: apertura 32.6</p>" & svgVaniOggi
nbRawHtml: "<p><b>Proposta</b>: apertura 41.7</p>" & svgVaniProposta

nbText: "I controlli del modello con la proposta:"
nbCode:
  for r in controlli(fv, modello(fv)): echo "- ", r

nbSave