Home
- Tutorial POV-Ray
- Ferromodellismo
Modellismo ferroviario
con POV-Ray
Index of Content
- Mio 'Rail Track System',
un sistema di binari
per POV-Ray
Elementi di base dei binari
- Binari diritti e curvi
- Scambi o deviatoi
- Scambi Y e a 3 vie
- Incroci
- Uso semplificato con
RT_System_00.inc
- Gli elementi binari
di RT_System_00.inc
- Binari adattati alle
scale di fermodellismo
- Binari in scala H0
- Binari in scala N
- Binari in scala Z
- Piani Binari con
binari adattati
- Posa dei binari
> Binari su e giù
- Piani Binari Esempi
- Semplice ciclico
- Otto semplice
- Download
Rail Track System
|
|
|
Piani binari con binari adattati
a scale di fermodellismo
Binari su e giù
|
Una dimostrazione con binari in scala N di geometria tipo A:
1) Binari diritti e Curve su e giù
Binari su e giù con lo scorrimento elastico con
la Track_Up_00("NAME",STEP,GRADIENT_TYPE) macro
Qui:
NAME il nome del elemento binario da scorrere:
per es. T_222, T_115, T_111, T_107, T_058, T_055, T_028,
T_R1_45, T_R1_30, T_R1_15, T_R2_45, T_R2_30, ...
STEP il valore della differenza altezza in metro per i binari in scale N.
GRADIENT_TYPE:
0 per semplicemente andare su (o giù per un STEP negativo)
1 su/giù con suddivisione per una transizione lieve al inizio
(solo per T_222, T_115, T_111, T_107,
e curve di 45°, 30° e 15°.)
2 su/giù con suddivisione per una transizione lieve alla fine
(only for T_222, T_115, T_111, T_107,
e curve di 45°, 30° e 15°.)
Nota: Usare lo scorrimento elastico con matrix invece di una rotazione
non è totalmente esatto dal visto de la geometria.
La proiezione verticale di un binario ruotato sul piano del suolo è più corta come il binario (Pitagora!)!
Ma questa semplificazione può facilitare disegnare i piani binari dramaticamente,
perche non dobbiamo calculare questa lunghezza cambiata.
E per gradienti scarsi, la differenza di solito è più piccolo che le toleranze che abbiamo con i modellini di binali reali.
//----------------------------------------------//
#local Step_1 = 0.02;
object{ Track_Up_00("T_111",Step_1,0)
translate<0*L111,0*Step_1*N,0>}
object{ Track_Up_00("T_111",Step_1,0)
translate<1*L111,1*Step_1*N,0>}
//----------------------------------------------// |
Senza e con transizione:
Fare gradienti con un angolo acuto al inizio e alla fine
non è solo una soluzione esteticamente non-ottimale,
questo provoca anche problemi nel modellismo ferroviario per i modelini dei treni.
Per evitare questo in piani binari con POV-Ray possiamo usare
la suddivisione GRADIENT_TYPE 1 (al inizio) e 2 (alla fine)
con ~ 1/2 dello STEP usato.
//----------------------------------------------//
#local Step_1 = 0.0225;
object{ Track_Up_00("T_111", Step_1/2, 1)
translate<0*L111,0.0*Step_1*N,0>}
object{ Track_Up_00("T_111", Step_1 , 0)
translate<1*L111,0.5*Step_1*N,0>}
object{ Track_Up_00("T_111", Step_1/2, 2)
translate<2*L111,1.5*Step_1*N,0>}
//----------------------------------------------// |
|
Binari su con lo scorrimento elastico con
la macro Track_Up_00("NAME",STEP,GRADIENT_TYPE)
|
|
Senza e con transizione
|
|
2) Curve su e giù.
Qui c'è un problema speciale:
non c'è nessuna funzione di POV-Ray per deformare un oggetto a spirale!
Cosi non possiamo ottenere una transizione lieve per le due rotaie del binario con ruotare o con lo scorrimento elastico.
Soluzione: Possiamo suddividere gli elementi di una curva per minimizzare le divergenze!
Nota: Queste è solamente relevante per le rappresentazioni di gradienti in curve con POV-Ray!
Con i modellini di binari reali normalmente non ci sono questi problemi!
Invece di
//----------------------------------------------//
object{ Track_Up_00("T_L1_45",Step_1,0)
Rotate_Around_Trans(<0,-0*45,0>,<0,0,R1>)
translate<0,0*Step_1*N,0>}
object{ Track_Up_00("T_L1_45",Step_1,0)
Rotate_Around_Trans(<0,-1*45,0>,<0,0,R1>)
translate<0,1*Step_1*N,0>}
//----------------------------------------------// |
è meglio: Usare curve suddivise in angoli più piccoli:
//----------------------------------------------//
object{ Track_Up_00("T_L1_15",Step_1,0)
Rotate_Around_Trans(<0,-0*15,0>,<0,0,R1>)
translate<0,0*Step_1*N,0>}
object{ Track_Up_00("T_L1_15",Step_1,0)
Rotate_Around_Trans(<0,-1*15,0>,<0,0,R1>)
translate<0,1*Step_1*N,0>}
object{ Track_Up_00("T_L1_15",Step_1,0)
Rotate_Around_Trans(<0,-2*15,0>,<0,0,R1>)
translate<0,2*Step_1*N,0>}
object{ Track_Up_00("T_L1_15",Step_1,0)
Rotate_Around_Trans(<0,-3*15,0>,<0,0,R1>)
translate<0,3*Step_1*N,0>}
object{ Track_Up_00("T_L1_15",Step_1,0)
Rotate_Around_Trans(<0,-4*15,0>,<0,0,R1>)
translate<0,4*Step_1*N,0>}
object{ Track_Up_00("T_L1_15",Step_1,0)
Rotate_Around_Trans(<0,-5*15,0>,<0,0,R1>)
translate<0,5*Step_1*N,0>}
//----------------------------------------------// |
Nota:Le suddivisioni di curve (con GRADIENT_TYPE 1 o 2)
sono à dispositione solo per binari dei curve con i angoli 45°, 30° e 15°.
La suddivisione di binari diritti sono à dispositione solo per i binari T_222, T_115, T_111, e T_105.
Per una transizione perfetta in curve dobbiamo usare solo i segementi di curve con 15°!
Per binari curvi abbiamo spesso bisogno di ruotare binari con un angolo intorno un centro di rotazione
usando la macro 'Rotate_Around_Trans( RotationVector, Center_of_Rotation )' dal
include file 'transforms.inc'.
Possiamo sostituire questo comando molto lungo
'Rotate_Around_Trans(<0, 1*15,0>,<0,0,-R1>)'
con una espressione come
'RTyz( 1*15, -R1 )'
con dichiare la macro seguente:
//----------------------------------------------------//
#include "transforms.inc"
#macro RTyz( Y_Angle, Z_Distance )
Rotate_Around_Trans(<0, Y_Angle,0>,<0,0, Z_Distance>)
#end
//----------------------------------------------------// |
Con questa macro il testo è più corto:
//----------------------------------------------//
object{ Track_Up_00("T_L1_15",Step_1,0)
RTyz(-0*15,R1) translate<0,0*Step_1*N,0>}
object{ Track_Up_00("T_L1_15",Step_1,0)
RTyz(-1*15,R1) translate<0,1*Step_1*N,0>}
object{ Track_Up_00("T_L1_15",Step_1,0)
RTyz(-2*15,R1) translate<0,2*Step_1*N,0>}
object{ Track_Up_00("T_L1_15",Step_1,0)
RTyz(-3*15,R1) translate<0,3*Step_1*N,0>}
object{ Track_Up_00("T_L1_15",Step_1,0)
RTyz(-4*15,R1) translate<0,4*Step_1*N,0>}
object{ Track_Up_00("T_L1_15",Step_1,0)
RTyz(-5*15,R1) translate<0,5*Step_1*N,0>}
//----------------------------------------------// |
|
Binari curvi a spirale
con lo scorrimento elastico in y - senza transizione
|
|
Binari curvi a spirale con lo scorrimento elastico in y
- con transizione
|
|
Binari curvi a spirale con lo scorrimento elastico in y
- con transizione
|
|
2) Deviatoi e alti elementi su e giù.
Non si può ruotare su o giù i deviatoi e gli incroci con la macro 'Track_Up_00(...)'!
Per questi elementi binari abbiamo bisogno di usare lo scorrimento elastico con la matrice di POV-Ray direttamente.
Per fare questo più facile, possiamo usare la macro seguente.br>
Questa macro fa lo scorrimento elastico di un elemento della lunghezza in x di 'Shear_Len'
con un valore 'Step_Up'('+' o '-' in valori a scala N in metro) nella direzione y:
#macro Shear_Up(Shear_Len,Step_Up) //-----------//
matrix<1,Step_Up*N/Shear_Len ,0,
0,1,0, 0,0,1, 0,0,0>
#end // end of macro ---------------------------// |
L'esempio dell'immagine qui :
//----------------------------------------------//
#declare TD = Track_Distance;
object{ SW_L( SD_1) translate< 0*L111,0,0>}
object{ T_R9_15
Rotate_Around_Trans(<0,-1*15,0>,<0,0, R9>)
translate< 0*L111,0,0>}
object{ T_111 translate< 1*L111,0,0>}
// tracks upward:
object{ Track_Up_00("T_111",Step_1,0)
translate<2*L111,0*Step_1*N,1*TD>}
object{ Track_Up_00("T_111",Step_1,0)
translate<2*L111,0*Step_1*N,0>}
object{ SW_R(SD_2) Shear_Up(L111,Step_1)
translate<3*L111,1*Step_1*N,1*TD>}
object{ Track_Up_00("T_111",Step_1,0)
translate<3*L111,1*Step_1*N,0>}
object{ Track_Up_00("T_111",Step_1,0)
translate<4*L111,2*Step_1*N,1*TD>}
object{ SW_R(SD_3) Shear_Up(L111,-Step_1)
rotate<0,180,0>
translate<5*L111,3*Step_1*N,0>}
//----------------------------------------------// |
|
Lo scorrimento elastico di deviatoi e altri oggetti
|
|
