DIRECTORY
Cubic,
Complex,
FitState,
SafeStorage USING [ReclaimCollectibleObjects],
JaM,
FitJaM,
FitBasic,
FitStateUtils,
FitIO,
Real,
Rope,
Seq,
Vector;

FitEditJaM: CEDAR PROGRAM
IMPORTS Complex, JaM, Real, Vector, FitState, FitJaM, FitIO, FitStateUtils, SafeStorage = {

State: TYPE = JaM.State;
GetVec: PROC [state: JaM.State] RETURNS [z:Complex.Vec] = {
z.y _ JaM.PopReal[state];
z.x _ JaM.PopReal[state];
};
ResetSa: PROC[state: State] = {FitState.ResetData[FitJaM.defaultFitState, samples]};
StartSa: PROC[state: State] = {
y: REAL _ JaM.PopReal[state];
x: REAL _ JaM.PopReal[state];
FitState.StartSamples[FitJaM.defaultFitState, x,y];
};
AddSa: PROC[state: State] = {
y: REAL _ JaM.PopReal[state];
x: REAL _ JaM.PopReal[state];
FitState.AddSample[FitJaM.defaultFitState, x,y];
};
CountSa: PROC[state: State] = {
n: INT _ 0;
count: FitStateUtils.SampleProc = {n _ n+1};
FitStateUtils.ForAllSamples[FitJaM.defaultFitState.slist,count];
JaM.PushInt[state,n];
};
SelectSa: PROC [state: JaM.State] = {
closest: FitBasic.SampleHandle;
z: Complex.Vec;
z.y _ JaM.PopReal[state];
z.x _ JaM.PopReal[state];
[closest,] _ FindSa[z];
IF closest#NIL THEN FitJaM.defaultFitState.slist.selectedSample _ closest;
};

TheSa: PROC [state: JaM.State] = {
JaM.PushReal[state,FitJaM.defaultFitState.slist.selectedSample.xy.x];
JaM.PushReal[state,FitJaM.defaultFitState.slist.selectedSample.xy.y];
};

FindSa: PROC [z: Complex.Vec] RETURNS[found: FitBasic.SampleHandle, index: NAT] = {
closest,d: REAL _ 10.0E+30;
i: NAT _ 0;
do: FitStateUtils.SampleProc = {
p: Complex.Vec _ FitIO.MagnifyPoint[s.xy];
IF ABS[p.x-z.x]<closest AND ABS[p.y-z.y]<closest
AND (d _ Vector.Mag[Vector.Sub[z,p]]) < closest THEN {
closest _ d; found _ s; index _ i;
};
i _ i+1;
};
found _ NIL;
FitStateUtils.ForAllSamples[FitJaM.defaultFitState.slist,do];
};

TheTan: PROC [state: JaM.State] = {OPEN FitJaM.defaultFitState.slist.selectedSample;
JaM.PushReal[state,tangent.x];
JaM.PushReal[state,tangent.y];
JaM.PushBool[state,isNode];
};

DeleteSa: PROC [state: JaM.State] = {
FitState.RemoveSample[FitJaM.defaultFitState];
};

InsertSa: PROC [state: JaM.State] = {
x,y: REAL;
y _ JaM.PopReal[state];
x _ JaM.PopReal[state];
FitState.InsertBeforeSample[FitJaM.defaultFitState, x,y];
};

InsertBetween: PROC [state: JaM.State] = {
z: Complex.Vec;
insertBefore: BOOLEAN;
samp: FitBasic.SampleHandle _ FitJaM.defaultFitState.slist.selectedSample;
z.y _ JaM.PopReal[state];
z.x _ JaM.PopReal[state];
insertBefore _
(Vector.Mag[Vector.Sub[z, samp.prev.xy]] < Vector.Mag[Vector.Sub[z, samp.next.xy]]);
IF insertBefore THEN FitState.InsertBeforeSample[FitJaM.defaultFitState, z.x, z.y]
ELSE {
FitJaM.defaultFitState.slist.selectedSample _ FitJaM.defaultFitState.slist.selectedSample.next;
FitState.InsertBeforeSample[FitJaM.defaultFitState, z.x, z.y];
FitJaM.defaultFitState.slist.selectedSample _ samp;
};
};

NodeSa: PROC [state: JaM.State] = {OPEN FitJaM.defaultFitState;
slist.selectedSample.isNode _ JaM.PopBool[state];
IF ~slist.selectedSample.isNode THEN slist.selectedSample.isCusp _ FALSE;
};

TanSa: PROC [state: JaM.State] = {
FitJaM.defaultFitState.slist.selectedSample.tangent _ GetVec[state]};

CuspSa: PROC [state: JaM.State] = {OPEN FitJaM.defaultFitState;
slist.selectedSample.isCusp _ slist.selectedSample.isNode _ JaM.PopBool[state]};
CuspNode: PROC [state: JaM.State] = {OPEN FitJaM.defaultFitState;
IF slist.selectedSample.isNode THEN slist.selectedSample.isCusp _ JaM.PopBool[state]};
TanOutSa: PROC [state: JaM.State] = {
FitJaM.defaultFitState.slist.selectedSample.tanOut _ GetVec[state]};
HomeSa: PROC [state: JaM.State] = {OPEN FitJaM.defaultFitState;
slist.selectedSample _ slist.header;
};
MakeFirstSa: PROC [state: JaM.State] = {OPEN FitJaM.defaultFitState;
IF slist.selectedSample # NIL AND slist.selectedSample # slist.header AND slist.selectedSample # slist.header.next THEN {
slist.header.next.prev _ slist.header.prev;
slist.header.prev.next _  slist.header.next;
slist.header.next _ slist.selectedSample;
slist.header.prev _ slist.selectedSample.prev;
slist.header.next.prev _ slist.header;
slist.header.prev.next _ slist.header;
};
};

