void testArrayPropHashes()
{
std::string archiveName = "arrayHashTest.abc";
{
AO::WriteArchive w;
ABCA::ArchiveWriterPtr a = w(archiveName, ABCA::MetaData());
ABCA::ObjectWriterPtr archive = a->getTop();
ABCA::ObjectWriterPtr child;
// add a time sampling for later use
std::vector < double > timeSamps(1,-4.0);
ABCA::TimeSamplingType tst(3.0);
ABCA::TimeSampling ts(tst, timeSamps);
a->addTimeSampling(ts);
// 2 objects without any properties whatsoever
archive->createChild(ABCA::ObjectHeader("emptyA", ABCA::MetaData()));
archive->createChild(ABCA::ObjectHeader("emptyB", ABCA::MetaData()));
// 2 objects with with the same property with no samples
child = archive->createChild(ABCA::ObjectHeader(
"1propA", ABCA::MetaData()));
child->getProperties()->createArrayProperty("empty", ABCA::MetaData(),
ABCA::DataType(Alembic::Util::kInt32POD, 1), 0);
child = archive->createChild(ABCA::ObjectHeader(
"1propB", ABCA::MetaData()));
child->getProperties()->createArrayProperty("empty", ABCA::MetaData(),
ABCA::DataType(Alembic::Util::kInt32POD, 1), 0);
// 2 objects with with the same property with a differnt name from above
child = archive->createChild(ABCA::ObjectHeader(
"1propAName", ABCA::MetaData()));
child->getProperties()->createArrayProperty("null", ABCA::MetaData(),
ABCA::DataType(Alembic::Util::kInt32POD, 1), 0);
child = archive->createChild(ABCA::ObjectHeader(
"1propBName", ABCA::MetaData()));
child->getProperties()->createArrayProperty("null", ABCA::MetaData(),
ABCA::DataType(Alembic::Util::kInt32POD, 1), 0);
// 2 objects with with the same property with a differnt MetaData
ABCA::MetaData m;
m.set("Bleep", "bloop");
child = archive->createChild(ABCA::ObjectHeader(
"1propAMeta", ABCA::MetaData()));
child->getProperties()->createArrayProperty("empty", m,
ABCA::DataType(Alembic::Util::kInt32POD, 1), 0);
child = archive->createChild(ABCA::ObjectHeader(
"1propBMeta", ABCA::MetaData()));
child->getProperties()->createArrayProperty("empty", m,
ABCA::DataType(Alembic::Util::kInt32POD, 1), 0);
// 2 objects with with the same property with a different POD
child = archive->createChild(ABCA::ObjectHeader(
"1propAPod", ABCA::MetaData()));
child->getProperties()->createArrayProperty("empty", ABCA::MetaData(),
ABCA::DataType(Alembic::Util::kFloat32POD, 1), 0);
child = archive->createChild(ABCA::ObjectHeader(
"1propBPod", ABCA::MetaData()));
child->getProperties()->createArrayProperty("empty", ABCA::MetaData(),
ABCA::DataType(Alembic::Util::kFloat32POD, 1), 0);
// 2 objects with with the same property with a different extent
child = archive->createChild(ABCA::ObjectHeader(
"1propAExtent", ABCA::MetaData()));
child->getProperties()->createArrayProperty("empty", ABCA::MetaData(),
ABCA::DataType(Alembic::Util::kInt32POD, 2), 0);
child = archive->createChild(ABCA::ObjectHeader(
"1propBExtent", ABCA::MetaData()));
child->getProperties()->createArrayProperty("empty", ABCA::MetaData(),
ABCA::DataType(Alembic::Util::kInt32POD, 2), 0);
// 2 objects with with the same property with a differnt time sampling
child = archive->createChild(ABCA::ObjectHeader(
"1propATS", ABCA::MetaData()));
child->getProperties()->createArrayProperty("empty", ABCA::MetaData(),
ABCA::DataType(Alembic::Util::kInt32POD, 1), 1);
child = archive->createChild(ABCA::ObjectHeader(
"1propBTS", ABCA::MetaData()));
child->getProperties()->createArrayProperty("empty", ABCA::MetaData(),
ABCA::DataType(Alembic::Util::kInt32POD, 1), 1);
// 2 objects with 1 sample
ABCA::ArrayPropertyWriterPtr awp;
std::vector <Alembic::Util::int32_t> vali(4, 0);
Alembic::Util::Dimensions dims(4);
ABCA::DataType i32d(Alembic::Util::kInt32POD, 1);
child = archive->createChild(ABCA::ObjectHeader(
"1propA1Samp", ABCA::MetaData()));
awp = child->getProperties()->createArrayProperty("int",
ABCA::MetaData(), ABCA::DataType(Alembic::Util::kInt32POD, 1), 0);
awp->setSample(ABCA::ArraySample(&(vali.front()), i32d, dims));
child = archive->createChild(ABCA::ObjectHeader(
"1propB1Samp", ABCA::MetaData()));
awp = child->getProperties()->createArrayProperty("int",
ABCA::MetaData(), ABCA::DataType(Alembic::Util::kInt32POD, 1), 0);
awp->setSample(ABCA::ArraySample(&(vali.front()), i32d, dims));
// 2 objects with 2 samples, no repeats
std::vector <Alembic::Util::int32_t> valiB(4, 1);
child = archive->createChild(ABCA::ObjectHeader(
"1propA2Samp", ABCA::MetaData()));
awp = child->getProperties()->createArrayProperty("int",
ABCA::MetaData(), ABCA::DataType(Alembic::Util::kInt32POD, 1), 0);
awp->setSample(ABCA::ArraySample(&(vali.front()), i32d, dims));
awp->setSample(ABCA::ArraySample(&(valiB.front()), i32d, dims));
child = archive->createChild(ABCA::ObjectHeader(
"1propB2Samp", ABCA::MetaData()));
awp = child->getProperties()->createArrayProperty("int",
ABCA::MetaData(), ABCA::DataType(Alembic::Util::kInt32POD, 1), 0);
awp->setSample(ABCA::ArraySample(&(vali.front()), i32d, dims));
awp->setSample(ABCA::ArraySample(&(valiB.front()), i32d, dims));
// 2 objects with 4 samples, with repeats
child = archive->createChild(ABCA::ObjectHeader(
"1propA4Samp", ABCA::MetaData()));
awp = child->getProperties()->createArrayProperty("int",
ABCA::MetaData(), ABCA::DataType(Alembic::Util::kInt32POD, 1), 0);
awp->setSample(ABCA::ArraySample(&(vali.front()), i32d, dims));
awp->setSample(ABCA::ArraySample(&(vali.front()), i32d, dims));
awp->setSample(ABCA::ArraySample(&(valiB.front()), i32d, dims));
awp->setSample(ABCA::ArraySample(&(valiB.front()), i32d, dims));
child = archive->createChild(ABCA::ObjectHeader(
"1propB4Samp", ABCA::MetaData()));
awp = child->getProperties()->createArrayProperty("int",
ABCA::MetaData(), ABCA::DataType(Alembic::Util::kInt32POD, 1), 0);
awp->setSample(ABCA::ArraySample(&(vali.front()), i32d, dims));
awp->setSample(ABCA::ArraySample(&(vali.front()), i32d, dims));
awp->setSample(ABCA::ArraySample(&(valiB.front()), i32d, dims));
awp->setSample(ABCA::ArraySample(&(valiB.front()), i32d, dims));
// 2 objects with 1 samplem different dimensions
Alembic::Util::Dimensions dimsB;
dimsB.setRank(2);
dimsB[0] = 2;
dimsB[1] = 2;
child = archive->createChild(ABCA::ObjectHeader(
"1propA1Dims", ABCA::MetaData()));
awp = child->getProperties()->createArrayProperty("int",
ABCA::MetaData(), ABCA::DataType(Alembic::Util::kInt32POD, 1), 0);
awp->setSample(ABCA::ArraySample(&(vali.front()), i32d, dimsB));
child = archive->createChild(ABCA::ObjectHeader(
"1propB1Dims", ABCA::MetaData()));
awp = child->getProperties()->createArrayProperty("int",
ABCA::MetaData(), ABCA::DataType(Alembic::Util::kInt32POD, 1), 0);
awp->setSample(ABCA::ArraySample(&(vali.front()), i32d, dimsB));
// 2 objects with with the same 2 properties with no samples
child = archive->createChild(ABCA::ObjectHeader(
"2propA", ABCA::MetaData()));
child->getProperties()->createArrayProperty("empty", ABCA::MetaData(),
ABCA::DataType(Alembic::Util::kInt32POD, 1), 0);
child->getProperties()->createArrayProperty("null", ABCA::MetaData(),
ABCA::DataType(Alembic::Util::kInt32POD, 1), 0);
child = archive->createChild(ABCA::ObjectHeader(
"2propB", ABCA::MetaData()));
child->getProperties()->createArrayProperty("empty", ABCA::MetaData(),
ABCA::DataType(Alembic::Util::kInt32POD, 1), 0);
child->getProperties()->createArrayProperty("null", ABCA::MetaData(),
ABCA::DataType(Alembic::Util::kInt32POD, 1), 0);
// 2 objects with with the same 2 properties created in opposite order
child = archive->createChild(ABCA::ObjectHeader(
"2propASwap", ABCA::MetaData()));
child->getProperties()->createArrayProperty("null", ABCA::MetaData(),
ABCA::DataType(Alembic::Util::kInt32POD, 1), 0);
child->getProperties()->createArrayProperty("empty", ABCA::MetaData(),
ABCA::DataType(Alembic::Util::kInt32POD, 1), 0);
child = archive->createChild(ABCA::ObjectHeader(
"2propBSwap", ABCA::MetaData()));
child->getProperties()->createArrayProperty("null", ABCA::MetaData(),
ABCA::DataType(Alembic::Util::kInt32POD, 1), 0);
child->getProperties()->createArrayProperty("empty", ABCA::MetaData(),
ABCA::DataType(Alembic::Util::kInt32POD, 1), 0);
}
{
AO::ReadArchive r;
ABCA::ArchiveReaderPtr a = r( archiveName );
ABCA::ObjectReaderPtr archive = a->getTop();
TESTING_ASSERT(archive->getNumChildren() == 26);
// every 2 hashes should be the same
for (size_t i = 0; i < archive->getNumChildren(); i += 2)
{
Alembic::Util::Digest dA, dB;
TESTING_ASSERT(archive->getChild(i)->getPropertiesHash(dA) &&
archive->getChild(i+1)->getPropertiesHash(dB));
TESTING_ASSERT(dA == dB);
}
// make sure that every 2 child objects have different properties hashes
for (size_t i = 0; i < archive->getNumChildren() / 2; ++i)
{
Alembic::Util::Digest dA;
archive->getChild(i*2)->getPropertiesHash(dA);
for (size_t j = i + 1; j < archive->getNumChildren() / 2; ++j)
{
Alembic::Util::Digest dB;
archive->getChild(j*2)->getPropertiesHash(dB);
TESTING_ASSERT(dA != dB);
}
}
}
}
//-*****************************************************************************
void printValue( Abc::ICompoundProperty iParent, Abc::PropertyHeader header,
int index, bool justSize, bool printTime, double fps )
{
Abc::ISampleSelector iss( (index_t) index );
Abc::DataType dt = header.getDataType();
AbcU::PlainOldDataType pod = dt.getPod();
AbcU ::uint8_t extent = dt.getExtent();
if ( header.isArray() ) {
Abc::IArrayProperty p( iParent, header.getName() );
if ( printTime ) {
std::cout << "Time: " <<
p.getTimeSampling()->getSampleTime( index ) * fps << std::endl;
}
if ( justSize ) {
AbcU::Dimensions dims;
p.getDimensions( dims, iss );
std::cout << "Extent: " << (int) extent << " Num points: " <<
dims.numPoints() << std::endl;
return;
}
switch ( pod )
{
CASE_RETURN_ARRAY_VALUE(Abc::BooleanTPTraits, bool, p, header, iss);
CASE_RETURN_ARRAY_VALUE(Abc::Uint8TPTraits, uint8_t, p, header, iss);
CASE_RETURN_ARRAY_VALUE(Abc::Int8TPTraits, int8_t, p, header, iss);
CASE_RETURN_ARRAY_VALUE(Abc::Uint16TPTraits, uint16_t, p, header, iss);
CASE_RETURN_ARRAY_VALUE(Abc::Int16TPTraits, int16_t, p, header, iss);
CASE_RETURN_ARRAY_VALUE(Abc::Uint32TPTraits, uint32_t, p, header, iss);
CASE_RETURN_ARRAY_VALUE(Abc::Int32TPTraits, int32_t, p, header, iss);
CASE_RETURN_ARRAY_VALUE(Abc::Uint64TPTraits, uint64_t, p, header, iss);
CASE_RETURN_ARRAY_VALUE(Abc::Int64TPTraits, int64_t, p, header, iss);
CASE_RETURN_ARRAY_VALUE(Abc::Float32TPTraits, float, p, header, iss);
CASE_RETURN_ARRAY_VALUE(Abc::Float64TPTraits, double, p, header, iss);
CASE_RETURN_ARRAY_VALUE(Abc::StringTPTraits, std::string, p, header, iss);
default:
std::cout << "Unknown property type" << std::endl;
break;
}
} else if ( header.isScalar() ) {
Abc::IScalarProperty p( iParent, header.getName() );
if ( printTime ) {
std::cout << "Time: " <<
p.getTimeSampling()->getSampleTime( index ) * fps << std::endl;
}
if ( justSize ) {
std::cout << "Extent: " << (int) extent << std::endl;
return;
}
switch ( pod )
{
CASE_RETURN_SCALAR_VALUE( Abc::BooleanTPTraits, p, iss );
CASE_RETURN_SCALAR_VALUE( Abc::Uint8TPTraits, p, iss );
CASE_RETURN_SCALAR_VALUE( Abc::Int8TPTraits, p, iss );
CASE_RETURN_SCALAR_VALUE( Abc::Uint16TPTraits, p, iss );
CASE_RETURN_SCALAR_VALUE( Abc::Int16TPTraits, p, iss );
CASE_RETURN_SCALAR_VALUE( Abc::Uint32TPTraits, p, iss );
CASE_RETURN_SCALAR_VALUE( Abc::Int32TPTraits, p, iss );
CASE_RETURN_SCALAR_VALUE( Abc::Uint64TPTraits, p, iss );
CASE_RETURN_SCALAR_VALUE( Abc::Int64TPTraits, p, iss );
CASE_RETURN_SCALAR_VALUE( Abc::Float32TPTraits, p, iss );
CASE_RETURN_SCALAR_VALUE( Abc::Float64TPTraits, p, iss );
CASE_RETURN_SCALAR_VALUE( Abc::StringTPTraits, p, iss );
default:
std::cout << "Unknown property type" << std::endl;
break;
}
}
}
void readWriteColorArrayProperty(const std::string &archiveName, bool useOgawa)
{
{
OArchive archive;
if (useOgawa)
{
archive = OArchive( Alembic::AbcCoreOgawa::WriteArchive(),
archiveName, ErrorHandler::kThrowPolicy );
}
else
{
archive = OArchive( Alembic::AbcCoreHDF5::WriteArchive(),
archiveName, ErrorHandler::kThrowPolicy );
}
OObject archiveTop = archive.getTop();
OObject child( archiveTop, "test" );
OCompoundProperty childProps = child.getProperties();
OC3fArrayProperty shades( childProps, "shades", 0 );
std::vector < C3f > grays(8);
grays[0].x = 0.0; grays[0].y = 0.0; grays[0].z = 0.0;
grays[1].x = 0.125; grays[1].y = 0.125; grays[1].z = 0.125;
grays[2].x = 0.25; grays[2].y = 0.25; grays[2].z = 0.25;
grays[3].x = 0.375; grays[3].y = 0.375; grays[3].z = 0.375;
grays[4].x = 0.5; grays[4].y = 0.5; grays[4].z = 0.5;
grays[5].x = 0.625; grays[5].y = 0.625; grays[5].z = 0.625;
grays[6].x = 0.75; grays[6].y = 0.75; grays[6].z = 0.75;
grays[7].x = 0.875; grays[7].y = 0.875; grays[7].z = 0.875;
// let's write 4 different color3f[2]
Dimensions d;
d.setRank(2);
d[0] = 2;
d[1] = 4;
C3fArraySample cas(&(grays.front()), d);
shades.set(cas);
}
{
// now read it
AbcF::IFactory factory;
factory.setPolicy( ErrorHandler::kThrowPolicy );
AbcF::IFactory::CoreType coreType;
IArchive archive = factory.getArchive(archiveName, coreType);
TESTING_ASSERT( (useOgawa && coreType == AbcF::IFactory::kOgawa) ||
(!useOgawa && coreType == AbcF::IFactory::kHDF5) );
IObject archiveTop = archive.getTop();
IObject child( archiveTop, archiveTop.getChildHeader(0).getName() );
ICompoundProperty props = child.getProperties();
IC3fArrayProperty shades( props, "shades" );
C3fArraySamplePtr samplePtr;
shades.get( samplePtr );
ABCA_ASSERT( samplePtr->getDimensions().rank() == 2,
"Incorrect rank on the sample." );
ABCA_ASSERT( samplePtr->getDimensions().numPoints() == 8,
"Incorrect number of total points." );
ABCA_ASSERT( samplePtr->getDimensions()[0] == 2,
"Incorrect size on dimension 0." );
ABCA_ASSERT( samplePtr->getDimensions()[1] == 4,
"Incorrect size on dimension 1." );
Alembic::Util::Dimensions dims;
shades.getDimensions( dims );
ABCA_ASSERT( dims.rank() == 2,
"Incorrect rank on the sample." );
ABCA_ASSERT( dims.numPoints() == 8,
"Incorrect number of total points." );
ABCA_ASSERT( dims[0] == 2,
"Incorrect size on dimension 0." );
ABCA_ASSERT( dims[1] == 4,
"Incorrect size on dimension 1." );
for (size_t i = 0; i < 8; ++i)
{
ABCA_ASSERT( (*samplePtr)[i].x == i/8.0 &&
(*samplePtr)[i].x == (*samplePtr)[i].y &&
(*samplePtr)[i].x == (*samplePtr)[i].z,
"Color [" << i << "] is incorrect.");
}
double start, end;
GetArchiveStartAndEndTime( archive, start, end );
TESTING_ASSERT( almostEqual(start, 0.0) );
TESTING_ASSERT( almostEqual(end, 0.0) );
}
}