<<>>
<<G3dTubeCmdImpl.mesa>>
<<Copyright Ó 1985, 1992 by Xerox Corporation.  All rights reserved.>>
<<Bloomenthal, October 20, 1992 4:33 pm PDT>>

DIRECTORY Args, Commander, Controls, Draw2d, FileNames, FS, G2dBasic, G2dContour, G3dBasic, G3dControl, G3dCurve, G3dDraw, 
G3dMatrix, G3dPlane, G3dSpline, G3dTool, G3dTube, G3dVector, G3dView, Icons, IO, ImagerInterpress, Menus, MessageWindow, Real, 
Rope, ViewerOps;

G3dTubeCmdImpl: CEDAR PROGRAM
IMPORTS Args, Controls, Draw2d, FileNames, FS, G2dContour, G3dControl, G3dCurve, G3dDraw, G3dMatrix, G3dPlane, G3dSpline, G3dTool, 
G3dTube, G3dVector, G3dView, Icons, IO, ImagerInterpress, MessageWindow, Real, Rope, ViewerOps

~ BEGIN
<<Types>>
ClickProc:            TYPE ~ Controls.ClickProc;
Control:                TYPE ~ Controls.Control;
ControlList:            TYPE ~ Controls.ControlList;
Mouse:                TYPE ~ Controls.Mouse;
OuterData:            TYPE ~ Controls.OuterData;
Zip:                    TYPE ~ Draw2d.Zip;
Contour:                TYPE ~ G2dContour.Contour;
Pair:                    TYPE ~ G3dBasic.Pair;
Triple:                TYPE ~ G3dBasic.Triple;
Quad:                    TYPE ~ G3dBasic.Quad;
Hold:                    TYPE ~ G3dControl.Hold;
Matrix:                TYPE ~ G3dMatrix.Matrix;
Plane:                    TYPE ~ G3dPlane.Plane;
RenderTool:            TYPE ~ G3dTool.Tool;
SplineRep:            TYPE ~ G3dSpline.SplineRep;
STREAM:                TYPE ~ IO.STREAM;
ROPE:                    TYPE ~ Rope.ROPE;

Details:                TYPE ~ G3dTube.Details;
DetailType:            TYPE ~ G3dTube.DetailType;

RadiusMode:            TYPE ~ G3dTube.RadiusMode;
Tube:                    TYPE ~ G3dTube.Tube;
TubeProc:            TYPE ~ G3dTube.TubeProc;
TubeRep:                TYPE ~ G3dTube.TubeRep;

Pendings:                TYPE ~ REF PendingsRep;
PendingsRep:        TYPE ~ RECORD [
epsilon:                        BOOL Ź FALSE,
size:                            BOOL Ź FALSE,
r:                                BOOL Ź FALSE,
taper:                            BOOL Ź FALSE,
tens:                            BOOL Ź FALSE,
tw0:                            BOOL Ź FALSE,
tw1:                            BOOL Ź FALSE,
cres:                            BOOL Ź FALSE,
holdPosition:                    BOOL Ź FALSE,
holdTangent:                    BOOL Ź FALSE,
holdRoll:                        BOOL Ź FALSE,
shape:                            BOOL Ź FALSE,
skin:                            BOOL Ź FALSE
];

Pick:                    TYPE ~ REF PickRep;
PickRep:                TYPE ~ RECORD [
type:                            {point, segment, subTree} Ź point,
pos, tan:                        Triple Ź G3dBasic.origin,
tube:                            Tube Ź NIL,
t:                                REAL Ź 1.0,
selected0, selected1:            Tube Ź NIL,
dividePending:                BOOL Ź FALSE,
plane:                            Plane Ź [0.0, 0.0, 0.0, 0.0],
mouse:                        Mouse 
];

ActionType:            TYPE ~ {none, select, camera, spline, shape, button};

