Index: therion/loch/lxLRUD.cxx
==================================================================
--- therion/loch/lxLRUD.cxx
+++ therion/loch/lxLRUD.cxx
@@ -398,17 +398,17 @@
     prevProfile = psi->arrow.edge->shot->profile;
 
     shotDir = nodes[si->arrow.GetTX()].p - nodes[si->arrow.GetFX()].p;
 
     rDir = lxVec(shotDir.y, -shotDir.x, 0.0);
-    if (rDir.Norm() == 0.0) {
+    if ((rDir.Norm() == 0.0) && (si->arrow.edge->shot->vthresh != -1.0)) {
       rDir = lxVec(1.0, 0.0, 0.0);
       uDir = lxVec(0.0, (shotDir.z < 0 ? 1.0 : -1.0), 0.0);
     } else {
       rDir.Normalize();
       ci = shotDir.Inclination();
-      if  (fabs(ci) < si->arrow.edge->shot->vthresh)
+      if  ((fabs(ci) < si->arrow.edge->shot->vthresh || (si->arrow.edge->shot->vthresh == -1.0) ))
         uDir = lxVec(0.0, 0.0, 1.0);
       else {
         uDir = lxVec(0.0, 1.0, 0.0);
         ca = shotDir.Azimuth();
         uDir = lxPol2Vec(1.0, (ci >= 0.0 ? ca + 180.0 : ca), (ci >= 0.0 ? 90 - ci : 90 + ci));

Index: therion/thbook/ch02.tex
==================================================================
--- therion/thbook/ch02.tex
+++ therion/thbook/ch02.tex
@@ -495,10 +495,13 @@
     
     If passages are more or less vertical (|inclination > vthreshold|), even UD
     becomes perpendicular to the shot -- otherwise passages would not look very
     good. In the case of vertical shots, UD is interpreted as north-south
     dimension from the station to allow tube-like modelling of verticals.
+
+    To disable vthreshold and use only LR for vertical you can use -1 like :
+    |vthreshold -1 deg|
     
   * |extend <spec> [<station> [<station>]]| =
     control how the centerline is extended. |<spec>| is one of the following
 
     |normal/reverse| = extend given and following stations 

Index: therion/thdata.cxx
==================================================================
--- therion/thdata.cxx
+++ therion/thdata.cxx
@@ -833,11 +833,11 @@
     ththrow(("invalid vthreshold -- %s", args[0]))
   if (nargs > 1) {
     dlu.parse_units(args[1]);
     this->d_vtresh = dlu.transform(this->d_vtresh);
   }
-  if ((this->d_vtresh < 0.0) || (this->d_vtresh > 90.0))
+  if (((this->d_vtresh < 0.0) && (this->d_vtresh !=-1.0 )) || (this->d_vtresh > 90.0))
     ththrow(("vthreshold out of range -- %s", args[0]))
   
 }
 
 

Index: therion/thdb1d.cxx
==================================================================
--- therion/thdb1d.cxx
+++ therion/thdb1d.cxx
@@ -2679,11 +2679,11 @@
       
       // spocitame si X a Y section vectors
       secXx = cos((*tlegs)->leg->total_bearing / 180.0 * THPI);
       secXy = -sin((*tlegs)->leg->total_bearing / 180.0 * THPI);
       secXz = 0;
-      if (fabs((*tlegs)->leg->total_gradient) < (*tlegs)->leg->vtresh) {
+      if ((fabs((*tlegs)->leg->total_gradient) < (*tlegs)->leg->vtresh) || ((*tlegs)->leg->vtresh == -1.0)) {
         secYx = 0.0;
         secYy = 0.0;
         secYz = 1.0;
       } else {
         secYx = -sin((*tlegs)->leg->total_gradient / 180.0 * THPI) * sin((*tlegs)->leg->total_bearing / 180.0 * THPI);

Index: therion/thexpmap.cxx
==================================================================
--- therion/thexpmap.cxx
+++ therion/thexpmap.cxx
@@ -657,11 +657,11 @@
     }
     if (isexp[ff] && isexp[tt]) {
       fprintf(pltf,"  {%12.2f %12.2f %12.2f %12.2f", vff.x, vff.y, vtt.x, vtt.y);
       // calculate and export LRUD if needed
       if (cl->walls != TT_FALSE) {
-        if ((vff.x == vtt.x) && (vff.y == vtt.y)) {
+        if ((vff.x == vtt.x) && (vff.y == vtt.y) && (cl->vtresh != -1.0)) {
           vlim.valid = false;
           vlim.Add(-sf * cl->from_left,-sf * cl->from_down,0.0);
           vlim.Add(sf * cl->from_right, sf * cl->from_up  ,0.0);
           vlim.Add(-sf * cl->to_left,-sf * cl->to_down,0.0);
           vlim.Add(sf * cl->to_right, sf * cl->to_up  ,0.0);
@@ -672,11 +672,11 @@
         } else {
           vertical = false;
           switch (prj->type) {
             case TT_2DPROJ_ELEV:
             case TT_2DPROJ_EXTEND:
-              if (fabs(cl->total_gradient) < cl->vtresh)
+              if ((fabs(cl->total_gradient) < cl->vtresh) || (cl->vtresh == -1.0))
                 vertical = true;
               if ((vertical) || (vff.x < vtt.x) || ((vff.x == vtt.x) && (vff.y < vtt.y))) {
                 fl = sf * cl->from_up; 
                 fr = sf * cl->from_down; 
                 tl = sf * cl->to_up;

Index: therion/thscrapis.cxx
==================================================================
--- therion/thscrapis.cxx
+++ therion/thscrapis.cxx
@@ -501,11 +501,11 @@
           for(i = 0; i < 2; i++) {
             f.m_dim = f.m_dim && ((!thisnan(udlr1[i])) && (!thisnan(udlr2[i])));
             setudlr(s1->asl, udlr1[i], i);
             setudlr(s2->asl, udlr2[i], i);
           }
-          if (fabs(slp->arrow->leg->leg->total_gradient) > slp->arrow->leg->leg->vtresh) {
+          if ((fabs(slp->arrow->leg->leg->total_gradient) > slp->arrow->leg->leg->vtresh) && (slp->arrow->leg->leg->vtresh != -1.0))  {
             coef = fabs(slp->arrow->leg->leg->total_gradient);
             if (coef > 60) coef = 60;
             coef = 1 / cos(coef / 180.0 * THPI);
           }
           f.m_upf = coef * udlr1[0];
@@ -1407,11 +1407,11 @@
     return;
   }
   if (slp->arrow != NULL) {
     tmpup = (slp->arrow->is_reversed ? slp->arrow->leg->leg->to_up : slp->arrow->leg->leg->from_up);
     tmpdown = (slp->arrow->is_reversed ? slp->arrow->leg->leg->to_down : slp->arrow->leg->leg->from_down);
-    if (fabs(slp->arrow->leg->leg->total_gradient) >= slp->arrow->leg->leg->vtresh) {
+    if ((fabs(slp->arrow->leg->leg->total_gradient) >= slp->arrow->leg->leg->vtresh) && (slp->arrow->leg->leg->vtresh != -1.0))  {
       d = cos(slp->arrow->leg->leg->total_gradient / 180.0 * THPI);     
     } else {
       d = 1.0;
     }
     if (!thisnan(tmpup)) {

Index: therion/thscraplp.cxx
==================================================================
--- therion/thscraplp.cxx
+++ therion/thscraplp.cxx
@@ -66,11 +66,11 @@
       vff = lxVec(this->lnx1, this->lny1, this->lnz1);
       vtt = lxVec(this->lnx2, this->lny2, this->lnz2);
     }
 
     if (cl->walls != TT_FALSE) {
-      if ((vff.x == vtt.x) && (vff.y == vtt.y)) {
+      if ((vff.x == vtt.x) && (vff.y == vtt.y) && (cl->vtresh != -1.0)) {
         vlim.valid = false;
         vlim.Add(-cl->from_left,-cl->from_down,0.0);
         vlim.Add(cl->from_right,cl->from_up  ,0.0);
         vlim.Add(-cl->to_left,-cl->to_down,0.0);
         vlim.Add(cl->to_right,cl->to_up  ,0.0);
@@ -81,11 +81,11 @@
       } else {
         vertical = false;
         switch (out->proj->type) {
           case TT_2DPROJ_ELEV:
           case TT_2DPROJ_EXTEND:
-            if (fabs(cl->total_gradient) < cl->vtresh)
+            if ((fabs(cl->total_gradient) < cl->vtresh) || (cl->vtresh == -1.0))
               vertical = true;
             if ((vertical) || (vff.x < vtt.x) || ((vff.x == vtt.x) && (vff.y < vtt.y))) {
               fl = cl->from_up; 
               fr = cl->from_down; 
               tl = cl->to_up;

