From d1a8285f818eb7e5c3d6a05709ea21a808490b8c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=B6rg=20Frings-F=C3=BCrst?= Date: Mon, 19 Mar 2018 19:55:58 +0100 Subject: New upstream version 5.1.0 --- app/bin/tcornu.c | 1321 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1321 insertions(+) create mode 100644 app/bin/tcornu.c (limited to 'app/bin/tcornu.c') diff --git a/app/bin/tcornu.c b/app/bin/tcornu.c new file mode 100644 index 0000000..9d9587a --- /dev/null +++ b/app/bin/tcornu.c @@ -0,0 +1,1321 @@ +/** \file tcornu.c + * + * CORNU SPIRAL TRACK + * + * A Cornu is a spiral arc defined by a polynomial that has the property + * that curvature varies linearly with distance along the curve. It is a family + * of curves that include Euler spirals. + * + * In order to be useful in XtrkCAD it is defined as a set of Bezier curves each of + * which is defined as a set of circular arcs and lines. + * + * The derivation of the Beziers is done by the Cornu library which must be recalled + * whenever a change is made in the end conditions. + * + * A cornu has a minimum radius and a maximum rate of change of radius. + * + * Acknowledgment is given to Dr. Raph Levien whose seminal PhD work on Cornu curves and + * generous open-sourcing of his libraries both inspired and powers this function. + * + * + * XTrkCad - Model Railroad CAD + * + * 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 "draw.h" +#include "cbezier.h" +#include "tbezier.h" +#include "tcornu.h" +#include "ccornu.h" +#include "ccurve.h" +#include "cstraigh.h" +#include "cjoin.h" +#include "utility.h" +#include "common.h" +#include "i18n.h" +#include "param.h" +#include "math.h" +#include "string.h" +#include "cundo.h" +#include "layout.h" +#include "fileio.h" +#include "assert.h" + +EXPORT TRKTYP_T T_CORNU = -1; + +struct extraData { + cornuData_t cornuData; + }; + +static int log_cornu = 0; + +static DIST_T GetLengthCornu( track_p ); + +/**************************************** + * + * UTILITIES + * + */ + +/* + * Run after any changes to the Cornu points + */ +void SetUpCornuParmFromTracks(track_p trk[2],cornuParm_t * cp, struct extraData* xx) { + if (!trk[0]) { + cp->center[0] = xx->cornuData.c[0]; + cp->angle[0] = xx->cornuData.a[0]; + cp->radius[0] = xx->cornuData.r[0]; + } + if (!trk[1]) { + cp->center[1] = xx->cornuData.c[1]; + cp->angle[1] = xx->cornuData.a[1]; + cp->radius[1] = xx->cornuData.r[1]; + } +} + +EXPORT BOOL_T FixUpCornu(coOrd pos[2], track_p trk[2], EPINX_T ep[2], struct extraData* xx) { + + cornuParm_t cp; + + SetUpCornuParmFromTracks(trk,&cp,xx); + + if (!CallCornu(pos, trk, ep, &xx->cornuData.arcSegs, &cp)) return FALSE; + + xx->cornuData.r[0] = cp.radius[0]; + if (cp.radius[0]==0) { + xx->cornuData.a[0] = cp.angle[0]; + } else { + xx->cornuData.c[0] = cp.center[0]; + } + xx->cornuData.r[1] = cp.radius[1]; + if (cp.radius[1]==0) { + xx->cornuData.a[1] = cp.angle[1]; + } else { + xx->cornuData.c[1] = cp.center[1]; + } + + xx->cornuData.minCurveRadius = CornuMinRadius(pos,xx->cornuData.arcSegs); + xx->cornuData.windingAngle = CornuTotalWindingArc(pos,xx->cornuData.arcSegs); + DIST_T last_c; + if (xx->cornuData.r[0] == 0) last_c = 0; + else last_c = 1/xx->cornuData.r[0]; + xx->cornuData.maxRateofChange = CornuMaxRateofChangeofCurvature(pos,xx->cornuData.arcSegs,&last_c); + xx->cornuData.length = CornuLength(pos, xx->cornuData.arcSegs); + return TRUE; +} + +EXPORT BOOL_T FixUpCornu0(coOrd pos[2],coOrd center[2],ANGLE_T angle[2],DIST_T radius[2],struct extraData* xx) { + DIST_T last_c; + if (!CallCornu0(pos, center, angle, radius,&xx->cornuData.arcSegs,FALSE)) return FALSE; + xx->cornuData.minCurveRadius = CornuMinRadius(pos, + xx->cornuData.arcSegs); + if (xx->cornuData.r[0] == 0) last_c = 0; + else last_c = 1/xx->cornuData.r[0]; + xx->cornuData.maxRateofChange = CornuMaxRateofChangeofCurvature(pos,xx->cornuData.arcSegs,&last_c); + xx->cornuData.length = CornuLength(pos, xx->cornuData.arcSegs); + xx->cornuData.windingAngle = CornuTotalWindingArc(pos,xx->cornuData.arcSegs); + return TRUE; +} + +EXPORT char * CreateSegPathList(track_p trk) { + char * cp = "\0\0"; + if (GetTrkType(trk) != T_CORNU) return cp; + struct extraData *xx = GetTrkExtraData(trk); + if (xx->cornuData.cornuPath) free(xx->cornuData.cornuPath); + xx->cornuData.cornuPath = malloc(xx->cornuData.arcSegs.cnt+2); + int j= 0; + for (int i = 0;icornuData.arcSegs.cnt;i++,j++) { + xx->cornuData.cornuPath[j] = i+1; + } + xx->cornuData.cornuPath[j] = cp[0]; + xx->cornuData.cornuPath[j+1] = cp[0]; + return xx->cornuData.cornuPath; +} + + +static void GetCornuAngles( ANGLE_T *a0, ANGLE_T *a1, track_p trk ) +{ + assert( trk != NULL ); + + *a0 = NormalizeAngle( GetTrkEndAngle(trk,0) ); + *a1 = NormalizeAngle( GetTrkEndAngle(trk,1) ); + + LOG( log_cornu, 4, ( "getCornuAngles: = %0.3f %0.3f\n", *a0, *a1 ) ) +} + + +static void ComputeCornuBoundingBox( track_p trk, struct extraData * xx ) +{ + coOrd orig, size; + + GetSegBounds(zero,0,xx->cornuData.arcSegs.cnt,xx->cornuData.arcSegs.ptr, &orig, &size); + + coOrd hi, lo; + + lo.x = orig.x; + lo.y = orig.y; + hi.x = orig.x+size.x; + hi.y = orig.y+size.y; + + SetBoundingBox( trk, hi, lo ); +} + + +DIST_T CornuDescriptionDistance( + coOrd pos, + track_p trk ) +{ + struct extraData *xx = GetTrkExtraData(trk); + coOrd p1; + + if ( GetTrkType( trk ) != T_CORNU || ( GetTrkBits( trk ) & TB_HIDEDESC ) != 0 ) + return 100000; + + p1.x = xx->cornuData.pos[0].x + ((xx->cornuData.pos[1].x-xx->cornuData.pos[0].x)/2) + xx->cornuData.descriptionOff.x; + p1.y = xx->cornuData.pos[0].y + ((xx->cornuData.pos[1].y-xx->cornuData.pos[0].y)/2) + xx->cornuData.descriptionOff.y; + + return FindDistance( p1, pos ); +} + + +static void DrawCornuDescription( + track_p trk, + drawCmd_p d, + wDrawColor color ) +{ + struct extraData *xx = GetTrkExtraData(trk); + wFont_p fp; + coOrd pos; + + if (layoutLabels == 0) + return; + if ((labelEnable&LABELENABLE_TRKDESC)==0) + return; + pos.x = xx->cornuData.pos[0].x + ((xx->cornuData.pos[1].x - xx->cornuData.pos[0].x)/2); + pos.y = xx->cornuData.pos[0].y + ((xx->cornuData.pos[1].y - xx->cornuData.pos[0].y)/2); + pos.x += xx->cornuData.descriptionOff.x; + pos.y += xx->cornuData.descriptionOff.y; + fp = wStandardFont( F_TIMES, FALSE, FALSE ); + sprintf( message, _("Cornu Curve: length=%0.3f min radius=%0.3f"), + xx->cornuData.length, xx->cornuData.minCurveRadius); + DrawBoxedString( BOX_BOX, d, pos, message, fp, (wFontSize_t)descriptionFontSize, color, 0.0 ); +} + + +STATUS_T CornuDescriptionMove( + track_p trk, + wAction_t action, + coOrd pos ) +{ + struct extraData *xx = GetTrkExtraData(trk); + static coOrd p0,p1; + static BOOL_T editState; + wDrawColor color; + + if (GetTrkType(trk) != T_CORNU) return C_TERMINATE; + + p0.x = xx->cornuData.pos[0].x + ((xx->cornuData.pos[1].x - xx->cornuData.pos[0].x)/2); + p0.y = xx->cornuData.pos[0].y + ((xx->cornuData.pos[1].y - xx->cornuData.pos[0].y)/2); + + switch (action) { + case C_DOWN: + case C_MOVE: + case C_UP: + editState = TRUE; + p1 = pos; + color = GetTrkColor( trk, &mainD ); + xx->cornuData.descriptionOff.x = pos.x - p0.x; + xx->cornuData.descriptionOff.y = pos.y - p0.y; + DrawCornuDescription( trk, &mainD, color ); + if (action == C_UP) { + editState = FALSE; + } + MainRedraw(); + MapRedraw(); + return action==C_UP?C_TERMINATE:C_CONTINUE; + + case C_REDRAW: + if (editState) + DrawLine( &mainD, p1, p0, 0, wDrawColorBlack ); + break; + + } + return C_CONTINUE; +} + +/**************************************** + * + * GENERIC FUNCTIONS + * + */ + +static struct { + coOrd pos[2]; + ANGLE_T angle[2]; + DIST_T radius[2]; + coOrd center[2]; + FLOAT_T elev[2]; + FLOAT_T length; + FLOAT_T grade; + DIST_T minRadius; + DIST_T maxRateOfChange; + ANGLE_T windingAngle; + unsigned int layerNumber; + dynArr_t segs; + long width; + wDrawColor color; + } cornData; + +typedef enum { P0, A0, R0, C0, Z0, P1, A1, R1, C1, Z1, RA, RR, WA, LN, GR, LY } cornuDesc_e; +static descData_t cornuDesc[] = { +/*P0*/ { DESC_POS, N_("End Pt 1: X,Y"), &cornData.pos[0] }, +/*A0*/ { DESC_ANGLE, N_("End Angle"), &cornData.angle[0] }, +/*R0*/ { DESC_DIM, N_("Radius "), &cornData.radius[0] }, +/*C0*/ { DESC_POS, N_("Center X,Y"), &cornData.center[0] }, +/*Z0*/ { DESC_DIM, N_("Z1"), &cornData.elev[0] }, +/*P1*/ { DESC_POS, N_("End Pt 2: X,Y"), &cornData.pos[1] }, +/*A1*/ { DESC_ANGLE, N_("End Angle"), &cornData.angle[1] }, +/*R1*/ { DESC_DIM, N_("Radius"), &cornData.radius[1] }, +/*C1*/ { DESC_POS, N_("Center X,Y"), &cornData.center[1] }, +/*Z1*/ { DESC_DIM, N_("Z2"), &cornData.elev[1] }, +/*RA*/ { DESC_DIM, N_("Minimum Radius"), &cornData.minRadius }, +/*RR*/ { DESC_DIM, N_("Maximum Rate Of Change Of Curvature"), &cornData.maxRateOfChange }, +/*WA*/ { DESC_ANGLE, N_("Total Winding Angle"), &cornData.windingAngle }, +/*LN*/ { DESC_DIM, N_("Length"), &cornData.length }, +/*GR*/ { DESC_FLOAT, N_("Grade"), &cornData.grade }, +/*LY*/ { DESC_LAYER, N_("Layer"), &cornData.layerNumber }, + { DESC_NULL } }; + + +static void UpdateCornu( track_p trk, int inx, descData_p descUpd, BOOL_T final ) +{ + struct extraData *xx = GetTrkExtraData(trk); + BOOL_T updateEndPts; + EPINX_T ep; + + cornuParm_t cp; + + + if ( inx == -1 ) + return; + updateEndPts = FALSE; + switch ( inx ) { + case P0: + if (GetTrkEndTrk(trk,0)) break; + updateEndPts = TRUE; + xx->cornuData.pos[0] = cornData.pos[0]; + cornuDesc[P0].mode |= DESC_CHANGE; + /* no break */ + case P1: + if (GetTrkEndTrk(trk,1)) break; + updateEndPts = TRUE; + xx->cornuData.pos[1]= cornData.pos[1]; + cornuDesc[P1].mode |= DESC_CHANGE; + break; + case A0: + if (GetTrkEndTrk(trk,0)) break; + updateEndPts = TRUE; + xx->cornuData.a[0] = cornData.angle[0]; + cornuDesc[A0].mode |= DESC_CHANGE; + break; + case A1: + if (GetTrkEndTrk(trk,1)) break; + updateEndPts = TRUE; + xx->cornuData.a[1]= cornData.angle[1]; + cornuDesc[A1].mode |= DESC_CHANGE; + break; + case C0: + if (GetTrkEndTrk(trk,0)) break; + updateEndPts = TRUE; + xx->cornuData.c[0] = cornData.center[0]; + cornuDesc[C0].mode |= DESC_CHANGE; + break; + case C1: + if (GetTrkEndTrk(trk,1)) break; + updateEndPts = TRUE; + xx->cornuData.c[1] = cornData.center[1]; + cornuDesc[C1].mode |= DESC_CHANGE; + break; + case R0: + if (GetTrkEndTrk(trk,0)) break; + updateEndPts = TRUE; + xx->cornuData.r[0] = cornData.radius[0]; + cornuDesc[R0].mode |= DESC_CHANGE; + break; + case R1: + if (GetTrkEndTrk(trk,1)) break; + updateEndPts = TRUE; + xx->cornuData.r[1]= cornData.radius[1]; + cornuDesc[R1].mode |= DESC_CHANGE; + break; + case Z0: + case Z1: + ep = (inx==Z0?0:1); + UpdateTrkEndElev( trk, ep, GetTrkEndElevUnmaskedMode(trk,ep), cornData.elev[ep], NULL ); + ComputeElev( trk, 1-ep, FALSE, &cornData.elev[1-ep], NULL ); + if ( cornData.length > minLength ) + cornData.grade = fabs( (cornData.elev[0]-cornData.elev[1])/cornData.length )*100.0; + else + cornData.grade = 0.0; + cornuDesc[GR].mode |= DESC_CHANGE; + cornuDesc[inx==Z0?Z1:Z0].mode |= DESC_CHANGE; + return; + case LY: + SetTrkLayer( trk, cornData.layerNumber); + break; + default: + AbortProg( "updateCornu: Bad inx %d", inx ); + } + track_p tracks[2]; + tracks[0] = GetTrkEndTrk(trk,0); + tracks[1] = GetTrkEndTrk(trk,1); + + if (updateEndPts) { + if ( GetTrkEndTrk(trk,0) == NULL ) { + SetTrkEndPoint( trk, 0, cornData.pos[0], xx->cornuData.a[0]); + cornuDesc[A0].mode |= DESC_CHANGE; + } + if ( GetTrkEndTrk(trk,1) == NULL ) { + SetTrkEndPoint( trk, 1, cornData.pos[1], xx->cornuData.a[1]); + cornuDesc[A1].mode |= DESC_CHANGE; + } + } + + EPINX_T new_ep[2]; + track_p ts[2]; + ts[0] = GetTrkEndTrk(trk,0); + ts[1] = GetTrkEndTrk(trk,1); + SetUpCornuParmFromTracks(ts,&cp,xx); + CallCornu(xx->cornuData.pos, tracks, new_ep, &xx->cornuData.arcSegs, &cp); + + + //FixUpCornu(xx->bezierData.pos, xx, IsTrack(trk)); + ComputeCornuBoundingBox(trk, xx); + DrawNewTrack( trk ); +} + + +static void DescribeCornu( track_p trk, char * str, CSIZE_T len ) +{ + struct extraData *xx = GetTrkExtraData(trk); + DIST_T d; + + d = xx->cornuData.length; + sprintf( str, _("Cornu Track(%d): Layer=%u MinRadius=%s Length=%s EP=[%0.3f,%0.3f] [%0.3f,%0.3f]"), + GetTrkIndex(trk), + GetTrkLayer(trk)+1, + FormatDistance(xx->cornuData.minCurveRadius), + FormatDistance(d), + PutDim(xx->cornuData.pos[0].x),PutDim(xx->cornuData.pos[0].y), + PutDim(xx->cornuData.pos[1].x),PutDim(xx->cornuData.pos[1].y) + ); + + cornData.length = xx->cornuData.length; + cornData.minRadius = xx->cornuData.minCurveRadius; + cornData.maxRateOfChange = xx->cornuData.maxRateofChange; + cornData.windingAngle = xx->cornuData.windingAngle; + cornData.layerNumber = GetTrkLayer(trk); + cornData.pos[0] = xx->cornuData.pos[0]; + cornData.pos[1] = xx->cornuData.pos[1]; + cornData.angle[0] = xx->cornuData.a[0]; + cornData.angle[1] = xx->cornuData.a[1]; + cornData.center[0] = xx->cornuData.c[0]; + cornData.center[1] = xx->cornuData.c[1]; + cornData.radius[0] = xx->cornuData.r[0]; + cornData.radius[1] = xx->cornuData.r[1]; + if (GetTrkType(trk) == T_CORNU) { + ComputeElev( trk, 0, FALSE, &cornData.elev[0], NULL ); + ComputeElev( trk, 1, FALSE, &cornData.elev[1], NULL ); + + if ( cornData.length > minLength ) + cornData.grade = fabs( (cornData.elev[0]-cornData.elev[1])/cornData.length )*100.0; + else + cornData.grade = 0.0; + } + BOOL_T trk0 = (GetTrkEndTrk(trk,0)!=NULL); + BOOL_T trk1 = (GetTrkEndTrk(trk,1)!=NULL); + + cornuDesc[P0].mode = !trk0?0:DESC_RO; + cornuDesc[P1].mode = !trk1?0:DESC_RO; + cornuDesc[LN].mode = DESC_RO; + cornuDesc[Z0].mode = EndPtIsDefinedElev(trk,0)?0:DESC_RO; + cornuDesc[Z1].mode = EndPtIsDefinedElev(trk,1)?0:DESC_RO; + + + cornuDesc[A0].mode = !trk0?0:DESC_RO; + cornuDesc[A1].mode = !trk1?0:DESC_RO; + cornuDesc[C0].mode = !trk0?0:DESC_RO; + cornuDesc[C1].mode = !trk1?0:DESC_RO; + cornuDesc[R0].mode = !trk0?0:DESC_RO; + cornuDesc[R1].mode = !trk1?0:DESC_RO; + cornuDesc[GR].mode = DESC_RO; + cornuDesc[RA].mode = DESC_RO; + cornuDesc[RR].mode = DESC_RO; + cornuDesc[WA].mode = DESC_RO; + cornuDesc[LY].mode = DESC_NOREDRAW; + + DoDescribe( _("Cornu Track"), trk, cornuDesc, UpdateCornu ); + + +} + + +static DIST_T DistanceCornu( track_p t, coOrd * p ) +{ + struct extraData *xx = GetTrkExtraData(t); + //return BezierMathDistance(p,xx->bezierData.pos,100, &s); + + DIST_T d = 100000.0; + coOrd p2 = xx->cornuData.pos[0]; //Set initial point + segProcData_t segProcData; + for (int i = 0;icornuData.arcSegs.cnt;i++) { + trkSeg_t seg = DYNARR_N(trkSeg_t,xx->cornuData.arcSegs,i); + if (seg.type == SEG_FILCRCL) continue; + segProcData.distance.pos1 = * p; + SegProc(SEGPROC_DISTANCE,&seg,&segProcData); + if (segProcData.distance.ddbezierData.pos[0], xx->bezierData.pos[1], xx->bezierData.pos[2], xx->bezierData.pos[1], 100, NULL ); + * p = p2; + return d; +} + +static void DrawCornu( track_p t, drawCmd_p d, wDrawColor color ) +{ + struct extraData *xx = GetTrkExtraData(t); + long widthOptions = DTS_LEFT|DTS_RIGHT; + + if (GetTrkWidth(t) == 2) + widthOptions |= DTS_THICK2; + if (GetTrkWidth(t) == 3) + widthOptions |= DTS_THICK3; + + + if ( ((d->funcs->options&wDrawOptTemp)==0) && + (labelWhen == 2 || (labelWhen == 1 && (d->options&DC_PRINT))) && + labelScale >= d->scale && + ( GetTrkBits( t ) & TB_HIDEDESC ) == 0 ) { + DrawCornuDescription( t, d, color ); + } + DIST_T scale2rail = (d->options&DC_PRINT)?(twoRailScale*2+1):twoRailScale; + if ( tieDrawMode!=TIEDRAWMODE_NONE && + d!=&mapD && + (d->options&DC_TIES)!=0 && + d->scalecornuData.arcSegs.ptr,xx->cornuData.arcSegs.cnt, GetTrkGauge(t), color, widthOptions|DTS_TIES); + DrawSegsO(d,t,zero,0.0,xx->cornuData.arcSegs.ptr,xx->cornuData.arcSegs.cnt, GetTrkGauge(t), color, widthOptions); + if ( (d->funcs->options & wDrawOptTemp) == 0 && + (d->options&DC_QUICK) == 0 ) { + DrawEndPt( d, t, 0, color ); + DrawEndPt( d, t, 1, color ); + } +} + +void FreeSubSegs(trkSeg_t* s) { + if (s->type == SEG_BEZTRK || s->type == SEG_BEZLIN) { + if (s->bezSegs.ptr) { + MyFree(s->bezSegs.ptr); + } + s->bezSegs.max = 0; + s->bezSegs.cnt = 0; + s->bezSegs.ptr = NULL; + } +} + +static void DeleteCornu( track_p t ) +{ + struct extraData *xx = GetTrkExtraData(t); + + for (int i=0;icornuData.arcSegs.cnt;i++) { + trkSeg_t s = DYNARR_N(trkSeg_t,xx->cornuData.arcSegs,i); + FreeSubSegs(&s); + } + if (xx->cornuData.arcSegs.ptr) + MyFree(xx->cornuData.arcSegs.ptr); + xx->cornuData.arcSegs.max = 0; + xx->cornuData.arcSegs.cnt = 0; + xx->cornuData.arcSegs.ptr = NULL; +} + +static BOOL_T WriteCornu( track_p t, FILE * f ) +{ + struct extraData *xx = GetTrkExtraData(t); + long options; + BOOL_T rc = TRUE; + BOOL_T track =(GetTrkType(t)==T_CORNU); + options = GetTrkWidth(t) & 0x0F; + if ( ( GetTrkBits(t) & TB_HIDEDESC ) == 0 ) options |= 0x80; + rc &= fprintf(f, "%s %d %d %ld 0 0 %s %d %0.6f %0.6f %0.6f %0.6f %0.6f %0.6f %0.6f %0.6f %0.6f %0.6f %0.6f %0.6f \n", + "CORNU",GetTrkIndex(t), GetTrkLayer(t), (long)options, + GetTrkScaleName(t), GetTrkVisible(t), + xx->cornuData.pos[0].x, xx->cornuData.pos[0].y, + xx->cornuData.a[0], + xx->cornuData.r[0], + xx->cornuData.c[0].x,xx->cornuData.c[0].y, + xx->cornuData.pos[1].x, xx->cornuData.pos[1].y, + xx->cornuData.a[1], + xx->cornuData.r[1], + xx->cornuData.c[1].x,xx->cornuData.c[1].y )>0; + if (track) { + rc &= WriteEndPt( f, t, 0 ); + rc &= WriteEndPt( f, t, 1 ); + } + rc &= WriteSegs( f, xx->cornuData.arcSegs.cnt, xx->cornuData.arcSegs.ptr ); + //rc &= fprintf(f, "\tEND\n" )>0; + return rc; +} + +static void ReadCornu( char * line ) +{ + struct extraData *xx; + track_p t; + wIndex_t index; + BOOL_T visible; + DIST_T r0,r1; + ANGLE_T a0,a1; + coOrd p0, p1, c0, c1; + char scale[10]; + wIndex_t layer; + long options; + char * cp = NULL; + + if (!GetArgs( line+6, "dLl00sdpffppffp", + &index, &layer, &options, scale, &visible, &p0, &a0, &r0, &c0, &p1, &a1, &r1, &c1 ) ) { + return; + } + t = NewTrack( index, T_CORNU, 0, sizeof *xx ); + + xx = GetTrkExtraData(t); + SetTrkVisible(t, visible); + SetTrkScale(t, LookupScale(scale)); + SetTrkLayer(t, layer ); + SetTrkWidth(t, (int)(options&0x0F)); + if ( ( options & 0x80 ) == 0 ) SetTrkBits(t,TB_HIDEDESC); + xx->cornuData.pos[0] = p0; + xx->cornuData.pos[1] = p1; + xx->cornuData.a[0] = a0; + xx->cornuData.r[0] = r0; + xx->cornuData.a[1] = a1; + xx->cornuData.c[0] = c0; + xx->cornuData.c[1] = c1; + xx->cornuData.r[1] = r1; + xx->cornuData.descriptionOff.x = xx->cornuData.descriptionOff.y = 0.0; + ReadSegs(); + FixUpCornu0(xx->cornuData.pos,xx->cornuData.c,xx->cornuData.a, xx->cornuData.r, xx); + ComputeCornuBoundingBox(t,xx); + SetEndPts(t,2); +} + +static void MoveCornu( track_p trk, coOrd orig ) +{ + struct extraData *xx = GetTrkExtraData(trk); + UndoModify(trk); + for (int i=0;i<2;i++) { + xx->cornuData.pos[i].x += orig.x; + xx->cornuData.pos[i].y += orig.y; + xx->cornuData.c[i].x += orig.x; + xx->cornuData.c[i].y += orig.y; + } + RebuildCornu(trk); +} + +static void RotateCornu( track_p trk, coOrd orig, ANGLE_T angle ) +{ + struct extraData *xx = GetTrkExtraData(trk); + UndoModify(trk); + for (int i=0;i<2;i++) { + Rotate( &xx->cornuData.pos[i], orig, angle ); + Rotate( &xx->cornuData.c[i], orig, angle); + xx->cornuData.a[i] = NormalizeAngle(xx->cornuData.a[i]+angle); + } + RebuildCornu(trk); +} + +static void RescaleCornu( track_p trk, FLOAT_T ratio ) +{ + struct extraData *xx = GetTrkExtraData(trk); + UndoModify(trk); + for (int i=0;i<2;i++) { + xx->cornuData.pos[i].x *= ratio; + xx->cornuData.pos[i].y *= ratio; + } + RebuildCornu(trk); + +} + +EXPORT BOOL_T SetCornuEndPt(track_p trk, EPINX_T inx, coOrd pos, coOrd center, ANGLE_T angle, DIST_T radius) { + struct extraData *xx = GetTrkExtraData(trk); + + xx->cornuData.pos[inx] = pos; + xx->cornuData.c[inx] = center; + xx->cornuData.a[inx] = angle; + xx->cornuData.r[inx] = radius; + if (!RebuildCornu(trk)) return FALSE; + SetTrkEndPoint( trk, inx, xx->cornuData.pos[inx], xx->cornuData.a[inx]); + return TRUE; +} + + +/** + * Split the Track at approximately the point pos. + */ +static BOOL_T SplitCornu( track_p trk, coOrd pos, EPINX_T ep, track_p *leftover, EPINX_T * ep0, EPINX_T * ep1 ) +{ + struct extraData *xx = GetTrkExtraData(trk); + track_p trk1; + DIST_T radius = 0.0; + coOrd center; + int inx; + BOOL_T track; + track = IsTrack(trk); + + cornuParm_t new; + + double dd = DistanceCornu(trk, &pos); + if (dd>minLength) return FALSE; + BOOL_T back, neg; + + ANGLE_T angle = GetAngleSegs(xx->cornuData.arcSegs.cnt,(trkSeg_t *)(xx->cornuData.arcSegs.ptr),&pos,&inx,NULL,&back,NULL,&neg); + + trkSeg_p segPtr = &DYNARR_N(trkSeg_t, xx->cornuData.arcSegs, inx); + + GetAngleSegs(segPtr->bezSegs.cnt,(trkSeg_t *)(segPtr->bezSegs.ptr),&pos,&inx,NULL,&back,NULL,&neg); + segPtr = &DYNARR_N(trkSeg_t, segPtr->bezSegs, inx); + + if (segPtr->type == SEG_STRTRK) { + radius = 0.0; + center = zero; + } else if (segPtr->type == SEG_CRVTRK) { + center = segPtr->u.c.center; + radius = fabs(segPtr->u.c.radius); + } + if (ep) { + new.pos[0] = pos; + new.pos[1] = xx->cornuData.pos[1]; + new.angle[0] = NormalizeAngle(angle+(neg==back?180:0)); + new.angle[1] = xx->cornuData.a[1]; + new.center[0] = center; + new.center[1] = xx->cornuData.c[1]; + new.radius[0] = radius; + new.radius[1] = xx->cornuData.r[1]; + } else { + new.pos[1] = pos; + new.pos[0] = xx->cornuData.pos[0]; + new.angle[1] = NormalizeAngle(angle+(neg==back?0:180)); + new.angle[0] = xx->cornuData.a[0]; + new.center[1] = center; + new.center[0] = xx->cornuData.c[0]; + new.radius[1] = radius; + new.radius[0] = xx->cornuData.r[0]; + } + + trk1 = NewCornuTrack(new.pos,new.center,new.angle,new.radius,NULL,0); + if (trk1==NULL) { + wBeep(); + InfoMessage(_("Cornu Create Failed for p1[%0.3f,%0.3f] p2[%0.3f,%0.3f], c1[%0.3f,%0.3f] c2[%0.3f,%0.3f], a1=%0.3f a2=%0.3f, r1=%s r2=%s"), + new.pos[0].x,new.pos[0].y, + new.pos[1].x,new.pos[1].y, + new.center[0].x,new.center[0].y, + new.center[1].x,new.center[1].y, + new.angle[0],new.angle[1], + FormatDistance(new.radius[0]),FormatDistance(new.radius[1])); + UndoEnd(); + return FALSE; + } + + UndoModify(trk); + xx->cornuData.pos[ep] = pos; + xx->cornuData.a[ep] = NormalizeAngle(new.angle[1-ep]+180); + xx->cornuData.r[ep] = new.radius[1-ep]; + xx->cornuData.c[ep] = new.center[1-ep]; + + RebuildCornu(trk); + + SetTrkEndPoint(trk, ep, xx->cornuData.pos[ep], xx->cornuData.a[ep]); + + *leftover = trk1; + *ep0 = 1-ep; + *ep1 = ep; + + return TRUE; +} + +BOOL_T MoveCornuEndPt ( track_p *trk, EPINX_T *ep, coOrd pos, DIST_T d0 ) { + track_p trk2; + if (SplitTrack(*trk,pos,*ep,&trk2,TRUE)) { + struct extraData *xx = GetTrkExtraData(*trk); + if (trk2) DeleteTrack(trk2,TRUE); + SetTrkEndPoint( *trk, *ep, *ep?xx->cornuData.pos[1]:xx->cornuData.pos[0], *ep?xx->cornuData.a[1]:xx->cornuData.a[0] ); + return TRUE; + } + return FALSE; +} +static int log_traverseCornu = 0; +/* + * TraverseCornu is used to position a train/car. + * We find a new position and angle given a current pos, angle and a distance to travel. + * + * The output can be TRUE -> we have moved the point to a new point or to the start/end of the next track + * FALSE -> we have not found that point because pos was not on/near the track + * + * If true we supply the remaining distance to go (always positive). + * We detect the movement direction by comparing the current angle to the angle of the track at the point. + * + * The entire Cornu may be reversed or forwards depending on the way it was drawn. + * + * Each Bezier segment within that Cornu structure therefore may be processed forwards or in reverse. + * So for each segment we call traverse1 to get the direction and extra distance to go to get to the current point + * and then use that for traverse2 to actually move to the new point + * + * If we exceed the current point's segment we move on to the next until the end of this track or we have found the spot. + * + */ +static BOOL_T TraverseCornu( traverseTrack_p trvTrk, DIST_T * distR ) +{ + track_p trk = trvTrk->trk; + struct extraData *xx = GetTrkExtraData(trk); + DIST_T dist = *distR; + segProcData_t segProcData; + BOOL_T cornu_backwards= FALSE; + BOOL_T neg = FALSE; + DIST_T d = 10000; + coOrd pos1 = trvTrk->pos, pos2 = trvTrk->pos; + ANGLE_T a1,a2; + int inx, segInx = 0; + EPINX_T ep; + BOOL_T back; +LOG( log_traverseCornu, 1, ( "TravCornu-In [%0.3f %0.3f] A%0.3f D%0.3f \n", trvTrk->pos.x, trvTrk->pos.y, trvTrk->angle, *distR )) + trkSeg_p segPtr = (trkSeg_p)xx->cornuData.arcSegs.ptr; + + a2 = GetAngleSegs( //Find correct Segment and nearest point in it + xx->cornuData.arcSegs.cnt,segPtr, + &pos2, &segInx, &d , &back , NULL, &neg); //d = how far pos2 from old pos2 = trvTrk->pos + + if ( d > 10 ) { + ErrorMessage( "traverseCornu: Position is not near track: %0.3f", d ); + return FALSE; //This means the input pos is not on or close to the track. + } + if (back) a2 = NormalizeAngle(a2+180); //If reverse segs - reverse angle + a1 = NormalizeAngle(a2-trvTrk->angle); //Establish if we are going fwds or backwards globally + if (a1<270 && a1>90) { //Must add 180 if the seg is reversed or inverted (but not both) + cornu_backwards = TRUE; + ep = 0; + } else { + cornu_backwards = FALSE; + ep = 1; + } + if (neg) { + cornu_backwards = !cornu_backwards; //Reversed direction + ep = 1-ep; + } + segProcData.traverse1.pos = pos2; //actual point on curve + segProcData.traverse1.angle = trvTrk->angle; //direction car is going for Traverse 1 +LOG( log_traverseCornu, 1, ( " TravCornu-GetSubA A%0.3f I%d N%d B%d CB%d\n", a2, segInx, neg, back, cornu_backwards )) + inx = segInx; + while (inx >=0 && inxcornuData.arcSegs.cnt) { + segPtr = (trkSeg_p)xx->cornuData.arcSegs.ptr+inx; //move in to the identified Bezier segment + SegProc( SEGPROC_TRAVERSE1, segPtr, &segProcData ); + BOOL_T backwards = segProcData.traverse1.backwards; //do we process this segment backwards? + BOOL_T reverse_seg = segProcData.traverse1.reverse_seg; //Info only + int BezSegInx = segProcData.traverse1.BezSegInx; //Which subSeg was it? + BOOL_T segs_backwards = segProcData.traverse1.segs_backwards; + + dist += segProcData.traverse1.dist; //Add in the part of the Bezier to get to pos + + segProcData.traverse2.dist = dist; //Set up Traverse2 + segProcData.traverse2.segDir = backwards; + segProcData.traverse2.BezSegInx = BezSegInx; + segProcData.traverse2.segs_backwards = segs_backwards; +LOG( log_traverseCornu, 2, ( " TravCornu-Tr1 SI%d D%0.3f B%d RS%d \n", BezSegInx, dist, backwards, reverse_seg ) ) + SegProc( SEGPROC_TRAVERSE2, segPtr, &segProcData ); //Angle at pos2 + if ( segProcData.traverse2.dist <= 0 ) { //-ve or zero distance left over so stop there + *distR = 0; + trvTrk->pos = segProcData.traverse2.pos; //Use finishing pos + trvTrk->angle = segProcData.traverse2.angle; //Use finishing angle +LOG( log_traverseCornu, 1, ( "TravCornu-Ex1 -> [%0.3f %0.3f] A%0.3f D%0.3f\n", trvTrk->pos.x, trvTrk->pos.y, trvTrk->angle, *distR ) ) + return TRUE; + } + dist = segProcData.traverse2.dist; //How far left? + coOrd pos = segProcData.traverse2.pos; //Will always be at a Bezseg end + ANGLE_T angle = segProcData.traverse2.angle; //Angle of end therefore + + segProcData.traverse1.angle = angle; //Set up Traverse1 + segProcData.traverse1.pos = pos; + inx = cornu_backwards?inx-1:inx+1; //Here's where the global segment direction comes in +LOG( log_traverseCornu, 2, ( " TravCornu-Loop D%0.3f A%0.3f I%d \n", dist, angle, inx ) ) + } + //Ran out of Bez-Segs so punt to next Track + *distR = dist; //Tell caller what dist is left + + trvTrk->pos = GetTrkEndPos(trk,ep); //Which end were we heading for? + trvTrk->angle = NormalizeAngle(GetTrkEndAngle(trk, ep)+(cornu_backwards?180:0)); + trvTrk->trk = GetTrkEndTrk(trk,ep); //go onto next track (or NULL) + + if (trvTrk->trk==NULL) { + trvTrk->pos = pos1; + return TRUE; + } +LOG( log_traverseCornu, 1, ( "TravCornu-Ex2 --> [%0.3f %0.3f] A%0.3f D%0.3f\n", trvTrk->pos.x, trvTrk->pos.y, trvTrk->angle, *distR ) ) + return TRUE; + +} + + +static BOOL_T EnumerateCornu( track_p trk ) +{ + + if (trk != NULL) { + struct extraData *xx = GetTrkExtraData(trk); + DIST_T d; + d = xx->cornuData.length; + ScaleLengthIncrement( GetTrkScale(trk), d ); + } + return TRUE; +} + +static BOOL_T MergeCornu( + track_p trk0, + EPINX_T ep0, + track_p trk1, + EPINX_T ep1 ) +{ + struct extraData *xx0 = GetTrkExtraData(trk0); + struct extraData *xx1 = GetTrkExtraData(trk1); + track_p trk_after,trk_before; + EPINX_T ep_before,ep_after=-1; + coOrd p[2]; + coOrd c[2]; + ANGLE_T a[2]; + DIST_T r[2]; + + + if (!IsTrack(trk0) || !IsTrack(trk1) ) return FALSE; + if (GetTrkType(trk0) != GetTrkType(trk1)) return FALSE; + if (GetEndPtConnectedToMe(trk0,trk1) != ep0) return FALSE; + if (GetEndPtConnectedToMe(trk1,trk0) != ep1) return FALSE; + + if (ep0 == ep1) + return FALSE; + + UndoStart( _("Merge Cornu"), "MergeCornu( T%d[%d] T%d[%d] )", GetTrkIndex(trk0), ep0, GetTrkIndex(trk1), ep1 ); + p[0] = xx0->cornuData.pos[0]; + p[1] = xx1->cornuData.pos[1]; + a[0] = xx0->cornuData.a[0]; + a[1] = xx1->cornuData.a[1]; + c[0] = xx0->cornuData.c[0]; + c[1] = xx1->cornuData.c[1]; + r[0] = xx0->cornuData.r[0]; + r[1] = xx1->cornuData.r[1]; + track_p trk3 = NewCornuTrack(p,c,a,r,NULL,0); + if (trk3==NULL) { + wBeep(); + InfoMessage(_("Cornu Create Failed for p1[%0.3f,%0.3f] p2[%0.3f,%0.3f], c1[%0.3f,%0.3f] c2[%0.3f,%0.3f], a1=%0.3f a2=%0.3f, r1=%s r2=%s"), + p[0].x,p[0].y, + p[1].x,p[1].y, + c[0].x,c[0].y, + c[1].x,c[1].y, + a[0],a[1], + FormatDistance(r[0]),FormatDistance(r[1])); + UndoEnd(); + return FALSE; + } + + UndoModify( trk0 ); + UndoModify( trk1 ); + UndrawNewTrack( trk0 ); + UndrawNewTrack( trk1 ); + trk_after = GetTrkEndTrk( trk1, 1-ep1 ); + if (trk_after) { + ep_after = GetEndPtConnectedToMe( trk_after, trk1 ); + DisconnectTracks( trk1, 1-ep1, trk_after, ep_after ); + } + trk_before = GetTrkEndTrk( trk0, 1-ep0 ); + if (trk_before) { + ep_before = GetEndPtConnectedToMe( trk_before, trk0 ); + DisconnectTracks( trk0, 1-ep1, trk_before, ep_before ); + } + + DeleteTrack( trk1, TRUE ); + DeleteTrack( trk0, TRUE ); + if (trk_after) { + SetTrkEndPoint( trk_after, ep_after, xx0->cornuData.pos[1], NormalizeAngle(xx0->cornuData.a[1]+180)); + ConnectTracks( trk3, 1, trk_after, ep_after); + } + if (trk_before) { + SetTrkEndPoint( trk_before, ep_before, xx0->cornuData.pos[0], NormalizeAngle(xx0->cornuData.a[0]+180)); + ConnectTracks( trk3, 0, trk_before, ep_before); + } + DrawNewTrack( trk3 ); + UndoEnd(); + + + return TRUE; +} + +BOOL_T GetBezierSegmentsFromCornu(track_p trk, dynArr_t * segs) { + struct extraData * xx = GetTrkExtraData(trk); + for (int i=0;icornuData.arcSegs.cnt;i++) { + DYNARR_APPEND(trkSeg_t, * segs, 10); + trkSeg_p segPtr = &DYNARR_N(trkSeg_t,* segs,segs->cnt-1); + segPtr->type = SEG_BEZTRK; + segPtr->color = wDrawColorBlack; + segPtr->width = 0; + if (segPtr->bezSegs.ptr) MyFree(segPtr->bezSegs.ptr); + segPtr->bezSegs.cnt = 0; + segPtr->bezSegs.max = 0; + segPtr->bezSegs.ptr = NULL; + trkSeg_p p = (trkSeg_t *) xx->cornuData.arcSegs.ptr+i; + for (int j=0;j<4;j++) segPtr->u.b.pos[j] = p->u.b.pos[j]; + FixUpBezierSeg(segPtr->u.b.pos,segPtr,TRUE); + } + return TRUE; +} + +static DIST_T GetLengthCornu( track_p trk ) +{ + struct extraData *xx = GetTrkExtraData(trk); + DIST_T length = 0.0; + segProcData_t segProcData; + for(int i=0;icornuData.arcSegs.cnt;i++) { + trkSeg_t seg = DYNARR_N(trkSeg_t,xx->cornuData.arcSegs,i); + if (seg.type == SEG_FILCRCL) continue; + SegProc(SEGPROC_LENGTH, &seg, &segProcData); + length += segProcData.length.length; + } + return length; +} + + +static BOOL_T GetParamsCornu( int inx, track_p trk, coOrd pos, trackParams_t * params ) +{ + int segInx, segInx2; + BOOL_T back, negative; + DIST_T d; + struct extraData *xx = GetTrkExtraData(trk); + params->type = curveTypeCornu; + params->track_angle = GetAngleSegs( //Find correct Segment and nearest point in it + xx->cornuData.arcSegs.cnt,xx->cornuData.arcSegs.ptr, + &pos, &segInx, &d , &back, &segInx2, &negative ); + trkSeg_p segPtr = &DYNARR_N(trkSeg_t,xx->cornuData.arcSegs,segInx); + if (negative != back) params->track_angle = NormalizeAngle(params->track_angle+180); //Cornu is in reverse + if (segPtr->type == SEG_STRTRK) { + params->arcR = 0.0; + } else if (segPtr->type == SEG_CRVTRK) { + params->arcR = fabs(segPtr->u.c.radius); + params->arcP = segPtr->u.c.center; + params->arcA0 = segPtr->u.c.a0; + params->arcA1 = segPtr->u.c.a1; + } else if (segPtr->type == SEG_BEZTRK) { + trkSeg_p segPtr2 = &DYNARR_N(trkSeg_t,segPtr->bezSegs,segInx2); + if (segPtr2->type == SEG_STRTRK) { + params->arcR = 0.0; + } else if (segPtr2->type == SEG_CRVTRK) { + params->arcR = fabs(segPtr2->u.c.radius); + params->arcP = segPtr2->u.c.center; + params->arcA0 = segPtr2->u.c.a0; + params->arcA1 = segPtr2->u.c.a1; + } + } + for (int i=0;i<2;i++) { + params->cornuEnd[i] = xx->cornuData.pos[i]; + params->cornuAngle[i] = xx->cornuData.a[i]; + params->cornuRadius[i] = xx->cornuData.r[i]; + params->cornuCenter[i] = xx->cornuData.c[i]; + } + params->len = xx->cornuData.length; + if ( inx == PARAMS_PARALLEL ) { + params->ep = 0; + } else if (inx == PARAMS_CORNU) { + params->ep = PickEndPoint( pos, trk); + } else { + params->ep = PickUnconnectedEndPointSilent( pos, trk ); + } + if (params->ep>=0) { + params->angle = GetTrkEndAngle(trk,params->ep); + } + + return TRUE; + +} + + + +static BOOL_T QueryCornu( track_p trk, int query ) +{ + struct extraData * xx = GetTrkExtraData(trk); + switch ( query ) { + case Q_CAN_GROUP: + return FALSE; + break; + case Q_FLIP_ENDPTS: + case Q_HAS_DESC: + return TRUE; + break; + case Q_EXCEPTION: + return xx->cornuData.minCurveRadius < (GetLayoutMinTrackRadius()-EPSILON); + break; + case Q_IS_CORNU: + return TRUE; + break; + case Q_ISTRACK: + return TRUE; + break; + case Q_CAN_PARALLEL: + return TRUE; + break; + // case Q_MODIFY_CANT_SPLIT: Remove Split Restriction + // case Q_CANNOT_BE_ON_END: Remove Restriction - Can have Cornu with no ends + case Q_CANNOT_PLACE_TURNOUT: + return TRUE; + break; + case Q_IGNORE_EASEMENT_ON_EXTEND: + return TRUE; + break; + case Q_MODIFY_CAN_SPLIT: + case Q_CAN_EXTEND: + return TRUE; + default: + return FALSE; + } +} + + +static void FlipCornu( + track_p trk, + coOrd orig, + ANGLE_T angle ) +{ + struct extraData * xx = GetTrkExtraData(trk); + FlipPoint( &xx->cornuData.pos[0], orig, angle ); + FlipPoint( &xx->cornuData.pos[1], orig, angle ); + FlipPoint( &xx->cornuData.c[0], orig, angle); + FlipPoint( &xx->cornuData.c[1], orig, angle); + xx->cornuData.a[0] = NormalizeAngle( 2*angle - xx->cornuData.a[0] ); + xx->cornuData.a[1] = NormalizeAngle( 2*angle - xx->cornuData.a[1] ); + + RebuildCornu(trk); + +} + +static ANGLE_T GetAngleCornu( + track_p trk, + coOrd pos, + EPINX_T * ep0, + EPINX_T * ep1 ) +{ + struct extraData * xx = GetTrkExtraData(trk); + ANGLE_T angle; + BOOL_T back, neg; + int indx; + angle = GetAngleSegs( xx->cornuData.arcSegs.cnt, (trkSeg_p)xx->cornuData.arcSegs.ptr, &pos, &indx, NULL, &back, NULL, &neg ); + if ( ep0 ) *ep0 = -1; + if ( ep1 ) *ep1 = -1; + return angle; +} + +BOOL_T GetCornuSegmentFromTrack(track_p trk, trkSeg_p seg_p) { + //TODO If we support Group + return TRUE; +} + + +static BOOL_T MakeParallelCornu( + track_p trk, + coOrd pos, + DIST_T sep, + track_p * newTrkR, + coOrd * p0R, + coOrd * p1R ) +{ + struct extraData * xx = GetTrkExtraData(trk); + coOrd np[4], p, nc[2]; + ANGLE_T atrk, diff_a, na[2]; + DIST_T nr[2]; + + + //Produce cornu that is translated parallel to the existing Cornu + // - not a precise result if the cornu end angles are not in the same general direction. + // The expectation is that the user will have to adjust it - unless and until we produce + // a new algo to adjust the control points to be parallel to the endpoints. + + p = pos; + DistanceCornu(trk, &p); //Find nearest point on curve + atrk = GetAngleSegs(xx->cornuData.arcSegs.cnt,(trkSeg_t *)(xx->cornuData.arcSegs.ptr),&p,NULL,NULL,NULL,NULL, NULL); + diff_a = NormalizeAngle(FindAngle(pos,p)-atrk); //we know it will be +/-90... + //find parallel move x and y for points + BOOL_T above = FALSE; + if ( diff_a < 180 ) above = TRUE; //Above track + if (xx->cornuData.a[0] <180) above = !above; + Translate(&np[0],xx->cornuData.pos[0],xx->cornuData.a[0]+(above?90:-90),sep); + Translate(&np[1],xx->cornuData.pos[1],xx->cornuData.a[1]+(above?-90:90),sep); + na[0]=xx->cornuData.a[0]; + na[1]=xx->cornuData.a[1]; + if (xx->cornuData.r[0]) { + //Find angle between center and end angle of track + ANGLE_T ea0 = + NormalizeAngle(FindAngle(xx->cornuData.c[0],xx->cornuData.pos[0])-xx->cornuData.a[0]); + DIST_T sep0 = sep; + if (ea0>180) sep0 = -sep; + nr[0]=xx->cornuData.r[0]+(above?sep0:-sep0); //Needs adjustment + nc[0]=xx->cornuData.c[0]; + } else { + nr[0] = 0; + nc[0] = zero; + } + + if (xx->cornuData.r[1]) { + ANGLE_T ea1 = + NormalizeAngle(FindAngle(xx->cornuData.c[1],xx->cornuData.pos[1])-xx->cornuData.a[1]); + DIST_T sep1 = sep; + if (ea1<180) sep1 = -sep; + nr[1]=xx->cornuData.r[1]+(above?sep1:-sep1); //Needs adjustment + nc[1]=xx->cornuData.c[1]; + } else { + nr[1] = 0; + nc[1] = zero; + } + + if ( newTrkR ) { + *newTrkR = NewCornuTrack( np, nc, na, nr, NULL, 0); + if (*newTrkR==NULL) { + wBeep(); + InfoMessage(_("Cornu Create Failed for p1[%0.3f,%0.3f] p2[%0.3f,%0.3f], c1[%0.3f,%0.3f] c2[%0.3f,%0.3f], a1=%0.3f a2=%0.3f, r1=%s r2=%s"), + np[0].x,np[0].y, + np[1].x,np[1].y, + nc[0].x,nc[0].y, + nc[1].x,nc[1].y, + na[0],na[1], + FormatDistance(nr[0]),FormatDistance(nr[1])); + return FALSE; + } + + } else { + tempSegs_da.cnt = 0; + CallCornu0(np,nc,na,nr,&tempSegs_da,FALSE); + } + if ( p0R ) *p0R = np[0]; + if ( p1R ) *p1R = np[1]; + return TRUE; +} + +/* + * When an undo is run, the array of segs is missing - they are not saved to the Undo log. So Undo calls this routine to + * ensure + * - that the Segs are restored and + * - other fields reset. + */ +EXPORT BOOL_T RebuildCornu (track_p trk) +{ + struct extraData *xx; + xx = GetTrkExtraData(trk); + xx->cornuData.arcSegs.max = 0; + xx->cornuData.arcSegs.cnt = 0; + //if (xx->cornuData.arcSegs.ptr) MyFree(xx->cornuData.arcSegs.ptr); + xx->cornuData.arcSegs.ptr = NULL; + if (!FixUpCornu0(xx->cornuData.pos,xx->cornuData.c,xx->cornuData.a,xx->cornuData.r, xx)) return FALSE; + ComputeCornuBoundingBox(trk, xx); + return TRUE; +} + + +static trackCmd_t cornuCmds = { + "CORNU", + DrawCornu, + DistanceCornu, + DescribeCornu, + DeleteCornu, + WriteCornu, + ReadCornu, + MoveCornu, + RotateCornu, + RescaleCornu, + NULL, + GetAngleCornu, + SplitCornu, + TraverseCornu, + EnumerateCornu, + NULL, /* redraw */ + NULL, /* trim */ + MergeCornu, + NULL, /* modify */ + GetLengthCornu, + GetParamsCornu, + MoveCornuEndPt, /* Move EndPt */ + QueryCornu, + NULL, /* ungroup */ + FlipCornu, + NULL, + NULL, + NULL, + MakeParallelCornu, + NULL, + RebuildCornu + }; + + + + + +/**************************************** + * + * GRAPHICS COMMANDS + * + */ + + + + +track_p NewCornuTrack(coOrd pos[2], coOrd center[2],ANGLE_T angle[2], DIST_T radius[2], trkSeg_t * tempsegs, int count) +{ + struct extraData *xx; + track_p p; + p = NewTrack( 0, T_CORNU, 2, sizeof *xx ); + xx = GetTrkExtraData(p); + xx->cornuData.pos[0] = pos[0]; + xx->cornuData.pos[1] = pos[1]; + xx->cornuData.a[0] = angle[0]; + xx->cornuData.a[1] = angle[1]; + xx->cornuData.r[0] = radius[0]; + xx->cornuData.r[1] = radius[1]; + xx->cornuData.c[0] = center[0]; + xx->cornuData.c[1] = center[1]; + + if (!FixUpCornu0(xx->cornuData.pos,xx->cornuData.c,xx->cornuData.a,xx->cornuData.r, xx)) { + ErrorMessage("Create Cornu Failed"); + return NULL; + } +LOG( log_cornu, 1, ( "NewCornuTrack( EP1 %0.3f, %0.3f, EP2 %0.3f, %0.3f ) = %d\n", pos[0].x, pos[0].y, pos[1].x, pos[1].y, GetTrkIndex(p) ) ) + ComputeCornuBoundingBox( p, xx ); + SetTrkEndPoint( p, 0, pos[0], xx->cornuData.a[0]); + SetTrkEndPoint( p, 1, pos[1], xx->cornuData.a[1]); + CheckTrackLength( p ); + SetTrkBits( p, TB_HIDEDESC ); + return p; +} + + +EXPORT void InitTrkCornu( void ) +{ + T_CORNU = InitObject( &cornuCmds ); + log_cornu = LogFindIndex( "Cornu" ); + log_traverseCornu = LogFindIndex( "traverseCornu" ); +} + -- cgit v1.2.3