Descrizioni ed esempi per il raytracer POV-Ray di Friedrich A. Lohmüller
Ferromodellismo - Modellismo ferroviario con POV-Ray
English English English
Français français
Deutsch Deutsch

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


                                                     
Tracks up and down
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>}
//----------------------------------------------//






Sharp and smooth transition
Binari su con lo scorrimento elastico con
la macro Track_Up_00("NAME",STEP,GRADIENT_TYPE)











Sharp and smooth transition
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>}
//----------------------------------------------//
screw without smooth transition
Binari curvi a spirale con lo scorrimento elastico in y - senza transizione
screw with more smooth transition
Binari curvi a spirale con lo scorrimento elastico in y - con transizione
screw with more smooth transition
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>}
//----------------------------------------------//













shearing of turnouts
Lo scorrimento elastico di deviatoi e altri oggetti


top

© Friedrich A. Lohmüller, 2011
www.f-lohmueller.de