1191 lines
32 KiB
C++
1191 lines
32 KiB
C++
|
///////////////////////////////////////////////////////////////////////////
|
||
|
|
//
|
||
|
|
// Copyright (c) 2010, Industrial Light & Magic, a division of Lucas
|
||
|
|
// Digital Ltd. LLC
|
||
|
|
//
|
||
|
|
// All rights reserved.
|
||
|
|
//
|
||
|
|
// Redistribution and use in source and binary forms, with or without
|
||
|
|
// modification, are permitted provided that the following conditions are
|
||
|
|
// met:
|
||
|
|
// * Redistributions of source code must retain the above copyright
|
||
|
|
// notice, this list of conditions and the following disclaimer.
|
||
|
|
// * Redistributions in binary form must reproduce the above
|
||
|
|
// copyright notice, this list of conditions and the following disclaimer
|
||
|
|
// in the documentation and/or other materials provided with the
|
||
|
|
// distribution.
|
||
|
|
// * Neither the name of Industrial Light & Magic nor the names of
|
||
|
|
// its contributors may be used to endorse or promote products derived
|
||
|
|
// from this software without specific prior written permission.
|
||
|
|
//
|
||
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||
|
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||
|
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||
|
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||
|
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||
|
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||
|
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||
|
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||
|
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||
|
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||
|
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||
|
|
//
|
||
|
|
///////////////////////////////////////////////////////////////////////////
|
||
|
|
|
||
|
|
|
||
|
|
#include <testBoxAlgo.h>
|
||
|
|
#include "ImathBoxAlgo.h"
|
||
|
|
#include "ImathRandom.h"
|
||
|
|
#include <iostream>
|
||
|
|
#include <algorithm>
|
||
|
|
#include <assert.h>
|
||
|
|
#include <typeinfo>
|
||
|
|
#include <vector>
|
||
|
|
|
||
|
|
using namespace std;
|
||
|
|
using namespace IMATH_INTERNAL_NAMESPACE;
|
||
|
|
|
||
|
|
namespace {
|
||
|
|
|
||
|
|
//
|
||
|
|
// Test case generation utility - create a vector of IMATH_INTERNAL_NAMESPACE::Vec{2,3,4}
|
||
|
|
// with all permutations of integers 1..T::dimensions().
|
||
|
|
//
|
||
|
|
// Algorithm from www.bearcave.com/random_hacks/permute.html
|
||
|
|
//
|
||
|
|
template <class T>
|
||
|
|
static void
|
||
|
|
addItem(const std::vector<int> &value, std::vector<T> &perms)
|
||
|
|
{
|
||
|
|
T p;
|
||
|
|
for (unsigned int i = 0; i < value.size(); i++)
|
||
|
|
{
|
||
|
|
p[i] = value[i];
|
||
|
|
}
|
||
|
|
perms.push_back(p);
|
||
|
|
}
|
||
|
|
|
||
|
|
template <class T>
|
||
|
|
static void
|
||
|
|
visit(int &level, int n, int k, std::vector<int> &value, std::vector<T> &perms)
|
||
|
|
{
|
||
|
|
level = level + 1;
|
||
|
|
value[k] = level;
|
||
|
|
|
||
|
|
if (level == n)
|
||
|
|
addItem(value, perms);
|
||
|
|
else
|
||
|
|
for (int i = 0; i < n; i++)
|
||
|
|
if (value[i] == 0)
|
||
|
|
visit(level, n, i, value, perms);
|
||
|
|
|
||
|
|
level = level - 1;
|
||
|
|
value[k] = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
template <class T>
|
||
|
|
static void
|
||
|
|
permutations(std::vector<T> &perms)
|
||
|
|
{
|
||
|
|
std::vector<int> value(T::dimensions());
|
||
|
|
int level = -1;
|
||
|
|
int n = T::dimensions();
|
||
|
|
|
||
|
|
visit(level, n, 0, value, perms);
|
||
|
|
}
|
||
|
|
|
||
|
|
template <class T>
|
||
|
|
static void
|
||
|
|
testConstructors(const char *type)
|
||
|
|
{
|
||
|
|
cout << " constructors for type " << type << endl;
|
||
|
|
|
||
|
|
//
|
||
|
|
// Empty
|
||
|
|
//
|
||
|
|
{
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b;
|
||
|
|
assert(b.min == T(T::baseTypeMax()) &&
|
||
|
|
b.max == T(T::baseTypeMin()));
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Single point
|
||
|
|
//
|
||
|
|
{
|
||
|
|
T p;
|
||
|
|
for (unsigned int i = 0; i < T::dimensions(); i++)
|
||
|
|
p[i] = i;
|
||
|
|
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b(p);
|
||
|
|
assert(b.min == p && b.max == p);
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Min and max
|
||
|
|
//
|
||
|
|
{
|
||
|
|
T p0;
|
||
|
|
T p1;
|
||
|
|
for (unsigned int i = 0; i < T::dimensions(); i++)
|
||
|
|
{
|
||
|
|
p0[i] = i;
|
||
|
|
p1[i] = 10 * T::dimensions() - i - 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b(p0, p1);
|
||
|
|
assert(b.min == p0 && b.max == p1);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
template <class T>
|
||
|
|
void
|
||
|
|
testMakeEmpty(const char *type)
|
||
|
|
{
|
||
|
|
cout << " makeEmpty() for type " << type << endl;
|
||
|
|
|
||
|
|
//
|
||
|
|
// Empty box
|
||
|
|
//
|
||
|
|
{
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b;
|
||
|
|
b.makeEmpty();
|
||
|
|
assert(b.min == T(T::baseTypeMax()) &&
|
||
|
|
b.max == T(T::baseTypeMin()));
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Non-empty, has volume
|
||
|
|
//
|
||
|
|
{
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b(T(-1), T(1));
|
||
|
|
b.makeEmpty();
|
||
|
|
assert(b.min == T(T::baseTypeMax()) &&
|
||
|
|
b.max == T(T::baseTypeMin()));
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Non-empty, no volume
|
||
|
|
// Boxes are:
|
||
|
|
// 2D: [(0, 0), (0, 1) ]
|
||
|
|
// 3D: [(0, 0, 0), (0, 0, 1) ]
|
||
|
|
// 4D: [(0, 0, 0, 0), (0, 0, 0, 1)]
|
||
|
|
//
|
||
|
|
{
|
||
|
|
T min(0);
|
||
|
|
T max(0);
|
||
|
|
max[T::dimensions() - 1] = 1;
|
||
|
|
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b(min, max);
|
||
|
|
b.makeEmpty();
|
||
|
|
assert(b.min == T(T::baseTypeMax()) &&
|
||
|
|
b.max == T(T::baseTypeMin()));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
template <class T>
|
||
|
|
void
|
||
|
|
testMakeInfinite(const char *type)
|
||
|
|
{
|
||
|
|
cout << " makeInfinite() for type " << type << endl;
|
||
|
|
|
||
|
|
//
|
||
|
|
// Infinite box
|
||
|
|
//
|
||
|
|
{
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b;
|
||
|
|
b.makeInfinite();
|
||
|
|
assert(b.min == T(T::baseTypeMin()) &&
|
||
|
|
b.max == T(T::baseTypeMax()));
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Non-empty, has volume
|
||
|
|
//
|
||
|
|
{
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b(T(-1), T(1));
|
||
|
|
b.makeInfinite();
|
||
|
|
assert(b.min == T(T::baseTypeMin()) &&
|
||
|
|
b.max == T(T::baseTypeMax()));
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Non-empty, no volume
|
||
|
|
// Boxes are:
|
||
|
|
// 2D: [(0, 0), (0, 1) ]
|
||
|
|
// 3D: [(0, 0, 0), (0, 0, 1) ]
|
||
|
|
// 4D: [(0, 0, 0, 0), (0, 0, 0, 1)]
|
||
|
|
//
|
||
|
|
{
|
||
|
|
T min(0);
|
||
|
|
T max(0);
|
||
|
|
max[T::dimensions() - 1] = 1;
|
||
|
|
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b(min, max);
|
||
|
|
b.makeInfinite();
|
||
|
|
assert(b.min == T(T::baseTypeMin()) &&
|
||
|
|
b.max == T(T::baseTypeMax()));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
template <class T>
|
||
|
|
void
|
||
|
|
testExtendByPoint(const char *type)
|
||
|
|
{
|
||
|
|
cout << " extendBy() point for type " << type << endl;
|
||
|
|
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Rand32 rand(0);
|
||
|
|
|
||
|
|
const unsigned int iters = 10;
|
||
|
|
|
||
|
|
//
|
||
|
|
// Extend empty box with a single point.
|
||
|
|
//
|
||
|
|
for (unsigned int i = 0; i < iters; i++)
|
||
|
|
{
|
||
|
|
T p;
|
||
|
|
for (unsigned int j = 0; j < T::dimensions(); j++)
|
||
|
|
p[j] = typename T::BaseType (rand.nextf(-12345, 12345));
|
||
|
|
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b;
|
||
|
|
b.extendBy(p);
|
||
|
|
assert(b.min == p && b.max == p);
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Extend empty box with a number of random points. Note that
|
||
|
|
// this also covers extending a non-empty box.
|
||
|
|
//
|
||
|
|
for (unsigned int i = 0; i < iters; i++)
|
||
|
|
{
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b;
|
||
|
|
|
||
|
|
T min;
|
||
|
|
T max;
|
||
|
|
|
||
|
|
for (unsigned int j = 0; j < i; j++)
|
||
|
|
{
|
||
|
|
T p;
|
||
|
|
for (unsigned int k = 0; k < T::dimensions(); k++)
|
||
|
|
p[k] = typename T::BaseType (rand.nextf(-12345, 12345));
|
||
|
|
|
||
|
|
if (j == 0)
|
||
|
|
{
|
||
|
|
min = p;
|
||
|
|
max = p;
|
||
|
|
}
|
||
|
|
for (unsigned int k = 0; k < T::dimensions(); k++)
|
||
|
|
{
|
||
|
|
min[k] = std::min(min[k], p[k]);
|
||
|
|
max[k] = std::max(max[k], p[k]);
|
||
|
|
}
|
||
|
|
|
||
|
|
b.extendBy(p);
|
||
|
|
|
||
|
|
assert(b.min == min && b.max == max);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
template <class T>
|
||
|
|
void
|
||
|
|
testExtendByBox(const char *type)
|
||
|
|
{
|
||
|
|
cout << " extendBy() box for type " << type << endl;
|
||
|
|
|
||
|
|
//
|
||
|
|
// Extend empty box with an empty box;
|
||
|
|
//
|
||
|
|
{
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b;
|
||
|
|
b.extendBy(IMATH_INTERNAL_NAMESPACE::Box<T>());
|
||
|
|
assert(b.min == T(T::baseTypeMax()) &&
|
||
|
|
b.max == T(T::baseTypeMin()));
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Extend empty box with a non-empty box and vice versa.
|
||
|
|
//
|
||
|
|
{
|
||
|
|
std::vector<T> perms;
|
||
|
|
permutations(perms);
|
||
|
|
|
||
|
|
for (unsigned int i = 0; i < perms.size(); i++)
|
||
|
|
{
|
||
|
|
for (unsigned int j = 0; j < perms.size(); j++)
|
||
|
|
{
|
||
|
|
T p0 = -perms[i];
|
||
|
|
T p1 = perms[j];
|
||
|
|
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b0;
|
||
|
|
b0.extendBy(IMATH_INTERNAL_NAMESPACE::Box<T>(p0, p1));
|
||
|
|
assert(b0.min == p0 && b0.max == p1);
|
||
|
|
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b1(p0, p1);
|
||
|
|
b1.extendBy(IMATH_INTERNAL_NAMESPACE::Box<T>());
|
||
|
|
assert(b1.min == p0 && b1.max == p1);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Extend non-empty box with non-empty box. Starts with empty, then builds.
|
||
|
|
//
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Rand32 rand(0);
|
||
|
|
const unsigned int iters = 10;
|
||
|
|
{
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b;
|
||
|
|
|
||
|
|
T min, max;
|
||
|
|
|
||
|
|
for (unsigned int i = 1; i < iters; i++)
|
||
|
|
{
|
||
|
|
T p0;
|
||
|
|
T p1;
|
||
|
|
for (unsigned int k = 0; k < T::dimensions(); k++)
|
||
|
|
{
|
||
|
|
p0[k] = typename T::BaseType (rand.nextf( 0, 999));
|
||
|
|
p1[k] = typename T::BaseType (rand.nextf(1000, 1999));
|
||
|
|
}
|
||
|
|
|
||
|
|
min = b.min;
|
||
|
|
max = b.max;
|
||
|
|
for (unsigned int k = 0; k < T::dimensions(); k++)
|
||
|
|
{
|
||
|
|
min[k] = std::min(min[k], p0[k]);
|
||
|
|
max[k] = std::max(max[k], p1[k]);
|
||
|
|
}
|
||
|
|
b.extendBy(IMATH_INTERNAL_NAMESPACE::Box<T>(p0, p1));
|
||
|
|
|
||
|
|
assert(b.min == min && b.max == max);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
template <class T>
|
||
|
|
void
|
||
|
|
testComparators(const char *type)
|
||
|
|
{
|
||
|
|
cout << " comparators for type " << type << endl;
|
||
|
|
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Rand32 rand(0);
|
||
|
|
|
||
|
|
//
|
||
|
|
// Compare empty.
|
||
|
|
//
|
||
|
|
{
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b0;
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b1;
|
||
|
|
|
||
|
|
assert(b0 == b1);
|
||
|
|
assert(!(b0 != b1));
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Compare empty to non-empty.
|
||
|
|
//
|
||
|
|
{
|
||
|
|
std::vector<T> perms;
|
||
|
|
permutations(perms);
|
||
|
|
|
||
|
|
for (unsigned int i = 0; i < perms.size(); i++)
|
||
|
|
{
|
||
|
|
for (unsigned int j = 0; j < perms.size(); j++)
|
||
|
|
{
|
||
|
|
T p0 = -perms[i];
|
||
|
|
T p1 = perms[j];
|
||
|
|
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b0;
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b1(p0, p1);
|
||
|
|
assert(!(b0 == b1));
|
||
|
|
assert(b0 != b1);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Compare two non-empty
|
||
|
|
//
|
||
|
|
{
|
||
|
|
std::vector<T> perms;
|
||
|
|
permutations(perms);
|
||
|
|
|
||
|
|
for (unsigned int i = 0; i < perms.size(); i++)
|
||
|
|
{
|
||
|
|
for (unsigned int j = 0; j < perms.size(); j++)
|
||
|
|
{
|
||
|
|
T p0 = -perms[i];
|
||
|
|
T p1 = perms[j];
|
||
|
|
|
||
|
|
T p2 = -perms[j];
|
||
|
|
T p3 = perms[i];
|
||
|
|
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b0(p0, p1);
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b1(p2, p3);
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b2(p0, p1);
|
||
|
|
|
||
|
|
if (i == j)
|
||
|
|
{
|
||
|
|
assert(b0 == b1);
|
||
|
|
assert(!(b0 != b1));
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
assert(b0 != b1);
|
||
|
|
assert(!(b0 == b1));
|
||
|
|
}
|
||
|
|
assert(b0 == b2);
|
||
|
|
assert(!(b0 != b2));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
template <class T>
|
||
|
|
void
|
||
|
|
testIntersects(const char *type)
|
||
|
|
{
|
||
|
|
cout << " intersects() for type " << type << endl;
|
||
|
|
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Rand32 rand(0);
|
||
|
|
|
||
|
|
//
|
||
|
|
// Intersect point with empty box.
|
||
|
|
//
|
||
|
|
{
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b;
|
||
|
|
T p(1);
|
||
|
|
|
||
|
|
assert(!b.intersects(p));
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Intersect point with non-empty, has-volume box.
|
||
|
|
//
|
||
|
|
{
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b(T(-1), T(1));
|
||
|
|
T p0(0);
|
||
|
|
T p1(5);
|
||
|
|
T p2(-5);
|
||
|
|
|
||
|
|
assert(b.intersects(p0));
|
||
|
|
assert(!b.intersects(p1));
|
||
|
|
assert(!b.intersects(p2));
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Intersect point with non-empty, no-volume box.
|
||
|
|
// Boxes are:
|
||
|
|
// 2D: [(0, 0), (0, 1) ]
|
||
|
|
// 3D: [(0, 0, 0), (0, 0, 1) ]
|
||
|
|
// 4D: [(0, 0, 0, 0), (0, 0, 0, 1)]
|
||
|
|
//
|
||
|
|
{
|
||
|
|
T min(0);
|
||
|
|
T max = min;
|
||
|
|
max[T::dimensions() - 1] = 1;
|
||
|
|
|
||
|
|
T p0(0);
|
||
|
|
T p1(5);
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b(min, max);
|
||
|
|
|
||
|
|
assert(b.intersects(p0));
|
||
|
|
assert(!b.intersects(p1));
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Intersect empty box with empty box.
|
||
|
|
//
|
||
|
|
{
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b0;
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b1;
|
||
|
|
|
||
|
|
assert(!b0.intersects(b1));
|
||
|
|
assert(!b1.intersects(b0));
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Intersect empty box with non-empty has-volume boxes.
|
||
|
|
//
|
||
|
|
{
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b0;
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b1(T(-1), T(1));
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b2(T( 1), T(2));
|
||
|
|
|
||
|
|
assert(!b0.intersects(b1));
|
||
|
|
assert(!b0.intersects(b2));
|
||
|
|
|
||
|
|
assert(!b1.intersects(b0));
|
||
|
|
assert(!b2.intersects(b0));
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Intersect empty box with non-empty no-volume box.
|
||
|
|
// Boxes are:
|
||
|
|
// 2D: [(0, 0), (0, 1) ]
|
||
|
|
// 3D: [(0, 0, 0), (0, 0, 1) ]
|
||
|
|
// 4D: [(0, 0, 0, 0), (0, 0, 0, 1)]
|
||
|
|
//
|
||
|
|
{
|
||
|
|
T min(0);
|
||
|
|
T max = min;
|
||
|
|
max[T::dimensions() - 1] = 1;
|
||
|
|
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b0;
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b1(min, max);
|
||
|
|
|
||
|
|
assert(!b0.intersects(b1));
|
||
|
|
assert(!b1.intersects(b0));
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Intersect non-empty has-volume box with non-empty has-volume box.
|
||
|
|
//
|
||
|
|
{
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b1(T(-1), T(1));
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b2(T(-1), T(1));
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b3(T( 1), T(2));
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b4(T( 2), T(3));
|
||
|
|
|
||
|
|
assert(b1.intersects(b1));
|
||
|
|
assert(b1.intersects(b3));
|
||
|
|
assert(!b1.intersects(b4));
|
||
|
|
|
||
|
|
assert(b3.intersects(b1));
|
||
|
|
assert(!b4.intersects(b1));
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Intersect non-empty has-volume box with non-empty no-volume box.
|
||
|
|
//
|
||
|
|
// Boxes are:
|
||
|
|
// 2D: [(0, 0), (0, 1) ]
|
||
|
|
// 3D: [(0, 0, 0), (0, 0, 1) ]
|
||
|
|
// 4D: [(0, 0, 0, 0), (0, 0, 0, 1)]
|
||
|
|
//
|
||
|
|
{
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b0(T(-1), T(1));
|
||
|
|
|
||
|
|
T min(0);
|
||
|
|
T max = min;
|
||
|
|
max[T::dimensions() - 1] = 1;
|
||
|
|
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b1(min, max);
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b2(min + T(2), max + T(2));
|
||
|
|
|
||
|
|
assert(b0.intersects(b1));
|
||
|
|
assert(b1.intersects(b0));
|
||
|
|
|
||
|
|
assert(!b0.intersects(b2));
|
||
|
|
assert(!b2.intersects(b1));
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Intersect non-empty no-volume box with non-empty no-volume box.
|
||
|
|
//
|
||
|
|
// Boxes are:
|
||
|
|
// 2D: [(0, 0), (0, 1) ]
|
||
|
|
// 3D: [(0, 0, 0), (0, 0, 1) ]
|
||
|
|
// 4D: [(0, 0, 0, 0), (0, 0, 0, 1)]
|
||
|
|
//
|
||
|
|
{
|
||
|
|
T min(0);
|
||
|
|
T max = min;
|
||
|
|
max[T::dimensions() - 1] = 1;
|
||
|
|
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b0(min, max);
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b1(min, max + T(2));
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b2(min + T(2), max + T(2));
|
||
|
|
|
||
|
|
assert(b0.intersects(b1));
|
||
|
|
assert(b1.intersects(b0));
|
||
|
|
|
||
|
|
assert(!b0.intersects(b2));
|
||
|
|
assert(!b2.intersects(b0));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
template <class T>
|
||
|
|
void
|
||
|
|
testSize(const char *type)
|
||
|
|
{
|
||
|
|
cout << " size() for type " << type << endl;
|
||
|
|
|
||
|
|
//
|
||
|
|
// Size of empty box.
|
||
|
|
//
|
||
|
|
{
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b;
|
||
|
|
assert(b.size() == T(0));
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Size of non-empty, has-volume box.
|
||
|
|
// Boxes are:
|
||
|
|
// 2D: [(-1, -1), (1, 1) ]
|
||
|
|
// 3D: [(-1, -1, -1), (1, 1, 1) ]
|
||
|
|
// 4D: [(-1, -1, -1, -1), (1, 1, 1, 1) ]
|
||
|
|
//
|
||
|
|
// and
|
||
|
|
//
|
||
|
|
// 2D: [(-1, -2), (1, 2) ]
|
||
|
|
// 3D: [(-1, -2, -3), (1, 2, 3) ]
|
||
|
|
// 4D: [(-1, -2, -3, -4), (1, 2, 3, 4) ]
|
||
|
|
//
|
||
|
|
{
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b0(T(-1), T(1));
|
||
|
|
assert(b0.size() == T(2));
|
||
|
|
|
||
|
|
T p;
|
||
|
|
for (unsigned int i = 0; i < T::dimensions(); i++)
|
||
|
|
{
|
||
|
|
p[i] = i;
|
||
|
|
}
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b1(-p, p);
|
||
|
|
assert(b1.size() == p * T(2));
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Size of non-empty, no-volume box.
|
||
|
|
// Boxes are:
|
||
|
|
// 2D: [(0, 0), (0, 1) ]
|
||
|
|
// 3D: [(0, 0, 0), (0, 0, 1) ]
|
||
|
|
// 4D: [(0, 0, 0, 0), (0, 0, 0, 1)]
|
||
|
|
//
|
||
|
|
{
|
||
|
|
T min(0);
|
||
|
|
T max = min;
|
||
|
|
max[T::dimensions() - 1] = 1;
|
||
|
|
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b(min, max);
|
||
|
|
|
||
|
|
assert(b.size() == max);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
template <class T>
|
||
|
|
void
|
||
|
|
testCenter(const char *type)
|
||
|
|
{
|
||
|
|
cout << " center() for type " << type << endl;
|
||
|
|
|
||
|
|
//
|
||
|
|
// Center of empty box.
|
||
|
|
//
|
||
|
|
{
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b;
|
||
|
|
assert(b.center() == T(0));
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Center of non-empty, has-volume box.
|
||
|
|
// Boxes are:
|
||
|
|
// 2D: [(-1, -1), (1, 1) ]
|
||
|
|
// 3D: [(-1, -1, -1), (1, 1, 1) ]
|
||
|
|
// 4D: [(-1, -1, -1, -1), (1, 1, 1, 1) ]
|
||
|
|
//
|
||
|
|
// and
|
||
|
|
//
|
||
|
|
// 2D: [(-2, -4), ( 8, 2) ]
|
||
|
|
// 3D: [(-2, -4, -6), (12, 8, 2) ]
|
||
|
|
// 4D: [(-2, -4, -6, -8), (16, 12, 8, 4) ]
|
||
|
|
//
|
||
|
|
{
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b0(T(-1), T(1));
|
||
|
|
assert(b0.center() == T(0));
|
||
|
|
|
||
|
|
T p0;
|
||
|
|
T p1;
|
||
|
|
for (unsigned int i = 0; i < T::dimensions(); i++)
|
||
|
|
{
|
||
|
|
p0[i] = -typename T::BaseType(1 << (i + 1));
|
||
|
|
p1[i] = typename T::BaseType(1 << (T::dimensions() - i));
|
||
|
|
}
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b1(p0, p1);
|
||
|
|
assert(b1.center() == (p1 + p0) / 2);
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Center of non-empty, no-volume box.
|
||
|
|
// Boxes are:
|
||
|
|
// 2D: [(0, 0), (0, 2) ]
|
||
|
|
// 3D: [(0, 0, 0), (0, 0, 2) ]
|
||
|
|
// 4D: [(0, 0, 0, 0), (0, 0, 0, 2)]
|
||
|
|
//
|
||
|
|
{
|
||
|
|
T min(0);
|
||
|
|
T max = min;
|
||
|
|
max[T::dimensions() - 1] = 2;
|
||
|
|
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b(min, max);
|
||
|
|
|
||
|
|
assert(b.center() == max /2);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
template <class T>
|
||
|
|
void
|
||
|
|
testIsEmpty(const char *type)
|
||
|
|
{
|
||
|
|
cout << " isEmpty() for type " << type << endl;
|
||
|
|
|
||
|
|
//
|
||
|
|
// Empty box.
|
||
|
|
//
|
||
|
|
{
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b;
|
||
|
|
assert(b.isEmpty());
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Non-empty, has-volume box.
|
||
|
|
// 2D: [(-2, -4), ( 8, 2) ]
|
||
|
|
// 3D: [(-2, -4, -6), (12, 8, 2) ]
|
||
|
|
// 4D: [(-2, -4, -6, -8), (16, 12, 8, 4) ]
|
||
|
|
//
|
||
|
|
{
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b0(T(-1), T(1));
|
||
|
|
assert(!b0.isEmpty());
|
||
|
|
|
||
|
|
T p0;
|
||
|
|
T p1;
|
||
|
|
for (unsigned int i = 0; i < T::dimensions(); i++)
|
||
|
|
{
|
||
|
|
p0[i] = -typename T::BaseType(1 << (i + 1));
|
||
|
|
p1[i] = typename T::BaseType(1 << (T::dimensions() - i));
|
||
|
|
}
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b1(p0, p1);
|
||
|
|
assert(!b1.isEmpty());
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Non-empty, no-volume box.
|
||
|
|
// Boxes are:
|
||
|
|
// 2D: [(0, 0), (0, 2) ]
|
||
|
|
// 3D: [(0, 0, 0), (0, 0, 2) ]
|
||
|
|
// 4D: [(0, 0, 0, 0), (0, 0, 0, 2)]
|
||
|
|
//
|
||
|
|
{
|
||
|
|
T min(0);
|
||
|
|
T max = min;
|
||
|
|
max[T::dimensions() - 1] = 2;
|
||
|
|
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b(min, max);
|
||
|
|
|
||
|
|
assert(!b.isEmpty());
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
template <class T>
|
||
|
|
void
|
||
|
|
testIsInfinite(const char *type)
|
||
|
|
{
|
||
|
|
cout << " isInfinite() for type " << type << endl;
|
||
|
|
|
||
|
|
//
|
||
|
|
// Infinite box.
|
||
|
|
//
|
||
|
|
{
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b;
|
||
|
|
b.makeInfinite();
|
||
|
|
assert(b.isInfinite());
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Non-empty, has-volume box.
|
||
|
|
// 2D: [(-2, -4), ( 8, 2) ]
|
||
|
|
// 3D: [(-2, -4, -6), (12, 8, 2) ]
|
||
|
|
// 4D: [(-2, -4, -6, -8), (16, 12, 8, 4) ]
|
||
|
|
//
|
||
|
|
{
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b0(T(-1), T(1));
|
||
|
|
assert(!b0.isInfinite());
|
||
|
|
|
||
|
|
T p0;
|
||
|
|
T p1;
|
||
|
|
for (unsigned int i = 0; i < T::dimensions(); i++)
|
||
|
|
{
|
||
|
|
p0[i] = -typename T::BaseType(1 << (i + 1));
|
||
|
|
p1[i] = typename T::BaseType(1 << (T::dimensions() - i));
|
||
|
|
}
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b1(p0, p1);
|
||
|
|
assert(!b1.isInfinite());
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Non-empty, no-volume box.
|
||
|
|
// Boxes are:
|
||
|
|
// 2D: [(0, 0), (0, 2) ]
|
||
|
|
// 3D: [(0, 0, 0), (0, 0, 2) ]
|
||
|
|
// 4D: [(0, 0, 0, 0), (0, 0, 0, 2)]
|
||
|
|
//
|
||
|
|
{
|
||
|
|
T min(0);
|
||
|
|
T max = min;
|
||
|
|
max[T::dimensions() - 1] = 2;
|
||
|
|
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b(min, max);
|
||
|
|
|
||
|
|
assert(!b.isInfinite());
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
template <class T>
|
||
|
|
void
|
||
|
|
testHasVolume(const char *type)
|
||
|
|
{
|
||
|
|
cout << " hasVolume() for type " << type << endl;
|
||
|
|
|
||
|
|
//
|
||
|
|
// Empty box.
|
||
|
|
//
|
||
|
|
{
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b;
|
||
|
|
assert(!b.hasVolume());
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Infinite box.
|
||
|
|
//
|
||
|
|
{
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b;
|
||
|
|
b.makeInfinite();
|
||
|
|
assert(b.hasVolume());
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Non-empty, has-volume box.
|
||
|
|
// 2D: [(-2, -4), ( 8, 2) ]
|
||
|
|
// 3D: [(-2, -4, -6), (12, 8, 2) ]
|
||
|
|
// 4D: [(-2, -4, -6, -8), (16, 12, 8, 4) ]
|
||
|
|
//
|
||
|
|
{
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b0(T(-1), T(1));
|
||
|
|
assert(b0.hasVolume());
|
||
|
|
|
||
|
|
T p0;
|
||
|
|
T p1;
|
||
|
|
for (unsigned int i = 0; i < T::dimensions(); i++)
|
||
|
|
{
|
||
|
|
p0[i] = -typename T::BaseType(1 << (i + 1));
|
||
|
|
p1[i] = typename T::BaseType(1 << (T::dimensions() - i));
|
||
|
|
}
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b1(p0, p1);
|
||
|
|
assert(b1.hasVolume());
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Non-empty, no-volume box.
|
||
|
|
// Boxes are:
|
||
|
|
// 2D: [(0, 0), (0, 2) ]
|
||
|
|
// 3D: [(0, 0, 0), (0, 0, 2) ]
|
||
|
|
// 4D: [(0, 0, 0, 0), (0, 0, 0, 2)]
|
||
|
|
//
|
||
|
|
{
|
||
|
|
T min(0);
|
||
|
|
T max = min;
|
||
|
|
max[T::dimensions() - 1] = 2;
|
||
|
|
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b(min, max);
|
||
|
|
|
||
|
|
assert(!b.hasVolume());
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
template <class T>
|
||
|
|
void
|
||
|
|
testMajorAxis(const char *type)
|
||
|
|
{
|
||
|
|
cout << " majorAxis() for type " << type << endl;
|
||
|
|
|
||
|
|
//
|
||
|
|
// Empty box.
|
||
|
|
//
|
||
|
|
{
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b;
|
||
|
|
assert(b.majorAxis() == 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Non-empty, has-volume box.
|
||
|
|
// Boxes are [ (0, 0, ...), (<all permutations of 1..T::dimensions()>) ]
|
||
|
|
//
|
||
|
|
{
|
||
|
|
std::vector<T> perms;
|
||
|
|
permutations(perms);
|
||
|
|
|
||
|
|
for (unsigned int i = 0; i < perms.size(); i++)
|
||
|
|
{
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b(T(0), perms[i]);
|
||
|
|
|
||
|
|
unsigned int major = 0;
|
||
|
|
T size = perms[i] - T(0);
|
||
|
|
for (unsigned int j = 1; j < T::dimensions(); j++)
|
||
|
|
if (size[j] > size[major])
|
||
|
|
major = j;
|
||
|
|
|
||
|
|
assert(b.majorAxis() == major);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Non-empty, no-volume box.
|
||
|
|
// Boxes are:
|
||
|
|
// 2D: [(0, 0), (1, 0) ]
|
||
|
|
// 2D: [(0, 0), (0, 1) ]
|
||
|
|
//
|
||
|
|
// 3D: [(0, 0), (1, 0, 0) ]
|
||
|
|
// 3D: [(0, 0), (0, 1, 0) ]
|
||
|
|
// 3D: [(0, 0), (0, 0, 1) ]
|
||
|
|
//
|
||
|
|
// and similarly for 4D
|
||
|
|
//
|
||
|
|
{
|
||
|
|
for (unsigned int i = 0; i < T::dimensions(); i++)
|
||
|
|
{
|
||
|
|
for (unsigned int j = 0; j < T::dimensions(); j++)
|
||
|
|
{
|
||
|
|
T max(0);
|
||
|
|
max[j] = 1;
|
||
|
|
|
||
|
|
IMATH_INTERNAL_NAMESPACE::Box<T> b(T(0), max);
|
||
|
|
assert(b.majorAxis() == j);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
} // anonymous namespace
|
||
|
|
|
||
|
|
|
||
|
|
void
|
||
|
|
testBox()
|
||
|
|
{
|
||
|
|
cout << "Testing box methods" << endl;
|
||
|
|
|
||
|
|
//
|
||
|
|
// Constructors
|
||
|
|
//
|
||
|
|
testConstructors<IMATH_INTERNAL_NAMESPACE::V2s>("V2s");
|
||
|
|
testConstructors<IMATH_INTERNAL_NAMESPACE::V2i>("V2i");
|
||
|
|
testConstructors<IMATH_INTERNAL_NAMESPACE::V2f>("V2f");
|
||
|
|
testConstructors<IMATH_INTERNAL_NAMESPACE::V2d>("V2d");
|
||
|
|
|
||
|
|
testConstructors<IMATH_INTERNAL_NAMESPACE::V3s>("V3s");
|
||
|
|
testConstructors<IMATH_INTERNAL_NAMESPACE::V3i>("V3i");
|
||
|
|
testConstructors<IMATH_INTERNAL_NAMESPACE::V3f>("V3f");
|
||
|
|
testConstructors<IMATH_INTERNAL_NAMESPACE::V3d>("V3d");
|
||
|
|
|
||
|
|
testConstructors<IMATH_INTERNAL_NAMESPACE::V4s>("V4s");
|
||
|
|
testConstructors<IMATH_INTERNAL_NAMESPACE::V4i>("V4i");
|
||
|
|
testConstructors<IMATH_INTERNAL_NAMESPACE::V4f>("V4f");
|
||
|
|
testConstructors<IMATH_INTERNAL_NAMESPACE::V4d>("V4d");
|
||
|
|
|
||
|
|
//
|
||
|
|
// makeEmpty()
|
||
|
|
//
|
||
|
|
testMakeEmpty<IMATH_INTERNAL_NAMESPACE::V2s>("V2s");
|
||
|
|
testMakeEmpty<IMATH_INTERNAL_NAMESPACE::V2i>("V2i");
|
||
|
|
testMakeEmpty<IMATH_INTERNAL_NAMESPACE::V2f>("V2f");
|
||
|
|
testMakeEmpty<IMATH_INTERNAL_NAMESPACE::V2d>("V2d");
|
||
|
|
|
||
|
|
testMakeEmpty<IMATH_INTERNAL_NAMESPACE::V3s>("V3s");
|
||
|
|
testMakeEmpty<IMATH_INTERNAL_NAMESPACE::V3i>("V3i");
|
||
|
|
testMakeEmpty<IMATH_INTERNAL_NAMESPACE::V3f>("V3f");
|
||
|
|
testMakeEmpty<IMATH_INTERNAL_NAMESPACE::V3d>("V3d");
|
||
|
|
|
||
|
|
testMakeEmpty<IMATH_INTERNAL_NAMESPACE::V4s>("V4s");
|
||
|
|
testMakeEmpty<IMATH_INTERNAL_NAMESPACE::V4i>("V4i");
|
||
|
|
testMakeEmpty<IMATH_INTERNAL_NAMESPACE::V4f>("V4f");
|
||
|
|
testMakeEmpty<IMATH_INTERNAL_NAMESPACE::V4d>("V4d");
|
||
|
|
|
||
|
|
//
|
||
|
|
// makeInfinite()
|
||
|
|
//
|
||
|
|
testMakeInfinite<IMATH_INTERNAL_NAMESPACE::V2s>("V2s");
|
||
|
|
testMakeInfinite<IMATH_INTERNAL_NAMESPACE::V2i>("V2i");
|
||
|
|
testMakeInfinite<IMATH_INTERNAL_NAMESPACE::V2f>("V2f");
|
||
|
|
testMakeInfinite<IMATH_INTERNAL_NAMESPACE::V2d>("V2d");
|
||
|
|
|
||
|
|
testMakeInfinite<IMATH_INTERNAL_NAMESPACE::V3s>("V3s");
|
||
|
|
testMakeInfinite<IMATH_INTERNAL_NAMESPACE::V3i>("V3i");
|
||
|
|
testMakeInfinite<IMATH_INTERNAL_NAMESPACE::V3f>("V3f");
|
||
|
|
testMakeInfinite<IMATH_INTERNAL_NAMESPACE::V3d>("V3d");
|
||
|
|
|
||
|
|
testMakeInfinite<IMATH_INTERNAL_NAMESPACE::V4s>("V4s");
|
||
|
|
testMakeInfinite<IMATH_INTERNAL_NAMESPACE::V4i>("V4i");
|
||
|
|
testMakeInfinite<IMATH_INTERNAL_NAMESPACE::V4f>("V4f");
|
||
|
|
testMakeInfinite<IMATH_INTERNAL_NAMESPACE::V4d>("V4d");
|
||
|
|
|
||
|
|
//
|
||
|
|
// extendBy() (point)
|
||
|
|
//
|
||
|
|
testExtendByPoint<IMATH_INTERNAL_NAMESPACE::V2s>("V2s");
|
||
|
|
testExtendByPoint<IMATH_INTERNAL_NAMESPACE::V2i>("V2i");
|
||
|
|
testExtendByPoint<IMATH_INTERNAL_NAMESPACE::V2f>("V2f");
|
||
|
|
testExtendByPoint<IMATH_INTERNAL_NAMESPACE::V2d>("V2d");
|
||
|
|
|
||
|
|
testExtendByPoint<IMATH_INTERNAL_NAMESPACE::V3s>("V3s");
|
||
|
|
testExtendByPoint<IMATH_INTERNAL_NAMESPACE::V3i>("V3i");
|
||
|
|
testExtendByPoint<IMATH_INTERNAL_NAMESPACE::V3f>("V3f");
|
||
|
|
testExtendByPoint<IMATH_INTERNAL_NAMESPACE::V3d>("V3d");
|
||
|
|
|
||
|
|
testExtendByPoint<IMATH_INTERNAL_NAMESPACE::V4s>("V4s");
|
||
|
|
testExtendByPoint<IMATH_INTERNAL_NAMESPACE::V4i>("V4i");
|
||
|
|
testExtendByPoint<IMATH_INTERNAL_NAMESPACE::V4f>("V4f");
|
||
|
|
testExtendByPoint<IMATH_INTERNAL_NAMESPACE::V4d>("V4d");
|
||
|
|
|
||
|
|
//
|
||
|
|
// extendBy() box
|
||
|
|
//
|
||
|
|
testExtendByBox<IMATH_INTERNAL_NAMESPACE::V2s>("V2s");
|
||
|
|
testExtendByBox<IMATH_INTERNAL_NAMESPACE::V2i>("V2i");
|
||
|
|
testExtendByBox<IMATH_INTERNAL_NAMESPACE::V2f>("V2f");
|
||
|
|
testExtendByBox<IMATH_INTERNAL_NAMESPACE::V2d>("V2d");
|
||
|
|
|
||
|
|
testExtendByBox<IMATH_INTERNAL_NAMESPACE::V3s>("V3s");
|
||
|
|
testExtendByBox<IMATH_INTERNAL_NAMESPACE::V3i>("V3i");
|
||
|
|
testExtendByBox<IMATH_INTERNAL_NAMESPACE::V3f>("V3f");
|
||
|
|
testExtendByBox<IMATH_INTERNAL_NAMESPACE::V3d>("V3d");
|
||
|
|
|
||
|
|
testExtendByBox<IMATH_INTERNAL_NAMESPACE::V4s>("V4s");
|
||
|
|
testExtendByBox<IMATH_INTERNAL_NAMESPACE::V4i>("V4i");
|
||
|
|
testExtendByBox<IMATH_INTERNAL_NAMESPACE::V4f>("V4f");
|
||
|
|
testExtendByBox<IMATH_INTERNAL_NAMESPACE::V4d>("V4d");
|
||
|
|
|
||
|
|
//
|
||
|
|
// == and !==
|
||
|
|
//
|
||
|
|
testComparators<IMATH_INTERNAL_NAMESPACE::V2s>("V2s");
|
||
|
|
testComparators<IMATH_INTERNAL_NAMESPACE::V2i>("V2i");
|
||
|
|
testComparators<IMATH_INTERNAL_NAMESPACE::V2f>("V2f");
|
||
|
|
testComparators<IMATH_INTERNAL_NAMESPACE::V2d>("V2d");
|
||
|
|
|
||
|
|
testComparators<IMATH_INTERNAL_NAMESPACE::V3s>("V3s");
|
||
|
|
testComparators<IMATH_INTERNAL_NAMESPACE::V3i>("V3i");
|
||
|
|
testComparators<IMATH_INTERNAL_NAMESPACE::V3f>("V3f");
|
||
|
|
testComparators<IMATH_INTERNAL_NAMESPACE::V3d>("V3d");
|
||
|
|
|
||
|
|
testComparators<IMATH_INTERNAL_NAMESPACE::V4s>("V4s");
|
||
|
|
testComparators<IMATH_INTERNAL_NAMESPACE::V4i>("V4i");
|
||
|
|
testComparators<IMATH_INTERNAL_NAMESPACE::V4f>("V4f");
|
||
|
|
testComparators<IMATH_INTERNAL_NAMESPACE::V4d>("V4d");
|
||
|
|
|
||
|
|
//
|
||
|
|
// size()
|
||
|
|
//
|
||
|
|
testSize<IMATH_INTERNAL_NAMESPACE::V2s>("V2s");
|
||
|
|
testSize<IMATH_INTERNAL_NAMESPACE::V2i>("V2i");
|
||
|
|
testSize<IMATH_INTERNAL_NAMESPACE::V2f>("V2f");
|
||
|
|
testSize<IMATH_INTERNAL_NAMESPACE::V2d>("V2d");
|
||
|
|
|
||
|
|
testSize<IMATH_INTERNAL_NAMESPACE::V3s>("V3s");
|
||
|
|
testSize<IMATH_INTERNAL_NAMESPACE::V3i>("V3i");
|
||
|
|
testSize<IMATH_INTERNAL_NAMESPACE::V3f>("V3f");
|
||
|
|
testSize<IMATH_INTERNAL_NAMESPACE::V3d>("V3d");
|
||
|
|
|
||
|
|
testSize<IMATH_INTERNAL_NAMESPACE::V4s>("V4s");
|
||
|
|
testSize<IMATH_INTERNAL_NAMESPACE::V4i>("V4i");
|
||
|
|
testSize<IMATH_INTERNAL_NAMESPACE::V4f>("V4f");
|
||
|
|
testSize<IMATH_INTERNAL_NAMESPACE::V4d>("V4d");
|
||
|
|
|
||
|
|
//
|
||
|
|
// center()
|
||
|
|
//
|
||
|
|
testCenter<IMATH_INTERNAL_NAMESPACE::V2s>("V2s");
|
||
|
|
testCenter<IMATH_INTERNAL_NAMESPACE::V2i>("V2i");
|
||
|
|
testCenter<IMATH_INTERNAL_NAMESPACE::V2f>("V2f");
|
||
|
|
testCenter<IMATH_INTERNAL_NAMESPACE::V2d>("V2d");
|
||
|
|
|
||
|
|
testCenter<IMATH_INTERNAL_NAMESPACE::V3s>("V3s");
|
||
|
|
testCenter<IMATH_INTERNAL_NAMESPACE::V3i>("V3i");
|
||
|
|
testCenter<IMATH_INTERNAL_NAMESPACE::V3f>("V3f");
|
||
|
|
testCenter<IMATH_INTERNAL_NAMESPACE::V3d>("V3d");
|
||
|
|
|
||
|
|
testCenter<IMATH_INTERNAL_NAMESPACE::V4s>("V4s");
|
||
|
|
testCenter<IMATH_INTERNAL_NAMESPACE::V4i>("V4i");
|
||
|
|
testCenter<IMATH_INTERNAL_NAMESPACE::V4f>("V4f");
|
||
|
|
testCenter<IMATH_INTERNAL_NAMESPACE::V4d>("V4d");
|
||
|
|
|
||
|
|
//
|
||
|
|
// isEmpty()
|
||
|
|
//
|
||
|
|
testIsEmpty<IMATH_INTERNAL_NAMESPACE::V2s>("V2s");
|
||
|
|
testIsEmpty<IMATH_INTERNAL_NAMESPACE::V2i>("V2i");
|
||
|
|
testIsEmpty<IMATH_INTERNAL_NAMESPACE::V2f>("V2f");
|
||
|
|
testIsEmpty<IMATH_INTERNAL_NAMESPACE::V2d>("V2d");
|
||
|
|
|
||
|
|
testIsEmpty<IMATH_INTERNAL_NAMESPACE::V3s>("V3s");
|
||
|
|
testIsEmpty<IMATH_INTERNAL_NAMESPACE::V3i>("V3i");
|
||
|
|
testIsEmpty<IMATH_INTERNAL_NAMESPACE::V3f>("V3f");
|
||
|
|
testIsEmpty<IMATH_INTERNAL_NAMESPACE::V3d>("V3d");
|
||
|
|
|
||
|
|
testIsEmpty<IMATH_INTERNAL_NAMESPACE::V4s>("V4s");
|
||
|
|
testIsEmpty<IMATH_INTERNAL_NAMESPACE::V4i>("V4i");
|
||
|
|
testIsEmpty<IMATH_INTERNAL_NAMESPACE::V4f>("V4f");
|
||
|
|
testIsEmpty<IMATH_INTERNAL_NAMESPACE::V4d>("V4d");
|
||
|
|
|
||
|
|
//
|
||
|
|
// isInfinite()
|
||
|
|
//
|
||
|
|
testIsInfinite<IMATH_INTERNAL_NAMESPACE::V2s>("V2s");
|
||
|
|
testIsInfinite<IMATH_INTERNAL_NAMESPACE::V2i>("V2i");
|
||
|
|
testIsInfinite<IMATH_INTERNAL_NAMESPACE::V2f>("V2f");
|
||
|
|
testIsInfinite<IMATH_INTERNAL_NAMESPACE::V2d>("V2d");
|
||
|
|
|
||
|
|
testIsInfinite<IMATH_INTERNAL_NAMESPACE::V3s>("V3s");
|
||
|
|
testIsInfinite<IMATH_INTERNAL_NAMESPACE::V3i>("V3i");
|
||
|
|
testIsInfinite<IMATH_INTERNAL_NAMESPACE::V3f>("V3f");
|
||
|
|
testIsInfinite<IMATH_INTERNAL_NAMESPACE::V3d>("V3d");
|
||
|
|
|
||
|
|
testIsInfinite<IMATH_INTERNAL_NAMESPACE::V4s>("V4s");
|
||
|
|
testIsInfinite<IMATH_INTERNAL_NAMESPACE::V4i>("V4i");
|
||
|
|
testIsInfinite<IMATH_INTERNAL_NAMESPACE::V4f>("V4f");
|
||
|
|
testIsInfinite<IMATH_INTERNAL_NAMESPACE::V4d>("V4d");
|
||
|
|
|
||
|
|
//
|
||
|
|
// hasVolume()
|
||
|
|
//
|
||
|
|
testHasVolume<IMATH_INTERNAL_NAMESPACE::V2s>("V2s");
|
||
|
|
testHasVolume<IMATH_INTERNAL_NAMESPACE::V2i>("V2i");
|
||
|
|
testHasVolume<IMATH_INTERNAL_NAMESPACE::V2f>("V2f");
|
||
|
|
testHasVolume<IMATH_INTERNAL_NAMESPACE::V2d>("V2d");
|
||
|
|
|
||
|
|
testHasVolume<IMATH_INTERNAL_NAMESPACE::V3s>("V3s");
|
||
|
|
testHasVolume<IMATH_INTERNAL_NAMESPACE::V3i>("V3i");
|
||
|
|
testHasVolume<IMATH_INTERNAL_NAMESPACE::V3f>("V3f");
|
||
|
|
testHasVolume<IMATH_INTERNAL_NAMESPACE::V3d>("V3d");
|
||
|
|
|
||
|
|
testHasVolume<IMATH_INTERNAL_NAMESPACE::V4s>("V4s");
|
||
|
|
testHasVolume<IMATH_INTERNAL_NAMESPACE::V4i>("V4i");
|
||
|
|
testHasVolume<IMATH_INTERNAL_NAMESPACE::V4f>("V4f");
|
||
|
|
testHasVolume<IMATH_INTERNAL_NAMESPACE::V4d>("V4d");
|
||
|
|
|
||
|
|
//
|
||
|
|
// majorAxis()
|
||
|
|
//
|
||
|
|
testMajorAxis<IMATH_INTERNAL_NAMESPACE::V2s>("V2s");
|
||
|
|
testMajorAxis<IMATH_INTERNAL_NAMESPACE::V2i>("V2i");
|
||
|
|
testMajorAxis<IMATH_INTERNAL_NAMESPACE::V2f>("V2f");
|
||
|
|
testMajorAxis<IMATH_INTERNAL_NAMESPACE::V2d>("V2d");
|
||
|
|
|
||
|
|
testMajorAxis<IMATH_INTERNAL_NAMESPACE::V3s>("V3s");
|
||
|
|
testMajorAxis<IMATH_INTERNAL_NAMESPACE::V3i>("V3i");
|
||
|
|
testMajorAxis<IMATH_INTERNAL_NAMESPACE::V3f>("V3f");
|
||
|
|
testMajorAxis<IMATH_INTERNAL_NAMESPACE::V3d>("V3d");
|
||
|
|
|
||
|
|
testMajorAxis<IMATH_INTERNAL_NAMESPACE::V4s>("V4s");
|
||
|
|
testMajorAxis<IMATH_INTERNAL_NAMESPACE::V4i>("V4i");
|
||
|
|
testMajorAxis<IMATH_INTERNAL_NAMESPACE::V4f>("V4f");
|
||
|
|
testMajorAxis<IMATH_INTERNAL_NAMESPACE::V4d>("V4d");
|
||
|
|
|
||
|
|
cout << "ok\n" << endl;
|
||
|
|
}
|