Tool:                    TYPE ~ REF ToolRep;
ToolRep:                TYPE ~ RECORD [
<<Controls:>>
controls:                    ControlList Ź NIL,            -- list of the following controls:
size:                        Control Ź NIL,                -- size of tube
r0:                            Control Ź NIL,                -- radius 0
r1:                            Control Ź NIL,                -- radius 1
tw0:                        Control Ź NIL,                -- twist 0
tw1:                        Control Ź NIL,                -- twist 1
tens0:                        Control Ź NIL,                -- tension 0
tens1:                        Control Ź NIL,                -- tension 1
cres:                        Control Ź NIL,                -- circ. resolution
epsilon:                    Control Ź NIL,                -- spline flatness value
taper:                        Control Ź NIL,                -- tube taper
hold:                        Hold Ź NIL,                    -- handle on a point and its tangent
lim:                        Control Ź NIL,                -- vector limit
<<Viewing:>>
renderTool:                RenderTool Ź NIL,
<<State:>>
details:                    Details Ź NIL,
pendings:                    Pendings Ź NIL,
noDraw:                    BOOL Ź FALSE,
vectors:                    BOOL Ź TRUE,
neverMoused:            BOOL Ź TRUE,
mouse:                    Mouse Ź [[0, 0], none, left],
mousePrev:                Mouse Ź [[0, 0], none, left],
pick:                        Pick Ź NIL,
action:                    ActionType Ź none,
radiusMode:                RadiusMode Ź linear,
round:                    BOOL Ź FALSE,
xformIO:                    BOOL Ź FALSE,                -- view-xform points when writing file
<<Geometry:>>
ground:                    Plane Ź [],                    -- something new
frill:                        Tube Ź NIL,                    -- the frilled tube
tube:                        Tube Ź NIL                    -- all the tube splines
];
<<Initialization>>
TubeDesignCmd: Commander.CommandProc ~ {
NewControl: PROC [name: ROPE, min, max, init: REAL, lin: BOOL Ź TRUE, precision: NAT Ź 3]
RETURNS [c: Control] ~ {
c Ź Controls.NewControl[
name, vSlider, t, min, max, init, TubeControl,, precision,,,,,,,,, IF lin THEN lin ELSE exp];
}; 
err: ROPE;
t: Tool ~ NEW[ToolRep];
SELECT Args.NArgs[cmd] FROM
0 => t.tube Ź ResetTube[];
1 => IF (err Ź TubeFromFile[t, Args.GetRope[cmd]]) # NIL THEN RETURN[$Failure, err];
ENDCASE => RETURN[$Failure, designUsage];
t.details Ź NEW[G3dTube.DetailsRep];
t.pendings Ź NEW[PendingsRep];
t.hold Ź G3dControl.InitHold[TubeControl, t];
t.tw0        Ź NewControl["tw0",    -1000., 1000., 0.0];
t.tw1        Ź NewControl["tw1",    -1000., 1000., 0.0];
t.tens0    Ź NewControl["tens0",    -3.0, 3.0, 0.0];
t.tens1    Ź NewControl["tens1",    -3.0, 3.0, 0.0];
t.r0        Ź NewControl["r0",        0.0, 0.5, 0.0];
t.r1        Ź NewControl["r1",        0.0, 0.5, 0.0];
t.size        Ź NewControl["size",    0.0, 4.0, 1.0];
t.epsilon    Ź NewControl["eps",    0.0, 0.2, 0.03, FALSE];
t.taper        Ź NewControl["taper",    -3.0, 3.0, 0.0, FALSE];
t.cres        Ź NewControl["cres",    2.0, 25.0, 6.0, TRUE, 0];
t.lim        Ź NewControl["lim",    0.0, 1000.0, 500.0, TRUE, 0];
t.pendings Ź NEW[PendingsRep Ź [shape: TRUE]];
MakePick[t];
SetPick[t];
Moused[t, [[0, 0], up, left], $Buttons];
t.renderTool Ź G3dTool.MakeTool[
name: Rope.Concat["3dTube ", IF t.tube # NIL THEN t.tube.name ELSE NIL],
extraButtons: LIST[
Controls.ClickButton["Tube Ops", TubeOps, t],
Controls.ClickButton["IO Ops", IOOps, t],
Controls.ClickButton["Draw Ops", DrawOps, t]],
extraControls: LIST[
t.hold.x, t.hold.y, t.hold.z, t.hold.pitch, t.hold.yaw, -- t.hold.roll, -- t.hold.mag,
t.tw0, t.tw1, t.r0, t.r1, t.tens0, t.tens1,
t.lim, t.epsilon, t.taper, t.size, t.cres],
controlSizes: [20, 200, 55, 20, 55, 150, 150],
client: [data: t, mouse: MouseProc, draw: DrawProc, destroy: DestroyProc],
ops: [FALSE, FALSE, FALSE, FALSE, FALSE, FALSE],
useArcBalls: FALSE,
arcBallSize: 80,
icon: icon];
};

ClearPendings: PROC [pendings: Pendings] ~ {
pendings.epsilon Ź pendings.size Ź pendings.r Ź pendings.tw0 Ź pendings.tw1 Ź
pendings.cres Ź pendings.holdPosition Ź pendings.holdTangent Ź pendings.shape Ź
pendings.skin Ź FALSE;
};
<<Tube Ops>>
TubeOps: ClickProc ~ {
t: Tool Ź NARROW[clientData];
SELECT Controls.PopUpRequest[["Tube Ops"], LIST[
-- 1 -- ["New Tube", "reset the current tube to the default tube"],
-- 2 -- ["Select All", "select the entire tube"],
-- 3 -- ["Branch", "add a branch to the current tube at the selected point"],
-- 4 -- ["Delete", "delete the current selected branch"],
-- 5 -- Controls.BoolRequest[t.round, "Round ends"],
-- 6 -- ["Wt Rad", "select different radius weighting scheme"],
-- 7 -- ["Radius Mode", "cycle through radius mode"],
-- 8 -- Controls.BoolRequest[t.xformIO, "Xform points"]]]
FROM
1    => ReplaceTube[t, ResetTube[]];
2    => G3dTube.SelectAll[t.tube];
3    => Branch[t];
4    => Delete[t];
5    => {
t.round Ź NOT t.round;
t.pendings.shape Ź TRUE;
};
6    => WeightRadii[t];
7    => {
t.radiusMode Ź SELECT Controls.MultiRequest["Radius mode is ", LIST[
["Linear", t.radiusMode = linear],
["Square", t.radiusMode = square]]]
FROM 1 => linear, 2 => square, ENDCASE => linear;
};
8    => t.xformIO Ź NOT t.xformIO;
ENDCASE;
IF Controls.GetPopUpButton[] = right THEN CheckPendingAndRePaint[t];
};
<<Drawing>>
DrawProc: G3dTool.DrawProc ~ {
t: Tool ~ NARROW[clientData];
IF NOT t.noDraw THEN {
IF whatChanged # $Camera THEN Draw2d.Clear[context];
IF t.details[spline] AND t.details[ends] THEN
G3dTube.DrawSplineEnds[context, t.tube, view];
IF t.details[enabled]
THEN G3dTube.DrawTube[context, t.tube, t.details, view, vp]
ELSE IF t.details[spline] THEN G3dTube.DrawSplines[context, t.tube, view, vp];
IF t.details[pick] AND t.pick # NIL AND t.pick.tube # NIL THEN {
IF NOT t.neverMoused THEN {
pairClip: G3dView.PairClip ~ G3dView.TransformAndClipInZ[t.pick.pos, view];
Imager.SetStrokeWidth[context, 1.0];
G3dDraw.Vector[context, t.pick.pos, t.pick.tan, view, vp];
IF NOT pairClip.clipped THEN {
Draw2d.Circle[context, pairClip.pair, 3.0, TRUE];
IF NOT t.pick.t IN (0.0..1.0) THEN Draw2d.Mark[context, pairClip.pair, asterisk];
};
};
};
};
};

