summaryrefslogtreecommitdiff
path: root/app/bin/tbezier.c
diff options
context:
space:
mode:
Diffstat (limited to 'app/bin/tbezier.c')
-rw-r--r--app/bin/tbezier.c1629
1 files changed, 1629 insertions, 0 deletions
diff --git a/app/bin/tbezier.c b/app/bin/tbezier.c
new file mode 100644
index 0000000..8d7ca6c
--- /dev/null
+++ b/app/bin/tbezier.c
@@ -0,0 +1,1629 @@
+/** \file tbezier.c
+ * 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.
+ *
+ *****************************************************************************
+ * BEZIER TRACK (and LINE)
+ *
+ * tbezier.c has all the Track functions (for both T_BEZIER and T_BEZLIN) but all the heavy-math-lifting is delegated to cbezier.c
+ *
+ * Both Bezier Tracks and Lines are defined with two end points and two control points. Each end and control point pair is joined by a control arm.
+ * The angle between the control and end point (arm angle) determines the angle at the end point.
+ * The way the curve moves in between the ends is driven by the relative lengths of the two control arms.
+ * In general, lengthening one arm while keeping the other arm length fixed results in a curve that changes more slowly from the lengthened end and more swiftly from the other.
+ * Very un-prototypical track curves are easy to draw with Bezier, so beware!
+ *
+ * Another large user of tbezier.c is the Cornu function by way of its support for Bezier segments, which are used to approximate Cornu curves.
+ *
+ * In XTrkcad, Bezier curves are rendered into a set of Curved and Straight segments for display. This set is also saved, although the code recalculates a fresh set upon reload.
+ *
+ */
+
+
+#include "track.h"
+#include "draw.h"
+#include "tbezier.h"
+#include "cbezier.h"
+#include "ccurve.h"
+#include "cstraigh.h"
+#include "cjoin.h"
+#include "utility.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_BEZIER = -1;
+EXPORT TRKTYP_T T_BZRLIN = -1;
+
+
+struct extraData {
+ BezierData_t bezierData;
+ };
+
+static int log_bezier = 0;
+
+static DIST_T GetLengthBezier( track_p );
+
+/****************************************
+ *
+ * UTILITIES
+ *
+ */
+
+/*
+ * Run after any changes to the Bezier points
+ */
+EXPORT void FixUpBezier(coOrd pos[4], struct extraData* xx, BOOL_T track) {
+ xx->bezierData.a0 = NormalizeAngle(FindAngle(pos[1], pos[0]));
+ xx->bezierData.a1 = NormalizeAngle(FindAngle(pos[2], pos[3]));
+
+ ConvertToArcs(pos, &xx->bezierData.arcSegs, track, xx->bezierData.segsColor,
+ xx->bezierData.segsWidth);
+ xx->bezierData.minCurveRadius = BezierMinRadius(pos,
+ xx->bezierData.arcSegs);
+ xx->bezierData.length = BezierLength(pos, xx->bezierData.arcSegs);
+}
+
+/*
+ * Run after any changes to the Bezier points for a Segment
+ */
+EXPORT void FixUpBezierSeg(coOrd pos[4], trkSeg_p p, BOOL_T track) {
+ p->u.b.angle0 = NormalizeAngle(FindAngle(pos[1], pos[0]));
+ p->u.b.angle3 = NormalizeAngle(FindAngle(pos[2], pos[3]));
+ ConvertToArcs(pos, &p->bezSegs, track, p->color,
+ p->width);
+ p->u.b.minRadius = BezierMinRadius(pos,
+ p->bezSegs);
+ p->u.b.length = BezierLength(pos, p->bezSegs);
+}
+
+EXPORT void FixUpBezierSegs(trkSeg_p p,int segCnt) {
+ for (int i=0;i<segCnt;i++,p++) {
+ if (p->type == SEG_BEZTRK || p->type == SEG_BEZLIN) {
+ FixUpBezierSeg(p->u.b.pos,p,p->type == SEG_BEZTRK);
+ }
+ }
+}
+
+
+static void GetBezierAngles( ANGLE_T *a0, ANGLE_T *a1, track_p trk )
+{
+ assert( trk != NULL );
+
+ *a0 = NormalizeAngle( GetTrkEndAngle(trk,0) );
+ *a1 = NormalizeAngle( GetTrkEndAngle(trk,1) );
+
+ LOG( log_bezier, 4, ( "getBezierAngles: = %0.3f %0.3f\n", *a0, *a1 ) )
+}
+
+
+static void ComputeBezierBoundingBox( track_p trk, struct extraData * xx )
+{
+ coOrd hi, lo;
+ hi.x = lo.x = xx->bezierData.pos[0].x;
+ hi.y = lo.y = xx->bezierData.pos[0].y;
+
+ for (int i=1; i<=3;i++) {
+ hi.x = hi.x < xx->bezierData.pos[i].x ? xx->bezierData.pos[i].x : hi.x;
+ hi.y = hi.y < xx->bezierData.pos[i].y ? xx->bezierData.pos[i].y : hi.y;
+ lo.x = lo.x > xx->bezierData.pos[i].x ? xx->bezierData.pos[i].x : lo.x;
+ lo.y = lo.y > xx->bezierData.pos[i].y ? xx->bezierData.pos[i].y : lo.y;
+ }
+ SetBoundingBox( trk, hi, lo );
+}
+
+
+DIST_T BezierDescriptionDistance(
+ coOrd pos,
+ track_p trk )
+{
+ struct extraData *xx = GetTrkExtraData(trk);
+ coOrd p1;
+
+ if ( GetTrkType( trk ) != T_BEZIER || ( GetTrkBits( trk ) & TB_HIDEDESC ) != 0 )
+ return 100000;
+
+ p1.x = xx->bezierData.pos[0].x + ((xx->bezierData.pos[3].x-xx->bezierData.pos[0].x)/2) + xx->bezierData.descriptionOff.x;
+ p1.y = xx->bezierData.pos[0].y + ((xx->bezierData.pos[3].y-xx->bezierData.pos[0].y)/2) + xx->bezierData.descriptionOff.y;
+
+ return FindDistance( p1, pos );
+}
+
+
+static void DrawBezierDescription(
+ 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->bezierData.pos[0].x + ((xx->bezierData.pos[3].x - xx->bezierData.pos[0].x)/2);
+ pos.y = xx->bezierData.pos[0].y + ((xx->bezierData.pos[3].y - xx->bezierData.pos[0].y)/2);
+ pos.x += xx->bezierData.descriptionOff.x;
+ pos.y += xx->bezierData.descriptionOff.y;
+ fp = wStandardFont( F_TIMES, FALSE, FALSE );
+ sprintf( message, _("Bezier Curve: length=%s min radius=%s"),
+ FormatDistance(xx->bezierData.length), FormatDistance(xx->bezierData.minCurveRadius));
+ DrawBoxedString( BOX_BOX, d, pos, message, fp, (wFontSize_t)descriptionFontSize, color, 0.0 );
+}
+
+
+STATUS_T BezierDescriptionMove(
+ 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_BEZIER) return C_TERMINATE;
+ p0.x = xx->bezierData.pos[0].x + ((xx->bezierData.pos[3].x - xx->bezierData.pos[0].x)/2);
+ p0.y = xx->bezierData.pos[0].y + ((xx->bezierData.pos[3].y - xx->bezierData.pos[0].y)/2);
+ switch (action) {
+ case C_DOWN:
+ case C_MOVE:
+ case C_UP:
+ editState = TRUE;
+ p1 = pos;
+ color = GetTrkColor( trk, &mainD );
+ DrawLine( &mainD, p0, pos, 0, wDrawColorBlack );
+ xx->bezierData.descriptionOff.x = pos.x - p0.x;
+ xx->bezierData.descriptionOff.y = pos.y - p0.y;
+ 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[4];
+ FLOAT_T elev[2];
+ FLOAT_T length;
+ DIST_T minRadius;
+ FLOAT_T grade;
+ unsigned int layerNumber;
+ ANGLE_T angle[2];
+ DIST_T radius[2];
+ coOrd center[2];
+ dynArr_t segs;
+ long width;
+ wDrawColor color;
+ } bezData;
+typedef enum { P0, A0, R0, C0, Z0, CP1, CP2, P1, A1, R1, C1, Z1, RA, LN, GR, LY, WI, CO } crvDesc_e;
+static descData_t bezDesc[] = {
+/*P0*/ { DESC_POS, N_("End Pt 1: X,Y"), &bezData.pos[0] },
+/*A0*/ { DESC_ANGLE, N_("End Angle"), &bezData.angle[0] },
+/*R0*/ { DESC_DIM, N_("Radius"), &bezData.radius[0] },
+/*C0*/ { DESC_POS, N_("Center X,Y"), &bezData.center[0]},
+/*Z0*/ { DESC_DIM, N_("Z1"), &bezData.elev[0] },
+/*CP1*/ { DESC_POS, N_("Ctl Pt 1: X,Y"), &bezData.pos[1] },
+/*CP2*/ { DESC_POS, N_("Ctl Pt 2: X,Y"), &bezData.pos[2] },
+/*P1*/ { DESC_POS, N_("End Pt 2: X,Y"), &bezData.pos[3] },
+/*A1*/ { DESC_ANGLE, N_("End Angle"), &bezData.angle[1] },
+/*R1*/ { DESC_DIM, N_("Radius"), &bezData.radius[1] },
+/*C1*/ { DESC_POS, N_("Center X,Y"), &bezData.center[1]},
+/*Z1*/ { DESC_DIM, N_("Z2"), &bezData.elev[1] },
+/*RA*/ { DESC_DIM, N_("MinRadius"), &bezData.radius },
+/*LN*/ { DESC_DIM, N_("Length"), &bezData.length },
+/*GR*/ { DESC_FLOAT, N_("Grade"), &bezData.grade },
+/*LY*/ { DESC_LAYER, N_("Layer"), &bezData.layerNumber },
+/*WI*/ { DESC_LONG, N_("Line Width"), &bezData.width},
+/*CO*/ { DESC_COLOR, N_("Line Color"), &bezData.color},
+ { DESC_NULL } };
+
+static void UpdateBezier( track_p trk, int inx, descData_p descUpd, BOOL_T final )
+{
+ struct extraData *xx = GetTrkExtraData(trk);
+ BOOL_T updateEndPts;
+ EPINX_T ep;
+ ANGLE_T angle1, angle2;
+
+ if ( inx == -1 )
+ return;
+ updateEndPts = FALSE;
+ switch ( inx ) {
+ case P0:
+ if (GetTrkEndTrk(trk,0)) break;
+ updateEndPts = TRUE;
+ xx->bezierData.pos[0] = bezData.pos[0];
+ bezDesc[P0].mode |= DESC_CHANGE;
+ /* no break */
+ case P1:
+ if (GetTrkEndTrk(trk,0) && GetTrkEndTrk(trk,1)) break;
+ updateEndPts = TRUE;
+ xx->bezierData.pos[3]= bezData.pos[3];
+ bezDesc[P1].mode |= DESC_CHANGE;
+ break;
+ case A0:
+ case A1:
+ break;
+ case CP1:
+ if (GetTrkEndTrk(trk,0)) {
+ angle1 = NormalizeAngle(GetTrkEndAngle(trk,0));
+ angle2 = NormalizeAngle(FindAngle(bezData.pos[1], xx->bezierData.pos[0])-angle1);
+ if (angle2 > 90.0 && angle2 < 270.0)
+ Translate( &bezData.pos[1], xx->bezierData.pos[0], angle1, -FindDistance( xx->bezierData.pos[0], bezData.pos[1] )*cos(D2R(angle2)));
+ }
+ xx->bezierData.pos[1] = bezData.pos[1];
+ bezDesc[CP1].mode |= DESC_CHANGE;
+ updateEndPts = TRUE;
+ break;
+ case CP2:
+ if (GetTrkEndTrk(trk,1)) {
+ angle1 = NormalizeAngle(GetTrkEndAngle(trk,1));
+ angle2 = NormalizeAngle(FindAngle(bezData.pos[2], xx->bezierData.pos[3])-angle1);
+ if (angle2 > 90.0 && angle2 < 270.0)
+ Translate( &bezData.pos[2], xx->bezierData.pos[3], angle1, -FindDistance( xx->bezierData.pos[3], bezData.pos[0] )*cos(D2R(angle2)));
+ }
+ xx->bezierData.pos[2] = bezData.pos[2];
+ bezDesc[CP2].mode |= DESC_CHANGE;
+ updateEndPts = TRUE;
+ break;
+ case Z0:
+ case Z1:
+ ep = (inx==Z0?0:1);
+ UpdateTrkEndElev( trk, ep, GetTrkEndElevUnmaskedMode(trk,ep), bezData.elev[ep], NULL );
+ ComputeElev( trk, 1-ep, FALSE, &bezData.elev[1-ep], NULL );
+ if ( bezData.length > minLength )
+ bezData.grade = fabs( (bezData.elev[0]-bezData.elev[1])/bezData.length )*100.0;
+ else
+ bezData.grade = 0.0;
+ bezDesc[GR].mode |= DESC_CHANGE;
+ bezDesc[inx==Z0?Z1:Z0].mode |= DESC_CHANGE;
+ return;
+ case LY:
+ SetTrkLayer( trk, bezData.layerNumber);
+ break;
+ case WI:
+ xx->bezierData.segsWidth = bezData.width/mainD.dpi;
+ break;
+ case CO:
+ xx->bezierData.segsColor = bezData.color;
+ break;
+ default:
+ AbortProg( "updateBezier: Bad inx %d", inx );
+ }
+ ConvertToArcs(xx->bezierData.pos, &xx->bezierData.arcSegs, IsTrack(trk)?TRUE:FALSE, xx->bezierData.segsColor, xx->bezierData.segsWidth);
+ trackParams_t params;
+ for (int i=0;i<2;i++) {
+ GetTrackParams(0,trk,xx->bezierData.pos[i],&params);
+ bezData.radius[i] = params.arcR;
+ bezData.center[i] = params.arcP;
+ }
+ if (updateEndPts) {
+ if ( GetTrkEndTrk(trk,0) == NULL ) {
+ SetTrkEndPoint( trk, 0, bezData.pos[0], NormalizeAngle( FindAngle(bezData.pos[0], bezData.pos[1]) ) );
+ bezData.angle[0] = GetTrkEndAngle(trk,0);
+ bezDesc[A0].mode |= DESC_CHANGE;
+ GetTrackParams(PARAMS_CORNU,trk,xx->bezierData.pos[0],&params);
+ bezData.radius[0] = params.arcR;
+ bezData.center[0] = params.arcP;
+ }
+ if ( GetTrkEndTrk(trk,1) == NULL ) {
+ SetTrkEndPoint( trk, 1, bezData.pos[3], NormalizeAngle( FindAngle(bezData.pos[2], bezData.pos[3]) ) );
+ bezData.angle[1] = GetTrkEndAngle(trk,1);
+ bezDesc[A1].mode |= DESC_CHANGE;
+ GetTrackParams(PARAMS_CORNU,trk,xx->bezierData.pos[1],&params);
+ bezData.radius[1] = params.arcR;
+ bezData.center[1] = params.arcP;
+ }
+ }
+
+ FixUpBezier(xx->bezierData.pos, xx, IsTrack(trk));
+ ComputeBezierBoundingBox(trk, xx);
+ DrawNewTrack( trk );
+}
+
+static void DescribeBezier( track_p trk, char * str, CSIZE_T len )
+{
+ struct extraData *xx = GetTrkExtraData(trk);
+ DIST_T d;
+ int fix0, fix1 = 0;
+
+ d = xx->bezierData.length;
+ sprintf( str, _("Bezier %s(%d): Layer=%u MinRadius=%s Length=%s EP=[%0.3f,%0.3f] [%0.3f,%0.3f] CP1=[%0.3f,%0.3f] CP2=[%0.3f, %0.3f]"),
+ GetTrkType(trk)==T_BEZIER?"Track":"Line",
+ GetTrkIndex(trk),
+ GetTrkLayer(trk)+1,
+ FormatDistance(xx->bezierData.minCurveRadius),
+ FormatDistance(d),
+ PutDim(xx->bezierData.pos[0].x),PutDim(xx->bezierData.pos[0].y),
+ PutDim(xx->bezierData.pos[3].x),PutDim(xx->bezierData.pos[3].y),
+ PutDim(xx->bezierData.pos[1].x),PutDim(xx->bezierData.pos[1].y),
+ PutDim(xx->bezierData.pos[2].x),PutDim(xx->bezierData.pos[2].y));
+
+ if (GetTrkType(trk) == T_BEZIER) {
+ fix0 = GetTrkEndTrk(trk,0)!=NULL;
+ fix1 = GetTrkEndTrk(trk,1)!=NULL;
+ }
+
+ bezData.length = GetLengthBezier(trk);
+ bezData.minRadius = xx->bezierData.minCurveRadius;
+ if (bezData.minRadius >= 100000.00) bezData.minRadius = 0;
+ bezData.layerNumber = GetTrkLayer(trk);
+ bezData.pos[0] = xx->bezierData.pos[0];
+ bezData.pos[1] = xx->bezierData.pos[1];
+ bezData.pos[2] = xx->bezierData.pos[2];
+ bezData.pos[3] = xx->bezierData.pos[3];
+ bezData.angle[0] = xx->bezierData.a0;
+ bezData.angle[1] = xx->bezierData.a1;
+ trackParams_t params;
+ GetTrackParams(PARAMS_CORNU,trk,xx->bezierData.pos[0],&params);
+ bezData.radius[0] = params.arcR;
+ bezData.center[0] = params.arcP;
+ GetTrackParams(PARAMS_CORNU,trk,xx->bezierData.pos[3],&params);
+ bezData.radius[1] = params.arcR;
+ bezData.center[1] = params.arcP;
+
+ if (GetTrkType(trk) == T_BEZIER) {
+ ComputeElev( trk, 0, FALSE, &bezData.elev[0], NULL );
+ ComputeElev( trk, 1, FALSE, &bezData.elev[1], NULL );
+
+ if ( bezData.length > minLength )
+ bezData.grade = fabs( (bezData.elev[0]-bezData.elev[1])/bezData.length )*100.0;
+ else
+ bezData.grade = 0.0;
+ }
+
+ bezDesc[P0].mode = fix0?DESC_RO:0;
+ bezDesc[P1].mode = fix1?DESC_RO:0;
+ bezDesc[LN].mode = DESC_RO;
+ bezDesc[CP1].mode = 0;
+ bezDesc[CP2].mode = 0;
+ if (GetTrkType(trk) == T_BEZIER) {
+ bezDesc[Z0].mode = EndPtIsDefinedElev(trk,0)?0:DESC_RO;
+ bezDesc[Z1].mode = EndPtIsDefinedElev(trk,1)?0:DESC_RO;
+ }
+ else
+ bezDesc[Z0].mode = bezDesc[Z1].mode = DESC_IGNORE;
+ bezDesc[A0].mode = DESC_RO;
+ bezDesc[A1].mode = DESC_RO;
+ bezDesc[C0].mode = DESC_RO;
+ bezDesc[C1].mode = DESC_RO;
+ bezDesc[R0].mode = DESC_RO;
+ bezDesc[R1].mode = DESC_RO;
+ bezDesc[GR].mode = DESC_RO;
+ bezDesc[RA].mode = DESC_RO;
+ bezDesc[LY].mode = DESC_NOREDRAW;
+ bezData.width = (long)floor(xx->bezierData.segsWidth*mainD.dpi+0.5);
+ bezDesc[WI].mode = GetTrkType(trk) == T_BEZIER?DESC_IGNORE:0;
+ bezData.color = xx->bezierData.segsColor;
+ bezDesc[CO].mode = GetTrkType(trk) == T_BEZIER?DESC_IGNORE:0;
+
+ if (GetTrkType(trk) == T_BEZIER)
+ DoDescribe( _("Bezier Track"), trk, bezDesc, UpdateBezier );
+ else
+ DoDescribe( _("Bezier Line"), trk, bezDesc, UpdateBezier );
+
+}
+
+static DIST_T DistanceBezier( track_p t, coOrd * p )
+{
+ struct extraData *xx = GetTrkExtraData(t);
+
+ DIST_T d = 100000.0;
+ coOrd p2 = xx->bezierData.pos[0]; //Set initial point
+ segProcData_t segProcData;
+ for (int i = 0;i<xx->bezierData.arcSegs.cnt;i++) {
+ segProcData.distance.pos1 = * p;
+ SegProc(SEGPROC_DISTANCE,&DYNARR_N(trkSeg_t,xx->bezierData.arcSegs,i),&segProcData);
+ if (segProcData.distance.dd<d) {
+ d = segProcData.distance.dd;
+ p2 = segProcData.distance.pos1;
+ }
+ }
+ * p = p2;
+ return d;
+}
+
+static void DrawBezier( track_p t, drawCmd_p d, wDrawColor color )
+{
+ struct extraData *xx = GetTrkExtraData(t);
+ long widthOptions = DTS_LEFT|DTS_RIGHT;
+
+
+ if (GetTrkType(t) == T_BZRLIN) {
+ DrawSegsO(d,t,zero,0.0,xx->bezierData.arcSegs.ptr,xx->bezierData.arcSegs.cnt, 0.0, color, 0);
+ return;
+ }
+
+ 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 ) {
+ DrawBezierDescription( 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->scale<scale2rail/2 )
+ DrawSegsO(d,t,zero,0.0,xx->bezierData.arcSegs.ptr,xx->bezierData.arcSegs.cnt, GetTrkGauge(t), color, widthOptions|DTS_TIES);
+ DrawSegsO(d,t,zero,0.0,xx->bezierData.arcSegs.ptr,xx->bezierData.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 );
+ }
+}
+
+static void DeleteBezier( track_p t )
+{
+ struct extraData *xx = GetTrkExtraData(t);
+
+ for (int i=0;i<xx->bezierData.arcSegs.cnt;i++) {
+ trkSeg_t s = DYNARR_N(trkSeg_t,xx->bezierData.arcSegs,i);
+ 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;
+ }
+ }
+ if (xx->bezierData.arcSegs.ptr && !xx->bezierData.arcSegs.max)
+ MyFree(xx->bezierData.arcSegs.ptr);
+ xx->bezierData.arcSegs.max = 0;
+ xx->bezierData.arcSegs.cnt = 0;
+ xx->bezierData.arcSegs.ptr = NULL;
+}
+
+static BOOL_T WriteBezier( track_p t, FILE * f )
+{
+ struct extraData *xx = GetTrkExtraData(t);
+ long options;
+ BOOL_T rc = TRUE;
+ BOOL_T track =(GetTrkType(t)==T_BEZIER);
+ options = GetTrkWidth(t) & 0x0F;
+ if ( ( GetTrkBits(t) & TB_HIDEDESC ) == 0 ) options |= 0x80;
+ rc &= fprintf(f, "%s %d %u %ld %ld %0.6f %s %d %0.6f %0.6f %0.6f %0.6f %0.6f %0.6f %0.6f %0.6f 0 %0.6f %0.6f \n",
+ track?"BEZIER":"BZRLIN",GetTrkIndex(t), GetTrkLayer(t), (long)options, wDrawGetRGB(xx->bezierData.segsColor), xx->bezierData.segsWidth,
+ GetTrkScaleName(t), GetTrkVisible(t),
+ xx->bezierData.pos[0].x, xx->bezierData.pos[0].y,
+ xx->bezierData.pos[1].x, xx->bezierData.pos[1].y,
+ xx->bezierData.pos[2].x, xx->bezierData.pos[2].y,
+ xx->bezierData.pos[3].x, xx->bezierData.pos[3].y,
+ xx->bezierData.descriptionOff.x, xx->bezierData.descriptionOff.y )>0;
+ if (track) {
+ rc &= WriteEndPt( f, t, 0 );
+ rc &= WriteEndPt( f, t, 1 );
+ }
+ rc &= WriteSegs( f, xx->bezierData.arcSegs.cnt, xx->bezierData.arcSegs.ptr );
+ return rc;
+}
+
+static void ReadBezier( char * line )
+{
+ struct extraData *xx;
+ track_p t;
+ wIndex_t index;
+ BOOL_T visible;
+ coOrd p0, c1, c2, p1, dp;
+ char scale[10];
+ wIndex_t layer;
+ long options;
+ char * cp = NULL;
+ unsigned long rgb;
+ DIST_T width;
+
+ if (!GetArgs( line+6, "dLluwsdpppp0p",
+ &index, &layer, &options, &rgb, &width, scale, &visible, &p0, &c1, &c2, &p1, &dp ) ) {
+ return;
+ }
+ if (strncmp(line,"BEZIER",6)==0)
+ t = NewTrack( index, T_BEZIER, 0, sizeof *xx );
+ else
+ t = NewTrack( index, T_BZRLIN, 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->bezierData.pos[0] = p0;
+ xx->bezierData.pos[1] = c1;
+ xx->bezierData.pos[2] = c2;
+ xx->bezierData.pos[3] = p1;
+ xx->bezierData.descriptionOff = dp;
+ xx->bezierData.segsWidth = width;
+ xx->bezierData.segsColor = wDrawFindColor( rgb );
+ ReadSegs();
+ FixUpBezier(xx->bezierData.pos,xx,GetTrkType(t) == T_BEZIER);
+ ComputeBezierBoundingBox(t,xx);
+ if (GetTrkType(t) == T_BEZIER) {
+ SetEndPts(t,2);
+ }
+}
+
+static void MoveBezier( track_p trk, coOrd orig )
+{
+ struct extraData *xx = GetTrkExtraData(trk);
+ UndoModify(trk);
+ for (int i=0;i<4;i++) {
+ xx->bezierData.pos[i].x += orig.x;
+ xx->bezierData.pos[i].y += orig.y;
+ }
+ FixUpBezier(xx->bezierData.pos,xx,IsTrack(trk));
+ ComputeBezierBoundingBox(trk,xx);
+
+}
+
+static void RotateBezier( track_p trk, coOrd orig, ANGLE_T angle )
+{
+ struct extraData *xx = GetTrkExtraData(trk);
+ UndoModify(trk);
+ for (int i=0;i<5;i++) {
+ Rotate( &xx->bezierData.pos[i], orig, angle );
+ }
+ FixUpBezier(xx->bezierData.pos,xx,IsTrack(trk));
+ ComputeBezierBoundingBox(trk,xx);
+
+}
+
+static void RescaleBezier( track_p trk, FLOAT_T ratio )
+{
+ struct extraData *xx = GetTrkExtraData(trk);
+ UndoModify(trk);
+ xx->bezierData.pos[0].x *= ratio;
+ xx->bezierData.pos[0].y *= ratio;
+ xx->bezierData.pos[1].x *= ratio;
+ xx->bezierData.pos[1].y *= ratio;
+ xx->bezierData.pos[2].x *= ratio;
+ xx->bezierData.pos[2].y *= ratio;
+ xx->bezierData.pos[3].x *= ratio;
+ xx->bezierData.pos[3].y *= ratio;
+ FixUpBezier(xx->bezierData.pos,xx,IsTrack(trk));
+ ComputeBezierBoundingBox(trk,xx);
+
+}
+
+EXPORT void AdjustBezierEndPt( track_p trk, EPINX_T inx, coOrd pos ) {
+ struct extraData *xx = GetTrkExtraData(trk);
+ UndoModify(trk);
+ if (inx ==0 ) {
+ xx->bezierData.pos[1].x += -xx->bezierData.pos[0].x+pos.x;
+ xx->bezierData.pos[1].y += -xx->bezierData.pos[0].y+pos.y;
+ xx->bezierData.pos[0] = pos;
+ }
+ else {
+ xx->bezierData.pos[2].x += -xx->bezierData.pos[3].x+pos.x;
+ xx->bezierData.pos[2].y += -xx->bezierData.pos[3].y+pos.y;
+ xx->bezierData.pos[3] = pos;
+ }
+ FixUpBezier(xx->bezierData.pos, xx, IsTrack(trk));
+ ComputeBezierBoundingBox(trk,xx);
+ SetTrkEndPoint( trk, inx, pos, inx==0?xx->bezierData.a0:xx->bezierData.a1);
+}
+
+
+/**
+ * Split the Track at approximately the point pos.
+ */
+static BOOL_T SplitBezier( 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;
+ double t;
+ BOOL_T track;
+ track = IsTrack(trk);
+
+ coOrd current[4], newl[4], newr[4];
+
+ double dd = DistanceBezier(trk, &pos);
+ if (dd>minLength) return FALSE;
+
+ BezierMathDistance(&pos, xx->bezierData.pos, 500, &t); //Find t value
+
+ for (int i=0;i<4;i++) {
+ current[i] = xx->bezierData.pos[i];
+ }
+
+ BezierSplit(current, newl, newr, t);
+
+ if (track) {
+ trk1 = NewBezierTrack(ep?newr:newl,NULL,0);
+ } else
+ trk1 = NewBezierLine(ep?newr:newl,NULL,0, xx->bezierData.segsColor,xx->bezierData.segsWidth);
+ UndoModify(trk);
+ for (int i=0;i<4;i++) {
+ xx->bezierData.pos[i] = ep?newl[i]:newr[i];
+ }
+ FixUpBezier(xx->bezierData.pos,xx,track);
+ ComputeBezierBoundingBox(trk,xx);
+ SetTrkEndPoint( trk, ep, xx->bezierData.pos[ep?3:0], ep?xx->bezierData.a1:xx->bezierData.a0);
+
+ *leftover = trk1;
+ *ep0 = 1-ep;
+ *ep1 = ep;
+
+ return TRUE;
+}
+
+static int log_traverseBezier = 0;
+static int log_bezierSegments = 0;
+/*
+ * TraverseBezier 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.
+ *
+ * Each segment may be processed forwards or in reverse (this really only applies to curved segments).
+ * 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 TraverseBezier( 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 segs_backwards= FALSE;
+ DIST_T d = 10000;
+ coOrd pos2 = trvTrk->pos;
+ ANGLE_T a1,a2;
+ int inx,segInx = 0;
+ EPINX_T ep;
+ BOOL_T back,neg;
+ trkSeg_p segPtr = (trkSeg_p)xx->bezierData.arcSegs.ptr;
+
+ a2 = GetAngleSegs( //Find correct Segment and nearest point in it
+ xx->bezierData.arcSegs.cnt,segPtr,
+ &pos2, &segInx, &d , &back, NULL, &neg ); //d = how far pos2 from old pos2 = trvTrk->pos
+
+ if ( d > 10 ) {
+ ErrorMessage( "traverseBezier: 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); //GetAngleSegs has reversed angle for backwards
+ 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)
+ segs_backwards = TRUE;
+ ep = 0;
+ } else {
+ segs_backwards = FALSE;
+ ep = 1;
+ }
+ if ( neg ) {
+ segs_backwards = !segs_backwards; //neg implies all the segs are reversed
+ ep = 1-ep; //other end
+ }
+
+ segProcData.traverse1.pos = pos2; //actual point on curve
+ segProcData.traverse1.angle = trvTrk->angle; //direction car is going for Traverse 1 has to be reversed...
+LOG( log_traverseBezier, 1, ( " TraverseBezier [%0.3f %0.3f] D%0.3f A%0.3f SB%d \n", trvTrk->pos.x, trvTrk->pos.y, dist, trvTrk->angle, segs_backwards ) )
+ inx = segInx;
+ while (inx >=0 && inx<xx->bezierData.arcSegs.cnt) {
+ segPtr = (trkSeg_p)xx->bezierData.arcSegs.ptr+inx; //move in to the identified segment
+ SegProc( SEGPROC_TRAVERSE1, segPtr, &segProcData ); //Backwards or forwards for THIS segment - note that this can differ from segs_backward!!
+ BOOL_T backwards = segProcData.traverse1.backwards; //Are we going to EP0?
+ BOOL_T reverse_seg = segProcData.traverse1.reverse_seg; //is it a backwards segment (we don't actually care as Traverse1 takes care of it)
+
+ dist += segProcData.traverse1.dist;
+ segProcData.traverse2.dist = dist;
+ segProcData.traverse2.segDir = backwards;
+LOG( log_traverseBezier, 2, ( " TraverseBezierT1 D%0.3f B%d RS%d \n", 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;
+ trvTrk->angle = segProcData.traverse2.angle;
+LOG( log_traverseBezier, 1, ( " -> [%0.3f %0.3f] A%0.3f D%0.3f\n", trvTrk->pos.x, trvTrk->pos.y, trvTrk->angle, *distR ) )
+ return TRUE;
+ } //NOTE Traverse1 and Traverse2 are overlays so get all out before storing
+ dist = segProcData.traverse2.dist; //How far left?
+ coOrd pos = segProcData.traverse2.pos; //Will be at seg end
+ ANGLE_T angle = segProcData.traverse2.angle; //Angle of end
+ segProcData.traverse1.angle = angle; //Reverse to suit Traverse1
+ segProcData.traverse1.pos = pos;
+ inx = segs_backwards?inx-1:inx+1; //Here's where the global segment direction comes in
+LOG( log_traverseBezier, 2, ( " TraverseBezierL D%0.3f A%0.3f\n", dist, angle ) )
+ }
+ *distR = dist; //Tell caller what is left
+ //Must be at one end or another
+ trvTrk->pos = GetTrkEndPos(trk,ep);
+ trvTrk->angle = NormalizeAngle(GetTrkEndAngle(trk, ep)+(segs_backwards?180:0));
+ trvTrk->trk = GetTrkEndTrk(trk,ep); //go to next track
+ if (trvTrk->trk==NULL) {
+ trvTrk->pos = pos2;
+ return TRUE;
+ }
+
+LOG( log_traverseBezier, 1, ( " -> [%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 MergeBezier(
+ track_p trk0,
+ EPINX_T ep0,
+ track_p trk1,
+ EPINX_T ep1 )
+{
+ struct extraData *xx0 = GetTrkExtraData(trk0);
+ struct extraData *xx1 = GetTrkExtraData(trk1);
+ track_p trk2 = NULL;
+ EPINX_T ep2=-1;
+ BOOL_T tracks = FALSE;
+
+ if (IsTrack(trk0) && IsTrack(trk1) ) tracks = TRUE;
+ if (GetTrkType(trk0) != GetTrkType(trk1)) return FALSE;
+
+ if (ep0 == ep1)
+ return FALSE;
+
+ UndoStart( _("Merge Bezier"), "MergeBezier( T%d[%d] T%d[%d] )", GetTrkIndex(trk0), ep0, GetTrkIndex(trk1), ep1 );
+ UndoModify( trk0 );
+ UndrawNewTrack( trk0 );
+ if (tracks) {
+ trk2 = GetTrkEndTrk( trk1, 1-ep1 );
+ if (trk2) {
+ ep2 = GetEndPtConnectedToMe( trk2, trk1 );
+ DisconnectTracks( trk1, 1-ep1, trk2, ep2 );
+ }
+ }
+ if (ep0 == 0) {
+ xx0->bezierData.pos[3] = xx1->bezierData.pos[3];
+ xx0->bezierData.pos[2] = xx1->bezierData.pos[2];
+ } else {
+ xx0->bezierData.pos[0] = xx1->bezierData.pos[0];
+ xx0->bezierData.pos[1] = xx1->bezierData.pos[1];
+ }
+ FixUpBezier(xx0->bezierData.pos,xx0,tracks);
+ ComputeBezierBoundingBox(trk0,xx0);
+ DeleteTrack( trk1, FALSE );
+ if (tracks && trk2) {
+ if (ep0 == 1)
+ SetTrkEndPoint( trk2, 1, xx0->bezierData.pos[0], xx0->bezierData.a0);
+ else
+ SetTrkEndPoint( trk2, 2, xx0->bezierData.pos[3], xx0->bezierData.a1);
+ ConnectTracks( trk0, ep0, trk2, ep2 );
+ }
+ DrawNewTrack( trk0 );
+
+
+ return TRUE;
+}
+
+
+static BOOL_T EnumerateBezier( track_p trk )
+{
+
+ if (trk != NULL) {
+ DIST_T d;
+ struct extraData *xx = GetTrkExtraData(trk);
+ d = xx->bezierData.length;
+ ScaleLengthIncrement( GetTrkScale(trk), d );
+ }
+ return TRUE;
+}
+
+static DIST_T GetLengthBezier( track_p trk )
+{
+ struct extraData *xx = GetTrkExtraData(trk);
+ DIST_T length = 0.0;
+ segProcData_t segProcData;
+ for(int i=0;i<xx->bezierData.arcSegs.cnt;i++) {
+ SegProc(SEGPROC_LENGTH,&(DYNARR_N(trkSeg_t,xx->bezierData.arcSegs,i)), &segProcData);
+ length += segProcData.length.length;
+ }
+ return length;
+}
+
+
+static BOOL_T GetParamsBezier( int inx, track_p trk, coOrd pos, trackParams_t * params )
+{
+ int segInx;
+ BOOL_T back,negative;
+ DIST_T d;
+
+ params->type = curveTypeBezier;
+ struct extraData *xx = GetTrkExtraData(trk);
+ for (int i=0;i<4;i++) params->bezierPoints[i] = xx->bezierData.pos[i];
+ params->len = xx->bezierData.length;
+ params->track_angle = GetAngleSegs( //Find correct Segment and nearest point in it
+ xx->bezierData.arcSegs.cnt,xx->bezierData.arcSegs.ptr,
+ &pos, &segInx, &d , &back, NULL, &negative );
+ if ( negative != back ) params->track_angle = NormalizeAngle(params->track_angle+180); //Bezier is in reverse
+ trkSeg_p segPtr = &DYNARR_N(trkSeg_t,xx->bezierData.arcSegs,segInx);
+ if (segPtr->type == SEG_STRLIN) {
+ params->arcR = 0.0;
+ } else {
+ 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;
+ }
+ 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 TrimBezier( track_p trk, EPINX_T ep, DIST_T dist ) {
+ DeleteTrack(trk, TRUE);
+ return TRUE;
+}
+
+
+
+static BOOL_T QueryBezier( 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 GetTrkType(trk) == T_BEZIER?xx->bezierData.minCurveRadius < (GetLayoutMinTrackRadius()-EPSILON):FALSE;
+ break;
+ case Q_CAN_MODIFY_CONTROL_POINTS:
+ return TRUE;
+ break;
+ case Q_CANNOT_PLACE_TURNOUT:
+ return FALSE;
+ break;
+ case Q_ISTRACK:
+ return GetTrkType(trk) == T_BEZIER?TRUE:FALSE;
+ break;
+ case Q_CAN_PARALLEL:
+ return (GetTrkType(trk) == T_BEZIER);
+ break;
+ case Q_MODIFY_CAN_SPLIT:
+ case Q_CORNU_CAN_MODIFY:
+ return (GetTrkType(trk) == T_BEZIER);
+ default:
+ return FALSE;
+ }
+}
+
+
+static void FlipBezier(
+ track_p trk,
+ coOrd orig,
+ ANGLE_T angle )
+{
+ struct extraData * xx = GetTrkExtraData(trk);
+ FlipPoint( &xx->bezierData.pos[0], orig, angle );
+ FlipPoint( &xx->bezierData.pos[1], orig, angle );
+ FlipPoint( &xx->bezierData.pos[2], orig, angle );
+ FlipPoint( &xx->bezierData.pos[3], orig, angle );
+ FixUpBezier(xx->bezierData.pos,xx,IsTrack(trk));
+ ComputeBezierBoundingBox(trk,xx);
+
+}
+
+static ANGLE_T GetAngleBezier(
+ 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->bezierData.arcSegs.cnt, (trkSeg_p)xx->bezierData.arcSegs.ptr, &pos, &indx, NULL, &back, NULL, &neg );
+ if (!back) angle = NormalizeAngle(angle+180); //Make CCW
+ if ( ep0 ) *ep0 = neg?1:0;
+ if ( ep1 ) *ep1 = neg?0:1;
+ return angle;
+}
+
+BOOL_T GetBezierSegmentFromTrack(track_p trk, trkSeg_p seg_p) {
+ struct extraData * xx = GetTrkExtraData(trk);
+
+ seg_p->type = IsTrack(trk)?SEG_BEZTRK:SEG_BEZLIN;
+ for (int i=0;i<4;i++) seg_p->u.b.pos[i] = xx->bezierData.pos[i];
+ seg_p->color = xx->bezierData.segsColor;
+ seg_p->bezSegs.cnt = 0;
+ if (seg_p->bezSegs.ptr) MyFree(seg_p->bezSegs.ptr);
+ seg_p->bezSegs.max = 0;
+ FixUpBezierSeg(seg_p->u.b.pos,seg_p,seg_p->type == SEG_BEZTRK);
+ return TRUE;
+
+}
+
+
+static BOOL_T MakeParallelBezier(
+ track_p trk,
+ coOrd pos,
+ DIST_T sep,
+ track_p * newTrkR,
+ coOrd * p0R,
+ coOrd * p1R )
+{
+ struct extraData * xx = GetTrkExtraData(trk);
+ coOrd np[4], p;
+ ANGLE_T a,a2;
+
+ //Produce bezier that is translated parallel to the existing Bezier
+ // - not a precise result if the bezier 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.
+
+ a = FindAngle(xx->bezierData.pos[0],xx->bezierData.pos[3]);
+ p = pos;
+ DistanceBezier(trk, &p);
+ a2 = NormalizeAngle(FindAngle(pos,p)-a);
+ //find parallel move x and y for points
+ for (int i =0; i<4;i++) {
+ np[i] = xx->bezierData.pos[i];
+ }
+
+ if ( a2 > 180 ) {
+ Translate(&np[0],np[0],a+90,sep);
+ Translate(&np[1],np[1],a+90,sep);
+ Translate(&np[2],np[2],a+90,sep);
+ Translate(&np[3],np[3],a+90,sep);
+ } else {
+ Translate(&np[0],np[0],a-90,sep);
+ Translate(&np[1],np[1],a-90,sep);
+ Translate(&np[2],np[2],a-90,sep);
+ Translate(&np[3],np[3],a-90,sep);
+ }
+
+ if ( newTrkR ) {
+ *newTrkR = NewBezierTrack( np, NULL, 0);
+ } else {
+ DYNARR_SET( trkSeg_t, tempSegs_da, 1 );
+ tempSegs(0).color = wDrawColorBlack;
+ tempSegs(0).width = 0;
+ tempSegs_da.cnt = 1;
+ tempSegs(0).type = SEG_BEZTRK;
+ if (tempSegs(0).bezSegs.ptr) MyFree(tempSegs(0).bezSegs.ptr);
+ tempSegs(0).bezSegs.max = 0;
+ tempSegs(0).bezSegs.cnt = 0;
+ for (int i=0;i<4;i++) tempSegs(0).u.b.pos[i] = np[i];
+ FixUpBezierSeg(tempSegs(0).u.b.pos,&tempSegs(0),TRUE);
+ }
+ 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.
+ */
+BOOL_T RebuildBezier (track_p trk)
+{
+ struct extraData *xx;
+ xx = GetTrkExtraData(trk);
+ xx->bezierData.arcSegs.cnt = 0;
+ FixUpBezier(xx->bezierData.pos,xx,IsTrack(trk));
+ ComputeBezierBoundingBox(trk, xx);
+ return TRUE;
+}
+
+BOOL_T MoveBezierEndPt ( track_p *trk, EPINX_T *ep, coOrd pos, DIST_T d0 ) {
+ track_p trk2;
+ struct extraData *xx;
+ if (SplitTrack(*trk,pos,*ep,&trk2,TRUE)) {
+ if (trk2) DeleteTrack(trk2,TRUE);
+ xx = GetTrkExtraData(*trk);
+ SetTrkEndPoint( *trk, *ep, *ep?xx->bezierData.pos[3]:xx->bezierData.pos[0], *ep?xx->bezierData.a1:xx->bezierData.a0 );
+ return TRUE;
+ }
+ return FALSE;
+}
+
+static trackCmd_t bezlinCmds = {
+ "BZRLIN",
+ DrawBezier,
+ DistanceBezier,
+ DescribeBezier,
+ DeleteBezier,
+ WriteBezier,
+ ReadBezier,
+ MoveBezier,
+ RotateBezier,
+ RescaleBezier,
+ NULL,
+ GetAngleBezier,
+ SplitBezier,
+ NULL,
+ NULL,
+ NULL, /* redraw */
+ NULL, /* trim */
+ MergeBezier,
+ NULL, /* modify */
+ GetLengthBezier,
+ GetParamsBezier,
+ NULL, /* Move EndPt */
+ QueryBezier,
+ NULL, /* ungroup */
+ FlipBezier,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ RebuildBezier
+ };
+
+static trackCmd_t bezierCmds = {
+ "BEZIER",
+ DrawBezier,
+ DistanceBezier,
+ DescribeBezier,
+ DeleteBezier,
+ WriteBezier,
+ ReadBezier,
+ MoveBezier,
+ RotateBezier,
+ RescaleBezier,
+ NULL,
+ GetAngleBezier,
+ SplitBezier,
+ TraverseBezier,
+ EnumerateBezier,
+ NULL, /* redraw */
+ TrimBezier, /* trim */
+ MergeBezier,
+ NULL, /* modify */
+ GetLengthBezier,
+ GetParamsBezier,
+ MoveBezierEndPt, /* Move EndPt */
+ QueryBezier,
+ NULL, /* ungroup */
+ FlipBezier,
+ NULL,
+ NULL,
+ NULL,
+ MakeParallelBezier,
+ NULL,
+ RebuildBezier
+ };
+
+
+EXPORT void BezierSegProc(
+ segProc_e cmd,
+ trkSeg_p segPtr,
+ segProcData_p data )
+{
+ ANGLE_T a1, a2;
+ DIST_T d, dd;
+ coOrd p0,p2 ;
+ segProcData_t segProcData;
+ trkSeg_p subSegsPtr;
+ coOrd temp0,temp1,temp2,temp3;
+ int inx,segInx;
+ BOOL_T back, segs_backwards, neg;
+#define bezSegs(N) DYNARR_N( trkSeg_t, segPtr->bezSegs, N )
+
+ switch (cmd) {
+
+ case SEGPROC_TRAVERSE1: //Work out how much extra dist and what direction
+ if (segPtr->type != SEG_BEZTRK) {
+ data->traverse1.dist = 0;
+ return;
+ }
+ d = data->traverse1.dist;
+ p0 = data->traverse1.pos;
+LOG( log_bezierSegments, 1, ( " BezTr1-Enter P[%0.3f %0.3f] A%0.3f\n", p0.x, p0.y, data->traverse1.angle ))
+ a2 = GetAngleSegs(segPtr->bezSegs.cnt,segPtr->bezSegs.ptr,&p0,&segInx,&d,&back, NULL, &neg); //Find right seg and pos
+ inx = segInx;
+ data->traverse1.BezSegInx = segInx;
+ data->traverse1.reverse_seg = FALSE;
+ data->traverse1.backwards = FALSE;
+ if (d>10) {
+ data->traverse1.dist = 0;
+ return;
+ }
+
+ if (back) a2 = NormalizeAngle(a2+180);
+ a1 = NormalizeAngle(a2-data->traverse1.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)
+ segs_backwards = TRUE;
+ } else {
+ segs_backwards = FALSE;
+ }
+ if ( neg ) {
+ segs_backwards = !segs_backwards; //neg implies all the segs are reversed
+ }
+ segProcData.traverse1.pos = data->traverse1.pos = p0; //actual point on curve
+ segProcData.traverse1.angle = data->traverse1.angle; //Angle of car
+ LOG( log_bezierSegments, 1, ( " BezTr1-GSA I%d P[%0.3f %0.3f] N%d SB%d\n", segInx, p0.x, p0.y, neg, segs_backwards ))
+ subSegsPtr = (trkSeg_p)segPtr->bezSegs.ptr+inx;
+ SegProc( SEGPROC_TRAVERSE1, subSegsPtr, &segProcData );
+ data->traverse1.reverse_seg = segProcData.traverse1.reverse_seg; //which way is curve (info)
+ data->traverse1.backwards = segProcData.traverse1.backwards; //Pass through Train direction
+ data->traverse1.dist = segProcData.traverse1.dist; //Get last seg partial dist
+ data->traverse1.segs_backwards = segs_backwards; //Get last
+ data->traverse1.negative = segProcData.traverse1.negative; //Is curve flipped (info)
+ data->traverse1.BezSegInx = inx; //Copy up Index
+LOG( log_bezierSegments, 1, ( " BezTr1-Exit -> A%0.3f B%d R%d N%d D%0.3f\n", a2, segProcData.traverse1.backwards, segProcData.traverse1.reverse_seg, segProcData.traverse1.negative, segProcData.traverse1.dist ))
+ break;
+
+ case SEGPROC_TRAVERSE2:
+ if (segPtr->type != SEG_BEZTRK) return; //Not SEG_BEZLIN
+LOG( log_bezierSegments, 1, ( " BezTr2-Enter D%0.3f SD%d SI%d SB%d\n", data->traverse2.dist, data->traverse2.segDir, data->traverse2.BezSegInx, data->traverse2.segs_backwards))
+ if (data->traverse2.dist <= segPtr->u.b.length) {
+
+ segProcData.traverse2.pos = data->traverse2.pos;
+ DIST_T dist = data->traverse2.dist;
+ segProcData.traverse2.dist = data->traverse2.dist;
+ segProcData.traverse2.angle = data->traverse2.angle;
+ segProcData.traverse2.segDir = data->traverse2.segDir;
+ segs_backwards = data->traverse2.segs_backwards;
+ BOOL_T backwards = data->traverse2.segDir;
+ inx = data->traverse2.BezSegInx; //Special from Traverse1
+ while (inx>=0 && inx<segPtr->bezSegs.cnt) {
+ subSegsPtr = (trkSeg_p)segPtr->bezSegs.ptr+inx;
+ SegProc(SEGPROC_TRAVERSE2, subSegsPtr, &segProcData);
+ if (segProcData.traverse2.dist<=0) { //Done
+ data->traverse2.angle = segProcData.traverse2.angle;
+ data->traverse2.dist = 0;
+ data->traverse2.pos = segProcData.traverse2.pos;
+LOG( log_bezierSegments, 1, ( " BezTr2-Exit1 -> A%0.3f P[%0.3f %0.3f] \n", data->traverse2.angle, data->traverse2.pos.x, data->traverse2.pos.y ))
+ return;
+ } else dist = segProcData.traverse2.dist;
+ p2 = segProcData.traverse2.pos;
+ a2 = segProcData.traverse2.angle;
+LOG( log_bezierSegments, 2, ( " BezTr2-Tr2 D%0.3f P[%0.3f %0.3f] A%0.3f\n", dist, p2.x, p2.y, a2 ))
+
+ segProcData.traverse1.pos = p2;
+ segProcData.traverse1.angle = a2;
+ inx = segs_backwards?inx-1:inx+1;
+ if (inx<0 || inx>=segPtr->bezSegs.cnt) break;
+ subSegsPtr = (trkSeg_p)segPtr->bezSegs.ptr+inx;
+ SegProc(SEGPROC_TRAVERSE1, subSegsPtr, &segProcData);
+ BOOL_T reverse_seg = segProcData.traverse1.reverse_seg; //For Info only
+ backwards = segProcData.traverse1.backwards;
+ dist += segProcData.traverse1.dist; //Add extra if needed - this is if we have to go from the other end of this seg
+ segProcData.traverse2.dist = dist; //distance left
+ segProcData.traverse2.segDir = backwards; //which way
+ segProcData.traverse2.pos = p2;
+ segProcData.traverse2.angle = a2;
+LOG( log_bezierSegments, 2, ( " BezTr2-Loop A%0.3f P[%0.3f %0.3f] D%0.3f SI%d B%d RS%d\n", a2, p2.x, p2.y, dist, inx, backwards, reverse_seg ))
+ }
+ data->traverse2.dist = dist;
+ } else data->traverse2.dist -= segPtr->u.b.length; //we got here because the desired point is not inside the segment
+ if (segs_backwards) {
+ data->traverse2.pos = segPtr->u.b.pos[0]; // Backwards so point 0
+ data->traverse2.angle = segPtr->u.b.angle0;
+ } else {
+ data->traverse2.pos = segPtr->u.b.pos[3]; // Forwards so point 3
+ data->traverse2.angle = segPtr->u.b.angle3;
+ }
+LOG( log_bezierSegments, 1, ( " BezTr-Exit2 --> SI%d A%0.3f P[%0.3f %0.3f] D%0.3f\n", inx, data->traverse2.angle, data->traverse2.pos.x, data->traverse2.pos.y, data->traverse2.dist))
+ break;
+
+ case SEGPROC_DRAWROADBEDSIDE:
+ //TODO - needs parallel bezier problem solved...
+ break;
+
+ case SEGPROC_DISTANCE:
+
+ dd = 100000.00; //Just find one distance
+ p0 = data->distance.pos1;
+
+ //initialize p2
+ p2 = segPtr->u.b.pos[0];
+ for(int i=0;i<segPtr->bezSegs.cnt;i++) {
+ segProcData.distance.pos1 = p0;
+ SegProc(SEGPROC_DISTANCE,&(DYNARR_N(trkSeg_t,segPtr->bezSegs,i)),&segProcData);
+ d = segProcData.distance.dd;
+ if (d<dd) {
+ dd = d;
+ p2 = segProcData.distance.pos1;
+ }
+ }
+ data->distance.dd = dd;
+ data->distance.pos1 = p2;
+ break;
+
+ case SEGPROC_FLIP:
+
+ temp0 = segPtr->u.b.pos[0];
+ temp1 = segPtr->u.b.pos[1];
+ temp2 = segPtr->u.b.pos[2];
+ temp3 = segPtr->u.b.pos[3];
+ segPtr->u.b.pos[0] = temp3;
+ segPtr->u.b.pos[1] = temp2;
+ segPtr->u.b.pos[2] = temp1;
+ segPtr->u.b.pos[3] = temp0;
+ FixUpBezierSeg(segPtr->u.b.pos,segPtr,segPtr->type == SEG_BEZTRK);
+ break;
+
+ case SEGPROC_NEWTRACK:
+ data->newTrack.trk = NewBezierTrack( segPtr->u.b.pos, (trkSeg_t *)segPtr->bezSegs.ptr, segPtr->bezSegs.cnt);
+ data->newTrack.ep[0] = 0;
+ data->newTrack.ep[1] = 1;
+ break;
+
+ case SEGPROC_LENGTH:
+ data->length.length = 0;
+ for(int i=0;i<segPtr->bezSegs.cnt;i++) {
+ SegProc(cmd,&(DYNARR_N(trkSeg_t,segPtr->bezSegs,i)),&segProcData);
+ data->length.length += segProcData.length.length;
+ }
+ break;
+
+ case SEGPROC_SPLIT:
+ //TODO Split
+ break;
+
+ case SEGPROC_GETANGLE:
+ inx = 0;
+ back = FALSE;
+ subSegsPtr = (trkSeg_p) segPtr->bezSegs.ptr;
+ coOrd pos = data->getAngle.pos;
+LOG( log_bezierSegments, 1, ( " BezGA-In P[%0.3f %0.3f] \n", pos.x, pos.y))
+ data->getAngle.angle = GetAngleSegs(segPtr->bezSegs.cnt,subSegsPtr, &pos, &inx, NULL, &back, NULL, NULL);
+ //Recurse for Bezier sub-segs (only straights and curves)
+
+ data->getAngle.negative_radius = FALSE;
+ data->getAngle.backwards = back;
+ data->getAngle.pos = pos;
+ data->getAngle.bezSegInx = inx;
+ subSegsPtr +=inx;
+ if (subSegsPtr->type == SEG_CRVTRK || subSegsPtr->type == SEG_CRVLIN ) {
+ data->getAngle.radius = fabs(subSegsPtr->u.c.radius);
+ if (subSegsPtr->u.c.radius<0 ) data->getAngle.negative_radius = TRUE;
+ data->getAngle.center = subSegsPtr->u.c.center;
+ }
+ else data->getAngle.radius = 0.0;
+LOG( log_bezierSegments, 1, ( " BezGA-Out SI%d A%0.3f P[%0.3f %0.3f] B%d\n", inx, data->getAngle.angle, pos.x, pos.y, back))
+ break;
+
+ }
+
+}
+
+
+/****************************************
+ *
+ * GRAPHICS COMMANDS
+ *
+ */
+
+
+track_p NewBezierTrack(coOrd pos[4], trkSeg_t * tempsegs, int count)
+{
+ struct extraData *xx;
+ track_p p;
+ p = NewTrack( 0, T_BEZIER, 2, sizeof *xx );
+ xx = GetTrkExtraData(p);
+ xx->bezierData.pos[0] = pos[0];
+ xx->bezierData.pos[1] = pos[1];
+ xx->bezierData.pos[2] = pos[2];
+ xx->bezierData.pos[3] = pos[3];
+ xx->bezierData.segsColor = wDrawColorBlack;
+ xx->bezierData.segsWidth = 0;
+ FixUpBezier(pos, xx, TRUE);
+LOG( log_bezier, 1, ( "NewBezierTrack( EP1 %0.3f, %0.3f, CP1 %0.3f, %0.3f, CP2 %0.3f, %0.3f, EP2 %0.3f, %0.3f ) = %d\n", pos[0].x, pos[0].y, pos[1].x, pos[1].y, pos[2].x, pos[2].y, pos[3].x, pos[3].y, GetTrkIndex(p) ) )
+ ComputeBezierBoundingBox( p, xx );
+ SetTrkEndPoint( p, 0, pos[0], xx->bezierData.a0);
+ SetTrkEndPoint( p, 1, pos[3], xx->bezierData.a1);
+ CheckTrackLength( p );
+ SetTrkBits( p, TB_HIDEDESC );
+ return p;
+}
+
+EXPORT track_p NewBezierLine( coOrd pos[4], trkSeg_t * tempsegs, int count, wDrawColor color, DIST_T width )
+{
+ struct extraData *xx;
+ track_p p;
+ p = NewTrack( 0, T_BZRLIN, 2, sizeof *xx );
+ xx = GetTrkExtraData(p);
+ xx->bezierData.pos[0] = pos[0];
+ xx->bezierData.pos[1] = pos[1];
+ xx->bezierData.pos[2] = pos[2];
+ xx->bezierData.pos[3] = pos[3];
+ xx->bezierData.segsColor = color;
+ xx->bezierData.segsWidth = width;
+ FixUpBezier(pos, xx, FALSE);
+LOG( log_bezier, 1, ( "NewBezierLine( EP1 %0.3f, %0.3f, CP1 %0.3f, %0.3f, CP2 %0.3f, %0.3f, EP2 %0.3f, %0.3f) = %d\n", pos[0].x, pos[0].y, pos[1].x, pos[1].y, pos[2].x, pos[2].y, pos[3].x, pos[3].y, GetTrkIndex(p) ) )
+ ComputeBezierBoundingBox( p, xx );
+ return p;
+}
+
+
+
+EXPORT void InitTrkBezier( void )
+{
+ T_BEZIER = InitObject( &bezierCmds );
+ T_BZRLIN = InitObject( &bezlinCmds );
+ log_bezier = LogFindIndex( "Bezier" );
+ log_traverseBezier = LogFindIndex( "traverseBezier" );
+ log_bezierSegments = LogFindIndex( "traverseBezierSegs");
+}
+
+/********************************************************************************
+ *
+ * Bezier Functions
+ *
+ ********************************************************************************/
+
+
+/**
+ * Return point on Bezier using "t" (from 0 to 1)
+ */
+extern coOrd BezierPointByParameter(coOrd p[4], double t)
+{
+
+ double a,b,c,d;
+ double mt = 1-t;
+ double mt2 = mt*mt;
+ double t2 = t*t;
+
+ a = mt2*mt;
+ b = mt2*t*3;
+ c = mt*t2*3;
+ d = t*t2;
+
+ coOrd o;
+ o.x = a*p[0].x+b*p[1].x+c*p[2].x+d*p[3].x;
+ o.y = a*p[0].y+b*p[1].y+c*p[2].y+d*p[3].y;
+
+ return o;
+
+}
+/**
+ * Find distance from point to Bezier. Return also the "t" value of that closest point.
+ */
+extern DIST_T BezierMathDistance( coOrd * pos, coOrd p[4], int segments, double * t_value)
+{
+ DIST_T dd = 10000.0;
+ double t = 0.0;
+ coOrd pt;
+ coOrd save_pt = p[0];
+ for (int i=0; i<=segments; i++) {
+ pt = BezierPointByParameter(p, (double)i/segments);
+ if (FindDistance(*pos,pt) < dd) {
+ dd = FindDistance(*pos,pt);
+ t = (double)i/segments;
+ save_pt = pt;
+ }
+ }
+ if (t_value) *t_value = t;
+ * pos = save_pt;
+ return dd;
+}
+
+extern coOrd BezierMathFindNearestPoint(coOrd *pos, coOrd p[4], int segments) {
+ double t = 0.0;
+ BezierMathDistance(pos, p, segments, &t);
+ return BezierPointByParameter(p, t);
+}
+
+void BezierSlice(coOrd input[], coOrd output[], double t) {
+ coOrd p1,p12,p2,p23,p3,p34,p4;
+ coOrd p123, p234, p1234;
+
+ p1 = input[0];
+ p2 = input[1];
+ p3 = input[2];
+ p4 = input[3];
+
+ p12.x = (p2.x-p1.x)*t+p1.x;
+ p12.y = (p2.y-p1.y)*t+p1.y;
+
+ p23.x = (p3.x-p2.x)*t+p2.x;
+ p23.y = (p3.y-p2.y)*t+p2.y;
+
+ p34.x = (p4.x-p3.x)*t+p3.x;
+ p34.y = (p4.y-p3.y)*t+p3.y;
+
+ p123.x = (p23.x-p12.x)*t+p12.x;
+ p123.y = (p23.y-p12.y)*t+p12.y;
+
+ p234.x = (p34.x-p23.x)*t+p23.x;
+ p234.y = (p34.y-p23.y)*t+p23.y;
+
+ p1234.x = (p234.x-p123.x)*t+p123.x;
+ p1234.y = (p234.y-p123.y)*t+p123.y;
+
+ output[0]= p1;
+ output[1] = p12;
+ output[2] = p123;
+ output[3] = p1234;
+
+};
+
+/**
+ * Split bezier into two parts
+ */
+extern void BezierSplit(coOrd input[], coOrd left[], coOrd right[] , double t) {
+
+ BezierSlice(input,left,t);
+
+ coOrd back[4],backright[4];
+
+ for (int i = 0;i<4;i++) {
+ back[i] = input[3-i];
+ }
+ BezierSlice(back,backright,1-t);
+ for (int i = 0;i<4;i++) {
+ right[i] = backright[3-i];
+ }
+
+}
+
+
+/**
+ * If close enough (length of control polygon exceeds chord by < error) add length of polygon.
+ * Else split and recurse
+ */
+double BezierAddLengthIfClose(coOrd start[4], double error) {
+ coOrd left[4], right[4]; /* bez poly splits */
+ double len = 0.0; /* arc length */
+ double chord; /* chord length */
+ int index; /* misc counter */
+
+ for (index = 0; index <= 2; index++)
+ len = len + FindDistance(start[index],start[index+1]); //add up control polygon
+
+ chord = FindDistance(start[0],start[3]); //find chord length
+
+ if((len-chord) > error) { // If error too large -
+ BezierSplit(start,left,right,0.5); /* split in two */
+ len = BezierAddLengthIfClose(left, error); /* recurse left side */
+ len += BezierAddLengthIfClose(right, error); /* recurse right side */
+ }
+ return len; // Add length of this curve
+
+}
+
+/**
+ * Use recursive splitting to get close approximation ot length of bezier
+ *
+ */
+extern double BezierMathLength(coOrd p[4], double error)
+{
+ if (error == 0.0) error = 0.01;
+ return BezierAddLengthIfClose(p, error); /* kick off recursion */
+
+}
+
+coOrd BezierFirstDerivative(coOrd p[4], double t)
+{
+ //checkParameterT(t);
+
+ double tSquared = t * t;
+ double s0 = -3 + 6 * t - 3 * tSquared;
+ double s1 = 3 - 12 * t + 9 * tSquared;
+ double s2 = 6 * t - 9 * tSquared;
+ double s3 = 3 * tSquared;
+ double resultX = p[0].x * s0 + p[1].x * s1 + p[2].x * s2 + p[3].x * s3;
+ double resultY = p[0].y * s0 + p[1].y * s1 + p[2].y * s2 + p[3].y * s3;
+
+ coOrd v;
+
+ v.x = resultX;
+ v.y = resultY;
+ return v;
+}
+
+/**
+ * Gets 2nd derivate wrt t of a Bezier curve at a point
+
+ */
+coOrd BezierSecondDerivative(coOrd p[4], double t)
+{
+ //checkParameterT(t);
+
+ double s0 = 6 - 6 * t;
+ double s1 = -12 + 18 * t;
+ double s2 = 6 - 18 * t;
+ double s3 = 6 * t;
+ double resultX = p[0].x * s0 + p[1].x * s1 + p[2].x * s2 + p[3].x * s3;
+ double resultY = p[0].y * s0 + p[1].y * s1 + p[2].y * s2 + p[3].y * s3;
+
+ coOrd v;
+ v.x = resultX;
+ v.y = resultY;
+ return v;
+}
+
+/**
+ * Get curvature of a Bezier at a point
+*/
+extern double BezierCurvature(coOrd p[4], double t, coOrd * center)
+{
+ //checkParameterT(t);
+
+ coOrd d1 = BezierFirstDerivative(p, t);
+ coOrd d2 = BezierSecondDerivative(p, t);
+
+ if (center) {
+ double curvnorm = (d1.x * d1.x + d1.y* d1.y)/(d1.x * d2.y - d2.x * d1.y);
+ coOrd p = BezierPointByParameter(&p, t);
+ center->x = p.x-d1.y*curvnorm;
+ center->y = p.y+d1.x*curvnorm;
+ }
+
+ double r1 = sqrt(pow(d1.x * d1.x + d1.y* d1.y, 3.0));
+ double r2 = fabs(d1.x * d2.y - d2.x * d1.y);
+ return r2 / r1;
+}
+
+/**
+ * Get Maximum Curvature
+ */
+extern double BezierMaxCurve(coOrd p[4]) {
+ double max = 0;
+ for (int t = 0;t<100;t++) {
+ double curv = BezierCurvature(p, t/100, NULL);
+ if (max<curv) max = curv;
+ }
+ return max;
+}
+
+/**
+ * Get Minimum Radius
+ */
+extern double BezierMathMinRadius(coOrd p[4]) {
+ double curv = BezierMaxCurve(p);
+ if (curv >= 1000.0 || curv <= 0.001 ) return 0.0;
+ return 1/curv;
+}
+
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-11 08:21:20 +0000