Polygonidl

CHANGES.md

@@ -45,6 +45,10 @@ Beta Releases
 * Fixed an error in Web Worker creation when loading Cesium.js from a different origin.
 * Fixed `EllipsoidPrimitive` picking and picking objects with materials that have transparent parts.
 
+### TODO
+
+* Added `IntersectionTests.trianglePlaneIntersection`.
+
 ### b15 - 2013-04-01
 
 * Breaking changes:

Source/Core/EllipsoidTangentPlane.js

@@ -208,4 +208,4 @@ define([
     };
 
     return EllipsoidTangentPlane;
-});
+});

Source/Core/IntersectionTests.js

@@ -20,6 +20,13 @@ define([
         QuarticRealPolynomial) {
     "use strict";
 
+// TODO
+// equals, etc. for Plane?
+// Should ray constructor normalize?
+// Make EllipsoidTangentPlane contain plane?
+// Does extent triangulator work over IDL?
+// Tests for new wrapLongitude.
+
     /**
      * DOC_TBA
      *
@@ -418,5 +425,280 @@ define([
         return result;
     };
 
+    /**
+     * Computes the intersection of a triangle and a plane
+     * @memberof IntersectionTests
+     *
+     * @param {Cartesian3} p0 First point of the triangle
+     * @param {Cartesian3} p1 Second point of the triangle
+     * @param {Cartesian3} p2 Third point of the triangle
+     * @param {Plane} plane Intersection plane
+     *
+     * @returns Three triangles that do not cross the plane. (Undefined if no intersection exists)
+     *
+     * @exception {DeveloperError} p0, p1, p2, and plane are required.
+     */
+    IntersectionTests.trianglePlaneIntersection = function(p0, p1, p2, plane) {
+        if ((typeof p0 === 'undefined') ||
+            (typeof p1 === 'undefined') ||
+            (typeof p2 === 'undefined') ||
+            (typeof plane === 'undefined')) {
+            throw new DeveloperError('p0, p1, p2, and plane are required.');
+        }
+
+        // TODO: returning triangle strips or fans?
+        var planeNormal = plane.normal;
+        var planeD = plane.distance;
+        var p0Behind = (Cartesian3.dot(planeNormal, p0) + planeD) < 0.0;
+        var p1Behind = (Cartesian3.dot(planeNormal, p1) + planeD) < 0.0;
+        var p2Behind = (Cartesian3.dot(planeNormal, p2) + planeD) < 0.0;
+        // Given these dots products, the calls to lineSegmentPlaneIntersection
+        // always have defined results.
+
+        var numBehind = 0;
+        numBehind += p0Behind ? 1 : 0;
+        numBehind += p1Behind ? 1 : 0;
+        numBehind += p2Behind ? 1 : 0;
+
+        var u1, u2;
+        if (numBehind === 1 || numBehind === 2) {
+            u1 = new Cartesian3();
+            u2 = new Cartesian3();
+        }
+
+        if (numBehind === 1) {
+            if (p0Behind) {
+                IntersectionTests.lineSegmentPlane(p0, p1, plane, u1);
+                IntersectionTests.lineSegmentPlane(p0, p2, plane, u2);
+
+                return {
+                    positions : [p0, p1, p2, u1, u2 ],
+                    indices : [
+                        // Behind
+                        0, 3, 4,
+
+                        // In front
+                        1, 2, 4,
+                        1, 4, 3
+                    ]
+                };
+            } else if (p1Behind) {
+                IntersectionTests.lineSegmentPlane(p1, p2, plane, u1);
+                IntersectionTests.lineSegmentPlane(p1, p0, plane, u2);
+
+                return {
+                    positions : [p0, p1, p2, u1, u2 ],
+                    indices : [
+                        // Behind
+                        1, 3, 4,
+
+                        // In front
+                        2, 0, 4,
+                        2, 4, 3
+                    ]
+                };
+            } else if (p2Behind) {
+                IntersectionTests.lineSegmentPlane(p2, p0, plane, u1);
+                IntersectionTests.lineSegmentPlane(p2, p1, plane, u2);
+
+                return {
+                    positions : [p0, p1, p2, u1, u2 ],
+                    indices : [
+                        // Behind
+                        2, 3, 4,
+
+                        // In front
+                        0, 1, 4,
+                        0, 4, 3
+                    ]
+                };
+            }
+        } else if (numBehind === 2) {
+            if (!p0Behind) {
+                IntersectionTests.lineSegmentPlane(p1, p0, plane, u1);
+                IntersectionTests.lineSegmentPlane(p2, p0, plane, u2);
+
+                return {
+                    positions : [p0, p1, p2, u1, u2 ],
+                    indices : [
+                        // Behind
+                        1, 2, 4,
+                        1, 4, 3,
+
+                        // In front
+                        0, 3, 4
+                    ]
+                };
+            } else if (!p1Behind) {
+                IntersectionTests.lineSegmentPlane(p2, p1, plane, u1);
+                IntersectionTests.lineSegmentPlane(p0, p1, plane, u2);
+
+                return {
+                    positions : [p0, p1, p2, u1, u2 ],
+                    indices : [
+                        // Behind
+                        2, 0, 4,
+                        2, 4, 3,
+
+                        // In front
+                        1, 3, 4
+                    ]
+                };
+            } else if (!p2Behind) {
+                IntersectionTests.lineSegmentPlane(p0, p2, plane, u1);
+                IntersectionTests.lineSegmentPlane(p1, p2, plane, u2);
+
+                return {
+                    positions : [p0, p1, p2, u1, u2 ],
+                    indices : [
+                        // Behind
+                        0, 1, 4,
+                        0, 4, 3,
+
+                        // In front
+                        2, 3, 4
+                    ]
+                };
+            }
+        }
+
+        // if numBehind is 3, the triangle is completely behind the plane;
+        // otherwise, it is completely in front (numBehind is 0).
+        return undefined;
+    };
+
+
+    /**
+     * Computes the intersection of a triangle and the XZ plane.  Offsets points from the XZ plane.
+     * @memberof IntersectionTests
+     *
+     * @param {Cartesian3} p0 First point of triangle
+     * @param {Cartesian3} p1 Second point of triange
+     * @param {Cartesian3} p2 Third point of triange
+     *
+     * @return Three triangles that are offset from intersecting with the plane. (Undefined if no intersection found)
+     *
+     * @exception {DeveloperError} p0, p1 and p2 are required.
+     */
+    var xz_plane = new Plane(Cartesian3.UNIT_Y, 0.0);
+    IntersectionTests.triangleXZPlaneIntersection = function(p0, p1, p2) {
+        if ((typeof p0 === 'undefined') ||
+            (typeof p1 === 'undefined') ||
+            (typeof p2 === 'undefined')) {
+            throw new DeveloperError('p0, p1 and p2 are required.');
+        }
+
+        var p0Behind = p0.y  < 0.0;
+        var p1Behind = p1.y < 0.0;
+        var p2Behind = p2.y < 0.0;
+
+        offsetPointFromXZPlane(p0, p0Behind);
+        offsetPointFromXZPlane(p1, p1Behind);
+        offsetPointFromXZPlane(p2, p2Behind);
+
+        var numBehind = 0;
+        numBehind += p0Behind ? 1 : 0;
+        numBehind += p1Behind ? 1 : 0;
+        numBehind += p2Behind ? 1 : 0;
+
+        var u1, u2, v1, v2, result;
+
+        if (numBehind === 1 || numBehind === 2) {
+            u1 = new Cartesian3();
+            u2 = new Cartesian3();
+            v1 = new Cartesian3();
+            v2 = new Cartesian3();
+            result = { positions : [p0, p1, p2, u1, u2, v1, v2 ] };
+        }
+
+        if (numBehind === 1) {
+            if (p0Behind) {
+                getXZIntersectionOffsetPoints(p0, p1, p2, u1, u2, v1, v2);
+                result.indices = [
+                        // Behind
+                        0, 3, 4,
+
+                        // In front
+                        1, 2, 6,
+                        1, 6, 5
+                    ];
+            } else if (p1Behind) {
+                getXZIntersectionOffsetPoints(p1, p0, p2, u1, u2, v1, v2);
+                result.indices = [
+                        // Behind
+                        1, 3, 4,
+
+                        // In front
+                        2, 0, 6,
+                        2, 6, 5
+                    ];
+            } else if (p2Behind) {
+                getXZIntersectionOffsetPoints(p2, p0, p1, u1, u2, v1, v2);
+                result.indices = [
+                        // Behind
+                        2, 3, 4,
+
+                        // In front
+                        0, 1, 6,
+                        0, 6, 5
+                    ];
+            }
+        } else if (numBehind === 2) {
+            if (!p0Behind) {
+                getXZIntersectionOffsetPoints(p0, p1, p2, u1, u2, v1, v2);
+                result.indices = [
+                        // Behind
+                        1, 2, 4,
+                        1, 4, 3,
+
+                        // In front
+                        0, 5, 6
+                    ];
+            } else if (!p1Behind) {
+                getXZIntersectionOffsetPoints(p1, p2, p0, u1, u2, v1, v2);
+                result.indices = [
+                        // Behind
+                        2, 0, 4,
+                        2, 4, 3,
+
+                        // In front
+                        1, 5, 6
+                    ];
+            } else if (!p2Behind) {
+                getXZIntersectionOffsetPoints(p2, p0, p1, u1, u2, v1, v2);
+                result.indices = [
+                        // Behind
+                        0, 1, 4,
+                        0, 4, 3,
+
+                        // In front
+                        2, 5, 6
+                    ];
+            }
+        }
+        return result;
+    };
+
+    function getXZIntersectionOffsetPoints(p, p1, p2, u1, u2, v1, v2) {
+        IntersectionTests.lineSegmentPlane(p, p1, xz_plane, u1);
+        IntersectionTests.lineSegmentPlane(p, p2, xz_plane, u2);
+        Cartesian3.clone(u1, v1);
+        Cartesian3.clone(u2, v2);
+        offsetPointFromXZPlane(u1, true);
+        offsetPointFromXZPlane(u2, true);
+        offsetPointFromXZPlane(v1, false);
+        offsetPointFromXZPlane(v2, false);
+    }
+
+    function offsetPointFromXZPlane(p, isBehind) {
+        if (Math.abs(p.y) < CesiumMath.EPSILON11){
+            if (isBehind) {
+                p.y = -CesiumMath.EPSILON11;
+            } else {
+                p.y = CesiumMath.EPSILON11;
+            }
+        }
+    }
+
     return IntersectionTests;
 });

Source/Core/Plane.js

@@ -144,4 +144,4 @@ define([
     };
 
     return Plane;
-});
+});