NextSa: PROC [state: JaM.State] = {OPEN FitJaM.defaultFitState;
slist.selectedSample _ slist.selectedSample.next;
IF slist.selectedSample = slist.header THEN
slist.selectedSample _ slist.selectedSample.next
};

PrevSa: PROC [state: JaM.State] = {OPEN FitJaM.defaultFitState;
slist.selectedSample _ slist.selectedSample.prev;
IF slist.selectedSample = slist.header THEN
slist.selectedSample _ slist.selectedSample.prev
};

ScaleSa: PROC [state: JaM.State] = {
FitState.ScaleData[FitJaM.defaultFitState,JaM.PopReal[state], samples];
};
TranSa: PROC [state: JaM.State] = {
z: Complex.Vec _ GetVec[state];
FitState.TranslateData[FitJaM.defaultFitState, z, samples];
};

InterpolateSa: PROC[state: State] = { OPEN FitJaM.defaultFitState;
mindelta: REAL _ MAX[JaM.PopReal[state], 0.00001];
selected: FitBasic.SampleHandle _ slist.selectedSample;
first: BOOLEAN _ TRUE;
from: FitBasic.SampleHandle _ slist.header.next;
do: FitStateUtils.SampleProc = {
IF first THEN {from _ s; first _ FALSE}
ELSE {
to: FitBasic.SampleHandle _ s;
delta: Complex.Vec _ Complex.Sub[to.xy, from.xy];
k: REAL _ Real.RoundLI[Complex.Abs[delta]/mindelta];
slist.selectedSample _ to;
FOR i: REAL _ 1, i+1 UNTIL i>k DO
v: Complex.Vec _ Complex.Add[s.xy, Vector.Mul[delta, i/(k+1)]];
FitState.InsertBeforeSample[FitJaM.defaultFitState, v.x,v.y];
ENDLOOP; 
from _ to;
};
};
FitStateUtils.ForAllSamples[slist, do];
IF closed THEN [] _ do[slist.header.next];
slist.selectedSample _ selected;
}; 


Subrange: PROC [state: JaM.State] = {OPEN FitJaM.defaultFitState;
first,last: FitBasic.SampleHandle;
p0,p1: Complex.Vec;
i0,i1: NAT;
p1.y _ JaM.PopReal[state];
p1.x _ JaM.PopReal[state];
[last,i1] _ FindSa[p1];
p0.y _ JaM.PopReal[state];
p0.x _ JaM.PopReal[state];
[first,i0] _ FindSa[p0];
IF i0<i1 THEN {slist.first _ first; slist.last _ last} ELSE {slist.first _ last; slist.last _ first};
};
NoSubrange: PROC [state: JaM.State] = {OPEN FitJaM.defaultFitState; slist.first _ slist.last _ NIL};
ResetDefaultNodes: PROC [state: JaM.State] = {FitState.ResetData[FitJaM.defaultFitState, nodes]};
ResetDefaultCusps: PROC [state: JaM.State] = {FitState.ResetData[FitJaM.defaultFitState, cusps]};

