From 7b358424ebad9349421acd533c2fa1cbf6cf3e3e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=B6rg=20Frings-F=C3=BCrst?= Date: Wed, 28 Dec 2016 16:52:56 +0100 Subject: Initial import of xtrkcad version 1:4.0.2-2 --- app/bin/tease.c | 1950 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1950 insertions(+) create mode 100644 app/bin/tease.c (limited to 'app/bin/tease.c') diff --git a/app/bin/tease.c b/app/bin/tease.c new file mode 100644 index 0000000..3667fe1 --- /dev/null +++ b/app/bin/tease.c @@ -0,0 +1,1950 @@ +/* + * $Header: /home/dmarkle/xtrkcad-fork-cvs/xtrkcad/app/bin/tease.c,v 1.2 2008-01-20 23:29:15 mni77 Exp $ + * + * TRANSISTION-CURVES (JOINTS) + * + */ + +/* 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. + */ + +/* + +Transistion-curves (aka joints or spirals) connect curves with different +radius (including straights which have infinite radius, indicated by radius=0). +The curve is described by 2 control parameters: R and L. +L is the length along the tangent of the curve and +R is the radius of an arc at the end of the curve. +At any point (l) along the tangent the arc at that point has radius +r=(R*L)/l. +The transition curve offset (x) is the closest distance between the arc +and the tangent. +The center of any arc is at (l/2, r+x). +See 'ComputeJointPos()' for details on this. + +Warning crude ascii graphics! + +a aa + aaa aaa * + aaaa aaaa * + aaaaa aaaaa *** + aaaaaaa aaaaaa **** + aaaaaaa aaaaaaa ***** + aaaaaaaaaaaaaaaaaaaa ****** + ^ ******* + x ******** + *******v* +0*****************************TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT + L/2 L + +'R' and 'L' are curve control parameters. +'0' is curve origin. +'**..TT' is tangent line. +'a' is arc with radius 'R'. +'*' is the transisition curve. +'x' is transisition curve offset. + +For a better representation of this, build 'testjoin' and +do 'testjoin psplot 10 10 40 1 | lpr -Ppostscript' +*/ + + +#include "track.h" +#include "ccurve.h" +#include "cstraigh.h" +#include "cjoin.h" +#include "i18n.h" + +static TRKTYP_T T_EASEMENT = -1; + +static ANGLE_T JOINT_ANGLE_INCR = 2.0; + +struct extraData { + DIST_T l0, l1; /* curve start and end parameter */ + DIST_T R, L; /* curve control parameters */ + BOOL_T flip; /* T: endPt[1] - is l0 */ + BOOL_T negate; /* T: curves to the left */ + BOOL_T Scurve; /* T: is an S-curve */ + coOrd pos; /* Pos of origin */ + ANGLE_T angle; /* Angle of curve tangent */ + }; + +#define xl0 extraData->l0 +#define xl1 extraData->l1 +#define xR extraData->R +#define xL extraData->L +#define xflip extraData->flip +#define xnegate extraData->negate +#define xScurve extraData->Scurve +#define xpos extraData->pos +#define xangle extraData->angle + +#define EASE_MIN_X (0.01) + +static int log_ease; +static int log_traverseJoint; + + +static DIST_T FindL( + DIST_T r, + DIST_T R, + DIST_T L ) +/* + * Given a radius (r) return control value (l). + * This function is it's inverse! + */ +{ + return (r==0.0)?L:(R*L)/r; +} + + +static void GetLandD( + DIST_T *RL, + DIST_T *RD, + coOrd q, + coOrd p, + ANGLE_T a, + DIST_T R, + DIST_T L, + BOOL_T negate, + BOOL_T Scurve ) +{ + DIST_T l, d, x; + + q.x -= p.x; + q.y -= p.y; + Rotate( &q, zero, -a ); + l = q.y; + x = (l*l*l)/(6*R*L); + if (!negate) { + d = q.x - x; + } else { + d = q.x + x; + } + if (RL) + *RL = l; + if (RD) + *RD = d; +} + + +int OLDEASE = 0; +static void ComputeJoinPos( + DIST_T l, + DIST_T R, + DIST_T L, + DIST_T *RR, + ANGLE_T *RA, + coOrd *P, + coOrd *PC ) +/* + * Compute position along transition-curve. + * Also compute angle and position of tangent circle's center. + */ +{ + ANGLE_T a; + DIST_T r; + coOrd pp, pc; + if (l==0.0) + r = 100000.0; + else + r = (R*L)/l; + pp.y = l; + pc.y = l/2.0; + a = asin( l/2.0 / r ); +if (OLDEASE){ + pc.x = l*l / (24*r) + r; + pp.x = pc.x - r*cos(a); +}else{ + pp.x = (l*l*l)/(6*R*L); + pc.x = pp.x + r*cos(a); +} +/*lprintf( "A %0.3f %0.3f %0.3f [%0.3f %0.3f]\n", a, aa, aaa, q.x, q.y );*/ + if (P) + *P = pp; + if (PC) + *PC = pc; + if (RR) + *RR = r; + if (RA) + *RA = R2D(a); +} + +static DIST_T JoinD( + DIST_T l, + DIST_T R, + DIST_T L ) +/* + * Compute distance from transition-curve origin to specified point. + * Distance is approximately equal to length of arc from origin + * to specified point with radius = 2.0 * radius at point. + * This is a very good approximation (< 0.1%). + */ +{ + DIST_T rr1, d1; + ANGLE_T a1; + coOrd p0; + DIST_T sign = 1; + if ( l < 0 ) { + sign = -1; + l = -l; + } + ComputeJoinPos( l, R, L, &rr1, NULL, &p0, NULL ); + rr1 *= 2.0; + a1=asin(sqrt(p0.x*p0.x + p0.y*p0.y)/2.0/rr1); + d1 = rr1 * a1 * 2.0; + return d1*sign; +} + + +static DIST_T GetLfromD( + DIST_T D, + DIST_T R, + DIST_T L ) +{ + DIST_T deltaD, d, l, deltaL; + l = L/2.0; + deltaL = L/4.0; + while ( deltaL>0.0001 ) { + d = JoinD(l,R,L); + if ( d < D ) { + deltaD = D-d; + } else { + deltaD = d-D; + } + if ( deltaD < 0.000001 ) + return l; + if ( d < D ) + l += deltaL; + else + l -= deltaL; + deltaL /= 2.0; + } +/*printf( "GetLfromD( %0.3f %0.3f %0.3f ) = %0.3f\n", D, R, L, l );*/ + return l; +} + + +#ifdef LATER +static void JoinDistance( + DIST_T r, + DIST_T R, + DIST_T X, + DIST_T L, + DIST_T *dr, + DIST_T *xr, + DIST_T *lr ) +{ + DIST_T l, d, rr; + coOrd p, pc; + if (r == 0.0) { + *dr = 0.0; + *lr = *xr = 0.0; + return; + } + l = FindL( r, R, L ); + d = JoinD( l, R, L ); + ComputeJoinPos( l, R, L, NULL, NULL, &p, NULL ); +LOG( log_ease, 2, ( "joinDistance r=%0.3f rr=%0.3f\n", r, rr ) ) + *xr = pc.x - rr; + *dr = d; + *lr = pc.y; +} +#endif + +EXPORT STATUS_T ComputeJoint( + DIST_T r0, + DIST_T r1, + easementData_t * e ) +/* + * Compute joint data given radius of the 2 curves being joined. + * Radius is =0 for straight tracks and <0 for left-handed curves. + * S-curves are handled by treating them as 2 transition-curves joined + * origin to origin. + */ +{ + DIST_T t, l0, l1, d0, d1, rr0, rr1, xx; + ANGLE_T a, a0, a1; + coOrd rp0, rpc0, rp1, rpc1; + +LOG( log_ease, 4, ( "ComputeJoint( %0.3f, %0.3f )\n", r0, r1 ) ) + + if (easementVal <= 0.1) { + e->d0 = e->d1 = e->x = 0.0; + return E_NOTREQ; + } + if (r0 != 0.0 && fabs(r0) < easeR) { + ErrorMessage( MSG_RADIUS_LSS_EASE_MIN, + FormatDistance(fabs(r0)), FormatDistance(easeR) ); + e->d0 = e->d1 = e->x = 0.0; + return E_ERROR; + } + if (r1 != 0.0 && fabs(r1) < easeR) { + ErrorMessage( MSG_RADIUS_LSS_EASE_MIN, FormatDistance(fabs(r1)), FormatDistance(easeR) ); + e->d0 = e->d1 = e->x = 0.0; + return E_ERROR; + } + if (r0 == 0.0 && r1 == 0.0) { + /* ASSERT( FALSE ); CHECKME */ + e->d0 = e->d1 = e->x = 0.0; + return E_NOTREQ; + } + e->r0 = r0; + e->r1 = r1; + e->Scurve = FALSE; + if ( ! ( (r0 >= 0 && r1 >= 0) || (r0 <= 0 && r1 <= 0) ) ) { + /* S-curve */ + e->Scurve = TRUE; + e->flip = FALSE; + e->negate = (r0 > 0.0); + l0 = FindL( fabs(r0), easeR, easeL ); + ComputeJoinPos( l0, easeR, easeL, &rr0, NULL, &rp0, &rpc0 ); + l1 = FindL( fabs(r1), easeR, easeL ); + ComputeJoinPos( l1, easeR, easeL, &rr1, NULL, &rp1, &rpc1 ); + rp1.x = - rp1.x; + rp1.y = - rp1.y; + rpc1.x = - rpc1.x; + rpc1.y = - rpc1.y; + xx = FindDistance(rpc0, rpc1) - rr0 - rr1; + a0 = NormalizeAngle( FindAngle(rpc0, rp0) - FindAngle(rpc0, rpc1) ); + a1 = NormalizeAngle( FindAngle(rpc1, rp1) - FindAngle(rpc1, rpc0) ); + d0 = fabs( rr0 * D2R(a0) ); + d1 = fabs( rr1 * D2R(a1) ); + } else { + /* ! S-curve */ + e->negate = ( (r0==0.0||r1==0.0)? r0>r1 : r0flip = FALSE; + if ( r1 == 0 || (r0 != 0 && r1 > r0 ) ) { + e->flip = TRUE; + t=r0; r0=r1; r1=t; + } + if (r0 == 0) { + if (r1 == 0) { + xx = l0 = l1 = d0 = d1 = 0.0; + } else { + l0 = 0.0; + l1 = FindL( r1, easeR, easeL ); + ComputeJoinPos( l1, easeR, easeL, &rr1, NULL, &rp1, &rpc1 ); + d0 = rpc1.y; + a1 = FindAngle(rpc1, rp1) - 270.0; + d1 = rr1 * D2R(a1); + xx = rpc1.x - rr1; + } + } else { + l0 = FindL( r0, easeR, easeL ); + ComputeJoinPos( l0, easeR, easeL, &rr0, NULL, &rp0, &rpc0 ); + l1 = FindL( r1, easeR, easeL ); + ComputeJoinPos( l1, easeR, easeL, &rr1, NULL, &rp1, &rpc1 ); + a = FindAngle( rpc0, rpc1 ); + a0 = a - FindAngle(rpc0, rp0);/*???*/ + a1 = FindAngle(rpc1, rp1) - a; + xx = rr0 - ( rr1 + FindDistance(rpc0, rpc1) ); + d0 = rr0 * D2R(a0); + d1 = rr1 * D2R(a1); + } + } +LOG( log_ease, 2, ( "CJoint(%0.3f %0.3f) l0=%0.3f d0=%0.3f l1=%0.3f d1=%0.3f x=%0.3f S%d F%d N%d\n", + e->r0, e->r1, l0, d0, l1, d1, xx, e->Scurve, e->flip, e->negate ) ) + if (xx < EASE_MIN_X || d0+d1<=minLength) { + e->d0 = e->d1 = e->x = 0.0; + return E_NOTREQ; + } else { + if (!e->flip) { + e->d0 = d0; + e->d1 = d1; + e->l0 = l0; + e->l1 = l1; + } else { + e->d0 = d1; + e->d1 = d0; + e->l0 = l1; + e->l1 = l0; + } + e->x = xx; + return E_REQ; + } +} + +static track_p NewJoint( + coOrd pos0, + ANGLE_T angle0, + coOrd pos1, + ANGLE_T angle1, + DIST_T trackGauge, + DIST_T R, + DIST_T L, + easementData_t * e ) +/* + * Allocate a joint track segment. + * Allocate a track, save relevant data from (*e), + * and compute origin and angle of transition-curve. + * Position is determined relative to endPoints. + */ +{ + track_p trk; + struct extraData *xx; + coOrd p, p0, p1, q0, q1; + static coOrd qZero = { 0.0, 0.0 }; + ANGLE_T az0, a01, b, b01, b1, d, d1; + trk = NewTrack( 0, T_EASEMENT, 2, sizeof *xx ); + SetTrkScale( trk, curScaleInx ); + xx = GetTrkExtraData( trk ); + SetTrkEndPoint( trk, 0, pos0, NormalizeAngle(angle0+180.0) ); + SetTrkEndPoint( trk, 1, pos1, NormalizeAngle(angle1+180.0) ); + xx->R = R; + xx->L = L; + xx->flip = e->flip; + xx->negate = e->negate; + xx->Scurve = e->Scurve; + if (!e->flip) { + xx->l0 = e->l0; + xx->l1 = e->l1; + p0 = pos0; + p1 = pos1; + } else { + xx->l0 = e->l1; + xx->l1 = e->l0; + p0 = pos1; + p1 = pos0; + } + ComputeJoinPos( xx->l0, R, L, NULL, NULL, &q0, NULL ); + ComputeJoinPos( xx->l1, R, L, NULL, NULL, &q1, NULL ); + if (e->negate) { + q0.x = -q0.x; + q1.x = -q1.x; + } + b01 = FindAngle( p0, p1 ); + if (!e->Scurve) { + az0 = FindAngle( qZero, q0 ); + a01 = FindAngle( q0, q1 ); + b1 = NormalizeAngle( b01 - (a01+az0) ); + b = NormalizeAngle( b01 - a01 ); + } else { + q1.x = -q1.x; + q1.y = -q1.y; + az0 = FindAngle( qZero, q0 ); + a01 = FindAngle( q0, q1 ); + b = NormalizeAngle( b01 - a01 ); + } + /*a = NormalizeAngle(a0+a1-90.0);*/ + p = q0; + Rotate( &p, qZero, b ); + xx->pos.x = p0.x - p.x; + xx->pos.y = p0.y - p.y; + xx->angle = b; + ComputeBoundingBox( trk ); + d = FindDistance( p0, p1 ); + d1 = FindDistance( q0, q1 ); +LOG( log_ease, 1, ( "NewJoint( [%0.3f %0.3f] A%0.3f, [%0.3f %0.3f] A%0.3f\n B01=%0.3f AZ0=%0.3f A01=%0.3f B=%0.3f D0=%0.3f D1=%0.3f\n", + pos0.x, pos0.y, angle0, pos1.x, pos1.y, angle1, + b01, az0, a01, b, d, d1 ) ) + CheckTrackLength( trk ); + return trk; +} + +/**************************************** + * + * GENERIC FUNCTIONS + * + */ + +static DIST_T GetLengthJoint( track_p trk ) +{ + struct extraData *xx; + DIST_T d0, d1; + xx = GetTrkExtraData(trk); + d0 = JoinD( xx->l0, xx->R, xx->L ); + d1 = JoinD( xx->l1, xx->R, xx->L ); + if (xx->Scurve) + return d0+d1; + else + return fabs( d0-d1 ); +} + + +static struct { + coOrd endPt[2]; + DIST_T elev[2]; + FLOAT_T length; + coOrd orig; + ANGLE_T angle; + DIST_T r; + DIST_T l; + DIST_T l0; + DIST_T l1; + FLOAT_T grade; + descPivot_t pivot; + LAYER_T layerNumber; + } jointData; +typedef enum { E0, Z0, E1, Z1, OR, AL, RR, LL, L0, L1, GR, PV, LY } jointDesc_e; +static descData_t jointDesc[] = { +/*E0*/ { DESC_POS, N_("End Pt 1: X"), &jointData.endPt[0] }, +/*Z0*/ { DESC_DIM, N_("Z"), &jointData.elev[0] }, +/*E1*/ { DESC_POS, N_("End Pt 2: X"), &jointData.endPt[1] }, +/*Z1*/ { DESC_DIM, N_("Z"), &jointData.elev[1] }, +/*OR*/ { DESC_POS, N_("Origin: X"), &jointData.orig }, +/*AL*/ { DESC_ANGLE, N_("Angle"), &jointData.angle }, +/*RR*/ { DESC_DIM, N_("R"), &jointData.r }, +/*LL*/ { DESC_DIM, N_("L"), &jointData.l }, +/*L0*/ { DESC_DIM, N_("l0"), &jointData.l0 }, +/*L1*/ { DESC_DIM, N_("l1"), &jointData.l1 }, +/*GR*/ { DESC_FLOAT, N_("Grade"), &jointData.grade }, +/*PV*/ { DESC_PIVOT, N_("Pivot"), &jointData.pivot }, +/*LY*/ { DESC_LAYER, N_("Layer"), &jointData.layerNumber }, + { DESC_NULL } }; + +static void UpdateJoint( track_p trk, int inx, descData_p descUpd, BOOL_T final ) +{ + EPINX_T ep; + switch (inx) { + case Z0: + case Z1: + ep = (inx==Z0?0:1); + UpdateTrkEndElev( trk, ep, GetTrkEndElevUnmaskedMode(trk,ep), jointData.elev[ep], NULL ); + ComputeElev( trk, 1-ep, FALSE, &jointData.elev[1-ep], NULL ); + if ( jointData.length > minLength ) + jointData.grade = fabs( (jointData.elev[0]-jointData.elev[1])/jointData.length )*100.0; + else + jointData.grade = 0.0; + jointDesc[GR].mode |= DESC_CHANGE; + jointDesc[inx==Z0?Z1:Z0].mode |= DESC_CHANGE; + return; + case LY: + SetTrkLayer( trk, jointData.layerNumber ); + break; + default: + return; + } +} + + +static void DescribeJoint( + track_p trk, + char * str, + CSIZE_T len ) +/* + * Print some interesting info about the track. + */ +{ + struct extraData *xx = GetTrkExtraData(trk); + int fix0, fix1; + + sprintf( str, _("Joint Track(%d): Layer=%d Length=%0.3f EP=[%0.3f,%0.3f A%0.3f] [%0.3f,%0.3f A%0.3f]"), GetTrkIndex(trk), + GetTrkLayer(trk)+1, + GetLengthJoint( trk ), + GetTrkEndPosXY(trk,0), GetTrkEndAngle(trk,0), + GetTrkEndPosXY(trk,1), GetTrkEndAngle(trk,1) ); + + fix0 = GetTrkEndTrk(trk,0)!=NULL; + fix1 = GetTrkEndTrk(trk,1)!=NULL; + + jointData.endPt[0] = GetTrkEndPos(trk,0); + jointData.endPt[1] = GetTrkEndPos(trk,1); + jointData.length = GetLengthJoint(trk); + jointData.orig = xx->pos; + jointData.angle = xx->angle; + jointData.r = xx->R; + jointData.l = xx->L; + jointData.l0 = xx->l0; + jointData.l1 = xx->l1; + jointData.layerNumber = GetTrkLayer(trk); + ComputeElev( trk, 0, FALSE, &jointData.elev[0], NULL ); + ComputeElev( trk, 1, FALSE, &jointData.elev[1], NULL ); + if ( jointData.length > minLength ) + jointData.grade = fabs( (jointData.elev[0]-jointData.elev[1])/jointData.length )*100.0; + else + jointData.grade = 0.0; + + jointDesc[E0].mode = + jointDesc[E1].mode = + jointDesc[OR].mode = + jointDesc[AL].mode = + jointDesc[RR].mode = + jointDesc[LL].mode = + jointDesc[L0].mode = + jointDesc[L1].mode = + DESC_RO; + jointDesc[Z0].mode = (EndPtIsDefinedElev(trk,0)?0:DESC_RO)|DESC_NOREDRAW; + jointDesc[Z1].mode = (EndPtIsDefinedElev(trk,1)?0:DESC_RO)|DESC_NOREDRAW; + jointDesc[GR].mode = DESC_RO; + jointDesc[PV].mode = (fix0|fix1)?DESC_IGNORE:0; + jointDesc[LY].mode = DESC_NOREDRAW; + jointData.pivot = (fix0&fix1)?DESC_PIVOT_NONE: + fix0?DESC_PIVOT_FIRST: + fix1?DESC_PIVOT_SECOND: + DESC_PIVOT_MID; + + DoDescribe( _("Easement Track"), trk, jointDesc, UpdateJoint ); +} + +static void GetJointPos( + coOrd * RP, + ANGLE_T * RA, + DIST_T l, + DIST_T R, + DIST_T L, + coOrd P, + ANGLE_T A, + BOOL_T N ) +/* + * Compute position of point on transition-curve. + */ +{ + coOrd p1; + static coOrd pZero = {0.0,0.0}; + ComputeJoinPos( l, R, L, NULL, RA, &p1, NULL ); + if (N) + p1.x = -p1.x; + Rotate( &p1, pZero, A ); + if (RP) { + RP->x = P.x + p1.x; + RP->y = P.y + p1.y; + } + if (RA) + *RA = NormalizeAngle( A + (N?-*RA:*RA) ); +} + + +EXPORT DIST_T JointDistance( + coOrd * q, + coOrd pos, + ANGLE_T angle, + DIST_T l0, + DIST_T l1, + DIST_T R, + DIST_T L, + BOOL_T negate, + BOOL_T Scurve ) +{ + DIST_T d, l; + coOrd p0 = *q; + GetLandD( &l, &d, p0, pos, angle, R, L, negate, Scurve ); + if (Scurve) { + if ( l < -l1 ) + l = -l1; + else if ( l > l0 ) + l = l0; + } else { + if ( l < l0 ) + l = l0; + else if ( l > l1 ) + l = l1; + } + GetJointPos( q, NULL, l, R, L, pos, angle, negate ); + d = FindDistance( p0, *q ); + return d; +} + + +static DIST_T DistanceJoint( + track_p trk, + coOrd * p ) +/* + * Determine how close (p) is to (t). + */ +{ + struct extraData * xx = GetTrkExtraData(trk); + return JointDistance( p, xx->pos, xx->angle, xx->l0, xx->l1, xx->R, xx->L, xx->negate, xx->Scurve ); +} + + +#ifdef LATER +static void DrawJointSegment1( + drawCmd_p d, + wIndex_t cnt, + DIST_T l0, + DIST_T l1, + DIST_T R, + DIST_T L, + coOrd P, + ANGLE_T A, + BOOL_T N, + track_p trk, + DIST_T trackGauge, + wDrawColor color ) +/* + * Draw a transition-curve from (l0) to (l1), + * at angle (A) from origin (P). + */ +{ + DIST_T l, lincr; + wIndex_t i; + coOrd p0, p1; + long widthOptions = DTS_RIGHT|DTS_LEFT|DTS_TIES; + + if (GetTrkWidth(trk) == 2) + widthOptions |= DTS_THICK2; + if (GetTrkWidth(trk) == 3) + widthOptions |= DTS_THICK3; + + l = l0; + lincr = (l1-l0)/cnt; + GetJointPos( &p0, NULL, l0, R, L, P, A, N ); + for (i=1; i<=cnt; i++) { + l += lincr; + GetJointPos( &p1, NULL, l, R, L, P, A, N ); + DrawStraightTrack( d, p0, p1, + FindAngle( p1, p0 ), trk, trackGauge, color, widthOptions ); + p0 = p1; + } +} +#endif + +static void DrawJointSegment( + drawCmd_p d, + wIndex_t cnt, + DIST_T l0, + DIST_T l1, + DIST_T R, + DIST_T L, + coOrd P, + ANGLE_T A, + BOOL_T N, + DIST_T trackGauge, + wDrawColor color, + long widthOptions, + track_p trk ) +/* + * Draw a transition-curve from (l0) to (l1), + * at angle (A) from origin (P). + */ +{ + DIST_T ll; + wIndex_t i; + coOrd p0, p1; + ANGLE_T a0, a1; + int cnt1; + + ComputeJoinPos( l0, R, L, NULL, &a0, NULL, NULL ); + ComputeJoinPos( l1, R, L, NULL, &a1, NULL, NULL ); + a1 = a1-a0; + if ( (d->options&DC_QUICK) ) { + cnt1 = 1; + } else { + cnt1 = (int)floor(a1/JOINT_ANGLE_INCR) + 1; + a1 /= cnt1; + } + + widthOptions |= DTS_RIGHT|DTS_LEFT|DTS_TIES; + GetJointPos( &p0, NULL, l0, R, L, P, A, N ); + for (i=1; i<=cnt1; i++) { + a0 += a1; + ll = sqrt( sin(D2R(a0)) * 2 * R * L ); + GetJointPos( &p1, NULL, ll, R, L, P, A, N ); + DrawStraightTrack( d, p0, p1, FindAngle( p1, p0 ), trk, trackGauge, + color, widthOptions ); + p0 = p1; + } +} + + +EXPORT coOrd GetJointSegEndPos( + coOrd pos, + ANGLE_T angle, + DIST_T l0, + DIST_T l1, + DIST_T R, + DIST_T L, + BOOL_T negate, + BOOL_T flip, + BOOL_T Scurve, + EPINX_T ep, + ANGLE_T * angleR ) +{ + coOrd p1; + DIST_T ll; + if ( flip ) ep = 1-ep; + ll = (ep==0?l0:l1); + if ( Scurve ) { + if ( ep==1 ) + angle += 180; + } + GetJointPos( &p1, &angle, ll, R, L, pos, angle, negate ); + if ( angleR ) { + if ( (!Scurve) && ep==0 ) + angle = NormalizeAngle(angle+180); + *angleR = angle; + } + return p1; +} + + +EXPORT void DrawJointTrack( + drawCmd_p d, + coOrd pos, + ANGLE_T angle, + DIST_T l0, + DIST_T l1, + DIST_T R, + DIST_T L, + BOOL_T negate, + BOOL_T flip, + BOOL_T Scurve, + track_p trk, + EPINX_T ep0, + EPINX_T ep1, + DIST_T trackGauge, + wDrawColor color, + long options ) +{ + wIndex_t cnt; + DIST_T len; + trkSeg_p segPtr; + + if ( (d->options&DC_SEGTRACK) ) { + DYNARR_APPEND( trkSeg_t, tempSegs_da, 10 ); + segPtr = &tempSegs(tempSegs_da.cnt-1); + segPtr->type = SEG_JNTTRK; + segPtr->width = 0; + segPtr->color = wDrawColorBlack; + segPtr->u.j.pos = pos; + segPtr->u.j.angle = angle; + segPtr->u.j.l0 = l0; + segPtr->u.j.l1 = l1; + segPtr->u.j.R = R; + segPtr->u.j.L = L; + segPtr->u.j.negate = negate; + segPtr->u.j.flip = flip; + segPtr->u.j.Scurve = Scurve; + return; + } +LOG( log_ease, 4, ( "DJT( (X%0.3f Y%0.3f A%0.3f) \n", pos.x, pos.y, angle ) ) +#ifdef LATER + scale2rail = (d->options&DC_PRINT)?(twoRailScale*2+1):twoRailScale; + + if (options&DTS_THICK2) + width = 2; + if (options&DTS_THICK3) + width = 3; +#ifdef WINDOWS + width *= (wDrawWidth)(d->dpi/mainD.dpi); +#else + if (d->options&DC_PRINT) + width *= 300/75; +#endif +#endif + if (color == wDrawColorBlack) + color = normalColor; + if (!Scurve) { + /* print segments about 0.20" long */ + len = (l0-l1)/(0.20*d->scale); + cnt = (int)ceil(fabs(len)); + if (cnt == 0 || (d->options&DC_QUICK)) cnt = 1; + DrawJointSegment( d, cnt, l0, l1, R, L, pos, + angle, negate, trackGauge, color, options, trk ); + } else { + /* print segments about 0.20" long */ + cnt = (int)ceil((l0)/(0.20*d->scale)); + if (cnt == 0 || (d->options&DC_QUICK)) cnt = 1; + DrawJointSegment( d, cnt, 0, l0, R, L, pos, + angle, negate, trackGauge, color, options, trk ); + cnt = (int)ceil((l1)/(0.20*d->scale)); + if (cnt == 0 || (d->options&DC_QUICK)) cnt = 1; + DrawJointSegment( d, cnt, 0, l1, R, L, pos, + angle+180, negate, trackGauge, color, options, trk ); + } + if ( (d->funcs->options & wDrawOptTemp) == 0 && (d->options&DC_QUICK) == 0 ) { + DrawEndPt( d, trk, ep0, color ); + DrawEndPt( d, trk, ep1, color ); + } +} + + +static void DrawJoint( + track_p trk, + drawCmd_p d, + wDrawColor color ) +/* + * Draw a transition-curve. + */ +{ + struct extraData * xx = GetTrkExtraData(trk); + long widthOptions = 0; + + if (GetTrkWidth(trk) == 2) + widthOptions = DTS_THICK2; + if (GetTrkWidth(trk) == 3) + widthOptions = DTS_THICK3; + DrawJointTrack( d, xx->pos, xx->angle, xx->l0, xx->l1, xx->R, xx->L, xx->negate, xx->flip, xx->Scurve, trk, 0, 1, GetTrkGauge(trk), color, widthOptions ); +} + + +static void DeleteJoint( + track_p t ) +/* Delete track - nothing to do */ +{ +} + +static BOOL_T WriteJoint( + track_p t, + FILE * f ) +/* + * Write track data to a file (f). + */ +{ + struct extraData * xx = GetTrkExtraData(t); + BOOL_T rc = TRUE; + rc &= fprintf(f, "JOINT %d %d %ld 0 0 %s %d %0.6f %0.6f %0.6f %0.6f %d %d %d %0.6f %0.6f 0 %0.6f\n", + GetTrkIndex(t), GetTrkLayer(t), (long)GetTrkWidth(t), + GetTrkScaleName(t), GetTrkVisible(t), xx->l0, xx->l1, xx->R, xx->L, + xx->flip, xx->negate, xx->Scurve, xx->pos.x, xx->pos.y, xx->angle )>0; + rc &= WriteEndPt( f, t, 0 ); + rc &= WriteEndPt( f, t, 1 ); + rc &= fprintf(f, "\tEND\n" )>0; + return rc; +} + +static void ReadJoint( + char * line ) +/* + * Read track data from a file (f). + */ +{ + track_p trk; + TRKINX_T index; + BOOL_T visible; + struct extraData e, *xx; + char scale[10]; + wIndex_t layer; + long options; + DIST_T elev; + + if ( !GetArgs( line+6, paramVersion<3?"dXZsdffffdddpYf":paramVersion<9?"dLl00sdffffdddpYf":"dLl00sdffffdddpff", + &index, &layer, &options, scale, &visible, &e.l0, &e.l1, &e.R, &e.L, + &e.flip, &e.negate, &e.Scurve, &e.pos, &elev, &e.angle) ) + return; + trk = NewTrack( index, T_EASEMENT, 0, sizeof e ); + xx = GetTrkExtraData(trk); + SetTrkVisible(trk, visible); + SetTrkScale(trk, LookupScale(scale)); + SetTrkLayer(trk, layer); + SetTrkWidth(trk, (int)(options&3)); + *xx = e; + ReadSegs(); + SetEndPts( trk, 2 ); + ComputeBoundingBox( trk ); +} + +static void MoveJoint( + track_p trk, + coOrd orig ) +/* + * Move a track. + */ +{ + struct extraData * xx = GetTrkExtraData(trk); + xx->pos.x += orig.x; + xx->pos.y += orig.y; + ComputeBoundingBox( trk ); +} + +static void RotateJoint( + track_p trk, + coOrd orig, + ANGLE_T angle ) +/* + * Rotate a track. + */ +{ + struct extraData * xx = GetTrkExtraData(trk); + Rotate( &xx->pos, orig, angle ); + xx->angle = NormalizeAngle( xx->angle+angle ); + ComputeBoundingBox( trk ); +} + + +static void RescaleJoint( track_p trk, FLOAT_T ratio ) +{ + struct extraData *xx = GetTrkExtraData(trk); + xx->pos.x *= ratio; + xx->pos.y *= ratio; + xx->R *= ratio; + xx->L *= ratio; + xx->l0 *= ratio; + xx->l1 *= ratio; +} + + +static ANGLE_T GetAngleJoint( track_p trk, coOrd pos, EPINX_T * ep0, EPINX_T * ep1 ) +{ + struct extraData * xx = GetTrkExtraData(trk); + DIST_T l; + ANGLE_T a; + if ( ep0 && ep1 ) { + if (xx->flip) { + *ep0 = 1; + *ep1 = 0; + } else { + *ep0 = 0; + *ep1 = 1; + } + } + GetLandD( &l, NULL, pos, xx->pos, xx->angle, xx->R, xx->L, xx->negate, xx->Scurve ); + if (small(l)) { + a = xx->angle; + } else { +/* if (xx->Scurve && NormalizeAngle(FindAngle(xx->pos,pos)-xx->angle+90.0) > 180.0)*/ + if (xx->Scurve && l < 0.0) { + GetJointPos( NULL, &a, -l, xx->R, xx->L, xx->pos, xx->angle+180.0, xx->negate ); + a = NormalizeAngle( a-180.0 ); + } else { + GetJointPos( NULL, &a, l, xx->R, xx->L, xx->pos, xx->angle, xx->negate ); + } + } + return NormalizeAngle(a+180.0); +} + + +static void SplitJointA( + coOrd * posR, + EPINX_T ep, + struct extraData * xx, + struct extraData * xx1, + ANGLE_T * aR ) +{ + struct extraData * xx0; + BOOL_T flip; + DIST_T l; + + *xx1 = *xx; + if ( (ep==1) == (!xx->flip) ) { + xx0 = xx; + flip = FALSE; + } else { + xx0 = xx1; + xx1 = xx; + flip = TRUE; + } + GetLandD( &l, NULL, *posR, xx->pos, xx->angle, xx->R, xx->L, xx->negate, xx->Scurve ); + + if (!xx->Scurve) { + if (l < xx->l0 || l > xx->l1) { + NoticeMessage2( 0, "splitJoint: ! %0.3f <= %0.3f <= %0.3f", _("Ok"), NULL, xx->l0, l, xx->l1 ); + if ( l < xx->l0 ) l = xx->l0; + else if ( l > xx->l1 ) l = xx->l1; + } + GetJointPos( posR, aR, l, xx->R, xx->L, xx->pos, xx->angle, xx->negate ); + xx0->l1 = xx1->l0 = l; + } else if (small(l)){ + xx0->Scurve = xx1->Scurve = 0; + xx0->l1 = xx0->l0; + xx0->flip = !xx0->flip; + xx1->angle = NormalizeAngle(xx1->angle+180.0); + xx0->l0 = xx1->l0 = 0; + *posR = xx->pos; + *aR = xx1->angle; + } else { + GetJointPos( posR, aR, l, xx->R, xx->L, xx->pos, xx->angle, xx->negate ); + if (l > 0) { + xx0->Scurve = 0; + xx0->l1 = xx0->l0; + xx0->flip = !xx0->flip; + xx0->l0 = l; + xx1->l0 = l; + } else { + xx1->Scurve = 0; + xx1->l0 = -l; + xx1->angle = NormalizeAngle( xx1->angle+180.0 ); + xx0->l1 = -l; + } + *aR = NormalizeAngle( *aR+180.0 ); + } + if (flip) + *aR = NormalizeAngle( *aR + 180.0 ); +} + + +static BOOL_T SplitJoint( track_p trk, coOrd pos, EPINX_T ep, track_p * leftover, EPINX_T *ep0, EPINX_T *ep1 ) +{ + struct extraData *xx, *xx1; + track_p trk1; + ANGLE_T a; + + xx = GetTrkExtraData(trk); + trk1 = NewTrack( 0, T_EASEMENT, 2, sizeof *xx ); + xx1 = GetTrkExtraData(trk1); + *xx1 = *xx; + SetTrkEndPoint( trk1, ep, GetTrkEndPos(trk,ep), GetTrkEndAngle(trk,ep) ); + *leftover = trk1; + *ep0 = 1-ep; + *ep1 = ep; + SplitJointA( &pos, ep, xx, xx1, &a ); + SetTrkEndPoint( trk, ep, pos, a ); + SetTrkEndPoint( trk1, 1-ep, pos, NormalizeAngle(a+180.0) ); + + ComputeBoundingBox( trk ); + ComputeBoundingBox( trk1 ); + return TRUE; +} + + +static BOOL_T TraverseJoint( + coOrd * posR, + ANGLE_T *angleR, + DIST_T *distR, + coOrd pos, + ANGLE_T angle, + DIST_T l0, + DIST_T l1, + DIST_T R, + DIST_T L, + BOOL_T negate, + BOOL_T flip, + BOOL_T Scurve ) +{ + + DIST_T l, lx, d, dx, ll0, ll1, d0, d1; + BOOL_T from_tangent, flip_angle; + + GetLandD( &l, &d, *posR, pos, angle, R, L, negate, Scurve ); + +LOG( log_traverseJoint, 2, ( "TJ: [%0.3f %0.3f] D%0.3f l0:%0.3f l1:%0.3f [%0.3f %0.3f] A%0.3f N%d F%d S%d = l:%0.3f ", + posR->x, posR->y, *distR, l0, l1, pos.x, pos.y, angle, negate, flip, Scurve, l ) ) + + if ( (!Scurve) ) { + if ( l < l0 ) l = l0; + else if ( l > l1 ) l = l1; + } else { + if ( l > l0 ) l = l0; + else if ( l < -l1 ) l = -l1; + } + + lx = l; + from_tangent = !flip; + flip_angle = from_tangent; + if ( !Scurve ) { + ll0 = l0; + ll1 = l1; + } else if ( l > 0 ) { + ll1 = l0; + ll0 = 0; + } else { + ll0 = 0; + ll1 = l1; + lx = -l; + from_tangent = !from_tangent; + } + dx = JoinD( lx, R, L ); + d0 = JoinD( ll0, R, L ); + d1 = JoinD( ll1, R, L ); + if ( from_tangent ) + d = d1 - dx; + else + d = dx - d0; + if ( *distR < d ) { + if ( from_tangent ) { + d = dx + *distR; + } else { + d = dx - *distR; + } + lx = GetLfromD( d, R, L ); + if ( l < 0 ) + lx = - lx; + /* compute posR and angleR */ + GetJointPos( posR, angleR, lx, R, L, pos, angle, negate ); + if ( ! flip_angle ) + *angleR = NormalizeAngle( *angleR + 180.0 ); + *distR = 0; + goto doreturn; + } + *distR -= d; + if ( Scurve && (!from_tangent) ) { + /* skip over midpoint */ + if ( l > 0 ) + d = JoinD( l1, R, L ); + else + d = JoinD( l0, R, L ); + if ( *distR < d ) { + lx = GetLfromD( *distR, R, L ); + if ( l > 0 ) + lx = - lx; + GetJointPos( posR, angleR, lx, R, L, pos, angle, negate ); + if ( ! flip_angle ) + *angleR = NormalizeAngle( *angleR + 180.0 ); + *distR = 0; + goto doreturn; + } + *distR -= d; + } +doreturn: +LOG( log_traverseJoint, 2, ( " [%0.3f %0.3f] A%0.3f D%0.3f\n", posR->x, posR->y, *angleR, *distR ) ) + return TRUE; +} + + +static BOOL_T TraverseJointTrack( + traverseTrack_p trvTrk, + DIST_T * distR ) +{ + track_p trk = trvTrk->trk; + struct extraData * xx = GetTrkExtraData(trk); + BOOL_T rc; + EPINX_T ep; + ANGLE_T angle; + BOOL_T flip; + + angle = NormalizeAngle( xx->angle-trvTrk->angle ); + flip = ( angle < 270 && angle > 90 ); + rc = TraverseJoint( &trvTrk->pos, &trvTrk->angle, distR, xx->pos, xx->angle, xx->l0, xx->l1, xx->R, xx->L, xx->negate, flip, xx->Scurve ); + if ( *distR > 0 ) { + ep = (flip?0:1); + if ( xx->flip ) + ep = 1-ep; + if ( xx->Scurve ) + ep = 1-ep; + trvTrk->pos = GetTrkEndPos( trk, ep ); + trvTrk->angle = GetTrkEndAngle( trk, ep ); + trvTrk->trk = GetTrkEndTrk( trk, ep ); + } + return rc; +} + + +static BOOL_T EnumerateJoint( track_p trk ) +{ + if (trk != NULL) { + ScaleLengthIncrement( GetTrkScale(trk), GetLengthJoint(trk) ); + } + return TRUE; +} + +static BOOL_T TrimJoint( track_p trk, EPINX_T ep, DIST_T maxX ) +{ + DeleteTrack( trk, FALSE ); + return TRUE; +} + + +static BOOL_T MergeJoint( + track_p trk0, + EPINX_T ep0, + track_p trk1, + EPINX_T ep1 ) +{ + track_p trk2; + EPINX_T ep2=-1; + coOrd pos; + ANGLE_T a; + struct extraData *xx0 = GetTrkExtraData(trk0); + struct extraData *xx1 = GetTrkExtraData(trk1); + + if ( ep0 == ep1 ) + return FALSE; + if ( xx0->R != xx1->R || + xx0->L != xx1->L || + xx0->flip != xx1->flip || + xx0->negate != xx1->negate || + xx0->angle != xx1->angle || + xx0->Scurve || + xx1->Scurve || + FindDistance( xx0->pos, xx1->pos ) > connectDistance ) + return FALSE; + + UndoStart( _("Merge Easements"), "MergeJoint( T%d[%d] T%d[%d] )", GetTrkIndex(trk0), ep0, GetTrkIndex(trk1), ep1 ); + UndoModify( trk0 ); + UndrawNewTrack( trk0 ); + trk2 = GetTrkEndTrk( trk1, 1-ep1 ); + if (trk2) { + ep2 = GetEndPtConnectedToMe( trk2, trk1 ); + DisconnectTracks( trk1, 1-ep1, trk2, ep2 ); + } + + if (ep0 == 0) { + xx0->l0 = xx1->l0; + } else { + xx0->l1 = xx1->l1; + } + + pos = GetTrkEndPos( trk1, 1-ep1 ); + a = GetTrkEndAngle( trk1, 1-ep1 ); + SetTrkEndPoint( trk0, ep0, pos, a ); + ComputeBoundingBox( trk0 ); + + DeleteTrack( trk1, TRUE ); + if (trk2) { + ConnectTracks( trk0, ep0, trk2, ep2 ); + } + DrawNewTrack( trk0 ); + return TRUE; +} + + +static BOOL_T GetParamsJoint( int inx, track_p trk, coOrd pos, trackParams_t * params ) +{ + params->type = curveTypeStraight; + params->ep = PickUnconnectedEndPoint( pos, trk ); + if (params->ep == -1) + return FALSE; + params->lineOrig = GetTrkEndPos(trk,params->ep); + params->lineEnd = params->lineOrig; + params->angle = GetTrkEndAngle(trk,params->ep); + params->len = 0.0; + params->arcR = 0.0; + return TRUE; +} + + +static BOOL_T MoveEndPtJoint( track_p *trk, EPINX_T *ep, coOrd pos, DIST_T d ) +{ + return FALSE; +} + + +static BOOL_T QueryJoint( track_p trk, int query ) +{ + struct extraData * xx = GetTrkExtraData(trk); + track_p trk1; + + switch ( query ) { + case Q_CANNOT_BE_ON_END: + case Q_IGNORE_EASEMENT_ON_EXTEND: + case Q_ISTRACK: + return TRUE; + case Q_CAN_PARALLEL: + if ( xx->Scurve ) { + if ( FindDistance( xx->pos, GetTrkEndPos(trk,0) ) <= minLength || + FindDistance( xx->pos, GetTrkEndPos(trk,1) ) <= minLength ) + return FALSE; + UndoStart( _("Split Easement Curve"), "queryJoint T%d Scurve", GetTrkIndex(trk) ); + SplitTrack( trk, xx->pos, 0, &trk1, FALSE ); + } + return TRUE; + default: + return FALSE; + } +} + + +static void FlipJoint( + track_p trk, + coOrd orig, + ANGLE_T angle ) +{ + struct extraData * xx = GetTrkExtraData(trk); + FlipPoint( &xx->pos, orig, angle ); + xx->angle = NormalizeAngle( 2*angle - xx->angle ); + xx->negate = !xx->negate; + ComputeBoundingBox( trk ); +} + + +static BOOL_T MakeParallelJoint( + track_p trk, + coOrd pos, + DIST_T sep, + track_p * newTrkR, + coOrd * p0R, + coOrd * p1R ) +{ + struct extraData * xx = GetTrkExtraData(trk), *xx1; + ANGLE_T angle, A; + coOrd p0, p1, P, q1, r1; + DIST_T d, d0; + DIST_T R, L, l0, l1, len, dl; + int cnt, inx; + + if ( xx->Scurve ) + return FALSE; + GetLandD( NULL, &d, pos, xx->pos, xx->angle, xx->R, xx->L, xx->negate, FALSE ); + angle = 90.0; + if ( (d < 0) == xx->negate ) + sep = -sep; + if ( xx->negate ) + angle = -90.0; + if ( xx->flip ) + angle = -angle; + p0 = GetTrkEndPos(trk,0); + p1 = GetTrkEndPos(trk,1); + d0 = FindDistance( p0, p1 ); + Translate( &p0, p0, GetTrkEndAngle(trk,0)+angle, sep ); + Translate( &p1, p1, GetTrkEndAngle(trk,1)-angle, sep ); + d = FindDistance( p0, p1 ); + angle = R2D(asin(xx->L/2/xx->R)); + A = xx->angle; + R = xx->R + sep*sin(D2R(angle)); + + dl = JoinD( xx->l1, xx->R, xx->L ) - JoinD( xx->l0, xx->R, xx->L ); +/*printf( "D = %0.3f %0.3f\n", d, dl );*/ + d /= d0; + R = xx->R * d; + L = xx->L * d; + l0 = xx->l0 * d; + l1 = xx->l1 * d; +/*printf( " R=%0.3f, L=%0.3f, l0=%0.3f, l1=%0.3f\n", R, L, l0, l1 );*/ + Translate( &P, xx->pos, xx->angle+(xx->negate?90:-90), sep ); + ComputeJoinPos( l1, R, L, NULL, NULL, &q1, NULL ); + r1 = (xx->flip?p0:p1); + r1.x -= P.x; + r1.y -= P.y; + Rotate( &r1, zero, -A ); + if ( xx->negate ) + r1.x = -r1.x; + if ( r1.x > 0 && q1.x > 0 ) { +/*printf( " %0.3f %0.3f, R=%0.3f ", q1.x, r1.x, R );*/ + R *= q1.x/r1.x; +/*printf( " %0.3f\n", R );*/ + } + + if ( newTrkR ) { + *newTrkR = NewTrack( 0, T_EASEMENT, 2, sizeof *xx ); + xx1 = GetTrkExtraData( *newTrkR ); + *xx1 = *xx; + xx1->angle = A; + xx1->R = R; + xx1->L = L; + xx1->l0 = l0; + xx1->l1 = l1; + xx1->pos = P; + SetTrkEndPoint( *newTrkR, 0, p0, GetTrkEndAngle(trk,0) ); + SetTrkEndPoint( *newTrkR, 1, p1, GetTrkEndAngle(trk,1) ); + ComputeBoundingBox( *newTrkR ); + } else { + /* print segments about 0.20" long */ + dl = fabs(l0-l1); + len = dl/(0.20*mainD.scale); + cnt = (int)ceil(len); + if (cnt == 0 || (mainD.options&DC_QUICK)) cnt = 1; + dl /= cnt; + DYNARR_SET( trkSeg_t, tempSegs_da, cnt ); + for ( inx=0; inxnegate ); + } else { + tempSegs(inx).u.l.pos[0] = tempSegs(inx-1).u.l.pos[1]; + } + l0 += dl; + GetJointPos( &tempSegs(inx).u.l.pos[1], NULL, l0, R, L, P, A, xx->negate ); + } + tempSegs_da.cnt = cnt; + } + if ( p0R ) *p0R = p0; + if ( p1R ) *p1R = p1; + return TRUE; +} + + +static trackCmd_t easementCmds = { + "JOINT", + DrawJoint, + DistanceJoint, + DescribeJoint, + DeleteJoint, + WriteJoint, + ReadJoint, + MoveJoint, + RotateJoint, + RescaleJoint, + NULL, /* audit */ + GetAngleJoint, + SplitJoint, + TraverseJointTrack, + EnumerateJoint, + NULL, /* redraw */ + TrimJoint, + MergeJoint, + ExtendStraightFromOrig, + GetLengthJoint, + GetParamsJoint, + MoveEndPtJoint, + QueryJoint, + NULL, /* ungroup */ + FlipJoint, + NULL, + NULL, + NULL, + MakeParallelJoint }; + + +EXPORT void JointSegProc( + segProc_e cmd, + trkSeg_p segPtr, + segProcData_p data ) +{ + DIST_T l; + ANGLE_T a; + BOOL_T flip; + struct extraData * xx, xxx[2]; + coOrd p; + int inx; + EPINX_T ep0; + + switch (cmd) { + + case SEGPROC_TRAVERSE1: + GetLandD( &l, NULL, data->traverse1.pos, segPtr->u.j.pos, segPtr->u.j.angle, segPtr->u.j.R, segPtr->u.j.L, segPtr->u.j.negate, segPtr->u.j.Scurve ); + if (small(l)) { + a = segPtr->u.j.angle; + } else { + if (segPtr->u.j.Scurve && l < 0.0) { + GetJointPos( NULL, &a, -l, segPtr->u.j.R, segPtr->u.j.L, segPtr->u.j.pos, segPtr->u.j.angle+180.0, segPtr->u.j.negate ); + a = NormalizeAngle( a-180.0 ); + } else { + GetJointPos( NULL, &a, l, segPtr->u.j.R, segPtr->u.j.L, segPtr->u.j.pos, segPtr->u.j.angle, segPtr->u.j.negate ); + } + } + a = NormalizeAngle( data->traverse1.angle+a ); + data->traverse1.backwards = (a < 270 && a > 90 ); + if ( !segPtr->u.j.Scurve ) { + if ( data->traverse1.backwards==0 ) + data->traverse1.dist = JoinD( l, segPtr->u.j.R, segPtr->u.j.L ) - JoinD( segPtr->u.j.l0, segPtr->u.j.R, segPtr->u.j.L ); + else + data->traverse1.dist = JoinD( segPtr->u.j.l1, segPtr->u.j.R, segPtr->u.j.L ) - JoinD( l, segPtr->u.j.R, segPtr->u.j.L ); + } else { + data->traverse1.backwards = !data->traverse1.backwards; + if ( data->traverse1.backwards==0 ) + data->traverse1.dist = JoinD( segPtr->u.j.l0, segPtr->u.j.R, segPtr->u.j.L ) - JoinD( l, segPtr->u.j.R, segPtr->u.j.L ); + else + data->traverse1.dist = JoinD( segPtr->u.j.l1, segPtr->u.j.R, segPtr->u.j.L ) + JoinD( l, segPtr->u.j.R, segPtr->u.j.L ); + } + if ( segPtr->u.j.flip ) + data->traverse1.backwards = !data->traverse1.backwards; +LOG( log_traverseJoint, 1, ( "TJ0: ?[%0.3f %0.3f] A=%0.3f l=%0.3f J[%0.3f %0.3f] A=%0.3f l0=%0.3f l1=%0.3f R=%0.3f L=%0.3f N:%d F:%d S:%d = a=%0.3f D=%0.3f B=%d\n", + data->traverse1.pos.x, data->traverse1.pos.y, data->traverse1.angle, + l, + segPtr->u.j.pos.x, segPtr->u.j.pos.y, segPtr->u.j.angle, + segPtr->u.j.l0, segPtr->u.j.l1, segPtr->u.j.R, segPtr->u.j.L, + segPtr->u.j.negate, segPtr->u.j.flip, segPtr->u.j.Scurve, + a, data->traverse1.dist, data->traverse1.backwards ) ); + break; + + case SEGPROC_TRAVERSE2: + flip = segPtr->u.j.flip; + if (data->traverse2.segDir!=0) + flip = !flip; + if (segPtr->u.j.Scurve) + flip = !flip; + data->traverse2.pos = GetSegEndPt( segPtr, data->traverse2.segDir, FALSE, NULL ); + TraverseJoint( &data->traverse2.pos, &data->traverse2.angle, &data->traverse2.dist, segPtr->u.j.pos, segPtr->u.j.angle, segPtr->u.j.l0, segPtr->u.j.l1, segPtr->u.j.R, segPtr->u.j.L, segPtr->u.j.negate, flip, segPtr->u.j.Scurve ); + break; + + case SEGPROC_DRAWROADBEDSIDE: + /* TODO: JointSegProc( SEGPROC_DRAWROADBEDSIDE, ... */ + break; + + case SEGPROC_DISTANCE: + data->distance.dd = JointDistance( &data->distance.pos1, segPtr->u.j.pos, segPtr->u.j.angle, segPtr->u.j.l0, segPtr->u.j.l1, segPtr->u.j.R, segPtr->u.j.L, segPtr->u.j.negate, segPtr->u.j.Scurve ); + break; + + case SEGPROC_FLIP: + segPtr->u.j.flip = !segPtr->u.j.flip; + break; + + case SEGPROC_NEWTRACK: + data->newTrack.trk = NewTrack( 0, T_EASEMENT, 2, sizeof *xx ); + xx = GetTrkExtraData(data->newTrack.trk); + xx->pos = segPtr->u.j.pos; + xx->angle = segPtr->u.j.angle; + xx->l0 = segPtr->u.j.l0; + xx->l1 = segPtr->u.j.l1; + xx->R = segPtr->u.j.R; + xx->L = segPtr->u.j.L; + xx->negate = segPtr->u.j.negate; + xx->flip = segPtr->u.j.flip; + xx->Scurve = segPtr->u.j.Scurve; + ep0 = 0; + if ( xx->flip ) + ep0 = 1-ep0; + if ( xx->Scurve ) + ep0 = 1-ep0; + GetJointPos( &p, &a, xx->l0, xx->R, xx->L, xx->pos, xx->angle, xx->negate ); + if ( !xx->Scurve ) + a = NormalizeAngle(a+180.0); + SetTrkEndPoint( data->newTrack.trk, ep0, p, a ); + a = xx->angle; + if ( xx->Scurve ) + a = NormalizeAngle(a+180.0); + GetJointPos( &p, &a, xx->l1, xx->R, xx->L, xx->pos, a, xx->negate ); + if ( xx->Scurve ) + a = NormalizeAngle(a+180.0); + SetTrkEndPoint( data->newTrack.trk, 1-ep0, p, a ); + ComputeBoundingBox( data->newTrack.trk ); + data->newTrack.ep[0] = 0; + data->newTrack.ep[1] = 1; + break; + + case SEGPROC_LENGTH: + if ( !segPtr->u.j.Scurve ) + data->length.length = JoinD( segPtr->u.j.l1, segPtr->u.j.R, segPtr->u.j.L ) - JoinD( segPtr->u.j.l0, segPtr->u.j.R, segPtr->u.j.L ); + else + data->length.length = JoinD( segPtr->u.j.l1, segPtr->u.j.R, segPtr->u.j.L ) + JoinD( segPtr->u.j.l0, segPtr->u.j.R, segPtr->u.j.L ); + break; + + case SEGPROC_SPLIT: + xxx[0].pos = segPtr->u.j.pos; + xxx[0].angle = segPtr->u.j.angle; + xxx[0].l0 = segPtr->u.j.l0; + xxx[0].l1 = segPtr->u.j.l1; + xxx[0].R = segPtr->u.j.R; + xxx[0].L = segPtr->u.j.L; + xxx[0].negate = segPtr->u.j.negate; + xxx[0].flip = segPtr->u.j.flip; + xxx[0].Scurve = segPtr->u.j.Scurve; + SplitJointA( &data->split.pos, 0, &xxx[0], &xxx[1], &a ); + for ( inx=0; inx<2; inx++ ) { + xx = &xxx[(!segPtr->u.j.flip)?1-inx:inx]; + data->split.newSeg[inx] = *segPtr; + data->split.newSeg[inx].u.j.pos = xx->pos; + data->split.newSeg[inx].u.j.angle = xx->angle; + data->split.newSeg[inx].u.j.l0 = xx->l0; + data->split.newSeg[inx].u.j.l1 = xx->l1; + data->split.newSeg[inx].u.j.R = xx->R; + data->split.newSeg[inx].u.j.L = xx->L; + data->split.newSeg[inx].u.j.negate = xx->negate; + data->split.newSeg[inx].u.j.flip = xx->flip; + data->split.newSeg[inx].u.j.Scurve = xx->Scurve; + if ( !xx->Scurve ) + data->split.length[inx] = JoinD( xx->l1, xx->R, xx->L ) - JoinD( xx->l0, xx->R, xx->L ); + else + data->split.length[inx] = JoinD( xx->l1, xx->R, xx->L ) + JoinD( xx->l0, xx->R, xx->L ); + } + break; + + case SEGPROC_GETANGLE: + GetLandD( &l, NULL, data->getAngle.pos, segPtr->u.j.pos, segPtr->u.j.angle, segPtr->u.j.R, segPtr->u.j.L, segPtr->u.j.negate, segPtr->u.j.Scurve ); + if (small(l)) { + a = segPtr->u.j.angle; + } else { + if (segPtr->u.j.Scurve && l < 0.0) { + GetJointPos( NULL, &a, -l, segPtr->u.j.R, segPtr->u.j.L, segPtr->u.j.pos, segPtr->u.j.angle+180.0, segPtr->u.j.negate ); + a = NormalizeAngle( a-180.0 ); + } else { + GetJointPos( NULL, &a, l, segPtr->u.j.R, segPtr->u.j.L, segPtr->u.j.pos, segPtr->u.j.angle, segPtr->u.j.negate ); + } + } + data->getAngle.angle = a; + break; + } +} + + + +#ifndef TEST +BOOL_T JoinTracks( + track_p trk0, + EPINX_T ep0, + coOrd pos0, + track_p trk1, + EPINX_T ep1, + coOrd pos1, + easementData_t * e ) +/* + * Join 2 tracks with joint described in (e). + * (pos0) and (pos1) are points that would be connected if there was no + * transition-curve. + * If there is then: + * (pos0) and (pos1) have been moved (x) apart. + * Adjust the endPoints by moving (pos0) and (pos1) by (e->d0) and (e->d1) + * along the track. + * Connect the tracks. + */ +{ + track_p joint; + +LOG( log_ease, 1, ( "join T%d[%d] @[%0.3f %0.3f], T%d[%d] @[%0.3f %0.3f]\n", + GetTrkIndex(trk0), ep0, pos0.x, pos0.y, GetTrkIndex(trk1), ep1, pos1.x, pos1.y ) ) + + if ( GetTrkType(trk0) == T_EASEMENT ) { + DIST_T d; + ANGLE_T aa; + d = FindDistance( GetTrkEndPos(trk0,ep0), GetTrkEndPos(trk1,ep1) ); + aa = NormalizeAngle( GetTrkEndAngle(trk0,ep0) - GetTrkEndAngle(trk1,ep1) + 180.0 + connectAngle/2.0 ); + if ( d <= connectDistance && aa <= connectAngle ) { + ConnectTracks( trk0, ep0, trk1, ep1 ); + } + return TRUE; + } + + /* Move the endPoint for (trk0) */ + if (!MoveEndPt( &trk0, &ep0, pos0, e->d0 )) + return FALSE; + + /* Move the endPoint for (trk1) */ + if (!MoveEndPt( &trk1, &ep1, pos1, e->d1 )) + return FALSE; + +LOG( log_ease, 1, ( " EASE R%0.3f..%0.3f L%0.3f..%0.3f\n", + e->r0, e->r1, e->d0, e->d1 ) ) + + /* Connect the tracks */ + if (e->x == 0.0) { + /* No transition-curve */ + ConnectTracks( trk0, ep0, trk1, ep1 ); + } else { + /* Connect with transition-curve */ + joint = NewJoint( GetTrkEndPos(trk0,ep0), GetTrkEndAngle(trk0,ep0), + GetTrkEndPos(trk1,ep1), GetTrkEndAngle(trk1,ep1), + GetTrkGauge(trk0), easeR, easeL, e ); + CopyAttributes( trk0, joint ); + ConnectTracks( trk1, ep1, joint, 1 ); + ConnectTracks( trk0, ep0, joint, 0 ); + DrawNewTrack( joint ); + } + return TRUE; +} + + +EXPORT void UndoJoint( + track_p trk, + EPINX_T ep, + track_p trk1, + EPINX_T ep1 ) +{ + struct extraData * xx; + DIST_T d; + + if ( GetTrkType(trk1) != T_EASEMENT ) + return; + xx = GetTrkExtraData(trk1); + if ( ep1 == 0 ) + d = xx->L/2.0 - xx->l0; + else + d = xx->l1 - xx->L/2.0; + if ( d < 0.01 ) + return; + UndrawNewTrack( trk ); + MoveEndPt( &trk, &ep, GetTrkEndPos(trk,ep), -d ); + DrawNewTrack( trk ); +} +#endif + +/***************************************************************************** + * + * INITIALIZATION + * + */ + + + +void InitTrkEase( void ) +{ + T_EASEMENT = InitObject( &easementCmds ); + log_ease = LogFindIndex( "ease" ); + log_traverseJoint = LogFindIndex( "traverseJoint" ); +} + + +/***************************************************************************** + * + * TEST + * + */ + +#ifdef TEST + + +void ErrorMessage( char * msg, ... ) +{ + lprintf( "%s\n", msg ); +} + +void InfoMessage( char * msg, ... ) +{ + lprintf( "%s\n", msg ); +} + +scaleInfo_p curScale; + +track_p NewTrack( TRKINX_T a, TRKTYP_T b, EPINX_T c, TRKTYP_T d ) +{ + return NULL; +} + +void DrawStraightTrack( drawCmd_p a, coOrd b, coOrd c, ANGLE_T d, + DIST_T trackGauge, wDrawColor color, int opts ) +{ +} + +void DrawNewTrack( track_p t ) +{ +} + +static DIST_T JoinDalt( + DIST_T x, + DIST_T R, + DIST_T L ) +/* + * Alternative distance computation, integrate over the curve. + */ +{ +#define DCNT (1000) + DIST_T d; + wIndex_t i; + coOrd p0, p1; + d = 0.0; + p0.x = p0.y = 0.0; + for ( i=1;i<=DCNT; i++) { + ComputeJoinPos( x*((DIST_T)i)/((DIST_T)DCNT), R, L, NULL, NULL, &p1, NULL ); + d += FindDistance( p0, p1 ); + p0 = p1; + } + return d; +} + + +test_plot( INT_T argc, char * argv[] ) +{ + DIST_T l, X, L, rr, ra, d, d1, R; + coOrd p, pc, p1; + INT_T i, C; + if (argc != 4) { + lprintf("%s R L C\n", argv[0]); + Exit(1); + } + argv++; + R = atof( *argv++ ); + L = atof( *argv++ ); + C = atol( *argv++ ); + X = L*L/(24*R); + lprintf("R=%0.3f X=%0.3f L=%0.3f\n", R, X, L ); + + for (i=0;i<=C;i++) { + l = L*((DIST_T)i)/((DIST_T)C); + d = JoinD( l, R, L ); + d1 = JoinDalt( l, R, L ); + ComputeJoinPos( l, R, L, &rr, &ra, &p, &pc ); + lprintf("d: [%0.3f %0.3f] [%0.3f %03f] R=%0.3f A=%0.3f D=%0.3f D1=%0.3f X=%0.4f\n", + i, p.x, p.y, pc.x, pc.y, rr, ra, d, d1, pc.x-rr ); + } +} + +test_psplot( INT_T argc, char * argv[] ) +{ + DIST_T l, L, rr, ra, d, d1, R, S, X; + coOrd p, q, pc, p1; + INT_T i, C; + if (argc != 5) { + lprintf("%s R L C S\n", argv[0]); + Exit(1); + } + argv++; + easeR = R = atof( *argv++ ); + easeL = L = atof( *argv++ ); + C = atol( *argv++ ); + S = atof( *argv++ ); + X = L*L/(24*R); + +lprintf("%%! kvjfv\nsave\n0 setlinewidth\n"); +lprintf("/Times-BoldItalic findfont 16 scalefont setfont\n"); +lprintf("36 36 moveto (R=%0.3f X=%0.3f L=%0.3f S=%0.3f) show\n", easeR, X, L, S ); +/*lprintf("24 768 translate -90 rotate\n");*/ +lprintf("gsave\n72 72 translate\n"); +lprintf("%0.3f %0.3f scale\n", 72.0/S, 72.0/S ); +lprintf("%0.3f %0.3f moveto %0.3f %0.3f lineto stroke\n", 0.0, 0.0, L, 0.0 ); +lprintf("%0.3f %0.3f %0.3f 270.0 90.0 arc stroke\n", L/2.0, easeR+X, easeR ); +lprintf("%0.3f %0.3f %0.3f 0.0 360.0 arc stroke\n", 0.0, 0.0, 0.25 ); + q.x = q.y = 0.0; + for (i=0;i<=C;i++) { + l = L*((DIST_T)i)/((DIST_T)C); + ComputeJoinPos( l, R, L, &rr, &ra, &p, &pc ); +lprintf("%0.3f %0.3f moveto %0.3f %0.3f lineto stroke\n", q.x, q.y, p.x, p.y ); + q = p; + } +lprintf("%0.3f %0.3f %0.3f 0.0 360.0 arc stroke\n", p.x, p.y, 0.25 ); +lprintf("grestore\nrestore\nshowpage\n%%Trailer\n%%Pages: 1\n"); +} + +void Test_compute( INT_T argc, char * argv[] ) +{ + DIST_T r0, r1, x, l0, l1, R, X, d; + coOrd q0, q1, qc0, qc1; + easementData_t e; + if (argc != 5) { + lprintf("compute R0 R1 R L\n"); + Exit(1); + } + /*debugEase = 5;*/ + argv++; + r0 = atof( *argv++); + r1 = atof( *argv++); + easementVal = 1.0; + easeR = atof( *argv++); + easeL = atof( *argv++); + ComputeJoint( r0, r1, &e ); + ComputeJoinPos( e.l0, easeR, easeL, NULL, NULL, &q0, &qc0 ); + ComputeJoinPos( e.l1, easeR, easeL, NULL, NULL, &q1, &qc1 ); + if (e.Scurve) { + q1.x = - q1.x; q1.y = - q1.y; + qc1.x = - qc1.x; qc1.y = - qc1.y; + } + d = FindDistance( q0, q1 ); + lprintf("ENDPT [%0.3f %0.3f] [%0.3f %0.3f]\n", q0.x, q0.y, q1.x, q1.y ); + lprintf("CENTER [%0.3f %0.3f] [%0.3f %0.3f]\n", qc0.x, qc0.y, qc1.x, qc1.y ); + lprintf("ComputeJoint( %0.3f %0.3f) { %0.3f %0.3f %0.3f } D0=%0.5f D1=%0.5f, D=%0.3f\n", + r0, r1, easeR, easeL, e.x, e.d0, e.d1, d ); +} + +void Test_findL( INT_T argc, char * argv[] ) +{ + DIST_T l, r, R, L; + if (argc != 5) { + lprintf("findL r R L\n"); + Exit(1); + } + /*debugEase = 5;*/ + argv++; + r = atof( *argv++ ); + R = atof( *argv++ ); + L = atof( *argv++ ); + l = FindL( r, R, L ); + lprintf("FindL( %0.3f %0.3f %0.3f ) = %0.3f\n", r, R, L, l ); +} + + +main( INT_T argc, char * argv[] ) +{ +INT_T flagX = 0; +INT_T flagV = 0; + if (argc<1) { + lprintf("plot|compute\n"); + Exit(1); + } + argv++; argc--; + while (argv[0][0] == '-') { + switch (argv[0][1]) { + case 'x': + flagX++; + argc--;argv++; + break; + case 'v': + flagV++; + argc--;argv++; + break; + default: + lprintf("Huh: %s\n", *argv ); + argc--;argv++; + break; + } + } + if (strcmp(argv[0],"plot")==0) { + Test_plot( argc, argv ); + } else if (strcmp(argv[0],"psplot")==0) { + Test_psplot( argc, argv ); + } else if (strcmp(argv[0],"compute")==0) { + Test_compute( argc, argv ); + } else if (strcmp(argv[0],"findL")==0) { + Test_findL( argc, argv ); + } else { + lprintf("unknown cmd %s\n", argv[0] ); + } +} +#endif -- cgit v1.2.3