summaryrefslogtreecommitdiff
path: root/app/bin/elev.c
diff options
context:
space:
mode:
Diffstat (limited to 'app/bin/elev.c')
-rw-r--r--app/bin/elev.c1317
1 files changed, 1317 insertions, 0 deletions
diff --git a/app/bin/elev.c b/app/bin/elev.c
new file mode 100644
index 0000000..ec232a4
--- /dev/null
+++ b/app/bin/elev.c
@@ -0,0 +1,1317 @@
+/*
+ * $Header: /home/dmarkle/xtrkcad-fork-cvs/xtrkcad/app/bin/elev.c,v 1.1 2005-12-07 15:47:20 rc-flyer Exp $
+ */
+
+/* XTrkCad - Model Railroad CAD
+ * Copyright (C) 2005 Dave Bullis
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#include "track.h"
+#include "shrtpath.h"
+#include "ccurve.h"
+
+
+EXPORT long oldElevationEvaluation = 0;
+static int log_fillElev = 0;
+static int log_dumpElev = 0;
+static BOOL_T log_fillElev_initted;
+static int checkTrk = 0;
+static char * elevPrefix;
+
+static void SetTrkOnElevPath( track_p trk, int mode, DIST_T elev );
+
+typedef struct {
+ track_p trk;
+ EPINX_T ep;
+ DIST_T len;
+ } elist_t;
+static dynArr_t elist_da;
+#define elist(N) DYNARR_N( elist_t, elist_da, N )
+#define elistAppend( T, E, L ) \
+ { DYNARR_APPEND( elist_t, elist_da, 10 );\
+ elist(elist_da.cnt-1).trk = T; elist(elist_da.cnt-1).len = L; elist(elist_da.cnt-1).ep = E; }
+
+EPINX_T GetNextTrkOnPath( track_p trk, EPINX_T ep )
+{
+/* Get next track on Path:
+ 1 - there is only 1 connected (not counting ep)
+ 2 - there are >1 but only 1 on Path
+ 3 - one of them is PST:PSE or PET:PEE
+*/
+ EPINX_T ep2;
+ track_p trkN;
+ int epCnt = GetTrkEndPtCnt(trk);
+
+ for ( ep2=0; ep2<epCnt; ep2++) {
+ if ( ep2 == ep )
+ continue;
+ trkN = GetTrkEndTrk(trk,ep2);
+ if (trkN && (GetTrkBits(trkN)&TB_PROFILEPATH))
+ return ep2;
+ }
+ return -1;
+}
+
+
+EXPORT int FindDefinedElev(
+ track_p trk,
+ EPINX_T ep,
+ int dir,
+ BOOL_T onpath,
+ DIST_T * Relev,
+ DIST_T *Rdist )
+{
+ track_p trk0, trk1;
+ EPINX_T ep0, ep1, ep2;
+ DIST_T dist=0.0;
+
+ if (dir) {
+ trk1 = GetTrkEndTrk( trk, ep );
+ if (trk1 == NULL)
+ return FDE_END;
+ ep = GetEndPtConnectedToMe( trk1, trk );
+ trk = trk1;
+ }
+ trk0 = trk;
+ ep0 = ep;
+ while (1) {
+ for (ep2=0; ep2<GetTrkEndPtCnt(trk); ep2++) {
+ if ((trk!=trk0||ep2!=ep0)&&
+ EndPtIsDefinedElev(trk,ep2) ) {
+ dist += GetTrkLength( trk, ep, ep2 );
+ *Relev = GetTrkEndElevHeight(trk,ep2);
+ *Rdist = dist;
+ return FDE_DEF;
+ }
+ }
+ if (onpath) {
+ ep2 = GetNextTrkOnPath( trk, ep );
+ if ( ep2 >= 0 ) {
+ trk1 = GetTrkEndTrk( trk, ep2 );
+ ep1 = GetEndPtConnectedToMe( trk1, trk );
+ } else {
+ trk1 = NULL;
+ }
+ } else {
+ ep2 = GetNextTrk( trk, ep, &trk1, &ep1, GNTignoreIgnore );
+ }
+ if (ep2 < 0) {
+ if (trk1) {
+ /* more than one branch */
+ return FDE_UDF;
+ } else {
+ /* end of the line */
+ return FDE_END;
+ }
+ }
+ dist += GetTrkLength( trk, ep, ep2 );
+ trk = trk1;
+ ep = ep1;
+ if (trk == trk0)
+ return FDE_UDF;
+ }
+}
+
+
+BOOL_T ComputeElev(
+ track_p trk,
+ EPINX_T ep,
+ BOOL_T onpath,
+ DIST_T *elevR,
+ DIST_T *gradeR )
+{
+ DIST_T grade;
+ DIST_T elev0, elev1, dist0, dist1;
+ BOOL_T rc = FALSE;
+if (oldElevationEvaluation) {
+ int rc0, rc1;
+ if (GetTrkEndElevMode(trk,ep) == ELEV_DEF) {
+ if (elevR)
+ *elevR = GetTrkEndElevHeight(trk,ep);
+ if (gradeR)
+ *gradeR = 0.0;
+ return TRUE;
+ }
+ rc0 = FindDefinedElev( trk, ep, 0, onpath, &elev0, &dist0 );
+ rc1 = FindDefinedElev( trk, ep, 1, onpath, &elev1, &dist1 );
+ if ( rc0 == FDE_DEF && rc1 == FDE_DEF ) {
+ if (dist0+dist1 > 0.1)
+ grade = (elev1-elev0)/(dist0+dist1);
+ else
+ grade = 0.0;
+ elev0 += grade*dist0;
+ rc = TRUE;
+ } else if ( rc0 == FDE_DEF && rc1 == FDE_END ) {
+ grade = 0.0;
+ rc = TRUE;
+ } else if ( rc1 == FDE_DEF && rc0 == FDE_END ) {
+ grade = 0.0;
+ elev0 = elev1;
+ rc = TRUE;
+ } else if ( rc0 == FDE_END && rc1 == FDE_END ) {
+ grade = 0.0;
+ elev0 = 0.0;
+ rc = TRUE;
+ } else {
+ grade = 0.0;
+ elev0 = 0.0;
+ }
+} else {
+ track_p trk1;
+ EPINX_T ep1;
+ grade = -1;
+ rc = TRUE;
+ if ( EndPtIsDefinedElev(trk,ep) ) {
+ elev0 = GetTrkEndElevHeight(trk,ep);
+ rc = FALSE;
+ } else {
+ elev0 = GetElevation( trk );
+ dist0 = GetTrkLength( trk, ep, -1 );
+ trk1 = GetTrkEndTrk( trk, ep );
+ if (trk1!=NULL) {
+ ep1 = GetEndPtConnectedToMe(trk1,trk);
+ elev1 = GetElevation( trk1 );
+ dist1 = GetTrkLength( trk1, ep1, -1 );
+ if (dist0+dist1>0.1) {
+ grade = (elev1-elev0)/(dist0+dist1);
+ elev0 += grade*dist0;
+ } else {
+ elev0 = (elev0+elev1)/2.0;
+ rc = FALSE;
+ }
+ } else {
+ grade = 0.0;
+ }
+ }
+}
+ if ( elevR )
+ *elevR = elev0;
+ if ( gradeR )
+ *gradeR = grade;
+ return rc;
+}
+
+
+
+/*
+ * DYNAMIC ELEVATION COMPUTATION
+ *
+ * Step 1: Find DefElev's marking the border of the area of interest (or all of them)
+ */
+
+typedef struct {
+ track_p trk;
+ EPINX_T ep;
+ DIST_T elev;
+ } defelev_t;
+static dynArr_t defelev_da;
+#define defelev(N) DYNARR_N( defelev_t, defelev_da, N )
+
+static void FindDefElev( void )
+{
+ track_p trk;
+ EPINX_T ep, cnt;
+ defelev_t * dep;
+ long time0 = wGetTimer();
+
+ DYNARR_RESET( defelev_t, defelev_da );
+ trk = NULL;
+ while ( TrackIterate( &trk ) ) {
+ cnt = GetTrkEndPtCnt( trk );
+ for ( ep = 0; ep < cnt; ep++ ) {
+ if ( !EndPtIsDefinedElev( trk, ep ) )
+ continue;
+ DYNARR_APPEND( defelev_t, defelev_da, 10 );
+ dep = &defelev( defelev_da.cnt-1 );
+ dep->trk = trk;
+ dep->ep = ep;
+ dep->elev = GetTrkEndElevHeight(trk,ep);
+ }
+ }
+LOG( log_fillElev, 1, ( "%s: findDefElev [%d] (%ld)\n", elevPrefix, defelev_da.cnt, wGetTimer()-time0 ) )
+}
+
+
+static int foundNewDefElev;
+static void FindAttachedDefElev( track_p trk, BOOL_T remove )
+/* Find all DefElev's attached (directly or not) to this trk
+ * if 'remove' then clr ELEVPATH bit
+ * Working:
+ * elist_da
+ * Outputs:
+ * defelev_da - list of DefElev
+ * foundNewDefElev - found a DefElev not already on ElevPath
+ */
+{
+ int i1;
+ track_p trk1;
+ EPINX_T ep, cnt;
+ defelev_t * dep;
+
+ foundNewDefElev = FALSE;
+ DYNARR_RESET( elist_t, elist_da );
+ elistAppend( trk, 0, 0 );
+ SetTrkBits( trk, TB_PROCESSED );
+ if (remove)
+ ClrTrkBits( trk, TB_ELEVPATH );
+ for ( i1=0; i1<elist_da.cnt; i1++ ) {
+ trk = elist(i1).trk;
+ if (!IsTrack(trk))
+ continue;
+ cnt = GetTrkEndPtCnt(trk);
+ for ( ep=0; ep<cnt; ep++ ) {
+ if ( EndPtIsDefinedElev(trk,ep) ) {
+ DYNARR_APPEND( defelev_t, defelev_da, 10 );
+ dep = &defelev( defelev_da.cnt-1 );
+ dep->trk = trk;
+ dep->ep = ep;
+ dep->elev = GetTrkEndElevHeight(trk,ep);
+ if ( !(GetTrkBits(trk)&TB_ELEVPATH) ) {
+ foundNewDefElev = TRUE;
+ }
+ } else {
+ trk1 = GetTrkEndTrk(trk,ep);
+ if (trk1) {
+#ifdef LATER
+ if ( defElevOnIsland == FALSE && (GetTrkBits(trk1)&TB_ELEVPATH) ) {
+ /* so far this island is only connected to forks */
+ DYNARR_APPEND( fork_t, fork_da, 10 );
+ n = &fork(fork_da.cnt-1);
+ n->trk = trk1;
+ n->ep = ep;
+ n->dist = dist;
+ n->elev = dep->elev;
+ n->ntrk = dep->trk;
+ n->nep = dep->ep;
+ }
+#endif
+ if ( !(GetTrkBits(trk1)&TB_PROCESSED) ) {
+ elistAppend( trk1, 0, 0 );
+ SetTrkBits( trk1, TB_PROCESSED );
+ if (remove)
+ ClrTrkBits( trk1, TB_ELEVPATH );
+ }
+ }
+ }
+ }
+ }
+}
+
+static int FindObsoleteElevs( void )
+{
+ track_p trk;
+ int cnt;
+ long time0 = wGetTimer();
+
+ ClrAllTrkBits( TB_PROCESSED );
+ DYNARR_RESET( defelev_t, defelev_da );
+ cnt = 0;
+ trk = NULL;
+ while ( TrackIterate( &trk ) ) {
+ if ( (!(GetTrkBits(trk)&(TB_ELEVPATH|TB_PROCESSED))) && IsTrack(trk) ) {
+ cnt++;
+ FindAttachedDefElev( trk, TRUE );
+ }
+ }
+LOG( log_fillElev, 1, ( "%s: findObsoleteElevs [%d] (%ld)\n", elevPrefix, cnt, wGetTimer()-time0 ) )
+ return cnt;
+}
+
+
+
+
+/*
+ * DYNAMIC ELEVATION COMPUTATION
+ *
+ * Step 2: Find Forks on Shortest Path between the DefElev's found in Step 1
+ */
+
+typedef struct {
+ track_p trk;
+ EPINX_T ep;
+ EPINX_T ep2;
+ DIST_T dist;
+ DIST_T elev;
+ } fork_t;
+static dynArr_t fork_da;
+#define fork(N) DYNARR_N( fork_t, fork_da, N )
+
+static int FillElevShortestPathFunc(
+ SPTF_CMD cmd,
+ track_p trk,
+ EPINX_T ep,
+ EPINX_T ep2,
+ DIST_T dist,
+ void * data )
+{
+ defelev_t * dep = (defelev_t *)data;
+ track_p trk1;
+ EPINX_T ep1, cnt, epRc;
+ fork_t * n;
+
+ switch ( cmd ) {
+ case SPTC_MATCH:
+ /*if ( (GetTrkBits(trk)&TB_PROCESSED) )
+ epRc = 0;
+ else*/ if ( (dep->trk!=trk || dep->ep!=ep) && EndPtIsDefinedElev(trk,ep))
+ epRc = 1;
+ else
+ epRc = 0;
+ break;
+
+ case SPTC_MATCHANY:
+ cnt = GetTrkEndPtCnt( trk );
+ epRc = -1;
+ /*if ( (GetTrkBits(trk)&TB_PROCESSED) )
+ break;*/
+ for ( ep1=0; ep1<cnt; ep1++ ) {
+ if ( ep != ep1 && EndPtIsDefinedElev( trk, ep1 ) ) {
+ epRc = ep1;
+ break;
+ }
+ }
+ break;
+
+ case SPTC_ADD_TRK:
+ if (!(GetTrkBits(trk)&TB_PROCESSED)) {
+ SetTrkBits(trk, TB_PROCESSED);
+ if ( EndPtIsDefinedElev( trk, ep ) ) {
+if (log_shortPath<=0||logTable(log_shortPath).level<4) LOG( log_fillElev, 5, ( " ADD_TRK: T%d:%d D=%0.1f -> DefElev\n", GetTrkIndex(trk), ep, dist ) )
+LOG( log_shortPath, 4, ( "DefElev " ) )
+ } else if ( GetNextTrk( trk, ep, &trk1, &ep1, GNTignoreIgnore ) < 0 && trk1 != NULL ) {
+if (log_shortPath<=0||logTable(log_shortPath).level<4) LOG( log_fillElev, 4, ( " ADD_TRK: T%d:%d D=%0.3f E=%0.3f -> Fork[%d]\n", GetTrkIndex(trk), ep, dist, dep->elev, fork_da.cnt ) )
+LOG( log_shortPath, 4, ( "E:%0.3f Fork[%d] ", dep->elev, fork_da.cnt ) )
+ DYNARR_APPEND( fork_t, fork_da, 10 );
+ n = &fork(fork_da.cnt-1);
+ n->trk = trk;
+ n->ep = ep;
+ n->ep2 = ep2;
+ n->dist = dist;
+ n->elev = dep->elev;
+#ifdef LATER
+ n->ntrk = dep->trk;
+ n->nep = dep->ep;
+#endif
+ } else {
+LOG( log_shortPath, 4, ( "Normal " ) )
+ }
+ } else {
+LOG( log_shortPath, 4, ( "Processed " ) )
+ }
+ return 0;
+
+ case SPTC_TERMINATE:
+ epRc = 0;
+ break;
+
+ case SPTC_IGNNXTTRK:
+ if ( EndPtIsIgnoredElev(trk,ep2) ) {
+LOG( log_shortPath, 4, ( "2 Ignore " ) )
+ epRc = 1;
+ } else if ( (!EndPtIsDefinedElev(trk,ep)) && GetTrkEndTrk(trk,ep)==NULL ) {
+LOG( log_shortPath, 4, ( "1 Null && !DefElev " ) )
+ epRc = 1;
+ } else {
+ epRc = 0;
+ }
+ break;
+
+ case SPTC_VALID:
+ epRc = (GetTrkBits(trk)&TB_PROCESSED)==0?1:0;
+ break;
+
+ default:
+ epRc = 0;
+ break;
+ }
+ return epRc;
+}
+
+static void FindForks( void )
+/* Find the Shortest Path between all DevElev's (in defelev_da)
+ * and record all Forks (Turnouts with >2 connections) with distance to and elevation of the DefElev
+ * Inputs:
+ * defelev_da - list of DefElev to consider
+ * Outputs:
+ * fork_da - list of distances btw Forks and DefElev (plus other info)
+ */
+{
+ int i;
+ defelev_t * dep;
+ int rc;
+ long time0 = wGetTimer();
+
+ DYNARR_RESET( fork_t, fork_da );
+ for ( i=0; i<defelev_da.cnt; i++ ) {
+ dep = &defelev(i);
+
+ ClrAllTrkBits( TB_PROCESSED );
+LOG( log_fillElev, 3, ( " findForks from T%d:%d\n", GetTrkIndex(dep->trk), dep->ep ) )
+ rc = FindShortestPath( dep->trk, dep->ep, FALSE, FillElevShortestPathFunc, dep );
+ }
+ ClrAllTrkBits( TB_PROCESSED );
+LOG( log_fillElev, 1, ( "%s: findForks [%d] (%ld)\n", elevPrefix, fork_da.cnt, wGetTimer()-time0 ) )
+}
+
+
+
+
+/*
+ * DYNAMIC ELEVATION COMPUTATION
+ *
+ * Step 3: Compute the elevation of each Fork based on the weighted sum of the elevations
+ * of the DefElev's that it is connected to.
+ */
+
+typedef struct {
+ DIST_T elev;
+ DIST_T dist;
+ } elevdist_t;
+static dynArr_t elevdist_da;
+#define elevdist(N) DYNARR_N( elevdist_t, elevdist_da, N );
+
+static DIST_T ComputeWeightedElev( DIST_T totalDist )
+/* Compute weighted elevation
+ * Inputs:
+ * totalDist - total distance of all tracks between DevElev's
+ * elevdist_da - elev + dist to DefElev from current node
+ * Outputs:
+ * elev (returned)
+ */
+{
+ int i2;
+ DIST_T d2;
+ elevdist_t * w;
+ DIST_T e;
+
+ /* Compute inverse weighted Distance (d2) */
+ d2 = 0;
+ for ( i2=0; i2<elevdist_da.cnt; i2++ ) {
+ w = &elevdist(i2);
+ if (w->dist < 0.001) {
+ e = w->elev;
+LOG( log_fillElev, 3, ( " computeWeightedElev: close! D%0.3f E%0.3f\n", w->dist, e ) )
+ return e;
+ }
+ d2 += totalDist/w->dist;
+ }
+
+ /* Compute weighted elevation (e) */
+ e = 0;
+ for ( i2=0; i2<elevdist_da.cnt; i2++ ) {
+ w = &elevdist(i2);
+ e += ((totalDist/w->dist)/d2)*w->elev;
+ }
+
+ if (log_fillElev >= 4) {
+ for ( i2=0; i2<elevdist_da.cnt; i2++ ) {
+ w = &elevdist(i2);
+ lprintf( " E%0.3f D%0.3f\n", w->elev, w->dist );
+ }
+ }
+LOG( log_fillElev, 3, ( " computeWeightedElev: E%0.3f\n", e ) )
+ return e;
+}
+
+
+static int forkCnt;
+static void ComputeForkElev( void )
+/* Compute elevations of all Forks
+ * Inputs:
+ * fork_da - fork distance/elev data (overwritten)
+ * Outputs:
+ * fork_da - just .trk used for forks
+ * forkCnt - numer of forks found
+ */
+{
+ int i1, i2;
+ fork_t * n1, * n2, * n3;
+ track_p trk, trk1;
+ EPINX_T ep, cnt;
+ DIST_T d1, e;
+ elevdist_t * w;
+ BOOL_T singlePath;
+ long time0 = wGetTimer();
+
+ forkCnt = 0;
+ for (i1=0; i1<fork_da.cnt; i1++) {
+ n1 = &fork(i1);
+ if ((trk=n1->trk)) {
+ cnt = GetTrkEndPtCnt(n1->trk);
+ if (cnt<=0)
+ continue;
+
+ /* collect dist/elev to connected DefElev points */
+ d1 = 0;
+ DYNARR_RESET( elevdist_t, elevdist_da );
+ singlePath = TRUE;
+ for (i2=i1; i2<fork_da.cnt; i2++) {
+ n2 = &fork(i2);
+ if (trk == n2->trk) {
+ DYNARR_APPEND( elevdist_t, elevdist_da, 10 );
+ w = &elevdist(elevdist_da.cnt-1);
+ w->dist = n2->dist;
+ w->elev = n2->elev;
+ w->dist += GetTrkLength( n2->trk, n2->ep, -1 );
+ n2->trk = NULL;
+ d1 += w->dist;
+ if ( ! ( ( n1->ep == n2->ep && n1->ep2 == n2->ep2 ) ||
+ ( n1->ep == n2->ep2 && n1->ep2 == n2->ep ) ) )
+ singlePath = FALSE;
+ }
+ }
+
+ /* Also check my EPs */
+ for (ep=0; ep<cnt; ep++) {
+ if ( (trk1=GetTrkEndTrk(trk,ep)) )
+ SetTrkBits( trk1, TB_PROCESSED );
+ if (!EndPtIsDefinedElev(trk,ep))
+ continue;
+ for (i2=i1; i2<fork_da.cnt; i2++) {
+ n2 = &fork(i2);
+ if (trk==n2->trk && ep==n2->ep)
+ break;
+ }
+ if (i2 >= fork_da.cnt) {
+ DYNARR_APPEND( elevdist_t, elevdist_da, 10 );
+ w = &elevdist(elevdist_da.cnt-1);
+ w->elev = GetTrkEndElevHeight(trk,ep);
+ w->dist = GetTrkLength( trk, ep, -1 );
+ d1 += w->dist;
+ singlePath = FALSE;
+ }
+ }
+
+ n3 = &fork(forkCnt);
+ n3->trk = trk;
+ if ( singlePath == TRUE ) {
+ /* only 2 EP are connected to DefElevs, treat other EPs as ignored */
+ n3->ep = n1->ep;
+ n3->ep2 = n1->ep2;
+ } else {
+ e = ComputeWeightedElev( d1 );
+ SetTrkOnElevPath( trk, ELEV_FORK, e );
+ /* 3 or more EPs are to DefElevs */
+ n3->ep = -1;
+LOG( log_fillElev, 2, ( " 1 T%d E%0.3f\n", GetTrkIndex(trk), e ) )
+ }
+ forkCnt++;
+ }
+ }
+LOG( log_fillElev, 1, ( "%s: computeForkElev [%d] (%ld)\n", elevPrefix, forkCnt, wGetTimer()-time0 ) )
+}
+
+
+
+
+/*
+ * DYNAMIC ELEVATION COMPUTATION
+ *
+ * Step 4: Compute the elevation of tracks on the Shortest Path between Forks and DefElev's
+ */
+
+static void RedrawCompGradeElev( track_p trk, EPINX_T ep )
+{
+ int mode;
+ coOrd pos;
+ track_p trk1;
+ mode = GetTrkEndElevMode( trk, ep );
+ if ( mode == ELEV_COMP || mode == ELEV_GRADE ) {
+ pos = GetTrkEndPos( trk, ep );
+ if (!OFF_MAIND( pos, pos ) ) {
+ trk1 = GetTrkEndTrk( trk, ep );
+ if ( (trk1=GetTrkEndTrk(trk,ep)) && GetTrkIndex(trk1)<GetTrkIndex(trk) )
+{
+ ep = GetEndPtConnectedToMe( trk1, trk );
+ trk = trk1;
+ }
+ DrawEndElev( &mainD, trk, ep, wDrawColorWhite );
+ DrawEndElev( &mainD, trk, ep, wDrawColorBlack );
+ }
+ }
+}
+
+
+static void PropogateForkElev(
+ track_p trk1,
+ EPINX_T ep1,
+ DIST_T d1,
+ DIST_T e )
+/* Propogate elev from fork connection
+ * The track list starting from trk1:ep1 ends at a DefElev or a Fork
+ * Inputs:
+ * Working:
+ * elist_da
+ * Outputs:
+ * Sets trk elev
+ */
+{
+ DIST_T d2;
+ DIST_T e1;
+ EPINX_T ep2, epN, cnt2;
+ track_p trkN;
+ fork_t * n1;
+ int i2, i3;
+
+ DYNARR_RESET( elist_t, elist_da );
+ while (trk1) {
+ if ( GetTrkIndex(trk1) == checkTrk )
+ printf( "found btw forks\n" );
+ if ( GetTrkOnElevPath( trk1, &e1 ) ) {
+ d1 += GetTrkLength( trk1, ep1, -1 );
+ goto nextStep;
+ }
+ cnt2 = GetTrkEndPtCnt(trk1);
+ for ( ep2=0; ep2<cnt2; ep2++ ) {
+ if ( ep2!=ep1 && EndPtIsDefinedElev(trk1,ep2) ) {
+ e1 = GetTrkEndElevHeight( trk1, ep2 );
+ d2 = GetTrkLength( trk1, ep1, ep2 )/2.0;
+ d1 += d2;
+ elistAppend( trk1, ep1, d1 );
+ d1 += d2;
+ goto nextStep;
+ }
+ }
+ ep2 = GetNextTrk( trk1, ep1, &trkN, &epN, GNTignoreIgnore );
+ if ( ep2<0 ) {
+ /* is this really a fork? */
+ for ( i2=0; i2<forkCnt; i2++ ) {
+ n1 = &fork(i2);
+ if ( trk1 == n1->trk && n1->ep >= 0 ) {
+ /* no: make sure we are on the path */
+ if ( n1->ep == ep1 )
+ ep2 = n1->ep2;
+ else if ( n1->ep2 == ep1 )
+ ep2 = n1->ep;
+ else
+ return;
+ trkN = GetTrkEndTrk(trk1,ep2);
+ epN = GetEndPtConnectedToMe( trkN, trk1 );
+ break;
+ }
+ }
+ if ( i2 >= forkCnt )
+ return;
+ }
+ d2 = GetTrkLength( trk1, ep1, ep2 )/2.0;
+ d1 += d2;
+ elistAppend( trk1, ep1, d1 );
+ d1 += d2;
+ trk1 = trkN;
+ ep1 = epN;
+ }
+nextStep:
+ ASSERT(d1>0.0);
+ e1 = (e1-e)/d1;
+ trk1 = NULL;
+ i3 = elist_da.cnt;
+ for (i2=0; i2<elist_da.cnt; i2++) {
+ trk1 = elist(i2).trk;
+ ep1 = elist(i2).ep;
+ if ( GetTrkOnElevPath( trk1, &e1 ) ) {
+ i3=i2;
+ break;
+ }
+ d2 = elist(i2).len;
+ SetTrkOnElevPath( trk1, ELEV_BRANCH, e+e1*d2 );
+LOG( log_fillElev, 2, ( " 2 T%d E%0.3f\n", GetTrkIndex(trk1), e+e1*d2 ) )
+ }
+ for (i2=0; i2<i3; i2++) {
+ trk1 = elist(i2).trk;
+ ep1 = elist(i2).ep;
+ RedrawCompGradeElev( trk1, ep1 );
+ }
+}
+
+static void PropogateForkElevs( void )
+/* For all Forks, For all connections not already processed or not on ElevPath do
+ * propogate elev along connection
+ * Inputs:
+ * fork_da - list of forks
+ * forkCnt - number of forks
+ * Working:
+ * elist_da (by subrtn)
+ * Outputs:
+ * Sets trk elev (by subrtn)
+ */
+{
+ int i1;
+ fork_t * n1;
+ track_p trk, trk1;
+ EPINX_T ep, cnt, ep1;
+ DIST_T d1, e;
+ long time0 = wGetTimer();
+
+ /* propogate elevs between forks */
+ for ( i1=0; i1<forkCnt; i1++ ) {
+ n1 = &fork(i1);
+ if ( n1->ep >= 0 )
+ continue;
+ trk = n1->trk;
+ GetTrkOnElevPath( trk, &e );
+ cnt = GetTrkEndPtCnt(trk);
+ for (ep=0; ep<cnt; ep++) {
+ trk1 = GetTrkEndTrk(trk,ep);
+ if ( trk1 && (GetTrkBits(trk1)&TB_PROCESSED) && !GetTrkOnElevPath(trk1,NULL) ) {
+ /* should find a fork with a computed elev */
+ ep1 = GetEndPtConnectedToMe( trk1, trk );
+ if ( EndPtIsDefinedElev(trk,ep) ) {
+ PropogateForkElev( trk1, ep1, 0, GetTrkEndElevHeight(trk,ep) );
+ } else {
+ d1 = GetTrkLength(trk,ep,-1);
+ PropogateForkElev( trk1, ep1, d1, e );
+ }
+ }
+ }
+ }
+LOG( log_fillElev, 1, ( "%s: propogateForkElev (%ld)\n", elevPrefix, wGetTimer()-time0 ) )
+}
+
+static void PropogateDefElevs( void )
+/* Propogate Elev from DefElev (if not handled already)
+ * Inputs:
+ * develev_da - list of DefElev
+ * Outputs:
+ * Set trk elev
+ */
+{
+ int i1;
+ defelev_t * dep;
+ DIST_T e;
+ long time0 = wGetTimer();
+
+ /* propogate elevs between DefElev pts (not handled by propogateForkElevs) */
+ for ( i1=0; i1<defelev_da.cnt; i1++ ) {
+ dep = &defelev(i1);
+ if (GetTrkOnElevPath( dep->trk, &e ))
+ /* propogateForkElevs beat us to it */
+ continue;
+ e = GetTrkEndElevHeight( dep->trk, dep->ep );
+ PropogateForkElev( dep->trk, dep->ep, 0, e );
+ }
+LOG( log_fillElev, 1, ( "%s: propogateDefElevs [%d] (%ld)\n", elevPrefix, defelev_da.cnt, wGetTimer()-time0 ) )
+}
+
+
+
+
+/*
+ * DYNAMIC ELEVATION COMPUTATION
+ *
+ * Step 5: Remaining tracks form either Islands connected to zero or more DefElev, Forks
+ * or Branches (Pivots). The elevation of these tracks is determined by the distance to
+ * the Pivots. Tracks which are not connected to Pivots are labeled 'Alone' and have no
+ * elevation.
+ */
+
+typedef struct {
+ track_p trk;
+ coOrd pos;
+ DIST_T elev;
+ } pivot_t;
+static dynArr_t pivot_da;
+#define pivot(N) DYNARR_N(pivot_t, pivot_da, N)
+
+static void SurveyIsland(
+ track_p trk,
+ BOOL_T stopAtElevPath )
+/* Find the tracks in this island and the pivots of this island
+ * Outputs:
+ * elist_da - tracks in the island
+ * pivot_da - pivots connecting island to tracks with some elev
+ */
+{
+ int i1;
+ track_p trk1;
+ EPINX_T ep, cnt;
+ pivot_t * pp;
+ coOrd hi, lo;
+ DIST_T elev;
+
+ DYNARR_RESET( elist_t, elist_da );
+ DYNARR_RESET( pivot_t, pivot_da );
+ ClrAllTrkBits( TB_PROCESSED );
+ elistAppend( trk, 0, 0 );
+ SetTrkBits( trk, TB_PROCESSED );
+ for ( i1=0; i1 < elist_da.cnt; i1++ ) {
+ trk = elist(i1).trk;
+ if ( GetTrkIndex(trk) == checkTrk )
+ printf( "found in island\n" );
+ cnt = GetTrkEndPtCnt(trk);
+ for ( ep=0; ep<cnt; ep++ ) {
+ trk1 = GetTrkEndTrk( trk, ep );
+ if ( EndPtIsDefinedElev(trk,ep)) {
+ DYNARR_APPEND( pivot_t, pivot_da, 10 );
+ pp = &pivot(pivot_da.cnt-1);
+ pp->trk = trk;
+ pp->pos = GetTrkEndPos(trk,ep);
+ pp->elev = GetTrkEndElevHeight(trk,ep);
+ } else if ( stopAtElevPath && trk1 && GetTrkOnElevPath(trk1, &elev) ) {
+ DYNARR_APPEND( pivot_t, pivot_da, 10 );
+ pp = &pivot(pivot_da.cnt-1);
+ pp->trk = trk1;
+ GetBoundingBox( trk1, &hi, &lo );
+ pp->pos.x = (hi.x+lo.x)/2.0;
+ pp->pos.y = (hi.y+lo.y)/2.0;
+ pp->elev = elev;
+ } else if ( trk1 && !(GetTrkBits(trk1)&TB_PROCESSED) ) {
+ SetTrkBits( trk1, TB_PROCESSED );
+ elistAppend( trk1, 0, 0 );
+ }
+ }
+ }
+ ClrAllTrkBits( TB_PROCESSED );
+}
+
+static void ComputeIslandElev(
+ track_p trk )
+/* Compute elev of tracks connected to 'trk'
+ * An island is the set of tracks bounded by a DefElev EP or a track already on ElevPath
+ * Inputs:
+ * Working:
+ * elist_da
+ * Outputs:
+ * pivot_da - list of tracks on boundary of Island
+ */
+{
+ int i1, i2;
+ coOrd hi, lo, pos;
+ pivot_t * pp;
+ DIST_T elev;
+ DIST_T totalDist;
+ elevdist_t * w;
+ int mode;
+ EPINX_T ep, epCnt;
+
+ SurveyIsland( trk, TRUE );
+
+ for ( i1=0; i1 < elist_da.cnt; i1++ ) {
+ trk = elist(i1).trk;
+ if ( !IsTrack(trk) )
+ continue;
+ mode = ELEV_ISLAND;
+ if (pivot_da.cnt == 0) {
+ elev = 0;
+ mode = ELEV_ALONE;
+ } else if (pivot_da.cnt == 1) {
+ elev = pivot(0).elev;
+ } else {
+ if ( !GetCurveMiddle( trk, &pos ) ) {
+ GetBoundingBox( trk, &hi, &lo );
+ pos.x = (hi.x+lo.x)/2.0;
+ pos.y = (hi.y+lo.y)/2.0;
+ }
+ DYNARR_RESET( elevdist_t, elevdist_da );
+ totalDist = 0;
+ for ( i2=0; i2<pivot_da.cnt; i2++ ) {
+ pp = &pivot(i2);
+ DYNARR_APPEND( elevdist_t, elevdist_da, 10 );
+ w = &elevdist(elevdist_da.cnt-1);
+ w->elev = pp->elev;
+ w->dist = FindDistance( pos, pp->pos );
+ totalDist += w->dist;
+ }
+ elev = ComputeWeightedElev( totalDist );
+ }
+ SetTrkOnElevPath( trk, mode, elev );
+LOG( log_fillElev, 1, ( " 3 T%d E%0.3f\n", GetTrkIndex(trk), elev ) )
+ }
+
+ for ( i1=0; i1<elist_da.cnt; i1++ ) {
+ trk = elist(i1).trk;
+ epCnt = GetTrkEndPtCnt( trk );
+ for ( ep=0; ep<epCnt; ep++ ) {
+ mode = GetTrkEndElevMode( trk, ep );
+ if ( (mode == ELEV_GRADE || mode == ELEV_COMP) ) {
+ RedrawCompGradeElev( trk, ep );
+ }
+ }
+ }
+}
+
+
+static void FindIslandElevs( void )
+{
+ track_p trk;
+ DIST_T elev;
+ int islandCnt;
+ long time0 = wGetTimer();
+
+ trk = NULL;
+ islandCnt = 0;
+ while ( TrackIterate( &trk ) ) {
+ if ( !GetTrkOnElevPath( trk, &elev ) ) {
+ if (IsTrack(trk)) {
+ ComputeIslandElev( trk );
+ islandCnt++;
+ }
+ }
+ }
+LOG( log_fillElev, 1, ( "%s: findIslandElevs [%d] (%ld)\n", elevPrefix, islandCnt, wGetTimer()-time0 ) )
+}
+
+/*
+ * DYNAMIC ELEVATION COMPUTATION
+ *
+ * Drivers
+ *
+ */
+
+EXPORT void RecomputeElevations( void )
+{
+ long time0 = wGetTimer();
+ elevPrefix = "RECELV";
+ if ( !log_fillElev_initted ) { log_fillElev = LogFindIndex( "fillElev" ); log_dumpElev = LogFindIndex( "dumpElev" ); log_fillElev_initted = TRUE; }
+ ClearElevPath();
+ FindDefElev();
+ FindForks();
+ ComputeForkElev();
+ PropogateForkElevs();
+ PropogateDefElevs();
+ FindIslandElevs();
+ MainRedraw();
+LOG( log_fillElev, 1, ( "%s: Total (%ld)\n", elevPrefix, wGetTimer()-time0 ) )
+ if ( log_dumpElev > 0 ) {
+ track_p trk;
+ DIST_T elev;
+ for ( trk=NULL; TrackIterate( &trk ); ) {
+ printf( "T%4.4d = ", GetTrkIndex(trk) );
+ if ( GetTrkOnElevPath( trk, &elev ) )
+ printf( "%d:%0.2f\n", GetTrkElevMode(trk), elev );
+ else
+ printf( "noelev\n" );
+#ifdef LATER
+ EPINX_T ep;
+ int mode;
+ for ( ep=0; ep<GetTrkEndPtCnt(trk); ep++ ) {
+ mode = GetTrkEndElevMode( trk, ep );
+ ComputeElev( trk, ep, FALSE, &elev, NULL );
+ printf( "T%4.4d[%2.2d] = %s:%0.3f\n",
+ GetTrkIndex(trk), ep,
+ mode==ELEV_NONE?"None":mode==ELEV_DEF?"Def":mode==ELEV_COMP?"Comp":
+ mode==ELEV_GRADE?"Grade":mode==ELEV_IGNORE?"Ignore":mode==ELEV_STATION?"Station":"???",
+ elev );
+ }
+#endif
+ }
+ }
+}
+
+
+static BOOL_T needElevUpdate = FALSE;
+EXPORT void UpdateAllElevations( void )
+{
+ int work;
+ long time0 = wGetTimer();
+
+ elevPrefix = "UPDELV";
+ if ( !log_fillElev_initted ) { log_fillElev = LogFindIndex( "fillElev" ); log_dumpElev = LogFindIndex( "dumpElev" ); log_fillElev_initted = TRUE; }
+ if (!needElevUpdate)
+ return;
+ work = FindObsoleteElevs();
+ if (!work)
+ return;
+ FindForks();
+ ComputeForkElev();
+ PropogateForkElevs();
+ PropogateDefElevs();
+ FindIslandElevs();
+ needElevUpdate = FALSE;
+LOG( log_fillElev, 1, ( "%s: Total (%ld)\n", elevPrefix, wGetTimer()-time0 ) )
+}
+
+
+EXPORT DIST_T GetElevation( track_p trk )
+{
+ DIST_T elev;
+
+ if ( !IsTrack(trk) ) {
+ return 0;
+ }
+ if ( GetTrkOnElevPath(trk,&elev) ) {
+ return elev;
+ }
+
+ elevPrefix = "GETELV";
+ if ( !log_fillElev_initted ) { log_fillElev = LogFindIndex( "fillElev" ); log_dumpElev = LogFindIndex( "dumpElev" ); log_fillElev_initted = TRUE; }
+ ClrAllTrkBits( TB_PROCESSED );
+ DYNARR_RESET( defelev_t, defelev_da );
+ FindAttachedDefElev( trk, TRUE );
+ /* at least one DevElev to be processed */
+ FindForks();
+ ComputeForkElev();
+ PropogateForkElevs();
+ PropogateDefElevs();
+ if ( GetTrkOnElevPath(trk,&elev) )
+ return elev;
+
+ ComputeIslandElev( trk );
+
+ if ( GetTrkOnElevPath(trk,&elev) )
+ return elev;
+
+ printf( "GetElevation(T%d) failed\n", GetTrkIndex(trk) );
+ return 0;
+}
+
+
+/*
+ * DYNAMIC ELEVATION COMPUTATION
+ *
+ * Utilities
+ *
+ */
+
+
+EXPORT void ClrTrkElev( track_p trk )
+{
+ needElevUpdate = TRUE;
+ DrawTrackElev( trk, &mainD, FALSE );
+ ClrTrkBits( trk, TB_ELEVPATH );
+}
+
+
+static void PropogateElevMode( track_p trk, DIST_T elev, int mode )
+{
+ int i1;
+ SurveyIsland( trk, FALSE );
+ for ( i1=0; i1<elist_da.cnt; i1++ )
+ SetTrkOnElevPath( elist(i1).trk, mode, elev );
+}
+
+
+static BOOL_T CheckForElevAlone( track_p trk )
+{
+ int i1;
+ SurveyIsland( trk, FALSE );
+ if ( pivot_da.cnt!=0 )
+ return FALSE;
+ for ( i1=0; i1<elist_da.cnt; i1++ )
+ SetTrkOnElevPath( elist(i1).trk, ELEV_ALONE, 0.0 );
+ return TRUE;
+}
+
+
+EXPORT void SetTrkElevModes( BOOL_T connect, track_p trk0, EPINX_T ep0, track_p trk1, EPINX_T ep1 )
+{
+ int mode0, mode1;
+ DIST_T elev, diff, elev0, elev1;
+ char * station;
+ BOOL_T update = TRUE;
+
+ mode0 = GetTrkElevMode( trk0 );
+ mode1 = GetTrkElevMode( trk1 );
+ if ( mode0 == ELEV_ALONE && mode1 == ELEV_ALONE ) {
+ update = FALSE;;
+ } else if ( connect ) {
+ if ( mode0 == ELEV_ALONE ) {
+ ComputeElev( trk1, ep1, FALSE, &elev, NULL );
+ PropogateElevMode( trk0, elev, ELEV_ISLAND );
+ update = FALSE;
+ } else if ( mode1 == ELEV_ALONE ) {
+ ComputeElev( trk0, ep0, FALSE, &elev, NULL );
+ PropogateElevMode( trk1, elev, ELEV_ISLAND );
+ update = FALSE;
+ }
+ } else {
+ if ( mode0 == ELEV_ISLAND ) {
+ if (CheckForElevAlone( trk0 ))
+ update = FALSE;
+ } else if ( mode1 == ELEV_ISLAND ) {
+ if (CheckForElevAlone( trk1 ))
+ update = FALSE;
+ }
+ }
+
+ if ( connect ) {
+ mode0 = GetTrkEndElevMode( trk0, ep0 );
+ mode1 = GetTrkEndElevMode( trk1, ep1 );
+ elev = 0.0;
+ station = NULL;
+ if (mode0 == ELEV_DEF && mode1 == ELEV_DEF) {
+ mode0 = GetTrkEndElevUnmaskedMode( trk0, ep0 ) | GetTrkEndElevUnmaskedMode( trk1, ep1 );
+ elev0 = GetTrkEndElevHeight( trk0, ep0 );
+ elev1 = GetTrkEndElevHeight( trk1, ep1 );
+ elev = (elev0+elev1)/2.0;
+ diff = fabs( elev0-elev1 );
+ if (diff>0.1)
+ ErrorMessage( MSG_JOIN_DIFFER_ELEV, PutDim(diff) );
+ } else if (mode0 == ELEV_DEF) {
+ mode0 = GetTrkEndElevUnmaskedMode( trk0, ep0 );
+ elev = GetTrkEndElevHeight( trk0, ep0 );
+ } else if (mode1 == ELEV_DEF) {
+ mode1 = GetTrkEndElevUnmaskedMode( trk1, ep1 );
+ elev = GetTrkEndElevHeight( trk1, ep1 );
+ } else if (mode0 == ELEV_STATION) {
+ station = GetTrkEndElevStation( trk0, ep0 );
+ } else if (mode1 == ELEV_STATION) {
+ station = GetTrkEndElevStation( trk1, ep1 );
+ mode0 = mode1;
+ } else if (mode0 == ELEV_GRADE) {
+ ;
+ } else if (mode1 == ELEV_GRADE) {
+ mode0 = mode1;
+ } else if (mode0 == ELEV_COMP) {
+ ;
+ } else if (mode1 == ELEV_COMP) {
+ mode0 = mode1;
+ } else {
+ ;
+ }
+ SetTrkEndElev( trk0, ep0, mode0, elev, station );
+ SetTrkEndElev( trk1, ep1, mode0, elev, station );
+ }
+
+ if (update) {
+ needElevUpdate = TRUE;
+ ClrTrkElev( trk0 );
+ ClrTrkElev( trk1 );
+ }
+}
+
+
+EXPORT void UpdateTrkEndElev(
+ track_p trk,
+ EPINX_T ep,
+ int newMode,
+ DIST_T newElev,
+ char * newStation )
+{
+ int oldMode;
+ DIST_T oldElev;
+ char * oldStation;
+ BOOL_T changed = TRUE;
+ track_p trk1;
+ EPINX_T ep1;
+
+ oldMode = GetTrkEndElevUnmaskedMode( trk, ep );
+ if ( (oldMode&ELEV_MASK) == (newMode&ELEV_MASK) ) {
+ switch ( (oldMode&ELEV_MASK) ) {
+ case ELEV_DEF:
+ oldElev = GetTrkEndElevHeight( trk, ep );
+ if ( oldElev == newElev ) {
+ if ( oldMode == newMode )
+ return;
+ changed = FALSE;
+ }
+ break;
+ case ELEV_STATION:
+ oldStation = GetTrkEndElevStation( trk, ep );
+ if ( strcmp( oldStation, newStation ) == 0 ) {
+ return;
+ }
+ break;
+ default:
+ return;
+ }
+ } else {
+ changed = TRUE;
+ if ( (newMode&ELEV_MASK)==ELEV_DEF || (oldMode&ELEV_MASK)==ELEV_DEF ||
+ (newMode&ELEV_MASK)==ELEV_IGNORE || (oldMode&ELEV_MASK)==ELEV_IGNORE )
+ changed = TRUE;
+ }
+ UndoModify( trk );
+ if ( (trk1 = GetTrkEndTrk( trk, ep )) ) {
+ UndoModify( trk1 );
+ }
+ DrawEndPt2( &mainD, trk, ep, drawColorWhite );
+ SetTrkEndElev( trk, ep, newMode, newElev, newStation );
+ DrawEndPt2( &mainD, trk, ep, drawColorBlack );
+ if ( changed ) {
+ ClrTrkElev( trk );
+ if ( trk1 ) {
+ ep1 = GetEndPtConnectedToMe( trk1, trk );
+ ClrTrkElev( trk1 );
+ }
+ UpdateAllElevations();
+ }
+}
+
+static void SetTrkOnElevPath( track_p trk, int mode, DIST_T elev )
+{
+ BOOL_T redraw = FALSE;
+ int oldMode = GetTrkElevMode( trk );
+ DIST_T oldElev;
+ coOrd hi, lo;
+
+ if ( !GetTrkOnElevPath( trk, &oldElev ) )
+ oldElev = 0.0;
+ GetBoundingBox( trk, &hi, &lo );
+ if ((labelEnable&LABELENABLE_TRACK_ELEV) &&
+ labelScale >= mainD.scale &&
+ (! OFF_MAIND( lo, hi ) ) &&
+ (GetTrkVisible(trk) || drawTunnel!=0/*DRAW_TUNNEL_NONE*/) &&
+ GetLayerVisible(GetTrkLayer(trk)) )
+ redraw = TRUE;
+
+ if ( (GetTrkBits(trk)&TB_ELEVPATH) && (oldElev == elev && oldMode == mode) )
+ return;
+ if ( redraw && (GetTrkBits(trk)&TB_ELEVPATH))
+ DrawTrackElev( trk, &mainD, FALSE );
+ SetTrkElev( trk, mode, elev );
+ if ( redraw )
+ DrawTrackElev( trk, &mainD, TRUE );
+}
+
+
+EXPORT void DrawTrackElev( track_cp trk, drawCmd_p d, BOOL_T drawIt )
+{
+ coOrd pos;
+ wFont_p fp;
+ wDrawColor color=(wDrawColor)0;
+ DIST_T elev;
+ coOrd lo, hi;
+
+ if ( (!IsTrack(trk)) ||
+ (!(labelEnable&LABELENABLE_TRACK_ELEV)) ||
+ (d == &mapD) ||
+ (labelScale < d->scale) ||
+ (!GetTrkOnElevPath( trk, &elev )) ||
+ ((GetTrkBits(trk)&TB_ELEVPATH) == 0) ||
+ (d->funcs->options & wDrawOptTemp) != 0 ||
+ (d->options & DC_QUICK) != 0 )
+ return;
+
+ if ( !GetCurveMiddle( trk, &pos ) ) {
+ GetBoundingBox( trk, &hi, &lo );
+ pos.x = (hi.x+lo.x)/2.0;
+ pos.y = (hi.y+lo.y)/2.0;
+ }
+ if ( d==&mainD && OFF_MAIND( pos, pos ) )
+ return;
+
+ switch ( GetTrkElevMode(trk) ) {
+ case ELEV_FORK:
+ color = drawColorBlue;
+ break;
+ case ELEV_BRANCH:
+ color = drawColorPurple;
+ break;
+ case ELEV_ISLAND:
+ color = drawColorGold;
+ break;
+ case ELEV_ALONE:
+ return;
+ }
+ if ( !drawIt )
+ color = wDrawColorWhite;
+ sprintf( message, "%s", FormatDistance(elev));
+ fp = wStandardFont( F_HELV, FALSE, FALSE );
+ DrawBoxedString( BOX_INVERT, d, pos, message, fp, (wFontSize_t)descriptionFontSize, color, 0 );
+}
+
+