DrawOps: ClickProc ~ {
t: Tool Ź NARROW[clientData];
SELECT Controls.PopUpRequest[["LF Ops"], LIST[
-- 1  -- Controls.BoolRequest[t.vectors, "Vectors"],
-- 2  -- Controls.BoolRequest[t.details[skeleton], "Skeleton"],
-- 3  -- Controls.BoolRequest[t.details[spline], "Splines"],
-- 4  -- Controls.BoolRequest[t.details[ends], "Ends"],
-- 5  -- Controls.BoolRequest[t.details[pick], "Pick"],
-- 6  -- Controls.BoolRequest[t.details[label], "Label"],
-- 7  -- Controls.BoolRequest[t.details[autoSimplify], "Auto"],
-- 8  -- Controls.BoolRequest[t.details[contours], "Contours"],
-- 9  -- Controls.BoolRequest[t.details[lines], "Lines"],
-- 10 -- Controls.BoolRequest[t.details[xSections], "XSections"],
-- 11 -- Controls.BoolRequest[t.details[points], "Points"],
-- 12 -- Controls.BoolRequest[t.details[normals], "Normals"],
-- 13 -- Controls.BoolRequest[t.details[curvature], "Curvature"],
-- 14 -- Controls.BoolRequest[t.details[velocity], "Velocity"],
-- 15 -- Controls.BoolRequest[t.details[acceleration], "Acceleration"]]]
FROM
1    => t.vectors Ź NOT t.vectors;
2    => TogDetail[t, skeleton];
3    => TogDetail[t, spline];
4    => TogDetail[t, ends];
5    => TogDetail[t, pick];
6    => TogDetail[t, label];
7    => TogDetail[t, autoSimplify];
8    => TogDetail[t, contours];
9    => TogDetail[t, lines];
10    => TogDetail[t, xSections];
11    => TogDetail[t, points];
12    => TogDetail[t, normals];
13    => TogDetail[t, curvature];
14    => TogDetail[t, velocity];
15    => TogDetail[t, acceleration];
ENDCASE;
IF Controls.GetPopUpButton[] = right THEN CheckPendingAndRePaint[t, TRUE];
};

TogDetail: PROC [t: Tool, detailType: DetailType] ~ {
button: Controls.MouseButton Ź Controls.GetPopUpButton[];
m: Mouse ~ [[0, 0], up, button];
wasShape: BOOL ~ t.details[shape];
wasSkin: BOOL ~ t.details[skin];
t.details[detailType] Ź NOT t.details[detailType];
t.details[shape] Ź
t.details[xSections] OR t.details[curvature] OR t.details[velocity] OR t.details[acceleration];
t.details[skin] Ź t.details[contours] OR t.details[lines] OR t.details[normals];
Moused[t, m, $Buttons];
IF wasShape # t.details[shape] THEN t.pendings.shape Ź t.details[shape];
IF wasSkin # t.details[skin] THEN t.pendings.skin Ź t.details[skin];
IF detailType # autoSimplify AND button = right THEN CheckPendingAndRePaint[t, TRUE];
};
<<User Interaction>>
Moused: PROC [
t: Tool,
mouse: Mouse,
whatChanged: REF ANY,
msg: ROPE Ź NIL]
~ {
c: Control Ź SELECT whatChanged FROM
t.hold.pitch, t.hold.yaw, t.hold.roll, t.hold.mag, t.hold.x, t.hold.y, t.hold.z,
t.epsilon, t.taper, t.size, t.r0, t.r1, t.tw0, t.tw1, t.cres => NARROW[whatChanged],
ENDCASE => NIL;
t.mousePrev Ź t.mouse;
t.mouse Ź mouse;
t.action Ź SELECT whatChanged FROM
$Buttons => button,
$Select => select,
t.hold.pitch, t.hold.yaw, t.hold.roll, t.hold.mag, t.hold.x, t.hold.y, t.hold.z => spline,
t.epsilon, t.taper => spline,
$Pull, t.size, t.r0, t.r1, t.tw0, t.tw1, t.cres => shape,
ENDCASE => none;
t.details[enabled] Ź NOT t.details[autoSimplify] OR t.action = shape OR t.mouse.state = up;
<<t.noDraw _ t.mouse.state = up AND (c = NIL OR c.whatChanged # $TypedIn) AND>>
<<t.action # button AND t.action # select AND NOT t.details[autoSimplify];>>
IF NOT t.noDraw THEN SELECT whatChanged FROM
t.size => t.pendings.size Ź TRUE;
t.r0, t.r1 => t.pendings.r Ź TRUE;
t.tw0 => t.pendings.tw0 Ź TRUE;
t.tw1 => t.pendings.tw1 Ź TRUE;
t.tens0, t.tens1 => t.pendings.tens Ź TRUE;
t.cres => t.pendings.cres Ź TRUE;
t.epsilon => t.pendings.epsilon Ź TRUE;
t.taper => t.pendings.taper Ź TRUE;
$Pull, t.hold.x, t.hold.y, t.hold.z => t.pendings.holdPosition Ź TRUE;
t.hold.pitch, t.hold.yaw, t.hold.mag => t.pendings.holdTangent Ź TRUE;
t.hold.roll => t.pendings.holdRoll Ź TRUE;
ENDCASE;
IF t.action = spline AND t.pick.dividePending THEN DivideSpline[t];
IF t.renderTool # NIL THEN {
IF msg = NIL
THEN Controls.TypescriptClear[t.renderTool.typescript]
ELSE Controls.TypescriptWrite[t.renderTool.typescript, msg];
};
};

DivideSpline: PROC [t: Tool] ~ {
DividePick[t.pick];
Controls.SetSliderDialValue[t.hold.mag, G3dVector.Length[t.pick.tube.v1]];
};