ForAllLinks: PROC[state: State] = {
body: JaM.Any _ JaM.Pop[state];
do: FitStateUtils.LinkProc = {
JaM.PushReal[state,l.cubic.b0.x];
JaM.PushReal[state,l.cubic.b0.y];
JaM.PushReal[state,l.cubic.b1.x];
JaM.PushReal[state,l.cubic.b1.y];
JaM.PushReal[state,l.cubic.b2.x];
JaM.PushReal[state,l.cubic.b2.y];
JaM.PushReal[state,l.cubic.b3.x];
JaM.PushReal[state,l.cubic.b3.y];
JaM.Execute[state, body ! JaM.Stop => CONTINUE];
};
FitStateUtils.ForAllLinks[FitJaM.defaultFitState.traj,do];
};

ResetCon: PROC[state: State] = {FitState.ResetData[FitJaM.defaultFitState, contour, TRUE]};
CountCon: PROC[state: State] = {
JaM.PushInt[state, FitState.CountContours[FitJaM.defaultFitState]]};
AddCon: PROC[state: State] = {FitState.NewContour[FitJaM.defaultFitState]};
NextCon: PROC[state: State] = {FitState.NextContour[FitJaM.defaultFitState]};

SetSLen: PROC[state: State] = {[] _ FitState.MinDist[FitJaM.defaultFitState,JaM.PopReal[state]]};
CollectGarbage: PROC[state: State] = {
SafeStorage.ReclaimCollectibleObjects[suspendMe: TRUE, traceAndSweep: TRUE];
};


Init: FitJaM.InitProc = {
JaM.Register[state,".startsa", StartSa];
JaM.Register[state,".resetsa", ResetSa];
JaM.Register[state,".addsa", AddSa];
JaM.Register[state,".countsa", CountSa];
JaM.Register[state,".selectsa", SelectSa]; -- x y => . Selects a sample point for editing
JaM.Register[state,".interpolatesa", InterpolateSa]; -- d => . Interpolates samples to make deltas no larger than about d
JaM.Register[state,".thesa", TheSa]; -- => x y . Returns the current sample
JaM.Register[state,".thetan", TheTan]; -- => x y boolean . Returns the tangent of the current sample, and whether it is a node
JaM.Register[state,".deletesa", DeleteSa]; -- =>  . Deletes the current sample
JaM.Register[state,".insertsa", InsertSa]; -- x y => . Inserts before the current sample
JaM.Register[state,".insertbetween", InsertBetween]; -- x y => . Inserts between the current sample and the neighbor nearest the new point
JaM.Register[state,".nodesa", NodeSa]; -- boolean => . Makes or unmakes a node
JaM.Register[state,".tansa", TanSa]; -- deltax deltay => . Sets the tangent at a sample
JaM.Register[state,".cuspsa", CuspSa]; -- boolean => . Makes or unmakes a cusp
JaM.Register[state,".cuspnode", CuspNode]; -- boolean => . Makes or unmakes a cusp ONLY on a node
JaM.Register[state,".tanoutsa", TanOutSa]; -- deltax deltay => . Sets the outgoing tangent
JaM.Register[state,".homesa", HomeSa]; -- => . Selects the header
JaM.Register[state,".makefirstsa", MakeFirstSa]; -- => . Selects the header
JaM.Register[state,".nextsa", NextSa]; -- => x y . Moves selection to the next sample
JaM.Register[state,".prevsa", PrevSa]; -- => x y . Moves selection to the previous sample
JaM.Register[state,".scalesa", ScaleSa]; -- x y =>  . Scales/rotates all samples by multiplying by x+iy
JaM.Register[state,".transa", TranSa]; -- x y =>  . Translates all samples by adding x+iy
JaM.Register[state,".subrange", Subrange]; -- change CurrentSamples so it returns a subrange
JaM.Register[state,".allsa", NoSubrange]; -- remove the subrange
JaM.Register[state,".resetnodes", ResetDefaultNodes]; -- remove the nodes
JaM.Register[state,".resetcusps", ResetDefaultCusps]; -- remove the cusps
JaM.Register[state,".foralllinks", ForAllLinks];
JaM.Register[state,".nextcon", NextCon];
JaM.Register[state,".resetcon", ResetCon];
JaM.Register[state,".addcon", AddCon];
JaM.Register[state,".countcon", CountCon];
JaM.Register[state,".setslen", SetSLen];
JaM.Register[state,".collectgarbage", CollectGarbage];
};
FitJaM.RegisterInit[$FitEditJaM, Init];
}.

