void readArchive( const ABCA::ArchiveReaderPtr& iArchiveReader) { std::vector< ABCA::ObjectReaderPtr > objs; objs.push_back( iArchiveReader->getTop() ); TESTING_ASSERT( objs[0]->getNumChildren() == 2 ); objs.push_back( objs[0]->getChild(0) ); objs.push_back( objs[0]->getChild(1) ); std::size_t numObjs = objs.size(); for (std::size_t i = 1; i < numObjs; ++i) { TESTING_ASSERT( objs[i]->getNumChildren() == 3 ); for (std::size_t j = 0; j < numObjs; ++j) { objs.push_back( objs[i]->getChild(j) ); } } for (std::size_t i = 0; i < objs.size(); ++i) { TESTING_ASSERT( objs[i]->getProperties()->getNumProperties() == 3 ); ABCA::CompoundPropertyReaderPtr cpr = objs[i]->getProperties(); ABCA::ArrayPropertyReaderPtr apr = cpr->getArrayProperty("a"); TESTING_ASSERT( 0 == objs[i]->getProperties()->getArrayProperty("a")->getNumSamples() ); TESTING_ASSERT( 1 == objs[i]->getProperties()->getArrayProperty("b")->getNumSamples() ); TESTING_ASSERT( 2 == objs[i]->getProperties()->getArrayProperty("c")->getNumSamples() ); } TESTING_ASSERT( iArchiveReader->getMaxNumSamplesForTimeSamplingIndex(0) == 2 ); }
void testReadWriteEmptyArchive() { std::string archiveName = "emptyArchive.abc"; { AO::WriteArchive w; ABCA::MetaData m; m.set("Bleep", "bloop"); m.set("eep", ""); m.set("potato", "salad"); m.set("geoScope", "tasty"); ABCA::ArchiveWriterPtr a = w(archiveName, m); ABCA::ObjectWriterPtr archive = a->getTop(); TESTING_ASSERT(archive->getFullName() == "/"); Alembic::AbcCoreOgawa::ReadArchive r; // can't read an already open archive (for now) TESTING_ASSERT_THROW(r( archiveName ), Alembic::Util::Exception); } { AO::ReadArchive r; ABCA::ArchiveReaderPtr a = r( archiveName ); ABCA::ObjectReaderPtr archive = a->getTop(); ABCA::MetaData m = archive->getHeader().getMetaData(); TESTING_ASSERT(m.get("Bleep") == "bloop"); TESTING_ASSERT(m.get("eep") == ""); TESTING_ASSERT(m.get("potato") == "salad"); TESTING_ASSERT(m.get("geoScope") == "tasty"); TESTING_ASSERT(archive->getName() == "ABC"); TESTING_ASSERT(archive->getFullName() == "/"); TESTING_ASSERT(archive->getParent() == NULL); TESTING_ASSERT(archive->getNumChildren() == 0); // even though we didn't write anything make sure we intrincially have // the default sampling TESTING_ASSERT(a->getNumTimeSamplings() == 1); TESTING_ASSERT(*(a->getTimeSampling(0)) == ABCA::TimeSampling()); TESTING_ASSERT(a->getMaxNumSamplesForTimeSamplingIndex(0) == 0); ABCA::CompoundPropertyReaderPtr parent = archive->getProperties(); TESTING_ASSERT(parent->getNumProperties() == 0); // get it again to make sure we clean ourselves up properly AO::ReadArchive r2; ABCA::ArchiveReaderPtr a2 = r2( archiveName ); ABCA::ObjectReaderPtr archive2 = a2->getTop(); ABCA::CompoundPropertyReaderPtr p2 = archive2->getProperties(); TESTING_ASSERT(p2->getNumProperties() == 0); } }
void readArchive( const std::string & iName, std::istream * iStream ) { std::vector< std::istream * > streamVec; if (iStream) { streamVec.push_back(iStream); } Alembic::AbcCoreOgawa::ReadArchive r(streamVec); ABCA::ArchiveReaderPtr a = r( iName ); std::vector< ABCA::ObjectReaderPtr > objs; objs.push_back( a->getTop() ); TESTING_ASSERT( objs[0]->getNumChildren() == 2 ); objs.push_back( objs[0]->getChild(0) ); objs.push_back( objs[0]->getChild(1) ); std::size_t numObjs = objs.size(); for (std::size_t i = 1; i < numObjs; ++i) { TESTING_ASSERT( objs[i]->getNumChildren() == 3 ); for (std::size_t j = 0; j < numObjs; ++j) { objs.push_back( objs[i]->getChild(j) ); } } for (std::size_t i = 0; i < objs.size(); ++i) { TESTING_ASSERT( objs[i]->getProperties()->getNumProperties() == 3 ); ABCA::CompoundPropertyReaderPtr cpr = objs[i]->getProperties(); ABCA::ArrayPropertyReaderPtr apr = cpr->getArrayProperty("a"); TESTING_ASSERT( 0 == objs[i]->getProperties()->getArrayProperty("a")->getNumSamples() ); TESTING_ASSERT( 1 == objs[i]->getProperties()->getArrayProperty("b")->getNumSamples() ); TESTING_ASSERT( 2 == objs[i]->getProperties()->getArrayProperty("c")->getNumSamples() ); } TESTING_ASSERT( a->getMaxNumSamplesForTimeSamplingIndex(0) == 2 ); }
void testReadWriteEmptyArchive() { std::string archiveName = "emptyArchive.abc"; { A5::WriteArchive w; ABCA::MetaData m; m.set("Bleep", "bloop"); m.set("eep", ""); m.set("potato", "salad"); m.set("geoScope", "tasty"); ABCA::ArchiveWriterPtr a = w(archiveName, m); ABCA::ObjectWriterPtr archive = a->getTop(); TESTING_ASSERT(archive->getFullName() == "/"); // use this to get current reporting mechanism, then supress it // since we expect to see H5F errors because we will be trying to open // a file that is already open for writing. H5E_auto_t func; void * client_data; H5Eget_auto2(H5E_DEFAULT, &func, &client_data); H5Eset_auto2(H5E_DEFAULT, NULL, NULL); // can't write an already open archive TESTING_ASSERT_THROW(w(archiveName, ABCA::MetaData()), Alembic::Util::Exception); Alembic::AbcCoreHDF5::ReadArchive r; // can't read an already open archive TESTING_ASSERT_THROW(r( archiveName ), Alembic::Util::Exception); // turn the error reporting back on for later tests H5Eset_auto2(H5E_DEFAULT, func, client_data); } { A5::ReadArchive r; ABCA::ArchiveReaderPtr a = r( archiveName ); ABCA::ObjectReaderPtr archive = a->getTop(); ABCA::MetaData m = archive->getHeader().getMetaData(); TESTING_ASSERT(m.get("Bleep") == "bloop"); TESTING_ASSERT(m.get("eep") == ""); TESTING_ASSERT(m.get("potato") == "salad"); TESTING_ASSERT(m.get("geoScope") == "tasty"); TESTING_ASSERT(archive->getName() == "ABC"); TESTING_ASSERT(archive->getFullName() == "/"); TESTING_ASSERT(archive->getParent() == NULL); TESTING_ASSERT(archive->getNumChildren() == 0); // even though we didn't write anything make sure we intrincially have // the default sampling TESTING_ASSERT(a->getNumTimeSamplings() == 1); TESTING_ASSERT(*(a->getTimeSampling(0)) == ABCA::TimeSampling()); TESTING_ASSERT(a->getMaxNumSamplesForTimeSamplingIndex(0) == 0); ABCA::CompoundPropertyReaderPtr parent = archive->getProperties(); TESTING_ASSERT(parent->getNumProperties() == 0); // get it again to make sure we clean ourselves up properly A5::ReadArchive r2; ABCA::ArchiveReaderPtr a2 = r2( archiveName ); ABCA::ObjectReaderPtr archive2 = a2->getTop(); ABCA::CompoundPropertyReaderPtr p2 = archive2->getProperties(); TESTING_ASSERT(p2->getNumProperties() == 0); } }
//-***************************************************************************** void ReadTestArchive( const std::string &iArchiveName ) { // When opening an archive for reading, you can pass in a pointer to // an AbcA::ReadArraySampleCache, but if you don't, it will construct one // for you by default. If you don't want to cache, just pass in NULL // as the second argument. Alembic::AbcCoreHDF5::ReadArchive ar; AbcA::ArchiveReaderPtr arkive = ar( iArchiveName ); // Just stashing away a compound property reader pointer; we know the last // child object in our hierarchy has all the properties, because we created // it in the WriteTestArchive function. AbcA::CompoundPropertyReaderPtr fcProps; // Now do a depth-first traversal of our archive; this is a little ugly AbcA::ObjectReaderPtr tmpOrp1; AbcA::ObjectReaderPtr tmpOrp2 = arkive->getTop(); while ( true ) { tmpOrp1 = tmpOrp2; if ( tmpOrp1->getNumChildren() < 1 ) { std::cout << "Found my last lonely child, named " << tmpOrp1->getFullName() << std::endl; fcProps = tmpOrp1->getProperties(); std::cout << "It has " << fcProps->getNumProperties() << " sub-properties." << std::endl; break; } tmpOrp2 = tmpOrp1->getChild( 0 ); } // OK, fcProps is a shared pointer to the compound property reader that // was in the last child object of the archive. Let's get the simple // properties out of it. AbcA::ScalarPropertyReaderPtr sProp; AbcA::ArrayPropertyReaderPtr aProp0; AbcA::ArrayPropertyReaderPtr aProp1; for ( size_t i = 0 ; i < fcProps->getNumProperties() ; ++i ) { AbcA::BasePropertyReaderPtr bp = fcProps->getProperty( i ); std::cout << "Found " << bp->getName() << std::endl; if ( bp->isScalar() ) { sProp = bp->asScalarPtr(); std::cout << "sProp has " << sProp->getNumSamples() << " samples." << std::endl; } if ( bp->isArray() && bp->getName() == "secondInt32ArrayProp" ) { aProp1 = bp->asArrayPtr(); std::cout << "aProp1 has " << aProp1->getNumSamples() << " samples." << std::endl; } if ( bp->isArray() && bp->getName() == "firstInt32ArrayProp" ) { aProp0 = bp->asArrayPtr(); std::cout << "aProp0 has " << aProp0->getNumSamples() << " samples." << std::endl; } } // OK, now we have pointers to the two properties, one scalar, the other // array. Let's read the scalar one first. for ( size_t i = 0 ; i < sProp->getNumSamples() ; ++i ) { float32_t sVal = 0; sProp->getSample( i, (void*)(&sVal) ); TESTING_ASSERT( sVal == 42.0 ); std::cout << sProp->getName() << " at sample " << i << " has the value " << sVal << std::endl << std::endl; } // OK, now the first int array property. AbcA::ArraySamplePtr samp; std::cout << "FIRST INT ARRAY PROPERTY (Cyclic time sampling)" << std::endl; for ( size_t i = 0 ; i < aProp0->getNumSamples() ; ++i ) { aProp0->getSample( i, samp ); const AbcA::TimeSampling ts = aProp0->getTimeSampling(); size_t numPoints = samp->getDimensions().numPoints(); TESTING_ASSERT( (AbcA::chrono_t)i == ts.getSampleTime( i ) ); std::cout << "At Sample " << i << ", " << aProp0->getName() << " is at time " << ts.getSampleTime( i ) << " and has " << numPoints << " points, with the values: " << std::endl; int32_t *vals = (int32_t*)(samp->getData()); for ( size_t j = 0 ; j < numPoints ; ++j ) { TESTING_ASSERT( vals[j] == i + j ); std::cout << j << ": " << vals[j] << ", "; } std::cout << std::endl << std::endl; samp->reset(); } // now the second int array std::cout << "SECOND INT ARRAY PROPERTY (Acyclic time sampling)" << std::endl; for ( size_t i = 0 ; i < aProp1->getNumSamples() ; ++i ) { aProp1->getSample( i, samp ); const AbcA::TimeSampling ts = aProp1->getTimeSampling(); size_t numPoints = samp->getDimensions().numPoints(); std::cout << "At Sample " << i << ", " << aProp1->getName() << " is at time " << ts.getSampleTime( i ) << " and has " << numPoints << " points," << std::endl << "with the values: " << std::endl; int32_t *vals = (int32_t*)(samp->getData()); for ( size_t j = 0 ; j < numPoints ; ++j ) { TESTING_ASSERT( vals[j] == i + j ); std::cout << j << ": " << vals[j] << ", "; } std::cout << std::endl << std::endl; samp->reset(); } }
//-***************************************************************************** void testWeirdStringScalar() { std::string archiveName = "weirdStr.abc"; Alembic::Util::string weirdStr = "Total failure"; weirdStr[5] = '\0'; Alembic::Util::wstring weirdWstr = L"Failure is always an option"; weirdWstr[5] = L'\0'; std::vector < Alembic::Util::string > weirdStrArray(3); weirdStrArray[0] = "watch"; weirdStrArray[1] = "this"; weirdStrArray[2] = "please"; weirdStrArray[2][3] = '\0'; Alembic::Util::string empty; Alembic::Util::wstring wempty; std::vector < Alembic::Util::string > allEmptyStr(3); std::vector < Alembic::Util::string > partEmptyStr(6); partEmptyStr[0] = ""; partEmptyStr[1] = ""; partEmptyStr[2] = "notEmpty!"; partEmptyStr[3] = ""; partEmptyStr[4] = "also not empty"; partEmptyStr[5] = ""; { A5::WriteArchive w; AbcA::ArchiveWriterPtr a = w(archiveName, AbcA::MetaData()); AbcA::ObjectWriterPtr archive = a->getTop(); AbcA::CompoundPropertyWriterPtr props = archive->getProperties(); { AbcA::ScalarPropertyWriterPtr emptyWrtPtr = props->createScalarProperty("empty", AbcA::MetaData(), AbcA::DataType(Alembic::Util::kStringPOD, 1), 0); // this should fail because of the NULL char in the string TESTING_ASSERT_THROW(emptyWrtPtr->setSample(&weirdStr), Alembic::Util::Exception); emptyWrtPtr->setSample(&empty); AbcA::ScalarPropertyWriterPtr wemptyWrtPtr = props->createScalarProperty("wempty", AbcA::MetaData(), AbcA::DataType(Alembic::Util::kWstringPOD, 1), 0); // this should fail because of the NULL char in the string TESTING_ASSERT_THROW(wemptyWrtPtr->setSample(&weirdWstr), Alembic::Util::Exception); wemptyWrtPtr->setSample(&wempty); AbcA::ScalarPropertyWriterPtr allEmptyWrtPtr = props->createScalarProperty("allEmpty", AbcA::MetaData(), AbcA::DataType(Alembic::Util::kStringPOD, 3), 0); // one of the strings has a NULL char in it TESTING_ASSERT_THROW( allEmptyWrtPtr->setSample(&(weirdStrArray.front())), Alembic::Util::Exception); allEmptyWrtPtr->setSample(&(allEmptyStr.front())); AbcA::ScalarPropertyWriterPtr partEmptyStrPtr = props->createScalarProperty("partEmpty", AbcA::MetaData(), AbcA::DataType(Alembic::Util::kStringPOD, 6), 0); partEmptyStrPtr->setSample(&(partEmptyStr.front())); } } { A5::ReadArchive r; AbcA::ArchiveReaderPtr a = r( archiveName ); AbcA::ObjectReaderPtr archive = a->getTop(); AbcA::CompoundPropertyReaderPtr parent = archive->getProperties(); for (size_t i = 0; i < parent->getNumProperties(); ++i) { AbcA::BasePropertyReaderPtr bp = parent->getProperty( i ); if (bp->getName() == "partEmpty") { std::vector < Alembic::Util::string > val (6); AbcA::ScalarPropertyReaderPtr sp = bp->asScalarPtr(); TESTING_ASSERT(sp->getDataType().getExtent() == 6); sp->getSample(0, &(val.front())); TESTING_ASSERT(val == partEmptyStr); } else if (bp->getName() == "allEmpty") { std::vector < Alembic::Util::string > val (3); AbcA::ScalarPropertyReaderPtr sp = bp->asScalarPtr(); TESTING_ASSERT(sp->getDataType().getExtent() == 3); sp->getSample(0, &(val.front())); TESTING_ASSERT(val == allEmptyStr); } else if (bp->getName() == "empty") { Alembic::Util::string val; AbcA::ScalarPropertyReaderPtr sp = bp->asScalarPtr(); sp->getSample(0, &val); TESTING_ASSERT(val == empty); } else if (bp->getName() == "wempty") { Alembic::Util::wstring val; AbcA::ScalarPropertyReaderPtr sp = bp->asScalarPtr(); sp->getSample(0, &val); TESTING_ASSERT(val == wempty); } else { TESTING_ASSERT(false); } } } }
//-***************************************************************************** void testRepeatedScalarData() { std::string archiveName = "repeatScalarData.abc"; { A5::WriteArchive w; AbcA::ArchiveWriterPtr a = w(archiveName, AbcA::MetaData()); AbcA::ObjectWriterPtr archive = a->getTop(); AbcA::CompoundPropertyWriterPtr parent = archive->getProperties(); AbcA::ScalarPropertyWriterPtr swp = parent->createScalarProperty("int32", AbcA::MetaData(), AbcA::DataType(Alembic::Util::kInt32POD, 3), 0); std::vector <Alembic::Util::uint32_t> ui(3); ui[0] = 0; ui[1] = 1; ui[2] = 2; std::vector <Alembic::Util::uint32_t> ui2(3); ui2[0] = 41; ui2[1] = 43; ui2[2] = 47; swp->setSample(&(ui.front())); swp->setSample(&(ui.front())); swp->setSample(&(ui2.front())); swp->setSample(&(ui.front())); swp->setSample(&(ui2.front())); swp->setSample(&(ui2.front())); swp->setSample(&(ui2.front())); swp->setSample(&(ui.front())); swp->setSample(&(ui.front())); swp->setSample(&(ui.front())); AbcA::ScalarPropertyWriterPtr swp2 = parent->createScalarProperty("float32", AbcA::MetaData(), AbcA::DataType(Alembic::Util::kFloat32POD, 1), 0); Alembic::Util::float32_t f = 42.0; Alembic::Util::float32_t f2 = -3.0; swp2->setSample(&f); swp2->setSample(&f); swp2->setSample(&f); swp2->setSample(&f2); swp2->setSample(&f2); swp2->setSample(&f2); AbcA::ScalarPropertyWriterPtr swp3 = parent->createScalarProperty("uint16", AbcA::MetaData(), AbcA::DataType(Alembic::Util::kUint16POD, 1), 0); Alembic::Util::uint16_t ui16 = 17; swp3->setSample(&ui16); swp3->setSample(&ui16); swp3->setSample(&ui16); swp3->setSample(&ui16); AbcA::ScalarPropertyWriterPtr swp4 = parent->createScalarProperty("str", AbcA::MetaData(), AbcA::DataType(Alembic::Util::kStringPOD, 3), 0); std::vector < Alembic::Util::string > strVec(3); strVec[0] = "Please"; strVec[1] = ""; strVec[2] = "work"; std::vector < Alembic::Util::string > strVec2(3); strVec2[0] = "Whats"; strVec2[1] = "going"; strVec2[2] = "on?"; swp4->setSample(&(strVec.front())); swp4->setSample(&(strVec.front())); swp4->setSample(&(strVec2.front())); swp4->setSample(&(strVec2.front())); } { A5::ReadArchive r; AbcA::ArchiveReaderPtr a = r( archiveName ); AbcA::ObjectReaderPtr archive = a->getTop(); AbcA::CompoundPropertyReaderPtr parent = archive->getProperties(); TESTING_ASSERT(parent->getNumProperties() == 4); for (size_t i = 0; i < parent->getNumProperties(); ++i) { AbcA::BasePropertyReaderPtr bp = parent->getProperty( i ); AbcA::ScalarPropertyReaderPtr sp = bp->asScalarPtr(); switch (sp->getDataType().getPod()) { case Alembic::Util::kUint16POD: { TESTING_ASSERT( sp->getNumSamples() == 4 ); const AbcA::TimeSamplingPtr t = sp->getTimeSampling(); TESTING_ASSERT( sp->isConstant() ); Alembic::Util::uint16_t us; for ( size_t i = 0; i < sp->getNumSamples(); ++i ) { us = 0; sp->getSample( 0, &us); TESTING_ASSERT(us == 17); } } break; case Alembic::Util::kFloat32POD: { TESTING_ASSERT( sp->getNumSamples() == 6 ); TESTING_ASSERT( sp->getDataType().getExtent() == 1); TESTING_ASSERT( !sp->isConstant() ); Alembic::Util::float32_t f = 0; // make sure we can't get a non-existant sample TESTING_ASSERT_THROW(sp->getSample( 100, &f ), Alembic::Util::Exception); sp->getSample( 5, &f ); TESTING_ASSERT(f == -3.0); sp->getSample( 1, &f ); TESTING_ASSERT(f == 42.0); sp->getSample( 4, &f ); TESTING_ASSERT(f == -3.0); sp->getSample( 0, &f ); TESTING_ASSERT(f == 42.0); sp->getSample( 3, &f ); TESTING_ASSERT(f == -3.0); sp->getSample( 2, &f ); TESTING_ASSERT(f == 42.0); } break; case Alembic::Util::kInt32POD: { TESTING_ASSERT( sp->getNumSamples() == 10 ); TESTING_ASSERT( sp->getDataType().getExtent() == 3); TESTING_ASSERT( !sp->isConstant() ); std::vector< Alembic::Util::uint32_t > ui(3); // lets explicitly test each sample sp->getSample( 0, &(ui.front()) ); TESTING_ASSERT(ui[0] == 0 && ui[1] == 1 && ui[2] == 2); sp->getSample( 1, &(ui.front()) ); TESTING_ASSERT(ui[0] == 0 && ui[1] == 1 && ui[2] == 2); sp->getSample( 2, &(ui.front()) ); TESTING_ASSERT(ui[0] == 41 && ui[1] == 43 && ui[2] == 47); sp->getSample( 3, &(ui.front()) ); TESTING_ASSERT(ui[0] == 0 && ui[1] == 1 && ui[2] == 2); sp->getSample( 4, &(ui.front()) ); TESTING_ASSERT(ui[0] == 41 && ui[1] == 43 && ui[2] == 47); sp->getSample( 5, &(ui.front()) ); TESTING_ASSERT(ui[0] == 41 && ui[1] == 43 && ui[2] == 47); sp->getSample( 6, &(ui.front()) ); TESTING_ASSERT(ui[0] == 41 && ui[1] == 43 && ui[2] == 47); sp->getSample( 7, &(ui.front()) ); TESTING_ASSERT(ui[0] == 0 && ui[1] == 1 && ui[2] == 2); sp->getSample( 8, &(ui.front()) ); TESTING_ASSERT(ui[0] == 0 && ui[1] == 1 && ui[2] == 2); sp->getSample( 9, &(ui.front()) ); TESTING_ASSERT(ui[0] == 0 && ui[1] == 1 && ui[2] == 2); } break; case Alembic::Util::kStringPOD: { TESTING_ASSERT( sp->getNumSamples() == 4 ); TESTING_ASSERT( sp->getDataType().getExtent() == 3); TESTING_ASSERT( !sp->isConstant() ); std::vector< Alembic::Util::string > val(3); sp->getSample(0, &(val.front())); TESTING_ASSERT( val[0] == "Please"); TESTING_ASSERT( val[1] == ""); TESTING_ASSERT( val[2] == "work"); sp->getSample(1, &(val.front())); TESTING_ASSERT( val[0] == "Please"); TESTING_ASSERT( val[1] == ""); TESTING_ASSERT( val[2] == "work"); sp->getSample(2, &(val.front())); TESTING_ASSERT( val[0] == "Whats"); TESTING_ASSERT( val[1] == "going"); TESTING_ASSERT( val[2] == "on?"); sp->getSample(3, &(val.front())); TESTING_ASSERT( val[0] == "Whats"); TESTING_ASSERT( val[1] == "going"); TESTING_ASSERT( val[2] == "on?"); } break; default: TESTING_ASSERT(false); break; } } // for } }
//-***************************************************************************** void testReadWriteScalars() { std::string archiveName = "staticProperties.abc"; { A5::WriteArchive w; AbcA::ArchiveWriterPtr a = w(archiveName, AbcA::MetaData()); AbcA::ObjectWriterPtr archive = a->getTop(); AbcA::CompoundPropertyWriterPtr props = archive->getProperties(); const AbcA::TimeSamplingType staticSampling; { AbcA::ScalarPropertyWriterPtr boolWrtPtr = props->createScalarProperty("bool", AbcA::MetaData(), AbcA::DataType(Alembic::Util::kBooleanPOD, 1), 0); Alembic::Util::bool_t b = true; boolWrtPtr->setSample(&b); } { AbcA::ScalarPropertyWriterPtr ucharWrtPtr = props->createScalarProperty("uchar", AbcA::MetaData(), AbcA::DataType(Alembic::Util::kUint8POD, 1), 0); Alembic::Util::uint8_t uc = 200; TESTING_ASSERT(ucharWrtPtr->getNumSamples() == 0); ucharWrtPtr->setSample(&uc); TESTING_ASSERT(ucharWrtPtr->getNumSamples() == 1); } { AbcA::ScalarPropertyWriterPtr charWrtPtr = props->createScalarProperty("char", AbcA::MetaData(), AbcA::DataType(Alembic::Util::kInt8POD, 1), 0); Alembic::Util::int8_t c = -20; charWrtPtr->setSample(&c); } { AbcA::ScalarPropertyWriterPtr ushortWrtPtr = props->createScalarProperty("ushort", AbcA::MetaData(), AbcA::DataType(Alembic::Util::kUint16POD, 1), 0); Alembic::Util::uint16_t us = 60000; ushortWrtPtr->setSample(&us); } { AbcA::ScalarPropertyWriterPtr shortWrtPtr = props->createScalarProperty("short", AbcA::MetaData(), AbcA::DataType(Alembic::Util::kInt16POD, 1), 0); Alembic::Util::int16_t s = -20000; shortWrtPtr->setSample(&s); } { AbcA::ScalarPropertyWriterPtr uintWrtPtr = props->createScalarProperty("uint", AbcA::MetaData(), AbcA::DataType(Alembic::Util::kUint32POD, 1), 0); Alembic::Util::uint32_t ui = 1000000; uintWrtPtr->setSample(&ui); } { AbcA::ScalarPropertyWriterPtr intWrtPtr = props->createScalarProperty("int", AbcA::MetaData(), AbcA::DataType(Alembic::Util::kInt32POD, 1), 0); Alembic::Util::int32_t i = -1000000; intWrtPtr->setSample(&i); } { AbcA::ScalarPropertyWriterPtr ui64WrtPtr = props->createScalarProperty("uint64", AbcA::MetaData(), AbcA::DataType(Alembic::Util::kUint64POD, 1), 0); Alembic::Util::uint64_t ui = 5000000000LL; ui64WrtPtr->setSample(&ui); } { AbcA::ScalarPropertyWriterPtr i64WrtPtr = props->createScalarProperty("i64", AbcA::MetaData(), AbcA::DataType(Alembic::Util::kInt64POD, 1), 0); Alembic::Util::int64_t i = -5000000000LL; i64WrtPtr->setSample(&i); } { AbcA::ScalarPropertyWriterPtr halfWrtPtr = props->createScalarProperty("half", AbcA::MetaData(), AbcA::DataType(Alembic::Util::kFloat16POD, 1), 0); Alembic::Util::float16_t h = 16.0; halfWrtPtr->setSample(&h); } { AbcA::ScalarPropertyWriterPtr floatWrtPtr = props->createScalarProperty("float", AbcA::MetaData(), AbcA::DataType(Alembic::Util::kFloat32POD, 1), 0); Alembic::Util::float32_t f = 128.0; floatWrtPtr->setSample(&f); } { AbcA::ScalarPropertyWriterPtr doubleWrtPtr = props->createScalarProperty("double", AbcA::MetaData(), AbcA::DataType(Alembic::Util::kFloat64POD, 1), 0); Alembic::Util::float64_t d = 32768.0; TESTING_ASSERT(doubleWrtPtr->getNumSamples() == 0); doubleWrtPtr->setSample(&d); TESTING_ASSERT(doubleWrtPtr->getNumSamples() == 1); } { AbcA::ScalarPropertyWriterPtr strWrtPtr = props->createScalarProperty("str", AbcA::MetaData(), AbcA::DataType(Alembic::Util::kStringPOD, 1), 0); Alembic::Util::string c = "This was a triumph!"; strWrtPtr->setSample(&c); } { AbcA::ScalarPropertyWriterPtr wstrWrtPtr = props->createScalarProperty("wstr", AbcA::MetaData(), AbcA::DataType(Alembic::Util::kWstringPOD, 1), 0); Alembic::Util::wstring c( L"Matt Lauer can suck it! \u2697" ); wstrWrtPtr->setSample(&c); } } // now we read what we've written { A5::ReadArchive r; AbcA::ArchiveReaderPtr a = r( archiveName ); AbcA::ObjectReaderPtr archive = a->getTop(); AbcA::CompoundPropertyReaderPtr parent = archive->getProperties(); TESTING_ASSERT(parent->getNumProperties() == 14); for ( size_t i = 0; i < parent->getNumProperties(); ++i ) { AbcA::BasePropertyReaderPtr bp = parent->getProperty( i ); // they are all supposed to be scalar TESTING_ASSERT( bp->isScalar() ); AbcA::ScalarPropertyReaderPtr sp = bp->asScalarPtr(); TESTING_ASSERT( sp->getNumSamples() == 1 ); TESTING_ASSERT( sp->isConstant() ); TESTING_ASSERT( sp->getParent() == parent); TESTING_ASSERT( sp->getDataType().getExtent() == 1); switch (sp->getDataType().getPod()) { case Alembic::Util::kBooleanPOD: { TESTING_ASSERT(sp->getName() == "bool"); Alembic::Util::bool_t val = false; sp->getSample(0, &val); TESTING_ASSERT(val == true); } break; case Alembic::Util::kUint8POD: { TESTING_ASSERT(sp->getName() == "uchar"); Alembic::Util::uint8_t val = 0; sp->getSample(0, &val); TESTING_ASSERT(val == 200); } break; case Alembic::Util::kInt8POD: { TESTING_ASSERT(sp->getName() == "char"); Alembic::Util::int8_t val = 0; sp->getSample(0, &val); TESTING_ASSERT(val == -20); } break; case Alembic::Util::kUint16POD: { TESTING_ASSERT(sp->getName() == "ushort"); Alembic::Util::uint16_t val = 0; sp->getSample(0, &val); TESTING_ASSERT(val == 60000); } break; case Alembic::Util::kInt16POD: { TESTING_ASSERT(sp->getName() == "short"); Alembic::Util::int16_t val = 0; sp->getSample(0, &val); TESTING_ASSERT(val == -20000); } break; case Alembic::Util::kUint32POD: { TESTING_ASSERT(sp->getName() == "uint"); Alembic::Util::uint32_t val = 0; sp->getSample(0, &val); TESTING_ASSERT(val == 1000000); } break; case Alembic::Util::kInt32POD: { TESTING_ASSERT(sp->getName() == "int"); Alembic::Util::int32_t val = 0; sp->getSample(0, &val); TESTING_ASSERT(val == -1000000); } break; case Alembic::Util::kUint64POD: { TESTING_ASSERT(sp->getName() == "uint64"); Alembic::Util::uint64_t val = 0; sp->getSample(0, &val); TESTING_ASSERT(val == 5000000000LL); } break; case Alembic::Util::kInt64POD: { TESTING_ASSERT(sp->getName() == "i64"); Alembic::Util::int64_t val = 0; sp->getSample(0, &val); TESTING_ASSERT(val == -5000000000LL); } break; case Alembic::Util::kFloat16POD: { TESTING_ASSERT(sp->getName() == "half"); Alembic::Util::float16_t val = 0; sp->getSample(0, &val); TESTING_ASSERT(val == 16.0); } break; case Alembic::Util::kFloat32POD: { TESTING_ASSERT(sp->getName() == "float"); Alembic::Util::float32_t val = 0; sp->getSample(0, &val); TESTING_ASSERT(val == 128.0); } break; case Alembic::Util::kFloat64POD: { TESTING_ASSERT(sp->getName() == "double"); Alembic::Util::float64_t val = 0; sp->getSample(0, &val); TESTING_ASSERT(val == 32768.0); } break; case Alembic::Util::kStringPOD: { TESTING_ASSERT(sp->getName() == "str"); Alembic::Util::string val; sp->getSample(0, &val); TESTING_ASSERT(val == "This was a triumph!"); } break; case Alembic::Util::kWstringPOD: { TESTING_ASSERT(sp->getName() == "wstr"); Alembic::Util::wstring val; sp->getSample(0, &val); TESTING_ASSERT(val == L"Matt Lauer can suck it! \u2697"); } break; default: TESTING_ASSERT(false); break; } } } // end of reading }
void testScalarSamples() { std::string archiveName = "numScalarSamplesTest.abc"; AbcA::DataType dtype(Alembic::Util::kFloat32POD); float samp = 0.0f; { AO::WriteArchive w; AbcA::ArchiveWriterPtr a = w(archiveName, AbcA::MetaData()); AbcA::ObjectWriterPtr archive = a->getTop(); AbcA::ObjectWriterPtr obj = archive->createChild( AbcA::ObjectHeader("test", AbcA::MetaData())); AbcA::CompoundPropertyWriterPtr parent = obj->getProperties(); AbcA::ScalarPropertyWriterPtr prop; AbcA::CompoundPropertyWriterPtr smallProp = parent->createCompoundProperty("small", AbcA::MetaData()); smallProp->createScalarProperty("a", AbcA::MetaData(), dtype, 0); prop = smallProp->createScalarProperty("b", AbcA::MetaData(), dtype, 0); for (std::size_t i = 0; i < 10; ++i, ++samp) { prop->setSample(&samp); } smallProp->createArrayProperty("c", AbcA::MetaData(), dtype, 0); AbcA::CompoundPropertyWriterPtr mdProp = parent->createCompoundProperty("md", AbcA::MetaData()); mdProp->createScalarProperty("a", AbcA::MetaData(), dtype, 0); prop = mdProp->createScalarProperty("b", AbcA::MetaData(), dtype, 0); for (std::size_t i = 0; i < 150; ++i, ++samp) { prop->setSample(&samp); } mdProp->createScalarProperty("c", AbcA::MetaData(), dtype, 0); AbcA::CompoundPropertyWriterPtr mdlgProp = parent->createCompoundProperty("mdlg", AbcA::MetaData()); mdlgProp->createScalarProperty("a", AbcA::MetaData(), dtype, 0); prop = mdlgProp->createScalarProperty("b", AbcA::MetaData(), dtype, 0); for (std::size_t i = 0; i < 300; ++i, ++samp) { prop->setSample(&samp); } mdlgProp->createScalarProperty("c", AbcA::MetaData(), dtype, 0); AbcA::CompoundPropertyWriterPtr lgProp = parent->createCompoundProperty("lg", AbcA::MetaData()); lgProp->createScalarProperty("a", AbcA::MetaData(), dtype, 0); prop = lgProp->createScalarProperty("b", AbcA::MetaData(), dtype, 0); for (std::size_t i = 0; i < 33000; ++i, ++samp) { prop->setSample(&samp); } lgProp->createScalarProperty("c", AbcA::MetaData(), dtype, 0); AbcA::CompoundPropertyWriterPtr insaneProp = parent->createCompoundProperty("insane", AbcA::MetaData()); insaneProp->createScalarProperty("a", AbcA::MetaData(), dtype, 0); prop = insaneProp->createScalarProperty("b", AbcA::MetaData(), dtype, 0); for (std::size_t i = 0; i < 66000; ++i, ++samp) { prop->setSample(&samp); } insaneProp->createScalarProperty("c", AbcA::MetaData(), dtype, 0); } { AO::ReadArchive r; AbcA::ArchiveReaderPtr a = r( archiveName ); AbcA::ObjectReaderPtr archive = a->getTop(); AbcA::ObjectReaderPtr obj = archive->getChild(0); AbcA::CompoundPropertyReaderPtr parent = obj->getProperties(); AbcA::CompoundPropertyReaderPtr smallProp = parent->getCompoundProperty("small"); TESTING_ASSERT(smallProp->getNumProperties() == 3); TESTING_ASSERT(smallProp->getScalarProperty("b")->getNumSamples() == 10); AbcA::CompoundPropertyReaderPtr mdProp = parent->getCompoundProperty("md"); TESTING_ASSERT(mdProp->getNumProperties() == 3); TESTING_ASSERT(mdProp->getScalarProperty("b")->getNumSamples() == 150); AbcA::CompoundPropertyReaderPtr mdlgProp = parent->getCompoundProperty("mdlg"); TESTING_ASSERT(mdlgProp->getNumProperties() == 3); TESTING_ASSERT(mdlgProp->getScalarProperty("b")->getNumSamples() == 300); AbcA::CompoundPropertyReaderPtr lgProp = parent->getCompoundProperty("lg"); TESTING_ASSERT(lgProp->getNumProperties() == 3); TESTING_ASSERT(lgProp->getScalarProperty("b")->getNumSamples() == 33000); AbcA::CompoundPropertyReaderPtr insaneProp = parent->getCompoundProperty("insane"); TESTING_ASSERT(insaneProp->getNumProperties() == 3); TESTING_ASSERT(insaneProp->getScalarProperty("b")->getNumSamples() == 66000); } }