CheckPendingAndRePaint: PROC [t: Tool, forceReDraw: BOOL Ź FALSE] ~ {
IF t.pick.tube = NIL THEN
t.pendings.holdPosition Ź t.pendings.holdTangent Ź t.pendings.holdRoll Ź FALSE;
t.pendings.shape Ź t.pendings.shape OR t.pendings.holdPosition OR
t.pendings.holdTangent OR t.pendings.holdRoll;
t.pendings.skin Ź
t.pendings.skin OR t.pendings.shape OR t.pendings.r OR t.pendings.tens OR
t.pendings.tw0 OR t.pendings.tw1 OR t.pendings.taper OR
t.pendings.epsilon OR t.pendings.cres;
IF t.pendings.holdPosition THEN
ChangePosition[t.pick, [t.hold.x.value, t.hold.y.value, t.hold.z.value]];
IF t.pendings.holdTangent THEN ChangeTangent[t.pick, t.hold];
IF t.pendings.holdRoll THEN
RollSubTree[t.pick, Controls.GetSliderDialDeltaValue[t.hold.roll]];
IF t.pendings.size OR t.pendings.taper
THEN G3dTube.ReScale[t.tube, t.size.value, t.taper.value];
IF t.pendings.epsilon THEN G3dTube.PropagateEpsilon[t.tube, t.epsilon.value];
IF t.pendings.cres
THEN G3dTube.PropagateCircleRes[t.tube, Real.Round[t.cres.value]];
IF t.pendings.tens THEN ChangeTension[t.pick, t.tens0.value, t.tens1.value];
IF t.pendings.shape OR t.pendings.skin THEN G3dTube.InvalidateTubeAttributes[t.tube];
IF t.details[skin] OR t.details[shape] THEN {
IF t.pendings.r THEN
ChangeRadii[t.pick, t.r0.value, t.r1.value, t.size.value, t.epsilon.value];
IF t.pendings.tw0 THEN {
ChangeTw0[t.pick, t.tw0.value, t.tw0.valuePrev];
IF t.pick.selected1 # NIL THEN Controls.SetSliderDialValue[t.tw1, t.pick.selected1.tw1];
};
IF t.pendings.tw1 THEN ChangeTw1[t.pick, t.tw1.value, t.tw1.valuePrev];
IF t.pendings.shape OR t.pendings.skin THEN MakeDetails[t];
};
IF forceReDraw THEN t.noDraw Ź FALSE;
IF t.vectors THEN G3dTool.Repaint[t.renderTool, t];
ClearPendings[t.pendings];
};

TubeControl: Controls.ControlProc ~ {
t: Tool ~ NARROW[control.clientData];
Moused[t, control.mouse, control];
IF NOT t.noDraw AND (control.mouse.button = right OR control.whatChanged = $TypedIn)
THEN CheckPendingAndRePaint[t];
};

MouseProc: Controls.MouseProc ~ {
t: Tool ~ NARROW[clientData];
whatChanged: REF ANY Ź $Select;
view: Matrix Ź GetView[viewer, t];
Moused[t, mouse, whatChanged];
t.neverMoused Ź FALSE;
IF mouse.state = up THEN RETURN;
IF -- mouse.state = down OR -- NOT mouse.controlKey THEN {
ScreenPick[t, mouse, view, t.pick];
G3dControl.SetHold[t.hold, t.pick.pos, t.pick.tan];
SetPick[t];
};
IF mouse.controlKey
THEN {
p: Pair Ź [mouse.pos.x, mouse.pos.y];
plane: Quad Ź [t.pick.plane.x, t.pick.plane.y, t.pick.plane.z, t.pick.plane.w];
q: Triple Ź G3dMatrix.TripleFromScreenAndPlane[p, plane, view];
Controls.SetSliderDialValue[t.hold.x, q.x];
Controls.SetSliderDialValue[t.hold.y, q.y];
Controls.SetSliderDialValue[t.hold.z, q.z];
whatChanged Ź t.hold.x -- $Pull -- ;
}
ELSE IF t.mouse.button = left THEN  {
point: Triple Ź G3dSpline.Position[t.pick.tube.spline, t.pick.t];
message: ROPE Ź IO.PutFLR["%g%g (%6.3f, %6.3f, %6.3f)", LIST[
IO.rope[IF t.tube.name # NIL THEN t.tube.name ELSE "Tube"],
IO.rope[G3dTube.Where[t.pick.tube, t.tube]],
IO.real[point.x], IO.real[point.y], IO.real[point.z]]];
MessageWindow.Append[message, TRUE]; 
};
<<G3dTool.Repaint[t.renderTool, t];>>
CheckPendingAndRePaint[t];
};

<<MouseProc: Controls.MouseProc ~ {>>
<<t: Tool ~ NARROW[clientData];>>
<<t.neverMoused _ FALSE;>>
<<Moused[t, mouse, $Select];>>
<<IF t.mouse.state = up THEN RETURN;>>
<<ScreenPick[t.tube, t.mouse, t.renderTool.view, t.pick];>>
<<G3dControl.SetHold[t.hold, t.pick.pos, t.pick.tan];>>
<<IF t.mouse.button = left THEN {>>
<<IF t.mouse.state = down THEN {>>
<<point: Triple _ G3dSpline.Position[t.pick.tube.spline, t.pick.t];>>
<<message: ROPE _ IO.PutFR["%g%g (%6.3f, %6.3f, %6.3f)",>>
<<IO.rope[IF t.tube.name # NIL THEN t.tube.name ELSE "Tube"],>>
<<IO.rope[G3dTube.Where[t.pick.tube, t.tube]],>>
<<IO.real[point.x], IO.real[point.y], IO.real[point.z]];>>
<<MessageWindow.Append[message, TRUE]; >>
<<};>>
<<};>>
<<SetPick[t];>>
<<G3dTool.Repaint[t.renderTool, clientData];>>
<<};>>
<<>>
SetPick: PROC [t: Tool] ~ {
<<adjust controls to selected splines settings:>>
IF t.pick.selected0 # NIL THEN {
Controls.SetSliderDialValue[t.r0, t.pick.selected0.r0];
Controls.SetSliderDialValue[t.tw0, t.pick.selected0.tw0];
Controls.SetSliderDialValue[t.tens0, t.pick.selected0.tens0];
};
IF t.pick.selected1 # NIL THEN {
Controls.SetSliderDialValue[t.r1, t.pick.selected1.r1];
Controls.SetSliderDialValue[t.tw1, t.pick.selected1.tw1];
Controls.SetSliderDialValue[t.tens1, t.pick.selected1.tens1];
};
};
<<Tube Modification>>
MakeDetails: PROC [t: Tool] ~ {
G3dTube.Make[t.tube, t.details[skin], t.round, NIL, t.epsilon.value];
};

