
DIRECTORY Convert, G3dBasic, G3dCurve, G3dMatrix, G3dSpline, IO, Real, Rope;

G3dCurveImpl: CEDAR PROGRAM
IMPORTS Convert, G3dMatrix, G3dSpline, IO, Real, Rope 
EXPORTS G3dCurve

~ BEGIN
Error:				PUBLIC SIGNAL [code: ATOM, reason: ROPE м NIL] = CODE;
Triple:				TYPE ~ G3dBasic.Triple;				-- RECORD [x, y, z: REAL]
RealSequence:		TYPE ~ G3dBasic.RealSequence;		-- sequence of reals
Matrix:				TYPE ~ G3dMatrix.Matrix;				-- a cubic spline
Spline:				TYPE ~ G3dSpline.Spline;				-- a cubic spline
SplineSequence:		TYPE ~ G3dSpline.SplineSequence;	-- a sequence of cubic splines
ROPE:					TYPE ~ Rope.ROPE;
STREAM:				TYPE ~ IO.STREAM;

Curve:				TYPE ~ G3dCurve.Curve;
CurveRep:			TYPE ~ G3dCurve.CurveRep;
Section: 				TYPE ~ G3dCurve.Section;
Fragment:			TYPE ~ G3dCurve.Fragment;
Fragments:			TYPE ~ G3dCurve.Fragments;
Spot:					TYPE ~ G3dCurve.Spot;
CurveSequence:		TYPE ~ G3dCurve.CurveSequence;
CurveSequenceRep:	TYPE ~ G3dCurve.CurveSequenceRep;

FSpot:					TYPE ~ RECORD [f: Fragment, t: REAL];
CurveFromSplines: PUBLIC PROC [splines: SplineSequence, res: NAT м 100] RETURNS [c: Curve]
~ {
IF splines # NIL THEN {
tmp: Spline м G3dMatrix.ObtainMatrix[];
nSegs: NAT м MAX[1, res];
lenSegs: NAT м MAX[1, nSegs/2];
c м NEW[CurveRep[splines.length]];
c.length м splines.length;
FOR s: NAT IN [0..splines.length) DO
t0: REAL м 0.0;
spline: Spline м splines[s];
fragments: Fragments м NEW[G3dCurve.FragmentsRep[nSegs]];
c[s] м [spline: spline, accumLength: c.totalLength, fragments: fragments];
FOR n: NAT IN [1..nSegs] DO
t1: REAL м REAL[n]/REAL[nSegs];
len: REAL м G3dSpline.Length[G3dSpline.Reparameterize[spline, t0, t1, tmp], lenSegs];
fragments[n-1] м [t0, t1, t1-t0, len, c.totalLength];
c.totalLength м c.totalLength+len;
t0 м t1;
ENDLOOP;
c[s].length м c.totalLength-c[s].accumLength;
ENDLOOP;
G3dMatrix.ReleaseMatrix[tmp];
};
};
Transform: PUBLIC PROC [curve: Curve, matrix: Matrix] ~ {
IF curve # NIL THEN FOR n: NAT IN [0..curve.length) DO
curve[n].spline м G3dMatrix.Mul[curve[n].spline, matrix];
ENDLOOP;
};
FSpotFromT: PROC [c: Curve, t: REAL] RETURNS [FSpot] ~ {
n: NAT м Real.Floor[t];										-- index to curve section
tt: REAL м t-n;												-- tt = parameter into section
fragments: Fragments м c[MIN[n, c.length-1]].fragments;
nf: NAT м Real.Round[tt*fragments.length];				-- guess at fragment
f: Fragment м fragments[MIN[nf, fragments.length-1]];
WHILE tt NOT IN [f.t0..f.t1] DO								-- ensure correct fragment	
f м fragments[nf м nf+(IF tt < f.t0 THEN -1 ELSE 1)]; 
ENDLOOP;
RETURN[[f, tt]];
};
SpotFromT: PUBLIC PROC [c: Curve, t: REAL] RETURNS [Spot] ~ {
n: NAT м Real.Floor[t];
RETURN[[c[n].spline, t-n]];
};