ðFitEditJaM.mesa
The point and link editing JaM commands
Display commands are in FitIOJaM
Last Edited by Maureen Stone July 3, 1984 11:33:19 am PDT
Last Edited by Michael Plass  December 7, 1982 10:25 am
Last Edited by: Stone, November 21, 1983 11:33 am
Sample Editing Commands
ScaleSa: PROC [state: JaM.State] = {
z: Complex.Vec _ GetVec[state];
FOR s: FitBasic.SampleHandle _ slist.header.next, s.next UNTIL s=slist.header DO
p:Complex.Vec _ s.xy;
s.xy _ Complex.Mul[p,z];
p _ s.tangent;
s.tangent _ Complex.Mul[p,z];
ENDLOOP;
};
JaM.Register[state,".cornersa", CornerSa]; -- => . moves the selected sample so it is colinear with its two left neightbors and with its two right neighbors
CornerSa: PROC = {OPEN Vector;
samp: SampleHandle _ IF FitJaM.defaultFitState.slist.selectedSample =
IF FitJaM.defaultFitState.slist.header THEN FitJaM.defaultFitState.slist.selectedSample.next
ELSE FitJaM.defaultFitState.slist.selectedSample;
p: SampleHandle _ IF samp.prev = FitJaM.defaultFitState.slist.header THEN samp.prev.prev ELSE samp.prev;
pp: SampleHandle _ IF p.prev = FitJaM.defaultFitState.slist.header THEN p.prev.prev ELSE p.prev;
n: SampleHandle _ IF samp.next = FitJaM.defaultFitState.slist.header THEN samp.next.next ELSE samp.next;
nn: SampleHandle _ IF n.next = FitJaM.defaultFitState.slist.header THEN n.next.next ELSE n.next;
a: Vec _ pp.xy;
b: Vec _ p.xy;
c: Vec _ nn.xy;
d: Vec _ n.xy;
coeffMat: Matrix _ [a.y-b.y, b.x-a.x, c.y-d.y, d.x-c.x];
r: Vec _ [Det[[b.x, b.y, a.x, a.y]], Det[[d.x, d.y, c.x, c.y]]];
denom: REAL _ Det[coeffMat];
xTimesDenom: REAL _ Det[[r.x, coeffMat.a12, r.y, coeffMat.a22]];
yTimesDenom: REAL _ Det[[coeffMat.a11, r.x, coeffMat.a21, r.y]];
IF denom=0 THEN RETURN;
samp.xy.x _ xTimesDenom/denom;
samp.xy.y _ yTimesDenom/denom;
};