ResetTube: PROC RETURNS [tube: Tube] ~ {
tube Ź NEW[TubeRep Ź [p0: [-0.5,0.,0.], p1: [0.5,0.,0.], v0: [1.,0.,1.], v1: [1.,0.,1.]]];
G3dTube.SetSpline[tube];
tube.name Ź "Tube";
};

RenameViewer: PROC [t: Tool] ~ {
IF Rope.Equal[t.tube.name, "Tube", FALSE] THEN RETURN;
t.renderTool.outer.name Ź Rope.Concat["3dTube ", t.tube.name];
t.renderTool.outer.label Ź t.tube.name;
ViewerOps.PaintViewer[t.renderTool.outer, caption];
};

ReplaceTube: PROC [t: Tool, tube: Tube] ~ {
t.tube Ź tube;
IF tube.name = NIL THEN tube.name Ź "Tube";
RenameViewer[t];
t.pendings Ź NEW[PendingsRep Ź [shape: TRUE]];
MakePick[t];
SetPick[t];
Moused[t, [[0, 0], up, left], $Buttons];
CheckPendingAndRePaint[t, TRUE];
};

Branch: PROC [t: Tool] ~ {
IF t.pick.t = 0.0 AND t.pick.tube.prev = NIL THEN RETURN;
IF t.pick.dividePending THEN DivideSpline[t];
G3dTube.AddBranch[t.pick.tube, G3dTube.NewBranch[t.pick.tube]];
CheckPendingAndRePaint[t, TRUE];
};

Delete: PROC [t: Tool] ~ {
G3dTube.Delete[t.pick.selected0];
t.pick.selected0 Ź t.pick.selected1 Ź NIL;
G3dTube.UnSelectAll[t.tube];
IF NOT G3dTube.Find[t.pick.tube, t.tube] THEN t.pick.tube Ź NIL;
CheckPendingAndRePaint[t, TRUE];
};

WeightRadii: PROC [t: Tool] ~ {
G3dTube.SetDescendantRadii[t.tube, t.radiusMode];
t.pendings.skin Ź TRUE;
CheckPendingAndRePaint[t, TRUE];
};

FromControl: PROC [control: Control, t: REAL Ź 0.0] RETURNS [contour: Contour] ~ {
ips: G2dBasic.IntegerPairSequence Ź Controls.GetContour[control];
IF ips # NIL THEN {
offset: Pair Ź [0.5*(control.w-1), 0.5*(control.h-1)];
scale: Pair Ź [IF offset.x>0 THEN 1./offset.x ELSE 1., IF offset.y>0 THEN 1./offset.y ELSE 1.];
contour Ź G2dContour.FromIntegerPairs[ips, Controls.IsContourClosed[control], t];
RETURN[G2dContour.Thin[G2dContour.Scale[G2dContour.Offset[contour, offset], scale]]];
};
};

GetContour: PROC [t: Tool] ~ {
c: Control ~ Controls.LastControlMoused[];
IF c # NIL AND c.type = contour AND NOT c.viewer.destroyed
THEN {
G3dTube.AddContour[t.tube, G2dContour.Orient[FromControl[c, t.pick.t]]];
Moused[t, [[0, 0], up, left], $Buttons, "Contour received\n"];
t.pendings.skin Ź TRUE;
CheckPendingAndRePaint[t, TRUE];
}
ELSE
Controls.TypescriptWrite[t.renderTool.typescript, "1st middle-click a contour viewer\n"];
};

GetTube: PROC [t: Tool] ~ {
tube: Tube ~ G3dTube.LastTubePicked[FALSE];
IF tube # NIL
THEN ReplaceTube[t, tube]
ELSE Controls.TypescriptWrite[t.renderTool.typescript, "1st click tube viewer\n"];
};

DestroyProc: Controls.DestroyProc ~ {
t: Tool ~ NARROW[clientData];
MessageWindow.Clear[];
IF G3dTube.LastTubePicked[FALSE] = t.tube THEN G3dTube.SetLastTubePicked[NIL];
};
<<IO>>
IOOps: ClickProc ~ {
t: Tool Ź NARROW[clientData];
SELECT Controls.PopUpRequest[["Misc Ops"], LIST[
-- 1 -- ["Read Tube", "read a tube from a file"],
-- 2 -- ["Get Tube", "get a tube from another viewer"],
-- 3 -- ["Get Contour", "get a contour from a viewer"],
-- 4 -- ["Write Tube", "write a tube to a file"],
-- 5 -- ["Write Curve", "write a curve to a file"],
-- 6 -- ["Write Interpress", "write an Interpress file of the current image"],
-- 7 -- ["Shape-Out", "write a shape file consisting of points and polygons"]]]
FROM
1 => ReadTube[t];
2 => GetTube[t];
3 => GetContour[t];
4 => WriteTube[t];
5 => WriteCurve[t];
6 => WriteInterpress[t];
7 => WritePointsPolys[t];
ENDCASE;
};

GetView: PROC [v: Controls.Viewer Ź NIL, t: Tool] RETURNS [m: Matrix] ~ {
m Ź G3dTool.GetViewTransform[v, t.renderTool];
};

WriteTube: PROC [t: Tool] ~ {
fileName: ROPE Ź Controls.TypescriptReadFileName[t.renderTool.typescript];
IF fileName # NIL THEN {
m: Matrix ~ IF t.xformIO THEN GetView[, t] ELSE NIL;
t.tube.name Ź G3dTube.ExtractTubeName[fileName];
G3dTube.TubeToFile[t.tube, fileName, m];
RenameViewer[t];
};
}; 