SpotFromArcLength: PUBLIC PROC [c: Curve, arcLength: REAL] RETURNS [Spot м []] ~ {
SectionSpot: PROC [section: Section] RETURNS [spot: Spot] ~ {
FragmentSpot: PROC [f: Fragment] RETURNS [Spot] ~ {
RETURN[[section.spline, f.t0+f.dt*((arcLength-f.accumLength)/f.length)]];
};
f: Fragments м section.fragments;
spot.spline м section.spline;
FOR nf: NAT IN [1..f.length) DO
IF f[nf].accumLength > arcLength THEN RETURN[FragmentSpot[f[nf-1]]];
ENDLOOP;
RETURN[FragmentSpot[f[f.length-1]]];
};
IF arcLength < 0.0 THEN Error[$BadArcLength];
IF arcLength > c.totalLength THEN {
s: Section м c[c.length-1];
f: Fragment м s.fragments[s.fragments.length-1];
IF arcLength-c.totalLength > f.length*0.1 	-- arbitrary
THEN Error[$BadArcLength]
ELSE RETURN[[s.spline, f.t1]];
};
FOR n: NAT IN [1..c.length) DO
IF c[n].accumLength > arcLength THEN RETURN[SectionSpot[c[n-1]]];
ENDLOOP;
RETURN[SectionSpot[c[c.length-1]]];
};

TFromArcLength: PUBLIC PROC [c: Curve, arcLength: REAL] RETURNS [t: REAL] ~ {
RETURN[SpotFromArcLength[c, arcLength].t];
};

ArcLengthFromT: PUBLIC PROC [c: Curve, t: REAL] RETURNS [REAL] ~ {
fs: FSpot м FSpotFromT[c, t];
RETURN[fs.f.accumLength+((fs.t-fs.f.t0)/fs.f.dt)*fs.f.length];
};

ArcLengthFromTs: PUBLIC PROC [c: Curve, t0, t1: REAL] RETURNS [REAL] ~ {
RETURN[ArcLengthFromT[c, t1]-ArcLengthFromT[c, t0]];
};
PositionT: PUBLIC PROC [c: Curve, t: REAL] RETURNS [Triple] ~ {
s: Spot м SpotFromT[c, t];
RETURN[G3dSpline.Position[s.spline, s.t]];
};

VelocityT: PUBLIC PROC [c: Curve, t: REAL] RETURNS [Triple] ~ {
s: Spot м SpotFromT[c, t];
RETURN[G3dSpline.Position[s.spline, s.t]];
};

AccelerationT: PUBLIC PROC [c: Curve, t: REAL] RETURNS [Triple] ~ {
s: Spot м SpotFromT[c, t];
RETURN[G3dSpline.Acceleration[s.spline, s.t]];
};

CurvatureT: PUBLIC PROC [c: Curve, t: REAL] RETURNS [Triple] ~ {
s: Spot м SpotFromT[c, t];
RETURN[G3dSpline.Curvature[s.spline, s.t]];
};
CurvatureMagT: PUBLIC PROC [c: Curve, t: REAL] RETURNS [REAL] ~ {
s: Spot м SpotFromT[c, t];
RETURN[G3dSpline.CurvatureMag[s.spline, s.t]];
};
PositionA: PUBLIC PROC [c: Curve, arcLength: REAL] RETURNS [Triple] ~ {
s: Spot м SpotFromArcLength[c, arcLength];
RETURN[G3dSpline.Position[s.spline, s.t]];
};

VelocityA: PUBLIC PROC [c: Curve, arcLength: REAL] RETURNS [Triple] ~ {
s: Spot м SpotFromArcLength[c, arcLength];
RETURN[G3dSpline.Velocity[s.spline, s.t]];
};

AccelerationA: PUBLIC PROC [c: Curve, arcLength: REAL] RETURNS [Triple] ~ {
s: Spot м SpotFromArcLength[c, arcLength];
RETURN[G3dSpline.Acceleration[s.spline, s.t]];
};

CurvatureA: PUBLIC PROC [c: Curve, arcLength: REAL] RETURNS [Triple] ~ {
s: Spot м SpotFromArcLength[c, arcLength];
RETURN[G3dSpline.Curvature[s.spline, s.t]];
};
CurvatureMagA: PUBLIC PROC [c: Curve, arcLength: REAL] RETURNS [REAL] ~ {
s: Spot м SpotFromArcLength[c, arcLength];
RETURN[G3dSpline.CurvatureMag[s.spline, s.t]];
};
Write: PUBLIC PROC [out: STREAM, c: Curve, name: ROPE м NIL] ~ {
IF name # NIL THEN name м Rope.Concat[name, " "];
IO.PutF[out, "Curve%g, %g sections:\n", IO.rope[name], IO.int[c.length]];
FOR n: NAT IN [0..c.length) DO
spline: Spline м c[n].spline;
IO.PutRope[out, "\t"];
FOR i: NAT IN [0..4) DO
r: ARRAY [0..4) OF REAL м spline[i];
IO.PutFL[out, "%g %g %g %g ",
LIST[IO.real[r[0]], IO.real[r[1]], IO.real[r[2]], IO.real[r[3]]]];
ENDLOOP;
IO.PutRope[out, "\n"];
ENDLOOP;
};
Read: PUBLIC PROC [in: STREAM] RETURNS [c: Curve] ~ {
ENABLE IO.Error, Convert.Error => GOTO Bad;
line: ROPE м IO.GetLineRope[in];
p1: INT м Rope.Find[line, "sections:"];
p0: INT м Rope.FindBackward[line, " ", p1-2];
nSections: INT м Convert.IntFromRope[Rope.Substr[line, p0, p1]];
splines: SplineSequence м NEW[G3dSpline.SplineSequenceRep[nSections]];
FOR n: NAT IN [0..splines.length м nSections) DO
splines[n] м NEW[G3dSpline.SplineRep];
FOR i: NAT IN [0..4) DO
splines[n][i] м [IO.GetReal[in], IO.GetReal[in], IO.GetReal[in], IO.GetReal[in]];
ENDLOOP;
ENDLOOP;
RETURN[CurveFromSplines[splines]];
EXITS Bad => Error[$BadInputFormat, IO.PutFR1["file position: %g", IO.int[IO.GetIndex[in]]]];
};
CopyCurveSequence: PUBLIC PROC [curves: CurveSequence]
RETURNS [CurveSequence] ~ {
copy: CurveSequence м NIL;
IF curves # NIL THEN {
copy м NEW[CurveSequenceRep[curves.length]];
copy.length м curves.length;
FOR n: NAT IN [0..curves.length) DO copy[n] м curves[n]; ENDLOOP;
};
RETURN[copy];
};

