[Indigo]<Solidviews>CSG>SVFacesImpl.mesa!8

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.