WritePointsPolys: PROC [t: Tool] ~ {
nPoints, nPolys: INT;
m: Matrix ~ IF t.xformIO THEN GetView[, t] ELSE NIL;
fileName: ROPE Ź Controls.TypescriptReadFileName[t.renderTool.typescript];
IF fileName = NIL THEN RETURN;
[nPoints, nPolys] Ź G3dTube.WritePointsPolys[t.tube, fileName, m];
Controls.TypescriptWrite[t.renderTool.typescript,
IO.PutFR["%g points and %g polys written\n", IO.int[nPoints], IO.int[nPolys]]];
}; 

WriteInterpress: PROC [t: Tool] ~ {
fileName: ROPE Ź Controls.TypescriptReadFileName[t.renderTool.typescript];
IF fileName # NIL THEN {
ref: ImagerInterpress.Ref Ź ImagerInterpress.Create[fileName];
G3dTube.WriteIP[ref, t.tube, t.details, G3dTool.GetViewTransform[, t.renderTool]];
ImagerInterpress.Close[ref];
};
}; 

WriteCurve: PROC [t: Tool] ~ {
fileName: ROPE Ź Controls.TypescriptReadFileName[t.renderTool.typescript];
IF fileName # NIL THEN {
out: STREAM Ź FS.StreamOpen[fileName, $create];
c: G3dCurve.Curve Ź G3dTube.CurveFromTube[t.tube];
name: ROPE Ź IF t.tube.name # NIL THEN Rope.Concat["from ", t.tube.name] ELSE NIL;
IF t.xformIO THEN G3dCurve.Transform[c, GetView[, t]];
G3dCurve.Write[out, c, name];
};
};

ReadTube: PROC [tool: Tool] ~ {
name: ROPE Ź Controls.TypescriptReadFileName[tool.renderTool.typescript];
tool.tube Ź G3dTube.TubeFromFile[name];
IF tool.tube # NIL THEN ReplaceTube[tool, tool.tube] ELSE Blink["Couldn't read tube"];
};

TubeFromFile: PROC [t: Tool, name: ROPE] RETURNS [error: ROPE] ~ {
r: ROPE Ź FileNames.ResolveRelativePath[name];
stream: STREAM Ź FS.StreamOpen[FS.ExpandName[r].fullFName ! FS.Error => GOTO noOpen];
t.tube Ź G3dTube.ReadTube[stream];
IO.Close[stream];
IF t.tube = NIL THEN RETURN["No tube in file."];
t.tube.name Ź G3dTube.ExtractTubeName[r];
EXITS
noOpen => error Ź IO.PutFR1["Couldn't open %g.\n", IO.rope[name]];
};

WriteTubeInfo: PROC [tube: Tube, o: OuterData] ~ {
nPoints, nPolys, minCres, maxCres: INTEGER;
[nPoints, nPolys, minCres, maxCres] Ź G3dTube.Info[tube];
Controls.TypescriptWrite[o.typescript, IO.PutFLR["%g points, %g polygons, cres: %g-%g\n",
LIST[IO.int[nPoints], IO.int[nPolys], IO.int[minCres], IO.int[maxCres]]]];
};
<<Pick Procedures>>
MakePick: PROC [t: Tool] ~ {
t.pick Ź NEW[PickRep Ź [tube: t.tube]];
t.pendings.holdPosition Ź t.pendings.holdTangent Ź t.pendings.holdRoll Ź FALSE;
SetPoint[t];
IF t.hold.x.viewer # NIL THEN G3dControl.SetHold[t.hold, t.pick.pos, t.pick.tan];
};

ScreenPick: PROC [tool: Tool, mouse: Mouse, view: Matrix, pick: Pick] ~ {
IF pick = NIL THEN RETURN;
pick.mouse Ź mouse;
[[pick.tube, pick.t]] Ź
G3dTube.NearestTube2d[tool.tube, [mouse.pos.x, mouse.pos.y], mouse. state= down, view];
SELECT TRUE FROM
mouse.button = right => {
pick.type Ź subTree;
SetSubTree[tool];
};
mouse.shiftKey => {
pick.type Ź segment;
SetSelection[tool];
};
ENDCASE => {
pick.type Ź point;
SetPoint[tool];
};
};

UpdatePick: PROC [t: Tool] ~ {
pick: Pick Ź t.pick;
IF pick.tube = NIL THEN RETURN;
G3dTube.SetLastTubePicked[pick.tube];
pick.dividePending Ź pick.t IN (0.0..1.0);
pick.tan Ź G3dSpline.Tangent[pick.tube.spline, pick.t];
pick.pos Ź --pick.origPos Ź-- G3dSpline.Position[pick.tube.spline, pick.t];
IF t.renderTool # NIL THEN {
<<Compute the plane perpendicular to the view direction and passing through pick.pos:>>
<<Find the 3d vector that presently points along z-axis after the view transform.>>
<<Thus, transform the z-axis by the inverse of the view transformation.>>
<<Note, the view transformation being considered includes the viewport.>>
<<To transform a vector, premultiply by the matrix's inverse (i.e., inverse of the inverse).>>
nrm: Quad Ź G3dMatrix.TransformH[[0,0,1], GetView[, t]];
pick.plane Ź G3dPlane.FromPointAndNormal[t.pick.pos, [nrm.x, nrm.y, nrm.z], TRUE];
};
};

SetPoint: PROC [tool: Tool] ~ {
IF tool.pick.tube = NIL THEN RETURN;
IF tool.pick.t = 0.0 AND tool.pick.tube.prev # NIL THEN {
tool.pick.t Ź 1.0;
tool.pick.tube Ź tool.pick.tube.prev;
};
IF tool.pick.selected0 # NIL THEN tool.pick.selected0.selected Ź FALSE;
IF tool.pick.selected1 # NIL THEN tool.pick.selected1.selected Ź FALSE;
tool.pick.selected0 Ź tool.pick.selected1 Ź NIL;
UpdatePick[tool];
};

