assimp/test/unit/utVertexTriangleAdjacency.cpp

185 lines
5.2 KiB
C++
Raw Normal View History

2015-05-19 04:24:07 +00:00
#include "UnitTestPCH.h"
#include "assimp/types.h"
#include "assimp/mesh.h"
#include <VertexTriangleAdjacency.h>
using namespace std;
using namespace Assimp;
class VTAdjacencyTest : public ::testing::Test
{
protected:
2015-05-19 04:26:05 +00:00
void checkMesh(const aiMesh& mesh);
2015-05-19 04:24:07 +00:00
};
// ------------------------------------------------------------------------------------------------
TEST_F(VTAdjacencyTest, largeRandomDataSet)
{
2015-05-19 04:26:05 +00:00
// build a test mesh with randomized input data
// *******************************************************************************
aiMesh mesh;
2015-05-19 04:24:07 +00:00
2015-05-19 04:26:05 +00:00
mesh.mNumVertices = 500;
mesh.mNumFaces = 600;
2015-05-19 04:24:07 +00:00
2015-05-19 04:26:05 +00:00
mesh.mFaces = new aiFace[600];
unsigned int iCurrent = 0;
for (unsigned int i = 0; i < 600;++i)
{
aiFace& face = mesh.mFaces[i];
face.mNumIndices = 3;
face.mIndices = new unsigned int[3];
2015-05-19 04:24:07 +00:00
2015-05-19 04:26:05 +00:00
if (499 == iCurrent)iCurrent = 0;
face.mIndices[0] = iCurrent++;
2015-05-19 04:24:07 +00:00
2015-05-19 04:26:05 +00:00
while(face.mIndices[0] == ( face.mIndices[1] = (unsigned int)(((float)rand()/RAND_MAX)*499)));
while(face.mIndices[0] == ( face.mIndices[2] = (unsigned int)(((float)rand()/RAND_MAX)*499)) ||
face.mIndices[1] == face.mIndices[2]);
}
2015-05-19 04:24:07 +00:00
2015-05-19 04:26:05 +00:00
checkMesh(mesh);
2015-05-19 04:24:07 +00:00
}
// ------------------------------------------------------------------------------------------------
TEST_F(VTAdjacencyTest, smallDataSet)
{
2015-05-19 04:26:05 +00:00
// build a test mesh - this one is extremely small
// *******************************************************************************
aiMesh mesh;
2015-05-19 04:24:07 +00:00
2015-05-19 04:26:05 +00:00
mesh.mNumVertices = 5;
mesh.mNumFaces = 3;
2015-05-19 04:24:07 +00:00
2015-05-19 04:26:05 +00:00
mesh.mFaces = new aiFace[3];
mesh.mFaces[0].mIndices = new unsigned int[3];
mesh.mFaces[1].mIndices = new unsigned int[3];
mesh.mFaces[2].mIndices = new unsigned int[3];
2015-05-19 04:24:07 +00:00
2015-05-19 04:26:05 +00:00
mesh.mFaces[0].mIndices[0] = 1;
mesh.mFaces[0].mIndices[1] = 3;
mesh.mFaces[0].mIndices[2] = 2;
2015-05-19 04:24:07 +00:00
2015-05-19 04:26:05 +00:00
mesh.mFaces[1].mIndices[0] = 0;
mesh.mFaces[1].mIndices[1] = 2;
mesh.mFaces[1].mIndices[2] = 3;
2015-05-19 04:24:07 +00:00
2015-05-19 04:26:05 +00:00
mesh.mFaces[2].mIndices[0] = 3;
mesh.mFaces[2].mIndices[1] = 0;
mesh.mFaces[2].mIndices[2] = 4;
2015-05-19 04:24:07 +00:00
2015-05-19 04:26:05 +00:00
checkMesh(mesh);
2015-05-19 04:24:07 +00:00
}
// ------------------------------------------------------------------------------------------------
TEST_F(VTAdjacencyTest, unreferencedVerticesSet)
{
2015-05-19 04:26:05 +00:00
// build a test mesh which does not reference all vertices
// *******************************************************************************
aiMesh mesh;
mesh.mNumVertices = 500;
mesh.mNumFaces = 600;
mesh.mFaces = new aiFace[600];
unsigned int iCurrent = 0;
for (unsigned int i = 0; i < 600;++i)
{
aiFace& face = mesh.mFaces[i];
face.mNumIndices = 3;
face.mIndices = new unsigned int[3];
if (499 == iCurrent)iCurrent = 0;
face.mIndices[0] = iCurrent++;
if (499 == iCurrent)iCurrent = 0;
face.mIndices[1] = iCurrent++;
if (499 == iCurrent)iCurrent = 0;
face.mIndices[2] = iCurrent++;
if (rand() > RAND_MAX/2 && face.mIndices[0])
{
face.mIndices[0]--;
}
else if (face.mIndices[1]) face.mIndices[1]--;
}
checkMesh(mesh);
2015-05-19 04:24:07 +00:00
}
// ------------------------------------------------------------------------------------------------
void VTAdjacencyTest::checkMesh(const aiMesh& mesh)
{
2015-05-19 04:26:05 +00:00
VertexTriangleAdjacency adj(mesh.mFaces,mesh.mNumFaces,mesh.mNumVertices,true);
unsigned int* const piNum = adj.mLiveTriangles;
// check the primary adjacency table and check whether all faces
// are contained in the list
unsigned int maxOfs = 0;
for (unsigned int i = 0; i < mesh.mNumFaces;++i)
{
aiFace& face = mesh.mFaces[i];
for (unsigned int qq = 0; qq < 3 ;++qq)
{
const unsigned int idx = face.mIndices[qq];
const unsigned int num = piNum[idx];
// go to this offset
const unsigned int ofs = adj.mOffsetTable[idx];
maxOfs = std::max(ofs+num,maxOfs);
unsigned int* pi = &adj.mAdjacencyTable[ofs];
// and search for us ...
unsigned int tt = 0;
for (; tt < num;++tt,++pi)
{
if (i == *pi)
{
// mask our entry in the table. Finally all entries should be masked
*pi = 0xffffffff;
// there shouldn't be two entries for the same face
break;
}
}
// assert if *this* vertex has not been found in the table
EXPECT_LT(tt, num);
}
}
// now check whether there are invalid faces
const unsigned int* pi = adj.mAdjacencyTable;
for (unsigned int i = 0; i < maxOfs;++i,++pi)
{
EXPECT_EQ(0xffffffff, *pi);
}
// check the numTrianglesPerVertex table
for (unsigned int i = 0; i < mesh.mNumFaces;++i)
{
aiFace& face = mesh.mFaces[i];
for (unsigned int qq = 0; qq < 3 ;++qq)
{
const unsigned int idx = face.mIndices[qq];
// we should not reach 0 here ...
EXPECT_NE(0U, piNum[idx]);
piNum[idx]--;
}
}
// check whether we reached 0 in all entries
for (unsigned int i = 0; i < mesh.mNumVertices;++i)
{
EXPECT_FALSE(piNum[i]);
}
2015-05-19 04:24:07 +00:00
}