�ÊŸ˜Jš
œ™Jš
œ'™'J™ Jš
œ9™9Jš
œ7™7Jš
œ1™1J˜š
Ïk	˜	J˜J˜Jš
œ	˜	Jšœ�œ˜.J˜J˜J˜	J˜J˜J˜J˜J˜J˜J˜—šœ�œ
�˜Jš�œT˜[—J˜Jšœ�œ
˜šÏnœ�œ�œ˜;Jš
œ˜Jš
œ˜Jš
œ˜—Jšžœ�œG˜Tšžœ�œ˜Jšœ�œ˜Jšœ�œ˜Jš
œ3˜3Jš
œ˜—šžœ�œ˜Jšœ�œ˜Jšœ�œ˜Jš
œ0˜0Jš
œ˜—šžœ�œ˜Jšœ�œ˜J˜,Jš
œ@˜@J˜J˜—šžœ�œ˜%J˜J˜J˜Jš
œ˜J˜Jš�œ	�œ
�œ7˜JJ˜J˜—šžœ�œ˜"Jš
œE˜EJš
œE˜EJš
œ˜—J˜šžœ�œ�œ&�œ˜SJšœ�œ˜Jšœ�œ˜š
œ ˜ J˜*š�œ
�œ�œ
�œ˜0š�œ-�˜6Jš
œ"˜"Jš
œ˜——J˜J˜—Jšœ�œ
˜Jš
œ=˜=J˜J˜—šžœ�œ�œ-˜TJ˜J˜J˜J˜J˜—šžœ�œ˜%Jš
œ.˜.J˜J˜—šžœ�œ˜%Jšœ�œ
˜
J˜J˜Jš
œ9˜9J˜J˜—šž
œ�œ˜*J˜Jšœ�œ
˜J˜JJ˜J˜˜J˜T—Jš�œ�œ>˜Rš�œ˜J˜_Jš
œ>˜>J˜3J˜—J˜J˜—šžœ�œ�œ˜?J˜1Jš�œ�œ�œ
˜IJ˜J˜—šžœ�œ˜"Jš
œE˜E—J˜šžœ�œ�œ˜?Jš
œP˜P—šžœ�œ�œ˜AJš�œ�œ3˜V—šžœ�œ˜%Jš
œD˜D—šžœ�œ�œ˜?Jš
œ$˜$Jš
œ˜—šžœ�œ�œ˜Dš
�œ�œ
�œ%�œ*�œ˜yJ˜+J˜,J˜)J˜.J˜&J˜&J˜—J˜J˜—šžœ�œ�œ˜?J˜1š�œ%�˜+J˜0—J˜J˜—šžœ�œ�œ˜?J˜1š�œ%�˜+J˜0—J˜J˜—šžœ�œ˜$J˜GJ˜—šžœ�œ˜#J˜J˜;J˜J˜—šž
œ�œ�œ˜BJšœ
�œ�œ˜2J˜7Jšœ�œ�œ
˜J˜0˜ Jš�œ�œ�œ
˜'š�œ˜J˜J˜1Jšœ�œ-˜4J˜š�œ�œ
�œ�˜!J˜?J˜=Jš�œ˜	—J˜
Jš
œ˜—J˜—J˜'Jš�œ�œ˜*J˜ J˜J˜—J˜šžœ�œ�œ˜AJ˜"J˜Jšœ�œ
˜J˜J˜J˜J˜J˜J˜Jš�œ�œ*�œ*˜eJ˜—Jšž
œ�œ�œ4�œ˜dJšžœ�œJ˜aJšžœ�œJ˜aJ˜šžœ�œ˜#J˜š
œ˜J˜!J˜!J˜!J˜!J˜!J˜!J˜!J˜!Jšœ&�œ˜0Jš
œ˜—J˜:J˜J˜—Jšžœ�œF�œ˜[šžœ�œ˜ Jš
œD˜D—Jšžœ�œ?˜KJšžœ�œ@˜MJ˜Jšžœ�œT˜ašžœ�œ˜&Jšœ1�œ�œ˜LJ˜J˜—J˜˜Jš
œ™Jš
œ(˜(Jš
œ(˜(Jš
œ$˜$Jš
œ(˜(Jšœ+Ïc.˜YJšœ5ŸD˜yJšœ%Ÿ&˜KJšœ'ŸW˜~Jšœ+Ÿ#˜NJšœ+Ÿ-˜XJšœ5ŸU˜Š
Jšœ'Ÿ'˜NJšœ%Ÿ2˜WJšœ'Ÿ'˜NJšœ+Ÿ6˜aJšœ+Ÿ/˜ZJšœ'Ÿ˜AJšœ1Ÿ˜KJšœ'Ÿ.˜UJšœ'Ÿ2˜YJšœ)Ÿ>˜gJšœ'Ÿ2˜YJšœ+Ÿ1˜\Jšœ*Ÿ˜@Jšœ6Ÿ˜IJšœ6Ÿ˜IJ˜0J˜(J˜*J˜&J˜*J˜(Jš
œ6˜6J˜—J˜'J˜šžœ�œ™$J™š�œ6�œ�™PJ™J™J™J™Jš�œ
™—J™—Jšœ+Ÿq™œ
šžœ�œ�œ™šœ�œ.™EJš�œ%�œ1™\Jš�œ-™1—Jšœ�œ1�œ�œ™hJšœ�œ.�œ
�œ™`Jšœ�œ1�œ�œ™hJšœ�œ.�œ
�œ™`J™J™J™J™J™8J™@Jšœ�œ™Jšœ
�œ/™@Jšœ
�œ/™@Jš�œ	�œ
�œ
™J™J™J™J™—J˜—…—&~6