AddToCurveSequence: PUBLIC PROC [curves: CurveSequence, curve: Curve]
RETURNS [CurveSequence]
~ {
IF curves = NIL THEN curves м NEW[CurveSequenceRep[1]];
IF curves.length = curves.maxLength THEN curves м LengthenCurveSequence[curves];
curves[curves.length] м curve;
curves.length м curves.length+1;
RETURN[curves];
};
LengthenCurveSequence: PUBLIC PROC [curves: CurveSequence, amount: REAL м 1.3]
RETURNS [new: CurveSequence] ~ {
newLength: CARDINAL м Real.Ceiling[amount*curves.maxLength];
newLength м MAX[newLength, 3];
new м NEW[CurveSequenceRep[newLength]];
FOR i: NAT IN [0..curves.length) DO new[i] м curves[i]; ENDLOOP;
new.length м curves.length;
};


END.

   (  
G3dCurveImpl.mesa
Copyright ╙ 1984, 1992 by Xerox Corporation.  All rights reserved.
Bloomenthal, October 21, 1992 5:01 pm PDT
Errors
Definitions
Creation
Tranformation
Support
Conversions Between Arc-length and t
Evaluation Given Parameter t

Evaluation Given Arc Length

IO

Sequences

 Э╩
2  Ц"cedarcode" styleХNewlineDelimiter
Щ ЩJЪЬ	╧eЬ6ЩBJЩ)JШ JЪ╧k	ЬCШLJШ ЧЪ╨blЬЮЬЮШJЪЮЬ/Ш6JЪЮЬ	ШJШ ЧJЪЬЮШheadЪ╧lЩJЪ╧nЬЮЬЮЬЮЬ
ЮЬЮЬЮЬШ@ЧЪаЩJЪЬ	ЮЬ╧c╨csвгвШ?JЪЬЮЬвШBJЪЬ	ЮЬвШ8JЪЬ	ЮЬвШ8JЪЬЮЬвШPJЪЮЬЮЬЮЬШЪЮЬЮЬЮЬЮЬШJШ ЧJЪЬЮЬШ JЪЬ
ЮЬШ%JЪЬЮЬШ%JЪЬ
ЮЬШ%JЪЬЮЬШ'JЪЬЮЬШJЪЬЮЬШ.ЪЬЮЬШ3JШ ЧJЪЬ	ЮЬЮЬЮЬШ0ЧЪаЩЪбЬЮ╧sЮдЬЮдЬдЬдЮЬШZJЪЬШЪЮЬЮЬЮЬШJШ'JЪЬЮЬЮЬ	ШJЪЬ	ЮЬЮЬШJЪЬЮЬШ"JШЪЮЬЮЬЮЬЮШ$JЪЬЮЬШJШJЪЬЮЬШ9JШJЪЮЬЮЬЮЬЮШJЪЬЮЬЮЬЮЬШJЪЬЮЬLШUJШ5JШ"JШJЪЮЬШЧJШ-JЪЮЬШЧJШJШЧJШЧЧЪаЩЪб	ЬЮЬЮЬ#Ш9ЪЮЬ	ЮЬЮЬЮЬЮЬЮЬЮШ6JШ9JЪЮЬШЧJШЧЧЪаЩЪб
ЬЮЬЮЬЮЬШ8JЪЬЮЬвШ:JЪЬЮЬвШ9JЪЬЮЬШ7JЪЬЮЬ'вШBJЪЬЮЬШ5Ъ	ЮЬЮЬЮЬЮЬвШBJЪЬЮЬЮЬЮЬШ6JЪЮЬШЧJЪЮЬ
ШJШЧЧЪа$Щ$Ъ
б	ЬЮЬЮЬЮЬЮЬШ=JЪЬЮЬШJЪЮЬШJШJШ ЧЪбЬЮЬЮЬЮЬШRЪбЬЮЬЮЬШ=ЪбЬЮЬЮЬШ3JЪЮЬCШIJШЧJШ!JШЪЮЬЮЬЮЬЮШJЪЮдЬдЬдЬ	дЮдЮЬШDJЪЮЬШЧJЪЮЬШ$JЪЬШЧJЪЮЬЮЬШ-ЪЮЬЮЬШ#JШJШ0ЪЮЬ)вШ7JЪЮЬШJЪЮЬЮЬШЧJШЧЪЮЬЮЬЮЬЮШJЪЮЬЮЬЮЬШAJЪЮЬШЧJЪЮЬШ#JШJШ ЧЪбЬЮЬЮЬЮЬЮЬЮЬШMJЪЮЬ$Ш*JШJШ ЧЪбЬЮЬЮЬЮЬЮЬЮЬШBJШJЪЮЬ8Ш>JШJШ ЧЪбЬЮЬЮЬЮЬЮЬЮЬШHJЪЮЬ.Ш4JШЧЧЪаЩЪ
б	ЬЮЬЮЬЮЬЮЬШ?JШJЪЮЬ$Ш*JШJШ ЧЪ
б	ЬЮЬЮЬЮЬЮЬШ?JШJЪЮЬ$Ш*JШJШ ЧЪ
бЬЮЬЮЬЮЬЮЬШCJШJЪЮЬ(Ш.JШJШ ЧЪ
б
ЬЮЬЮЬЮЬЮЬШ@JШJЪЮЬ%Ш+JШJЩ ЧЪбЬЮЬЮЬЮЬЮЬЮЬШAJШJЪЮЬ(Ш.JШЧЧЪаЩЪ
б	ЬЮЬЮЬЮЬЮЬШGJШ*JЪЮЬ$Ш*JЪЬШJШ ЧЪ
б	ЬЮЬЮЬЮЬЮЬШGJШ*JЪЮЬ$Ш*JШJШ ЧЪ
бЬЮЬЮЬЮЬЮЬШKJШ*JЪЮЬ(Ш.JШJШ ЧЪ
б
ЬЮЬЮЬЮЬЮЬШHJШ*JЪЮЬ%Ш+JШJЩ ЧЪбЬЮЬЮЬЮЬЮЬЮЬШIJШ*JЪЮЬ(Ш.JШЧЧЪаЩЪбЬЮЬЮЬЮЬЮЬЮЬШ@JЪЮЬЮЬЮЬШ1JЪЮЬ&ЮЬЮЬШIЪЮЬЮЬЮЬЮШJШJЪЮЬШЪЮЬЮЬЮЬЮШJЪЬЮЬЮЬЮЬШ$ЪЮЬШJЪ
ЮЬЮЬЮЬЮЬЮЬШBЧJЪЮЬШЧJЪЮЬШJЪЮЬШЧJШJЩ ЧЪ
бЬЮЬЮЬЮЬЮЬШ5JЪЮЬЮЬЮЬШ+JЪЬЮЬЮЬШ JЪЬЮЬ Ш'JЪЬЮЬ&Ш-JЪЬЮЬ2Ш@JЪЬЮЬ)ШFЪЮЬЮЬЮЬ!ЮШ0JЪЬЮЬШ&ЪЮЬЮЬЮЬЮШJЪ	ЬЮЬЮЬЮЬЮЬШQJЪЮЬШЧJЪЮЬШЧJЪЮЬШ"JЪЮЬЮЬЮЬЮЬШ]JШЧЧЪа	Щ	ЪбЬЮЬЮЬШ6JЪЮЬШJЪЬЮЬШЪЮЬ
ЮЬЮЬШJЪЬЮЬ"Ш,JШJЪ
ЮЬЮЬЮЬЮЬЮЬШAJШЧJЪЮЬШJШJШ ЧЪбЬЮЬЮЬ&ШEJЪЮЬШJШJЪЮЬ
ЮЬЮЬ
ЮЬШ7JЪЮЬ"ЮЬ(ШPJШJШ JЪЮЬ	ШJШJЩ ЧЪбЬЮЬЮЬ!ЮЬШNJЪЮЬШ JЪЬЮЬ)Ш<JЪЬЮЬШJЪЬЮЬШ'JЪ
ЮЬЮЬЮЬЮЬЮЬШ@JШJШJШ ЧЧJШ JЪЮЬШJШ Ч ЕЧ    ╥  ),  