SetSelection: PROC [tool: Tool] ~ {
pick: Pick Ź tool.pick;
pick.selected1 Ź pick.tube;
IF pick.mouse.button = middle OR pick.selected0 = NIL
THEN pick.selected0 Ź pick.selected1;
pick.t Ź IF pick.t > 0.5 THEN 1.0 ELSE 0.0;
FOR t: Tube Ź pick.selected0, t.next WHILE t # NIL DO    -- ensure selected0 before selected1
IF t = pick.selected1 THEN EXIT;
REPEAT
FINISHED => {
temp: Tube Ź pick.selected0;
pick.selected0 Ź pick.selected1;
pick.selected1 Ź temp;
};
ENDLOOP;
G3dTube.UnSelectAll[G3dTube.First[pick.tube]];            -- set selected splines
FOR t: Tube Ź pick.selected0, t.next WHILE t # NIL AND t # pick.selected1.next DO
t.selected Ź TRUE;
ENDLOOP;
UpdatePick[tool];
};

SetSubTree: PROC [tool: Tool] ~ {
tool.pick.selected0 Ź tool.pick.selected1 Ź tool.pick.tube;
tool.pick.t Ź IF tool.pick.t > 0.5 THEN 1.0 ELSE 0.0;
G3dTube.UnSelectAll[G3dTube.First[tool.pick.tube]];
G3dTube.SelectAll[tool.pick.tube];
UpdatePick[tool];
};

DividePick: PROC [pick: Pick] ~ {
IF pick.tube # NIL AND pick.dividePending AND pick.t IN (0.0..1.0) THEN {
tubeProc: TubeProc ~ {tube.prev Ź newTube};
newTube: Tube Ź NEW[TubeRep Ź [
spline: NEW[SplineRep],
xSpline: NEW[SplineRep],
prev: pick.tube,
selected: pick.tube.selected,
next: pick.tube.next,
branches: pick.tube.branches,
p1: pick.tube.p1,
r1: pick.tube.r1,
tw1: pick.tube.tw1]];
G3dTube.DivideContours[pick.tube, pick.tube, newTube, pick.t];
pick.tube.next Ź newTube;
pick.tube.branches Ź NIL;
G3dTube.ApplyToBranches[newTube, tubeProc, FALSE];
pick.tube.p1 Ź newTube.p0 Ź pick.pos --pick.origPos--;
pick.tube.r1 Ź newTube.r0 Ź 0.5*(pick.tube.r0+newTube.r1);
pick.tube.tw1 Ź newTube.tw0 Ź 0.5*(pick.tube.tw0+newTube.tw1);
[] Ź G3dSpline.Reparameterize[pick.tube.spline, pick.t, 1.0, newTube.spline];
[] Ź G3dSpline.Reparameterize[pick.tube.spline, 0.0, pick.t, pick.tube.spline];
pick.tube.v0 Ź G3dSpline.Tangent[pick.tube.spline, 0.0];
pick.tube.v1 Ź G3dSpline.Tangent[pick.tube.spline, 1.0];
newTube.v0 Ź G3dSpline.Tangent[newTube.spline, 0.0];
newTube.v1 Ź G3dSpline.Tangent[newTube.spline, 1.0];
<<pick.tube.v1 _ newTube.v0 _ [>>
<<0.25*(3.0*(newTube.p1.x-pick.tube.p0.x)-pick.tube.v0.x-newTube.v1.x),>>
<<0.25*(3.0*(newTube.p1.y-pick.tube.p0.y)-pick.tube.v0.y-newTube.v1.y),>>
<<0.25*(3.0*(newTube.p1.z-pick.tube.p0.z)-pick.tube.v0.z-newTube.v1.z)];>>
pick.t Ź 1.0;
pick.tan Ź pick.tube.v1;
};
pick.dividePending Ź FALSE;
};

NewSpline: PROC [pick: Pick] ~ {
tubeProc: TubeProc ~ {G3dTube.SetSpline[tube]};
[] Ź tubeProc[pick.tube];
G3dTube.ApplyToBranches[pick.tube, tubeProc];
};

RollSubTree: PROC [pick: Pick, rollAngle: REAL] ~ {
IF G3dTube.NBranches[pick.tube] = 0 THEN RETURN;
IF pick.t = 0.0
THEN G3dTube.Rotate[pick.tube, [pick.tube.p0, pick.tube.v0], rollAngle, TRUE, TRUE]
ELSE {
v: Triple Ź IF pick.tube.next#NIL THEN pick.tube.next.v0 ELSE pick.tube.branches[0].v0;
G3dTube.Rotate[pick.tube, [pick.tube.p1, v], rollAngle, TRUE, FALSE];
};
NewSpline[pick];
};

ChangeTangent: PROC [pick: Pick, hold: Hold] ~ {
IF pick.tube # NIL THEN {
tangent: Triple Ź G3dControl.VectorFromHold[hold];
SELECT pick.type FROM
point, segment => {
IF pick.t = 0.0
THEN pick.tube.v0 Ź tangent
ELSE {
<<If T = new vector, V0 = beginning vector of outgoing tube, and V1 = end>>
<<of incoming tube, then T|V0|/|T| is a vector in direction T with length of V0.>>
<<We would like V0 length to increase, however, by |T|/|V1|.>>
<<So, V0 should be assigned T|V0||T|/|T||V1| = T|V0|/|V1|.>>
tubeProc: TubeProc ~ {
IF tube # NIL THEN tube.v0 Ź
G3dVector.Mul[tangent, G3dVector.Length[tube.v0]*iV1];
};
iV1: REAL ~ IF G3dVector.Null[pick.tube.v1] THEN 0.0 ELSE 1.0/G3dVector.Length[pick.tube.v1];
pick.tube.v1 Ź tangent;
IF iV1 # 0.0 THEN G3dTube.ApplyToBranches[pick.tube, tubeProc];
};
};
subTree => {
axis: Triple Ź G3dVector.Cross[tangent, pick.tan];
base: Triple Ź IF pick.t = 0.0 THEN pick.tube.p0 ELSE pick.tube.p1;
angle: REAL Ź G3dVector.AngleBetween[tangent, pick.tan, , TRUE];
G3dTube.Rotate[pick.tube, [base, axis], angle, TRUE, pick.t = 0.0];
};
ENDCASE;
pick.tan Ź tangent;
NewSpline[pick];
};
};

