static bool enumTests()
{
// Create a vector and fill it in with some known values
ValueVectorOf<unsigned int> testVec(32);
unsigned int index;
for (index = 0; index < 32; index++)
testVec.addElement(index);
// Create an enumeration for it
ValueVectorEnumerator<unsigned int> enumTest(&testVec);
index = 0;
while (enumTest.hasMoreElements())
{
if (enumTest.nextElement() != index++)
{
XERCES_STD_QUALIFIER wcout << L" Enumerator sequence was incorrect"
<< XERCES_STD_QUALIFIER endl;
return false;
}
}
if (index != 32)
{
XERCES_STD_QUALIFIER wcout << L" Enumerator did not enum enough elements"
<< XERCES_STD_QUALIFIER endl;
return false;
}
return true;
}
// Test that uniform_int<> can be used with std::random_shuffle
// Author: Jos Hickson
void test_random_shuffle()
{
typedef boost::uniform_int<> distribution_type;
typedef boost::variate_generator<boost::mt19937 &, distribution_type> generator_type;
boost::mt19937 engine1(1234);
boost::mt19937 engine2(1234);
rand_for_random_shuffle<boost::mt19937> referenceRand(engine1);
distribution_type dist(0,10);
generator_type testRand(engine2, dist);
std::vector<int> referenceVec;
for (int i = 0; i < 200; ++i)
{
referenceVec.push_back(i);
}
std::vector<int> testVec(referenceVec);
std::random_shuffle(referenceVec.begin(), referenceVec.end(), referenceRand);
std::random_shuffle(testVec.begin(), testVec.end(), testRand);
typedef std::vector<int>::iterator iter_type;
iter_type theEnd(referenceVec.end());
for (iter_type referenceIter(referenceVec.begin()), testIter(testVec.begin());
referenceIter != theEnd;
++referenceIter, ++testIter)
{
BOOST_CHECK_EQUAL(*referenceIter, *testIter);
}
}
void QuadTree::DrawObjects(QuadTreeNode* node,Frustum* frust){
vec3 testVec(node->position.x,0.0f,node->position.y);
if(!frust->CheckRect(testVec,node->size/2.0f)){
node->culled = true;
return;
}
node->culled = false;
int count = 0;
for(int child = 0; child < 4; child++){
if(node->nodes[child] != 0){
count++;
DrawObjects(node->nodes[child],frust);
}
}
if(count!=0)
return;
if(node->indices){
//get shader
Shader* treeShader = m_shaderMan->GetElement(m_treeShader);
for(int obj = 0; obj < node->numObjs; obj++){
if(node->objPositions[obj].y < 20.0f) continue;
if(frust->CheckRect(node->objPositions[obj],5.0f)){
treeShader->SetUniform("translation",glm::translate(node->objPositions[obj]));
m_tree->Render();
}
}
}
}
void QuadTree::DrawGround(QuadTreeNode* node,Frustum* frust){
vec3 testVec(node->position.x,0.0f,node->position.y);
if(!frust->CheckRect(testVec,node->size/2.0f)){
node->culled = true;
return;
}
node->culled = false;
int count = 0;
for(int child = 0; child < 4; child++){
if(node->nodes[child] != 0){
count++;
DrawGround(node->nodes[child],frust);
}
}
if(count!=0)
return;
if(node->indices){
int numIndices = node->triangleCount * 3;
glDrawElements(GL_TRIANGLES,numIndices,GL_UNSIGNED_INT,node->indices);
m_drawCount += node->triangleCount;
}
}
int main()
{
int Error(0);
Error += testVec();
Error += testMat();
return Error;
}
template <class T> bool extendedValueTests()
{
const unsigned int testMax = 8;
// Create a test vector and put in ascending test values
ValueVectorOf<T> testVec(testMax);
testVec.addElement(T(0));
testVec.addElement(T(1));
testVec.addElement(T(2));
testVec.addElement(T(3));
testVec.addElement(T(4));
testVec.addElement(T(5));
testVec.addElement(T(6));
testVec.addElement(T(7));
// Now check that they went in that way
unsigned int index;
for (index = 0; index < testMax; index++)
{
if (testVec.elementAt(index) != T(index))
{
XERCES_STD_QUALIFIER wcout << L" addElement put elements in wrong order"
<< XERCES_STD_QUALIFIER endl;
return false;
}
}
// Remove the zero'th element and test again
testVec.removeElementAt(0);
for (index = 0; index < testMax-1; index++)
{
if (testVec.elementAt(index) != T(index+1))
{
XERCES_STD_QUALIFIER wcout << L" removeElement at head removed wrong element"
<< XERCES_STD_QUALIFIER endl;
return false;
}
}
// Test edge case by removing last element and test again
testVec.removeElementAt(6);
for (index = 0; index < testMax-2; index++)
{
if (testVec.elementAt(index) != T(index+1))
{
XERCES_STD_QUALIFIER wcout << L" removeElement at end removed wrong element"
<< XERCES_STD_QUALIFIER endl;
return false;
}
}
return true;
}
TEST( Transform, normalTransformation )
{
// construct a transformation we'll use for testing
Transform trans;
{
trans.m_rotation.setAxisAngle( Quad_1000, FastFloat::fromFloat( DEG2RAD( 90.0f ) ) );
trans.m_translation.set( 10, 20, 30 );
}
// create the test vector
Vector testVec( 0, 1, 0 );
// transform the vector
Vector transformedVec;
trans.transformNorm( testVec, transformedVec );
// the transform should:
// 1. rotate the vector around the X axis, transforming it to ( 0, 0, 1 )
// 2. doesn't translate it
COMPARE_VEC( Vector( 0, 0, 1 ), transformedVec );
}
// ---------------------------------------------------------------------------
// Templatized testing code. These allow the exact same tests to be run
// for any number of instantiation types over the by value vectors.
// ---------------------------------------------------------------------------
template <class T> bool commonValueTests()
{
const unsigned int testMax = 3;
bool caughtIt;
// Create a vector of testMax of the instantiation type
ValueVectorOf<T> testVec(testMax);
// Make sure the initial capacity is what we set
if (testVec.curCapacity() != testMax)
{
XERCES_STD_QUALIFIER wcout << L" Init capacity was bad" << XERCES_STD_QUALIFIER endl;
return false;
}
// Make sure the initial size is zero
if (testVec.size() != 0)
{
XERCES_STD_QUALIFIER wcout << L" Init size was bad" << XERCES_STD_QUALIFIER endl;
return false;
}
// Test value for adding
T testElem;
// Add a value and check the count is 1
testVec.addElement(testElem);
if (testVec.size() != 1)
{
XERCES_STD_QUALIFIER wcout << L" Adding one element caused bad size" << XERCES_STD_QUALIFIER endl;
return false;
}
// Add another value and check the count is 2
testVec.addElement(testElem);
if (testVec.size() != 2)
{
XERCES_STD_QUALIFIER wcout << L" Adding another element caused bad size" << XERCES_STD_QUALIFIER endl;
return false;
}
// Test that the two of them are the same
if (testVec.elementAt(0) != testVec.elementAt(1))
{
XERCES_STD_QUALIFIER wcout << L" First two elements did not match" << XERCES_STD_QUALIFIER endl;
return false;
}
// Add two more, which should cause an expansion of the vector
testVec.addElement(testElem);
testVec.addElement(testElem);
if (testVec.curCapacity() == testMax)
{
XERCES_STD_QUALIFIER wcout << L" Adding another element failed to cause an expansion"
<< XERCES_STD_QUALIFIER endl;
return false;
}
// Check that we get an array bounds exception after an expansion
caughtIt = false;
try
{
testVec.elementAt(4);
}
catch(const ArrayIndexOutOfBoundsException&)
{
caughtIt = true;
}
if (!caughtIt)
{
XERCES_STD_QUALIFIER wcout << L" Failed to catch array bounds error at element 4"
<< XERCES_STD_QUALIFIER endl;
return false;
}
// Remove an item and see if the count went down by one
testVec.removeElementAt(0);
if (testVec.size() != 3)
{
XERCES_STD_QUALIFIER wcout << L" Removing an element did not adjust size correctly"
<< XERCES_STD_QUALIFIER endl;
return false;
}
// Remove the rest of them and make sure we hit zero
testVec.removeElementAt(0);
testVec.removeElementAt(0);
testVec.removeElementAt(0);
if (testVec.size() != 0)
{
XERCES_STD_QUALIFIER wcout << L" Removing all elements did not zero the size"
<< XERCES_STD_QUALIFIER endl;
return false;
}
// Check that we get an array bounds exception now still
caughtIt = false;
try
{
testVec.elementAt(0);
}
catch(const ArrayIndexOutOfBoundsException&)
{
caughtIt = true;
}
if (!caughtIt)
{
XERCES_STD_QUALIFIER wcout << L" Failed to catch array bounds error at element 0"
<< XERCES_STD_QUALIFIER endl;
return false;
}
// Add a few more elements back in, via insertion
testVec.insertElementAt(testElem, 0);
testVec.insertElementAt(testElem, 0);
testVec.insertElementAt(testElem, 0);
if (testVec.size() != 3)
{
XERCES_STD_QUALIFIER wcout << L" Inserting elements caused bad size" << XERCES_STD_QUALIFIER endl;
return false;
}
// Now do a remove all elements
testVec.removeAllElements();
if (testVec.size() != 0)
{
XERCES_STD_QUALIFIER wcout << L" removeAllElements caused bad size" << XERCES_STD_QUALIFIER endl;
return false;
}
return true;
}
void testConvolutionAndPool()
{
if (true)
{
const int filterDim = 8;
const int imageDim = 28;
const int poolDim = 3;
const int numFilters = 100;
const int outputDim = (imageDim - filterDim + 1) / poolDim;
RandomFilterFunction rff(filterDim, numFilters);
rff.configure();
SigmoidFunction sf;
ConvolutionFunction cf(&rff, &sf);
MeanPoolFunction pf(numFilters, outputDim);
//MeanPoolFunction mpf;
Eigen::Vector2i configImageDim;
configImageDim << imageDim, imageDim;
MNISTDataFunction mnistdf;
Config config;
updateMNISTConfig(config);
config.setValue("addBiasTerm", false);
config.setValue("meanStddNormalize", false);
mnistdf.configure(&config);
Convolutions* convolvedFeatures = nullptr;
for (int i = 0; i < 13; ++i)
convolvedFeatures = cf.conv(mnistdf.getTrainingX().topRows<199>(), configImageDim);
assert(convolvedFeatures->unordered_map.size() == 199);
for (auto i = convolvedFeatures->unordered_map.begin();
i != convolvedFeatures->unordered_map.end(); ++i)
assert((int )i->second.size() == rff.getWeights().cols());
// Validate convoluations
Matrix_t ConvImages = mnistdf.getTrainingX().topRows<8>();
for (int i = 0; i < 1000; ++i)
{
const int filterNum = rand() % rff.getWeights().cols();
const int imageNum = rand() % 8;
const int imageRow = rand() % (configImageDim(0) - rff.getConfig()(0) + 1);
const int imageCol = rand() % (configImageDim(1) - rff.getConfig()(1) + 1);
Vector_t im = ConvImages.row(imageNum);
Eigen::Map<Matrix_t> Image(im.data(), configImageDim(0), configImageDim(1));
Matrix_t Patch = Image.block(imageRow, imageCol, rff.getConfig()(0), rff.getConfig()(1));
// Filter
Eigen::Map<Matrix_t> W(rff.getWeights().col(filterNum).data(), rff.getConfig()(0),
rff.getConfig()(1));
const double b = rff.getBiases()(filterNum);
double feature = Patch.cwiseProduct(W).sum() + b;
feature = 1.0f / (1.0f + exp(-feature));
if (fabs(
feature - convolvedFeatures->unordered_map[imageNum][filterNum]->X(imageRow, imageCol))
> 1e-9)
{
std::cout << "Convolved feature does not match test feature: " << i << std::endl;
std::cout << "Filter Number: " << filterNum << std::endl;
std::cout << "Image Number: " << imageNum << std::endl;
std::cout << "Image Row: " << imageRow << std::endl;
std::cout << "Image Col: " << imageCol << std::endl;
std::cout << "Convolved feature: "
<< convolvedFeatures->unordered_map[imageNum][filterNum]->X(imageRow, imageCol)
<< std::endl;
std::cout << "Test feature: " << feature << std::endl;
std::cout << "Convolved feature does not match test feature" << std::endl;
exit(EXIT_FAILURE);
}
}
// Pool
Poolings* pooling = nullptr;
for (int i = 0; i < 13; ++i)
pooling = pf.pool(convolvedFeatures, poolDim);
assert((int )pooling->unordered_map.size() == 199);
for (auto iter = pooling->unordered_map.begin(); iter != pooling->unordered_map.end(); ++iter)
{
assert(iter->second.size() == (size_t )rff.getWeights().cols());
for (auto iter2 = iter->second.begin(); iter2 != iter->second.end(); ++iter2)
{
assert(iter2->second->X.rows() == (configImageDim(0) - rff.getConfig()(0) + 1) / 3);
assert(iter2->second->X.rows() == 7);
assert(iter2->second->X.cols() == (configImageDim(0) - rff.getConfig()(0) + 1) / 3);
assert(iter2->second->X.cols() == 7);
}
}
}
if (true)
{
// test pool function
Vector_t testVec(64);
for (int i = 0; i < testVec.size(); ++i)
testVec(i) = i + 1;
Eigen::Map<Matrix_t> TestMatrix(testVec.data(), 8, 8);
std::cout << "TestMatrix: " << std::endl;
std::cout << TestMatrix << std::endl;
Matrix_t ExpectedMatrix(2, 2);
ExpectedMatrix(0, 0) = TestMatrix.block(0, 0, 4, 4).array().mean();
ExpectedMatrix(0, 1) = TestMatrix.block(0, 4, 4, 4).array().mean();
ExpectedMatrix(1, 0) = TestMatrix.block(4, 0, 4, 4).array().mean();
ExpectedMatrix(1, 1) = TestMatrix.block(4, 4, 4, 4).array().mean();
std::cout << "Expected: " << std::endl;
std::cout << ExpectedMatrix << std::endl;
Convolutions cfs;
Convolution xcf;
xcf.X = TestMatrix;
cfs.unordered_map[0].insert(std::make_pair(0, (&xcf)));
MeanPoolFunction testMpf(1, 2);
Poolings* pfs = testMpf.pool(&cfs, 4);
assert(pfs->unordered_map.size() == 1);
assert(pfs->unordered_map[0].size() == 1);
Matrix_t PX = pfs->unordered_map[0][0]->X;
std::cout << "Obtain: " << std::endl;
std::cout << PX << std::endl;
}
}