void test_optparser ()
{
MySystem sys;
optparser (sys, "i=14");
OIIO_CHECK_EQUAL (sys.i, 14);
optparser (sys, "i=-28");
OIIO_CHECK_EQUAL (sys.i, -28);
optparser (sys, "f=6.28");
OIIO_CHECK_EQUAL (sys.f, 6.28f);
optparser (sys, "f=-56.0");
OIIO_CHECK_EQUAL (sys.f, -56.0f);
optparser (sys, "f=-1.");
OIIO_CHECK_EQUAL (sys.f, -1.0f);
optparser (sys, "s=foo");
OIIO_CHECK_EQUAL (sys.s, "foo");
optparser (sys, "s=\"foo, bar\"");
OIIO_CHECK_EQUAL (sys.s, "foo, bar");
optparser (sys, "f=256.29,s=\"phone call\",i=100");
OIIO_CHECK_EQUAL (sys.i, 100);
OIIO_CHECK_EQUAL (sys.f, 256.29f);
OIIO_CHECK_EQUAL (sys.s, "phone call");
}
// Test ImageBuf::crop
void test_crop ()
{
int WIDTH = 8, HEIGHT = 6, CHANNELS = 4;
// Crop region we'll work with
int xbegin = 3, xend = 5, ybegin = 0, yend = 4;
ImageSpec spec (WIDTH, HEIGHT, CHANNELS, TypeDesc::FLOAT);
spec.alpha_channel = 3;
ImageBuf A, B;
A.reset ("A", spec);
B.reset ("B", spec);
float arbitrary1[4];
arbitrary1[0] = 0.2;
arbitrary1[1] = 0.3;
arbitrary1[2] = 0.4;
arbitrary1[3] = 0.5;
ImageBufAlgo::fill (A, arbitrary1);
// Test CUT crop
ImageBufAlgo::crop (B, A, xbegin, xend, ybegin, yend);
// Should have changed the data window (origin and width/height)
OIIO_CHECK_EQUAL (B.spec().x, xbegin);
OIIO_CHECK_EQUAL (B.spec().width, xend-xbegin);
OIIO_CHECK_EQUAL (B.spec().y, ybegin);
OIIO_CHECK_EQUAL (B.spec().height, yend-ybegin);
float *pixel = ALLOCA(float, CHANNELS);
for (int j = 0; j < B.spec().height; ++j) {
for (int i = 0; i < B.spec().width; ++i) {
B.getpixel (i+B.xbegin(), j+B.ybegin(), pixel);
// Inside the crop region should match what it always was
for (int c = 0; c < CHANNELS; ++c)
OIIO_CHECK_EQUAL (pixel[c], arbitrary1[c]);
}
}
}
// Tests ImageBuf construction from application buffer
void ImageBuf_test_appbuffer ()
{
const int WIDTH = 8;
const int HEIGHT = 8;
const int CHANNELS = 1;
static float buf[HEIGHT][WIDTH] = {
{ 0, 0, 0, 0, 1, 0, 0, 0 },
{ 0, 0, 0, 1, 0, 1, 0, 0 },
{ 0, 0, 1, 0, 0, 0, 1, 0 },
{ 0, 1, 0, 0, 0, 0, 0, 1 },
{ 0, 0, 1, 0, 0, 0, 1, 0 },
{ 0, 0, 0, 1, 0, 1, 0, 0 },
{ 0, 0, 0, 0, 1, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0 }
};
ImageSpec spec (WIDTH, HEIGHT, CHANNELS, TypeDesc::FLOAT);
ImageBuf A (spec, buf);
// Make sure A now points to the buffer
OIIO_CHECK_EQUAL ((void *)A.pixeladdr (0, 0, 0), (void *)buf);
// write it
A.write ("A.tif");
// Read it back and make sure it matches the original
ImageBuf B ("A.tif");
for (int y = 0; y < HEIGHT; ++y)
for (int x = 0; x < WIDTH; ++x)
OIIO_CHECK_EQUAL (A.getchannel (x, y, 0, 0),
B.getchannel (x, y, 0, 0));
}
void test_filename_searchpath_find ()
{
#if _WIN32
# define SEPARATOR "\\"
#else
# define SEPARATOR "/"
#endif
// This will be run via testsuite/unit_filesystem, from the
// build/ARCH/src/libOpenImageIO directory. Two levels up will be
// build/ARCH.
std::vector<std::string> dirs;
dirs.push_back (".." SEPARATOR "..");
std::string s;
// non-recursive search success
s = Filesystem::searchpath_find ("License.txt", dirs, false, false);
OIIO_CHECK_EQUAL (s, ".." SEPARATOR ".." SEPARATOR "License.txt");
// non-recursive search failure (file is in a subdirectory)
s = Filesystem::searchpath_find ("oiioversion.h", dirs, false, false);
OIIO_CHECK_EQUAL (s, "");
// recursive search success (file is in a subdirectory)
s = Filesystem::searchpath_find ("oiioversion.h", dirs, false, true);
OIIO_CHECK_EQUAL (s, ".." SEPARATOR ".." SEPARATOR "include" SEPARATOR "OpenImageIO" SEPARATOR "oiioversion.h");
}
void test_escape_sequences ()
{
OIIO_CHECK_EQUAL (Strutil::unescape_chars("\\\\ \\n \\r \\017"),
"\\ \n \r \017");
OIIO_CHECK_EQUAL (Strutil::escape_chars("\\ \n \r"),
"\\\\ \\n \\r");
}
// Tests ImageBufAlgo::add
void ImageBuf_add ()
{
const int WIDTH = 8;
const int HEIGHT = 8;
const int CHANNELS = 4;
ImageSpec spec (WIDTH, HEIGHT, CHANNELS, TypeDesc::FLOAT);
spec.alpha_channel = 3;
// Create buffers
ImageBuf A ("A", spec);
const float Aval[CHANNELS] = { 0.1, 0.2, 0.3, 0.4 };
ImageBufAlgo::fill (A, Aval);
ImageBuf B ("B", spec);
const float Bval[CHANNELS] = { 0.01, 0.02, 0.03, 0.04 };
ImageBufAlgo::fill (B, Bval);
ImageBuf C ("C", spec);
ImageBufAlgo::add (C, A, B);
for (int j = 0; j < HEIGHT; ++j) {
for (int i = 0; i < WIDTH; ++i) {
float pixel[CHANNELS];
C.getpixel (i, j, pixel);
for (int c = 0; c < CHANNELS; ++c)
OIIO_CHECK_EQUAL (pixel[c], Aval[c]+Bval[c]);
}
}
}
void test_filename_decomposition ()
{
std::cout << "filename(\"/directory/filename.ext\") = "
<< Filesystem::filename("/directory/filename.ext") << "\n";
OIIO_CHECK_EQUAL (Filesystem::filename("/directory/filename.ext"),
"filename.ext");
std::cout << "extension(\"/directory/filename.ext\") = "
<< Filesystem::extension("/directory/filename.ext") << "\n";
OIIO_CHECK_EQUAL (Filesystem::extension("/directory/filename.ext"),
".ext");
OIIO_CHECK_EQUAL (Filesystem::extension("/directory/filename"),
"");
OIIO_CHECK_EQUAL (Filesystem::extension("/directory/filename."),
".");
}
void
test_wrapmodes ()
{
const int ori = 0;
const int w = 4;
static int
val[] = {-7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -10},
cla[] = { 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 3, 3, 3, 3, 3, 3},
per[] = { 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1},
mir[] = { 1, 2, 3, 3, 2, 1, 0, 0, 1, 2, 3, 3, 2, 1, 0, 0, 1};
for (int i = 0; val[i] > -10; ++i) {
OIIO_CHECK_EQUAL (test_wrap (wrap_clamp, val[i], ori, w), cla[i]);
OIIO_CHECK_EQUAL (test_wrap (wrap_periodic, val[i], ori, w), per[i]);
OIIO_CHECK_EQUAL (test_wrap (wrap_periodic_pow2, val[i], ori, w), per[i]);
OIIO_CHECK_EQUAL (test_wrap (wrap_mirror, val[i], ori, w), mir[i]);
}
}
// Tests histogram computation.
void histogram_computation_test ()
{
const int INPUT_WIDTH = 64;
const int INPUT_HEIGHT = 64;
const int INPUT_CHANNEL = 0;
const int HISTOGRAM_BINS = 256;
const int SPIKE1 = 51; // 0.2f in range 0->1 maps to 51 in range 0->255
const int SPIKE2 = 128; // 0.5f in range 0->1 maps to 128 in range 0->255
const int SPIKE3 = 204; // 0.8f in range 0->1 maps to 204 in range 0->255
const int SPIKE1_COUNT = INPUT_WIDTH * 8;
const int SPIKE2_COUNT = INPUT_WIDTH * 16;
const int SPIKE3_COUNT = INPUT_WIDTH * 40;
// Create input image with three regions with different pixel values.
ImageSpec spec (INPUT_WIDTH, INPUT_HEIGHT, 1, TypeDesc::FLOAT);
ImageBuf A (spec);
float value[] = {0.2f};
ImageBufAlgo::fill (A, value, ROI(0, INPUT_WIDTH, 0, 8));
value[0] = 0.5f;
ImageBufAlgo::fill (A, value, ROI(0, INPUT_WIDTH, 8, 24));
value[0] = 0.8f;
ImageBufAlgo::fill (A, value, ROI(0, INPUT_WIDTH, 24, 64));
// Compute A's histogram.
std::vector<imagesize_t> hist;
ImageBufAlgo::histogram (A, INPUT_CHANNEL, hist, HISTOGRAM_BINS);
// Does the histogram size equal the number of bins?
OIIO_CHECK_EQUAL (hist.size(), (imagesize_t)HISTOGRAM_BINS);
// Are the histogram values as expected?
OIIO_CHECK_EQUAL (hist[SPIKE1], (imagesize_t)SPIKE1_COUNT);
OIIO_CHECK_EQUAL (hist[SPIKE2], (imagesize_t)SPIKE2_COUNT);
OIIO_CHECK_EQUAL (hist[SPIKE3], (imagesize_t)SPIKE3_COUNT);
for (int i = 0; i < HISTOGRAM_BINS; i++)
if (i!=SPIKE1 && i!=SPIKE2 && i!=SPIKE3)
OIIO_CHECK_EQUAL (hist[i], 0);
}
// Tests ImageBufAlgo::compare
void test_compare ()
{
std::cout << "test compare\n";
// Construct two identical 50% grey images
const int WIDTH = 10, HEIGHT = 10, CHANNELS = 3;
ImageSpec spec (WIDTH, HEIGHT, CHANNELS, TypeDesc::FLOAT);
ImageBuf A ("A", spec);
ImageBuf B ("B", spec);
const float grey[CHANNELS] = { 0.5, 0.5, 0.5 };
ImageBufAlgo::fill (A, grey);
ImageBufAlgo::fill (B, grey);
// Introduce some minor differences
const int NDIFFS = 10;
ImageBuf::Iterator<float> a (A);
for (int i = 0; i < NDIFFS && a.valid(); ++i, ++a) {
for (int c = 0; c < CHANNELS; ++c)
a[c] = a[c] + 0.01f * i;
}
// We expect the differences to be { 0, 0.01, 0.02, 0.03, 0.04, 0.05,
// 0.06, 0.07, 0.08, 0.09, 0, 0, ...}.
const float failthresh = 0.05;
const float warnthresh = 0.025;
ImageBufAlgo::CompareResults comp;
ImageBufAlgo::compare (A, B, failthresh, warnthresh, comp);
// We expect 5 pixels to exceed the fail threshold, 7 pixels to
// exceed the warn threshold, the maximum difference to be 0.09,
// and the maximally different pixel to be (9,0).
// The total error should be 3 chans * sum{0.01,...,0.09} / (pixels*chans)
// = 3 * 0.45 / (100*3) = 0.0045
std::cout << "Testing comparison: " << comp.nfail << " failed, "
<< comp.nwarn << " warned, max diff = " << comp.maxerror
<< " @ (" << comp.maxx << ',' << comp.maxy << ")\n";
std::cout << " mean err " << comp.meanerror << ", RMS err "
<< comp.rms_error << ", PSNR = " << comp.PSNR << "\n";
OIIO_CHECK_EQUAL (comp.nfail, 5);
OIIO_CHECK_EQUAL (comp.nwarn, 7);
OIIO_CHECK_EQUAL_THRESH (comp.maxerror, 0.09, 1e-6);
OIIO_CHECK_EQUAL (comp.maxx, 9);
OIIO_CHECK_EQUAL (comp.maxy, 0);
OIIO_CHECK_EQUAL_THRESH (comp.meanerror, 0.0045, 1.0e-8);
}
void test_open_with_config ()
{
// N.B. This function must run after ImageBuf_test_appbuffer, which
// writes "A.tif".
ImageCache *ic = ImageCache::create(false);
ImageSpec config;
config.attribute ("oiio:DebugOpenConfig!", 1);
ImageBuf A ("A.tif", 0, 0, ic, &config);
OIIO_CHECK_EQUAL (A.spec().get_int_attribute("oiio:DebugOpenConfig!",0), 42);
ic->destroy (ic);
}
void test_atomic_int64 ()
{
all = 0;
boost::thread_group threads;
for (int i = 0; i < numthreads; ++i) {
threads.create_thread (&do_int64_math);
}
threads.join_all ();
do_int64_math ();
OIIO_CHECK_EQUAL (all, 0);
}
void test_channel_append ()
{
std::cout << "test channel_append\n";
ImageSpec spec (2, 2, 1, TypeDesc::FLOAT);
ImageBuf A ("A", spec);
ImageBuf B ("B", spec);
float Acolor = 0.1, Bcolor = 0.2;
ImageBufAlgo::fill (A, &Acolor);
ImageBufAlgo::fill (B, &Bcolor);
ImageBuf R ("R");
ImageBufAlgo::channel_append (R, A, B);
OIIO_CHECK_EQUAL (R.spec().width, spec.width);
OIIO_CHECK_EQUAL (R.spec().height, spec.height);
OIIO_CHECK_EQUAL (R.nchannels(), 2);
for (ImageBuf::ConstIterator<float> r(R); !r.done(); ++r) {
OIIO_CHECK_EQUAL (r[0], Acolor);
OIIO_CHECK_EQUAL (r[1], Bcolor);
}
}
void test_atomic_int64 (int numthreads, int iterations)
{
all = 0;
thread_group threads;
for (int i = 0; i < numthreads; ++i) {
threads.create_thread (do_int64_math, iterations);
}
threads.join_all ();
OIIO_CHECK_EQUAL (all, 0);
// Test and, or, xor
all = 42;
all &= 15; OIIO_CHECK_EQUAL (all, 10);
all |= 6; OIIO_CHECK_EQUAL (all, 14);
all ^= 31; OIIO_CHECK_EQUAL (all, 17);
all = 42;
long long tmp;
tmp = all.fetch_and(15); OIIO_CHECK_EQUAL(tmp,42); OIIO_CHECK_EQUAL(all,10);
tmp = all.fetch_or ( 6); OIIO_CHECK_EQUAL(tmp,10); OIIO_CHECK_EQUAL(all,14);
tmp = all.fetch_xor(31); OIIO_CHECK_EQUAL(tmp,14); OIIO_CHECK_EQUAL(all,17);
}
void test_atomic_int (int numthreads, int iterations)
{
ai = 42;
thread_group threads;
for (int i = 0; i < numthreads; ++i) {
threads.create_thread (do_int_math, iterations);
}
ASSERT ((int)threads.size() == numthreads);
threads.join_all ();
OIIO_CHECK_EQUAL (ai, 42);
// Test and, or, xor
ai &= 15; OIIO_CHECK_EQUAL (ai, 10);
ai |= 6; OIIO_CHECK_EQUAL (ai, 14);
ai ^= 31; OIIO_CHECK_EQUAL (ai, 17);
ai = 42;
int tmp;
tmp = ai.fetch_and(15); OIIO_CHECK_EQUAL(tmp,42); OIIO_CHECK_EQUAL(ai,10);
tmp = ai.fetch_or ( 6); OIIO_CHECK_EQUAL(tmp,10); OIIO_CHECK_EQUAL(ai,14);
tmp = ai.fetch_xor(31); OIIO_CHECK_EQUAL(tmp,14); OIIO_CHECK_EQUAL(ai,17);
}
void test_bit_range_convert ()
{
OIIO_CHECK_EQUAL ((bit_range_convert<10,16>(1023)), 65535);
OIIO_CHECK_EQUAL ((bit_range_convert<2,8>(3)), 255);
OIIO_CHECK_EQUAL ((bit_range_convert<8,8>(255)), 255);
OIIO_CHECK_EQUAL ((bit_range_convert<16,10>(65535)), 1023);
OIIO_CHECK_EQUAL ((bit_range_convert<2,20>(3)), 1048575);
OIIO_CHECK_EQUAL ((bit_range_convert<20,2>(1048575)), 3);
OIIO_CHECK_EQUAL ((bit_range_convert<20,21>(1048575)), 2097151);
OIIO_CHECK_EQUAL ((bit_range_convert<32,32>(4294967295U)), 4294967295U);
OIIO_CHECK_EQUAL ((bit_range_convert<32,16>(4294967295U)), 65535);
// These are not expected to work, since bit_range_convert only takes a
// regular 'unsigned int' as parameter. If we need >32 bit conversion,
// we need to add a uint64_t version of bit_range_convert.
// OIIO_CHECK_EQUAL ((bit_range_convert<33,16>(8589934591)), 65535);
// OIIO_CHECK_EQUAL ((bit_range_convert<33,33>(8589934591)), 8589934591);
// OIIO_CHECK_EQUAL ((bit_range_convert<64,32>(18446744073709551615)), 4294967295);
}
static void
test_seq (const char *str, const char *expected)
{
std::vector<int> sequence;
Filesystem::enumerate_sequence (str, sequence);
std::stringstream joined;
for (size_t i = 0; i < sequence.size(); ++i) {
if (i)
joined << " ";
joined << sequence[i];
}
std::cout << " \"" << str << "\" -> " << joined.str() << "\n";
OIIO_CHECK_EQUAL (joined.str(), std::string(expected));
}
void test_atomic_int ()
{
#if (BOOST_VERSION >= 103500)
std::cout << "hw threads = " << boost::thread::hardware_concurrency() << "\n";
#endif
ai = 42;
boost::thread_group threads;
for (int i = 0; i < numthreads; ++i) {
threads.create_thread (&do_int_math);
}
std::cout << "Created " << threads.size() << " threads\n";
threads.join_all ();
OIIO_CHECK_EQUAL (ai, 42);
}
void benchmark_convert_type ()
{
const size_t size = 10000000;
const S testval(1.0);
std::vector<S> svec (size, testval);
std::vector<D> dvec (size);
std::cout << Strutil::format("Benchmark conversion of %6s -> %6s : ",
TypeDesc(BaseTypeFromC<S>::value),
TypeDesc(BaseTypeFromC<D>::value));
float time = time_trial (bind (do_convert_type<S,D>, OIIO::cref(svec), OIIO::ref(dvec)),
ntrials, iterations) / iterations;
std::cout << Strutil::format ("%7.1f Mvals/sec", (size/1.0e6)/time) << std::endl;
D r = convert_type<S,D>(testval);
OIIO_CHECK_EQUAL (dvec[size-1], r);
}
void test_paste ()
{
std::cout << "test paste\n";
// Create the source image, make it a gradient
ImageSpec Aspec (4, 4, 3, TypeDesc::FLOAT);
ImageBuf A ("A", Aspec);
for (ImageBuf::Iterator<float> it (A); !it.done(); ++it) {
it[0] = float(it.x()) / float(Aspec.width-1);
it[1] = float(it.y()) / float(Aspec.height-1);
it[2] = 0.1f;
}
// Create destination image -- black it out
ImageSpec Bspec (8, 8, 3, TypeDesc::FLOAT);
ImageBuf B ("B", Bspec);
float gray[3] = { .1, .1, .1 };
ImageBufAlgo::fill (B, gray);
// Paste a few pixels from A into B -- include offsets
ImageBufAlgo::paste (B, 2, 2, 0, 1 /* chan offset */,
A, ROI(1, 4, 1, 4));
// Spot check
float a[3], b[3];
B.getpixel (1, 1, 0, b);
OIIO_CHECK_EQUAL (b[0], gray[0]);
OIIO_CHECK_EQUAL (b[1], gray[1]);
OIIO_CHECK_EQUAL (b[2], gray[2]);
B.getpixel (2, 2, 0, b);
A.getpixel (1, 1, 0, a);
OIIO_CHECK_EQUAL (b[0], gray[0]);
OIIO_CHECK_EQUAL (b[1], a[0]);
OIIO_CHECK_EQUAL (b[2], a[1]);
B.getpixel (3, 4, 0, b);
A.getpixel (2, 3, 0, a);
OIIO_CHECK_EQUAL (b[0], gray[0]);
OIIO_CHECK_EQUAL (b[1], a[0]);
OIIO_CHECK_EQUAL (b[2], a[1]);
}
void
check_transfer(const ImageBuf &in, const float *table, int size) {
// skip the first pixel which will be an invalid negative luminance
// value, this value is just to test the fwd transfer doesn't create
// nan's.
float *pixel = ALLOCA(float, CHANNELS);
for (int y = 1; y < STEPS; y++) {
in.getpixel (0, y, pixel);
for (int c = 0; c < CHANNELS; ++c) {
if (c == in.spec().alpha_channel ||
c == in.spec().z_channel)
OIIO_CHECK_EQUAL (pixel[c], ALPHA);
else
OIIO_CHECK_ASSERT (is_equal(pixel[c], table[y]));
}
}
}
// Test ImageBuf::zero and ImageBuf::fill
void ImageBuf_zero_fill ()
{
const int WIDTH = 8;
const int HEIGHT = 6;
const int CHANNELS = 4;
ImageSpec spec (WIDTH, HEIGHT, CHANNELS, TypeDesc::FLOAT);
spec.alpha_channel = 3;
// Create a buffer -- pixels should be undefined
ImageBuf A ("A", spec);
// Set a pixel to an odd value, make sure it takes
const float arbitrary1[CHANNELS] = { 0.2, 0.3, 0.4, 0.5 };
A.setpixel (1, 1, arbitrary1);
float pixel[CHANNELS]; // test pixel
A.getpixel (1, 1, pixel);
for (int c = 0; c < CHANNELS; ++c)
OIIO_CHECK_EQUAL (pixel[c], arbitrary1[c]);
// Zero out and test that it worked
ImageBufAlgo::zero (A);
for (int j = 0; j < HEIGHT; ++j) {
for (int i = 0; i < WIDTH; ++i) {
float pixel[CHANNELS];
A.getpixel (i, j, pixel);
for (int c = 0; c < CHANNELS; ++c)
OIIO_CHECK_EQUAL (pixel[c], 0.0f);
}
}
// Test fill of whole image
const float arbitrary2[CHANNELS] = { 0.6, 0.7, 0.3, 0.9 };
ImageBufAlgo::fill (A, arbitrary2);
for (int j = 0; j < HEIGHT; ++j) {
for (int i = 0; i < WIDTH; ++i) {
float pixel[CHANNELS];
A.getpixel (i, j, pixel);
for (int c = 0; c < CHANNELS; ++c)
OIIO_CHECK_EQUAL (pixel[c], arbitrary2[c]);
}
}
// Test fill of partial image
const float arbitrary3[CHANNELS] = { 0.42, 0.43, 0.44, 0.45 };
{
const int xbegin = 3, xend = 5, ybegin = 0, yend = 4;
ImageBufAlgo::fill (A, arbitrary3, xbegin, xend, ybegin, yend);
for (int j = 0; j < HEIGHT; ++j) {
for (int i = 0; i < WIDTH; ++i) {
float pixel[CHANNELS];
A.getpixel (i, j, pixel);
if (j >= ybegin && j < yend && i >= xbegin && i < xend) {
for (int c = 0; c < CHANNELS; ++c)
OIIO_CHECK_EQUAL (pixel[c], arbitrary3[c]);
} else {
for (int c = 0; c < CHANNELS; ++c)
OIIO_CHECK_EQUAL (pixel[c], arbitrary2[c]);
}
}
}
}
}
void
test_int_helpers ()
{
std::cout << "\ntest_int_helpers\n";
// ispow2
for (int i = 1; i < (1<<30); i *= 2) {
OIIO_CHECK_ASSERT (ispow2(i));
if (i > 1)
OIIO_CHECK_ASSERT (! ispow2(i+1));
}
OIIO_CHECK_ASSERT (ispow2(int(0)));
OIIO_CHECK_ASSERT (! ispow2(-1));
OIIO_CHECK_ASSERT (! ispow2(-2));
// ispow2, try size_t, which is unsigned
for (size_t i = 1; i < (1<<30); i *= 2) {
OIIO_CHECK_ASSERT (ispow2(i));
if (i > 1)
OIIO_CHECK_ASSERT (! ispow2(i+1));
}
OIIO_CHECK_ASSERT (ispow2((unsigned int)0));
// pow2roundup
OIIO_CHECK_EQUAL (pow2roundup(4), 4);
OIIO_CHECK_EQUAL (pow2roundup(5), 8);
OIIO_CHECK_EQUAL (pow2roundup(6), 8);
OIIO_CHECK_EQUAL (pow2roundup(7), 8);
OIIO_CHECK_EQUAL (pow2roundup(8), 8);
// pow2rounddown
OIIO_CHECK_EQUAL (pow2rounddown(4), 4);
OIIO_CHECK_EQUAL (pow2rounddown(5), 4);
OIIO_CHECK_EQUAL (pow2rounddown(6), 4);
OIIO_CHECK_EQUAL (pow2rounddown(7), 4);
OIIO_CHECK_EQUAL (pow2rounddown(8), 8);
// round_to_multiple
OIIO_CHECK_EQUAL (round_to_multiple(1, 5), 5);
OIIO_CHECK_EQUAL (round_to_multiple(2, 5), 5);
OIIO_CHECK_EQUAL (round_to_multiple(3, 5), 5);
OIIO_CHECK_EQUAL (round_to_multiple(4, 5), 5);
OIIO_CHECK_EQUAL (round_to_multiple(5, 5), 5);
OIIO_CHECK_EQUAL (round_to_multiple(6, 5), 10);
// round_to_multiple_of_pow2
OIIO_CHECK_EQUAL (round_to_multiple_of_pow2(int(1), 4), 4);
OIIO_CHECK_EQUAL (round_to_multiple_of_pow2(int(2), 4), 4);
OIIO_CHECK_EQUAL (round_to_multiple_of_pow2(int(3), 4), 4);
OIIO_CHECK_EQUAL (round_to_multiple_of_pow2(int(4), 4), 4);
OIIO_CHECK_EQUAL (round_to_multiple_of_pow2(int(5), 4), 8);
// round_to_multiple_of_pow2
OIIO_CHECK_EQUAL (round_to_multiple_of_pow2(size_t(1), size_t(4)), 4);
OIIO_CHECK_EQUAL (round_to_multiple_of_pow2(size_t(2), size_t(4)), 4);
OIIO_CHECK_EQUAL (round_to_multiple_of_pow2(size_t(3), size_t(4)), 4);
OIIO_CHECK_EQUAL (round_to_multiple_of_pow2(size_t(4), size_t(4)), 4);
OIIO_CHECK_EQUAL (round_to_multiple_of_pow2(size_t(5), size_t(4)), 8);
}
void test_get_rest_arguments ()
{
int ret;
std::map <std::string, std::string> result;
std::string base;
std::string url = "someplace?arg1=value1&arg2=value2";
ret = Strutil::get_rest_arguments (url, base, result);
OIIO_CHECK_EQUAL (ret, true);
OIIO_CHECK_EQUAL (base, "someplace");
OIIO_CHECK_EQUAL (result["arg1"], "value1");
OIIO_CHECK_EQUAL (result["arg2"], "value2");
OIIO_CHECK_EQUAL (result["arg3"], "");
result.clear();
url = "?arg1=value1&arg2=value2";
ret = Strutil::get_rest_arguments (url, base, result);
OIIO_CHECK_EQUAL (ret, true);
OIIO_CHECK_EQUAL (base, "");
OIIO_CHECK_EQUAL (result["arg1"], "value1");
OIIO_CHECK_EQUAL (result["arg2"], "value2");
result.clear();
url = "arg1=value1&arg2=value2";
ret = Strutil::get_rest_arguments (url, base, result);
OIIO_CHECK_EQUAL (ret, true);
OIIO_CHECK_EQUAL (base, "arg1=value1&arg2=value2");
OIIO_CHECK_EQUAL (result["arg1"], "");
OIIO_CHECK_EQUAL (result["arg2"], "");
result.clear();
url = "";
ret = Strutil::get_rest_arguments (url, base, result);
OIIO_CHECK_EQUAL (ret, true);
OIIO_CHECK_EQUAL (base, "");
OIIO_CHECK_EQUAL (result["arg1"], "");
OIIO_CHECK_EQUAL (result["arg2"], "");
result.clear();
url = "sometextwithoutasense????&&&&&arg4=val1";
ret = Strutil::get_rest_arguments (url, base, result);
OIIO_CHECK_EQUAL (ret, false);
OIIO_CHECK_EQUAL (base, "sometextwithoutasense");
OIIO_CHECK_EQUAL (result["arg1"], "");
OIIO_CHECK_EQUAL (result["arg2"], "");
OIIO_CHECK_EQUAL (result["arg4"], "");
result.clear();
url = "atext?arg1value1&arg2value2";
ret = Strutil::get_rest_arguments (url, base, result);
OIIO_CHECK_EQUAL (ret, false);
OIIO_CHECK_EQUAL (base, "atext");
OIIO_CHECK_EQUAL (result["arg1"], "");
OIIO_CHECK_EQUAL (result["arg2"], "");
result.clear();
url = "atext?arg1=value1&arg2value2";
result["arg2"] = "somevalue";
ret = Strutil::get_rest_arguments (url, base, result);
OIIO_CHECK_EQUAL (ret, false);
OIIO_CHECK_EQUAL (base, "atext");
OIIO_CHECK_EQUAL (result["arg1"], "value1");
OIIO_CHECK_EQUAL (result["arg2"], "somevalue");
}
void iterator_read_test ()
{
const int WIDTH = 4, HEIGHT = 4, CHANNELS = 3;
static float buf[HEIGHT][WIDTH][CHANNELS] = {
{ {0,0,0}, {1,0,1}, {2,0,2}, {3,0,3} },
{ {0,1,4}, {1,1,5}, {2,1,6}, {3,1,7} },
{ {0,2,8}, {1,2,9}, {2,2,10}, {3,2,11} },
{ {0,3,12}, {1,3,13}, {2,3,14}, {3,3,15} }
};
ImageSpec spec (WIDTH, HEIGHT, CHANNELS, TypeDesc::FLOAT);
ImageBuf A (spec, buf);
ITERATOR p (A);
OIIO_CHECK_EQUAL (p[0], 0.0f);
OIIO_CHECK_EQUAL (p[1], 0.0f);
OIIO_CHECK_EQUAL (p[2], 0.0f);
// Explicit position
p.pos (2, 1);
OIIO_CHECK_EQUAL (p.x(), 2); OIIO_CHECK_EQUAL (p.y(), 1);
OIIO_CHECK_EQUAL (p[0], 2.0f);
OIIO_CHECK_EQUAL (p[1], 1.0f);
OIIO_CHECK_EQUAL (p[2], 6.0f);
// Iterate a few times
++p;
OIIO_CHECK_EQUAL (p.x(), 3); OIIO_CHECK_EQUAL (p.y(), 1);
OIIO_CHECK_EQUAL (p[0], 3.0f);
OIIO_CHECK_EQUAL (p[1], 1.0f);
OIIO_CHECK_EQUAL (p[2], 7.0f);
++p;
OIIO_CHECK_EQUAL (p.x(), 0); OIIO_CHECK_EQUAL (p.y(), 2);
OIIO_CHECK_EQUAL (p[0], 0.0f);
OIIO_CHECK_EQUAL (p[1], 2.0f);
OIIO_CHECK_EQUAL (p[2], 8.0f);
std::cout << "iterator_read_test result:";
int i = 0;
for (ITERATOR p (A); !p.done(); ++p, ++i) {
if ((i % 4) == 0)
std::cout << "\n ";
std::cout << " " << p[0] << ' ' << p[1] << ' ' << p[2];
}
std::cout << "\n";
}
void iterator_wrap_test (ImageBuf::WrapMode wrap, std::string wrapname)
{
const int WIDTH = 4, HEIGHT = 4, CHANNELS = 3;
static float buf[HEIGHT][WIDTH][CHANNELS] = {
{ {0,0,0}, {1,0,1}, {2,0,2}, {3,0,3} },
{ {0,1,4}, {1,1,5}, {2,1,6}, {3,1,7} },
{ {0,2,8}, {1,2,9}, {2,2,10}, {3,2,11} },
{ {0,3,12}, {1,3,13}, {2,3,14}, {3,3,15} }
};
ImageSpec spec (WIDTH, HEIGHT, CHANNELS, TypeDesc::FLOAT);
ImageBuf A (spec, buf);
std::cout << "iterator_wrap_test " << wrapname << ":";
int i = 0;
int noutside = 0;
for (ITERATOR p (A, ROI(-2, WIDTH+2, -2, HEIGHT+2), wrap);
!p.done(); ++p, ++i) {
if ((i % 8) == 0)
std::cout << "\n ";
std::cout << " " << p[0] << ' ' << p[1] << ' ' << p[2];
// Check wraps
if (! p.exists()) {
++noutside;
if (wrap == ImageBuf::WrapBlack) {
OIIO_CHECK_EQUAL (p[0], 0.0f);
OIIO_CHECK_EQUAL (p[1], 0.0f);
OIIO_CHECK_EQUAL (p[2], 0.0f);
} else if (wrap == ImageBuf::WrapClamp) {
ITERATOR q = p;
q.pos (clamp (p.x(), 0, WIDTH-1), clamp (p.y(), 0, HEIGHT-1));
OIIO_CHECK_EQUAL (p[0], q[0]);
OIIO_CHECK_EQUAL (p[1], q[1]);
OIIO_CHECK_EQUAL (p[2], q[2]);
} else if (wrap == ImageBuf::WrapPeriodic) {
ITERATOR q = p;
q.pos (p.x() % WIDTH, p.y() % HEIGHT);
OIIO_CHECK_EQUAL (p[0], q[0]);
OIIO_CHECK_EQUAL (p[1], q[1]);
OIIO_CHECK_EQUAL (p[2], q[2]);
} else if (wrap == ImageBuf::WrapMirror) {
ITERATOR q = p;
int x = p.x(), y = p.y();
wrap_mirror (x, 0, WIDTH);
wrap_mirror (y, 0, HEIGHT);
q.pos (x, y);
OIIO_CHECK_EQUAL (p[0], q[0]);
OIIO_CHECK_EQUAL (p[1], q[1]);
OIIO_CHECK_EQUAL (p[2], q[2]);
}
}
}
std::cout << "\n";
OIIO_CHECK_EQUAL (noutside, 48); // Should be 48 wrapped pixels
}