ChangePosition: PROC [pick: Pick, --change-- position: Triple] ~ {
pick.pos Ź position;
<<pick.pos _ G3dVector.Add[pick.origPos, change];>>
IF pick.tube = NIL THEN RETURN;
IF pick.t = 0.0
THEN pick.tube.p0 Ź pick.pos
ELSE {
pick.tube.p1 Ź pick.pos;
FOR n: NAT IN [0..G3dTube.NBranches[pick.tube]) DO
pick.tube.branches[n].p0 Ź pick.pos;
ENDLOOP;
IF pick.tube.next # NIL THEN pick.tube.next.p0 Ź pick.pos;
};
NewSpline[pick];
};

ChangeRadii: PROC [pick: Pick, r0, r1, scale, epsilon: REAL] ~ {
numberSelected: INTEGER ~ NumberSelected[pick];
IF numberSelected > 0 THEN {
r: REAL Ź r0;
dr: REAL ~ (r1-r)/REAL[numberSelected];
IF pick.selected0.prev # NIL THEN pick.selected0.prev.r1 Ź r;
FOR t: Tube Ź pick.selected0, t.next WHILE t # NIL AND t # pick.selected1.next DO
t.r0 Ź r;
r Ź r+dr;
t.r1 Ź r;
ENDLOOP;
IF pick.selected1.next # NIL THEN pick.selected1.next.r0 Ź r;
RemakeSelected[pick, scale, epsilon];
};
};

ChangeTension: PROC [pick: Pick, tens0, tens1: REAL] ~ {
numberSelected: INTEGER ~ NumberSelected[pick];
IF numberSelected > 0 THEN {
tens: REAL Ź tens0;
dtens: REAL ~ (tens1-tens0)/REAL[numberSelected];
FOR t: Tube Ź pick.selected0, t.next WHILE t # NIL AND t # pick.selected1.next DO
t.tens0 Ź tens;
tens Ź tens+dtens;
t.tens1 Ź tens;
G3dTube.SetSpline[t];
ENDLOOP;
};
};

ChangeTw0: PROC [pick: Pick, tw0, tw0Prev: REAL] ~ {
nBefore: INTEGER ~ BeforeSelected[pick];
change: REAL ~ tw0-tw0Prev;
IF nBefore > 0 THEN {
dchange: REAL Ź 0.0;
ddchange: REAL Ź change/REAL[nBefore];
FOR t: Tube Ź G3dTube.First[t], t.next WHILE t # pick.selected0 DO
t.tw0 Ź t.tw0+dchange;
dchange Ź dchange+ddchange;
t.tw1 Ź t.tw1+dchange;
ENDLOOP;
};
FOR t: Tube Ź pick.selected0, t.next WHILE t # NIL DO
t.tw0 Ź t.tw0+change;
t.tw1 Ź t.tw1+change;
ENDLOOP;
};

ChangeTw1: PROC [pick: Pick, tw1, tw1Prev: REAL] ~ {
nSelected: INTEGER ~ NumberSelected[pick];
change: REAL ~ tw1-tw1Prev;
IF nSelected > 0 THEN {
dchange: REAL Ź 0.0;
ddchange: REAL Ź change/REAL[nSelected];
FOR t: Tube Ź pick.selected0, t.next WHILE t # pick.selected1.next DO
t.tw0 Ź t.tw0+dchange;
dchange Ź dchange+ddchange;
t.tw1 Ź t.tw1+dchange;
ENDLOOP;
};
IF pick.selected1 # NIL THEN
FOR t: Tube Ź pick.selected1.next, t.next WHILE t # NIL DO
t.tw0 Ź t.tw0+change;
t.tw1 Ź t.tw1+change;
ENDLOOP;
};

NumberSelected: PROC [pick: Pick] RETURNS [INTEGER] ~ {
n: INTEGER Ź 0;
IF pick.selected0 = NIL OR pick.selected1 = NIL THEN RETURN[0];
FOR t: Tube Ź pick.selected0, t.next WHILE t # NIL AND t # pick.selected1.next DO
n Ź n+1;
ENDLOOP;
RETURN[n];
};

BeforeSelected: PROC [pick: Pick] RETURNS [INTEGER] ~ {
n: INTEGER Ź 0;
FOR t: Tube Ź pick.selected0.prev, t.prev WHILE t # NIL DO n Ź n+1; ENDLOOP;
RETURN[n];
};

AfterSelected: PROC [pick: Pick] RETURNS [INTEGER] ~ {
n: INTEGER Ź 0;
FOR t: Tube Ź pick.selected1.next, t.next WHILE t # NIL DO n Ź n+1; ENDLOOP;
RETURN[n];
};

RemakeSelected: PROC [pick: Pick, scale, epsilon: REAL] ~ {
t0: Tube Ź IF pick.selected0.prev # NIL THEN pick.selected0.prev ELSE pick.selected0;
t1: Tube Ź IF pick.selected1.next # NIL THEN pick.selected1.next ELSE pick.selected1;
FOR t: Tube Ź t0, t.next WHILE t # t1.next AND t # NIL DO
t.epsilon Ź epsilon;
t.scale Ź scale;
G3dTube.MakeSectionXSections[t];
ENDLOOP;
};
<<Miscellaneous>>
Blink: PROC [rope: ROPE] ~ {
MessageWindow.Append[rope, TRUE];
MessageWindow.Blink[];
};
<<Start Code>>
icon: Icons.IconFlavor Ź Icons.NewIconFromFile["G3dUser.icons", 5];

designUsage: ROPE ~ "tube <tube-file>: Model tubular structures.";

G3dTool.Register["Tube", TubeDesignCmd, designUsage];

END.