File: SVFacesImpl.mesa
Last edited by Bier on August 19, 1984 6:35:26 pm PDT
Contents: Definitions of various face types such as Cone, Disk Ring, and Cylinder and procedures which make them from simpler data
DIRECTORY
SV2d,
SV3d,
SVBoundBox,
SVFaces,
SVLines2d,
SVModelTypes,
SVVector2d,
SVVector3d;
SVFacesImpl: PROGRAM
IMPORTS SVBoundBox, SVLines2d, SVVector2d, SVVector3d
EXPORTS SVFaces =
BEGIN
TrigLineSeg: TYPE = SV2d.TrigLineSeg;
Vector: TYPE = SV3d.Vector;
Vector2d: TYPE = SV2d.Vector2d;
The cone described here is revolute around the y-axis. Otherwise it is very general, allowing for an arbitrary apex point (on the y-axis) and an arbitrary spread ratio.
Cone: TYPE = REF ConeObj;
ConeObj: TYPE = SVFaces.ConeObj;
The disk ring described here is revolute around the y-axis. Otherwise it is very general. It may be in an arbitrary horizontal plane (y = yPlane), may have any two radii, rIn and rOut subject to rIn, rOut >= 0 AND rOut > rIn, and may have an upward or downward pointing normal.
DiskRing: TYPE = REF DiskRingObj;
DiskRingObj: TYPE = SVFaces.DiskRingObj;
The cylinder described here is revolute around the y-axis. Otherwise it is very general. It may have its top and bottom in arbitrary horizontal planes (y = yHigh and y = yLow) subject to yHigh > yLow and may have an arbitrary radius r.
Cylinder: TYPE = REF CylinderObj;
CylinderObj: TYPE = SVFaces.CylinderObj;
The edge on rectangle has a surface normal parallel to the xy plane. That is, it is edge on when viewed from the z direction.
EdgeOnRect: TYPE = REF EdgeOnRectObj;
EdgeOnRectObj: TYPE = SVFaces.EdgeOnRectObj;
Abs: PROC [r: REAL] RETURNS [REAL] = {
RETURN[IF r >= 0 THEN r ELSE -r];
}; -- end of Abs
ConeFromTrigLineSeg: PUBLIC PROC [seg: TrigLineSeg] RETURNS [cone: Cone] = {
isParallel: BOOL;
x, y: REAL;
signHi, signLo: PosNeg;
cone ← NEW[ConeObj];
[cone.h, isParallel] ← SVLines2d.TrigLineMeetsYAxis[seg.line];
IF isParallel THEN ERROR AttemptToCreateDegenerateCone;
Seg cannot be vertical.
IF seg.pLo[2] = seg.pHi[2] THEN ERROR AttemptToCreateDegenerateCone;
Seg cannot be horizontal
To find the spread ratio r/|y-h|, we consider the intersection of the cone (meaning the two nose-to-nose "cones" meeting at the apex) with the z = 0 plane. This gives us two lines intersecting at (0,h). Consider the intersection of the line x = seg.pLo[1] or x = seg.pHi[1] (whichever is larger) (an arbitrary choice) with the negatively sloped line (corresponding to the nose-up cone at this point). The cone radius here is x. We can get the y of intersection from the line equation:
y * cos(theta) - x*sin(theta) - d = 0;
y = (x*sin(theta) + d)/cos(theta);
Finally, M = 1/Abs[y - h] .
x ← IF Abs[seg.pLo[1]] > Abs[seg.pHi[1]] THEN Abs[seg.pLo[1]] ELSE Abs[seg.pHi[1]];
y ← (x*seg.line.s + seg.line.d)/seg.line.c;
cone.M ← x/Abs[y - cone.h];
Debugging. Find the distance from the cone to each of the points of seg:
BEGIN
coneSeg: TrigLineSeg ← SVLines2d.CreateTrigLineSeg[[x, y], [0, cone.h]];
d1: REAL ← SVLines2d.DistancePointToTrigLineSeg[seg.pLo, coneSeg];
d2: REAL ← SVLines2d.DistancePointToTrigLineSeg[seg.pHi, coneSeg];
d2 ← SVLines2d.DistancePointToTrigLineSeg[seg.pHi, coneSeg];
END;
Make sure the y's are on the same side of the apex (or on the apex)
cone.yHi ← seg.pHi[2];
cone.yLo ← seg.pLo[2];
signHi ← Sign[cone.yHi - cone.h];
signLo ← Sign[cone.yLo - cone.h];
IF signHi # signLo AND signHi # zero AND signLo # zero THEN ERROR AttemptToCreateDegenerateCone;
IF cone.yHi > cone.h THEN cone.noseIsUp ← FALSE ELSE cone.noseIsUp ← TRUE;
IF seg goes down, normal should point out, else normal should point in.
By down, I mean second point is below first point, or equivalently, theta is negative.
IF y2<y1 THEN cone.normalPointsOut ← TRUE
ELSE cone.normalPointsOut ← FALSE;
IF seg.line.theta < 0 THEN cone.normalPointsOut ← TRUE ELSE cone.normalPointsOut ← FALSE;
made the boundHedron for this cone.
cone.boundHedron ← SVBoundBox.GeneralConeBoundHedron[seg.pHi[1], seg.pHi[2], seg.pLo[1], seg.pLo[2]];
}; -- end of ConeFromTrigLineSeg
AttemptToCreateDegenerateCone: PUBLIC ERROR = CODE;
PosNeg: TYPE = {pos, neg, zero};
Sign: PROC [r: REAL] RETURNS [sign: PosNeg] = {
RETURN[IF r > 0 THEN pos ELSE IF r < 0 THEN neg ELSE zero];
};
DiskRingFromTrigLineSeg: PUBLIC PROC [seg: TrigLineSeg] RETURNS [diskRing: DiskRing] = {
A disk ring is the region in the plane y = yPlane inside the disk x^2 + z^2 = rOut^2 and outside the disk x^2 + z^2 = rIn^2.
x1, x2: REAL;
diskRing ← NEW[DiskRingObj];
The line segment must be horizontal
IF seg.pLo[2] # seg.pHi[2] THEN ERROR AttemptToCreateDegenerateDiskRing;
diskRing.yPlane ← seg.pLo[2];
IF seg.pLoIsFirst THEN {
x1 ← seg.pLo[1]; x2 ← seg.pHi[1]} ELSE {x1 ← seg.pHi[1]; x2 ← seg.pLo[1]};
To find out if this segment points toward the y axis or away from it, make sure both points are on the same side of the y axis, then mirror the segment to the positive x side (if necessary) and test for x2 > x1;
IF Sign[x1] # Sign[x2] AND Sign[x1] # zero AND Sign[x2] # zero THEN ERROR AttemptToCreateDegenerateDiskRing;
x1 ← Abs[x1];
x2 ← Abs[x2];
If segment points out, normal points up, else normal points down.
IF x2 > x1 THEN {
diskRing.normal ← [0,1,0];
diskRing.rInSquared ← x1*x1;
diskRing.rOutSquared ← x2*x2;
diskRing.boundHedron ← SVBoundBox.DiskBoundHedron[r: x2, h: seg.pLo[2]]}
ELSE {
diskRing.normal ← [0,-1,0];
diskRing.rInSquared ← x2*x2;
diskRing.rOutSquared ← x1*x1;
diskRing.boundHedron ← SVBoundBox.DiskBoundHedron[r: x1, h: seg.pLo[2]]};
}; -- end of DiskRingFromTrigLineSeg
AttemptToCreateDegenerateDiskRing: PUBLIC ERROR = CODE;
CylinderFromTrigLineSeg: PUBLIC PROC [seg: TrigLineSeg] RETURNS [cylinder: Cylinder] = {
cylinder ← NEW[CylinderObj];
Seg must be vertical
IF seg.pLo[1] # seg.pHi[1] THEN ERROR AttemptToCreateDegenerateCylinder;
IF seg goes down normal should point out, else normal should point in.
IF seg.line.theta < 0 THEN cylinder.normalPointsOut ← TRUE
ELSE cylinder.normalPointsOut ← FALSE;
cylinder.yHi ← seg.pHi[2];
cylinder.yLo ← seg.pLo[2];
cylinder.r ← seg.pLo[1];
cylinder.rSquared ← cylinder.r*cylinder.r;
cylinder.boundHedron ← SVBoundBox.GeneralConeBoundHedron[seg.pLo[1], seg.pHi[2], seg.pLo[1], seg.pLo[2]];
};
AttemptToCreateDegenerateCylinder: PUBLIC ERROR = CODE;
EdgeOnRectFromTrigLineSeg: PUBLIC PROC [seg: TrigLineSeg, frontZ, backZ: REAL] RETURNS [edgeOnRect: EdgeOnRect] = {
We wish to find the line equation in the from Ax + By + D = 0.
Trig line segments have the form: y*cos(theta) - x*sin(theta) -d = 0;
So A = -sin(theta), B = cos(theta), D = -d;
To set valHi and valLo, we look at theta. If pi/4 <= theta < = 3pi/4 or -3pi/4 <=theta <= -pi/4 THEN use y else use x.
normal2d: Vector2d;
edgeOnRect ← NEW[EdgeOnRectObj];
edgeOnRect.frontZ ← frontZ;
edgeOnRect.backZ ← backZ;
edgeOnRect.A ← -seg.line.s;
edgeOnRect.B ← seg.line.c;
edgeOnRect.D ← -seg.line.d;
Assume that the interior of the polygon is to the right of this line segment so that normals should point to the left.
normal2d ← SVVector2d.LeftNormalOfTrigLineSeg[seg];
edgeOnRect.normal ← SVVector3d.Vector2DAsXYVector[vXY: normal2d];
IF (45 <= seg.line.theta AND seg.line.theta <= 135) OR (-135 <= seg.line.theta AND seg.line.theta <= -45) THEN {
edgeOnRect.valIsY ← TRUE;
edgeOnRect.valLo ← seg.pLo[2];
edgeOnRect.valHi ← seg.pHi[2];
}
ELSE {
edgeOnRect.valIsY ← FALSE;
edgeOnRect.valLo ← Min[seg.pLo[1], seg.pHi[1]];
edgeOnRect.valHi ← Max[seg.pLo[1], seg.pHi[1]];
};
}; -- end of EdgeOnRectFromTrigLineSeg
AttemptToCreateDegenerateEdgeOnRect: PUBLIC ERROR = CODE;
Max: PRIVATE PROC [a, b: REAL] RETURNS [REAL] = {
RETURN [IF a>b THEN a ELSE b];
};
Min: PRIVATE PROC [a, b: REAL] RETURNS [REAL] = {
RETURN [IF a<b THEN a ELSE b];
};
END.