Changeset 2911 for GTP/trunk/App/Demos/Vis/FriendlyCulling/src/AxisAlignedBox3.cpp

Timestamp:

09/07/08 13:44:28 (16 years ago)

Author:

mattausch

Message:

 

File:

• GTP/trunk/App/Demos/Vis/FriendlyCulling/src/AxisAlignedBox3.cpp (modified) (3 diffs)

GTP/trunk/App/Demos/Vis/FriendlyCulling/src/AxisAlignedBox3.cpp

@@ +1 @@
+#include "AxisAlignedBox3.h"
+#include "Plane3.h"
+#include "Polygon3.h"
+#include "Polyhedron.h"
+
 #include <cassert>
 #include <iostream>
-#include "AxisAlignedBox3.h"
-#include "Plane3.h"
-
 
 using namespace std;
@@ -50 +52 @@
         Minimize(mMin, newpt);
         Maximize(mMax, newpt);
+}
+
+
+void AxisAlignedBox3::Include(const Polygon3 &newpoly)
+{
+        VertexArray::const_iterator it, it_end = newpoly.mVertices.end();
+
+        for (it = newpoly.mVertices.begin(); it != it_end; ++ it)
+                Include(*it);
+}
+
+
+void AxisAlignedBox3::Include(const PolygonContainer &polys)
+{
+        PolygonContainer::const_iterator it, it_end = polys.end();
+
+        for (it = polys.begin(); it != it_end; ++ it)
+                Include(*(*it));
 }
 
@@ -1026 +1046 @@
 }
 
-}
-
+
+struct VertexData
+{
+        Vector3 mVertex;
+        float mAngle;
+        
+        VertexData(Vector3 vtx, float angle): mVertex(vtx), mAngle(angle)
+        {}
+
+        bool operator<(const VertexData &b) const 
+        {
+                return mAngle > b.mAngle;
+        }
+};
+
+// TODO: use a table to avoid normal and distance computations
+Polygon3 *AxisAlignedBox3::CrossSection(const Plane3 &plane) const
+{
+        Polygon3 *planePoly = new Polygon3();
+        
+        int side[8];
+        bool onFrontSide = false, onBackSide = false;
+        
+        Vector3 vtx;
+        
+        //////////////
+        //-- compute classification of vertices
+
+        for (int i = 0; i < 8; ++i)
+        {
+                GetVertex(i, vtx);
+                side[i] = plane.Side(vtx);
+                if (side[i] > 0)
+                        onFrontSide = true;
+                else if (side[i] < 0)
+                        onBackSide = true;
+                else // vertex coincident => push_back
+                        planePoly->mVertices.push_back(vtx);
+        }
+
+        ///////////
+        //-- find intersections
+
+        if (onFrontSide && onBackSide)
+        {
+                Vector3 ptA, ptB;
+                for (int i = 0; i < 12; ++ i)
+                {
+                        int aIdx, bIdx;
+                        GetEdge(i, aIdx, bIdx);
+
+                        ptA = GetVertex(aIdx);
+                        ptB = GetVertex(bIdx);
+
+                        int sideA = side[aIdx];
+                        int sideB = side[bIdx];
+
+                        if (((sideA > 0) && (sideB < 0)) || (sideA < 0) && (sideB > 0))
+                                planePoly->mVertices.push_back(plane.FindIntersection(ptA, ptB));       
+                }
+        }
+
+        // order intersections  
+        if (planePoly->mVertices.size() > 3)
+        {
+                Vector3 centerOfMass(0);
+
+                int i;
+                // compute center of mass
+                for (i = 0; i < (int)planePoly->mVertices.size(); ++ i)
+                        centerOfMass += planePoly->mVertices[i];
+                
+                centerOfMass /= (float)planePoly->mVertices.size();
+
+                vector<VertexData> vertexData;
+                Vector3 refVec = Normalize(centerOfMass - planePoly->mVertices[0]);
+
+                // compute angle to reference point
+                for (i = 1; i < (int)planePoly->mVertices.size(); ++ i)
+                {
+                    float angle = 
+                      Angle(refVec, centerOfMass - planePoly->mVertices[i], plane.mNormal);
+                    
+                    vertexData.push_back(VertexData(planePoly->mVertices[i], angle));
+                }
+                
+                std::stable_sort(vertexData.begin(), vertexData.end());
+
+                // update vertices
+                for (i = 1; i < (int)planePoly->mVertices.size(); ++ i)
+                        planePoly->mVertices[i] = vertexData[i - 1].mVertex;
+        }
+        else if (planePoly->mVertices.size() == 3)
+        {
+                // fix orientation if needed
+                if (DotProd(planePoly->GetNormal(), plane.mNormal) < 0)
+                {
+                        Vector3 v = planePoly->mVertices[1];
+                        planePoly->mVertices[1] = planePoly->mVertices[2];
+                        planePoly->mVertices[2] = v;
+                }
+        }
+        
+        return planePoly;
+}
+
+
+Plane3 AxisAlignedBox3::GetPlane(const int face) const
+{
+        switch (face) 
+        {
+        
+        case 0:
+                return Plane3(Vector3(-1, 0, 0), mMin);
+        case 1: 
+                return Plane3(Vector3(1, 0, 0), mMax);
+        case 2:
+                return Plane3(Vector3(0, -1, 0), mMin);
+        case 3:
+                return Plane3(Vector3(0, 1, 0), mMax);
+        case 4:
+                return Plane3(Vector3(0, 0, -1), mMin);
+        case 5:
+                return Plane3(Vector3(0, 0, 1), mMax);
+        }
+
+        // should not come here
+        return Plane3();
+}
+
+
+int AxisAlignedBox3::Side(const Plane3 &plane) const
+{
+        int s = 0;
+        // if exactly one of the vertices lies on the plane 
+        // and the others are on the same side, the plane is tangent
+        // to the box on either side and not intersecting
+        for (int i = 0; i < 8; ++ i)
+        {
+                Vector3 pt;
+                GetVertex(i, pt);
+
+                int side = plane.Side(pt);
+
+                if (side != 0)
+                {
+                        if (side == -s)
+                                return 0; // sign changed => intersects
+
+                        s = side;
+                }
+        }
+
+        return s;
+}
+
+
+Polyhedron *AxisAlignedBox3::CalcIntersection(Polyhedron *polyhedron) const
+{
+        Polyhedron *oldPolyhedron = new Polyhedron(*polyhedron);
+
+        Polyhedron *newPolyhedron = NULL;
+
+        for (int i = 0; i < 6; ++ i)
+        {
+                Polyhedron *newPolyhedron = oldPolyhedron->CalcIntersection(GetPlane(i));
+                DEL_PTR(oldPolyhedron);
+
+                if (!newPolyhedron)
+                        return NULL;
+        }
+
+        return newPolyhedron;
+}
+
+
+}
+