void readDeepHierarchy(const std::string &archiveName)
{
// Open an existing archive for reading. Indicate that we want
// Alembic to throw exceptions on errors.
AbcF::IFactory factory;
factory.setPolicy( ErrorHandler::kThrowPolicy );
AbcF::IFactory::CoreType coreType;
IArchive archive = factory.getArchive(archiveName, coreType);
IObject archiveTop = archive.getTop();
// Determine the number of (top level) children the archive has
const unsigned int numChildren = archiveTop.getNumChildren();
std::cout << "The archive has " << numChildren << " children:"
<< std::endl;
ABCA_ASSERT( numChildren == 2,
"Expected 2 children, found " << numChildren );
// Iterate through them, print out their names
for (unsigned int ii=0; ii<numChildren; ii++)
{
IObject child( archiveTop, archiveTop.getChildHeader(ii).getName() );
std::cout << " " << child.getName();
recursivelyReadChildren( child );
}
// do it again to make sure we clean up after ourselves properly
IArchive archive2 = factory.getArchive(archiveName, coreType);
IObject archiveTop2 = archive2.getTop();
// Done - the archive closes itself
}
void readEmptyCompoundProperties(const std::string &archiveName)
{
// Open an existing archive for reading. Indicate that we want
// Alembic to throw exceptions on errors.
AbcF::IFactory factory;
factory.setPolicy( ErrorHandler::kThrowPolicy );
AbcF::IFactory::CoreType coreType;
IArchive archive = factory.getArchive(archiveName, coreType);
IObject archiveTop = archive.getTop();
// Determine the number of (top level) children the archive has
const int numChildren = archiveTop.getNumChildren();
ABCA_ASSERT( numChildren == 2, "Wrong number of children (expected 2)");
std::cout << "The archive has " << numChildren << " children:"
<< std::endl;
// Iterate through them, print out their names
for (int ii=0; ii<numChildren; ii++)
{
IObject child( archiveTop, archiveTop.getChildHeader(ii).getName() );
std::cout << " " << child.getName();
std::cout << " has " << child.getNumChildren() << " children"
<< std::endl;
// Properties
ICompoundProperty props = child.getProperties();
int numProperties = props.getNumProperties();
std::cout << " ..and " << numProperties << " properties"
<< std::endl;
std::vector<std::string> propNames;
for (int pp=0; pp<numProperties; pp++)
propNames.push_back( props.getPropertyHeader(pp).getName() );
for (int jj=0; jj<numProperties; jj++)
{
std::cout << " ..named " << propNames[jj] << std::endl;
std::cout << " ..with type: ";
PropertyType pType = props.getPropertyHeader(jj).getPropertyType();
if (pType == kCompoundProperty)
{
std::cout << "compound" << std::endl;
}
else if (pType == kScalarProperty)
{
std::cout << "scalar" << std::endl;
}
else if (pType == kArrayProperty)
{
std::cout << "array" << std::endl;
}
}
}
// Done - the archive closes itself
}
void scopingTest(bool useOgawa)
{
{
OObject top;
{
OArchive archive;
if (useOgawa)
{
archive = CreateArchiveWithInfo(
Alembic::AbcCoreOgawa::WriteArchive(),
"archiveScopeTest.abc",
"Alembic test", "", MetaData() );
}
else
{
archive = CreateArchiveWithInfo(
Alembic::AbcCoreHDF5::WriteArchive(),
"archiveScopeTest.abc",
"Alembic test", "", MetaData() );
}
top = archive.getTop();
}
OObject childA( top, "a");
OObject childB( top, "b");
ODoubleProperty prop(top.getProperties(), "prop", 0);
TESTING_ASSERT(prop.getObject().getArchive().getName() ==
"archiveScopeTest.abc");
}
{
IObject top;
{
AbcF::IFactory factory;
AbcF::IFactory::CoreType coreType;
IArchive archive = factory.getArchive("archiveScopeTest.abc",
coreType);
TESTING_ASSERT( (useOgawa && coreType == AbcF::IFactory::kOgawa) ||
(!useOgawa && coreType == AbcF::IFactory::kHDF5) );
top = archive.getTop();
double start, end;
GetArchiveStartAndEndTime( archive, start, end );
TESTING_ASSERT( start == DBL_MAX && end == -DBL_MAX );
}
TESTING_ASSERT(top.getNumChildren() == 2 );
TESTING_ASSERT(top.getChildHeader("a") != NULL);
TESTING_ASSERT(top.getChildHeader("b") != NULL);
TESTING_ASSERT( ! top.getParent().valid() );
TESTING_ASSERT( top.getArchive().getName() ==
"archiveScopeTest.abc");
IScalarProperty prop(top.getProperties(), "prop");
TESTING_ASSERT(prop.valid());
TESTING_ASSERT(prop.getObject().getArchive().getName() ==
"archiveScopeTest.abc");
}
}
void archiveInfoTest(bool useOgawa)
{
std::string appWriter = "Alembic unit tests";
std::string userStr = "abcdefg";
{
Alembic::AbcCoreAbstract::MetaData md;
md.set("potato", "salad");
md.set("taco", "bar");
OArchive archive;
if (useOgawa)
{
archive = CreateArchiveWithInfo(
Alembic::AbcCoreOgawa::WriteArchive(), "archiveInfo.abc",
appWriter, userStr, md );
}
else
{
archive = CreateArchiveWithInfo(
Alembic::AbcCoreHDF5::WriteArchive(), "archiveInfo.abc",
appWriter, userStr, md );
}
TESTING_ASSERT( archive.getPtr()->getMetaData().get("taco") == "bar" );
}
{
AbcF::IFactory factory;
AbcF::IFactory::CoreType coreType;
IArchive archive = factory.getArchive("archiveInfo.abc", coreType);
TESTING_ASSERT( (useOgawa && coreType == AbcF::IFactory::kOgawa) ||
(!useOgawa && coreType == AbcF::IFactory::kHDF5) );
TESTING_ASSERT( archive.getPtr()->getMetaData().get("taco") == "bar" );
TESTING_ASSERT( archive.getPtr()->getMetaData().get("potato") ==
"salad" );
TESTING_ASSERT( archive.getArchiveVersion() ==
ALEMBIC_LIBRARY_VERSION );
std::string appInfo;
std::string abcVersionStr;
Alembic::Util::uint32_t abcVersion = 0;
std::string dateWritten;
std::string userInfo;
GetArchiveInfo( archive, appInfo, abcVersionStr, abcVersion,
dateWritten, userInfo );
TESTING_ASSERT( appWriter == appInfo );
TESTING_ASSERT( userStr == userInfo );
TESTING_ASSERT( abcVersion == ALEMBIC_LIBRARY_VERSION );
std::cout << "Alembic version: " << abcVersionStr << std::endl;
std::cout << "Date written: " << dateWritten << std::endl;
TESTING_ASSERT( dateWritten != "" );
TESTING_ASSERT( abcVersionStr != "" );
double start, end;
GetArchiveStartAndEndTime( archive, start, end );
TESTING_ASSERT( start == DBL_MAX && end == -DBL_MAX );
}
}
//-*****************************************************************************
void layerTest()
{
std::string fileName = "objectLayer1.abc";
std::string fileName2 = "objectLayer2.abc";
{
OArchive archive( Alembic::AbcCoreOgawa::WriteArchive(), fileName );
OObject child( archive.getTop(), "child" );
OObject childCool( child, "cool" );
OObject childGuy( child, "guy" );
OObject childA( archive.getTop(), "childA" );
OObject childAA( childA, "A" );
}
{
OArchive archive( Alembic::AbcCoreOgawa::WriteArchive(), fileName2 );
OObject child( archive.getTop(), "child" );
OObject childCool( child, "cool" );
OObject childGal( child, "gal" );
OObject childA( archive.getTop(), "childB" );
OObject childAA( childA, "B" );
}
{
std::vector< std::string > files;
files.push_back( fileName );
files.push_back( fileName2 );
Alembic::AbcCoreFactory::IFactory factory;
IArchive archive = factory.getArchive( files );
// child, childA, childB
TESTING_ASSERT( archive.getTop().getNumChildren() == 3 );
IObject child = archive.getTop().getChild("child");
TESTING_ASSERT( child.getNumChildren() == 3 );
TESTING_ASSERT( child.getChild("cool").valid() );
TESTING_ASSERT( child.getChild("cool").getNumChildren() == 0 );
TESTING_ASSERT( child.getChild("guy").valid() );
TESTING_ASSERT( child.getChild("guy").getNumChildren() == 0 );
TESTING_ASSERT( child.getChild("gal").valid() );
TESTING_ASSERT( child.getChild("gal").getNumChildren() == 0 );
IObject childA = archive.getTop().getChild("childA");
TESTING_ASSERT( childA.getNumChildren() == 1 );
TESTING_ASSERT( childA.getChild("A").valid() );
TESTING_ASSERT( childA.getChild("A").getNumChildren() == 0 );
IObject childB = archive.getTop().getChild("childB");
TESTING_ASSERT( childB.getNumChildren() == 1 );
TESTING_ASSERT( childB.getChild("B").valid() );
TESTING_ASSERT( childB.getChild("B").getNumChildren() == 0 );
}
}
//-*****************************************************************************
// SCENE CLASS
//-*****************************************************************************
Scene::Scene( const std::string &fileName, bool verbose )
: m_fileName( fileName )
, m_minTime( ( chrono_t )FLT_MAX )
, m_maxTime( ( chrono_t )-FLT_MAX )
{
Timer playbackTimer;
Alembic::AbcCoreFactory::IFactory factory;
m_archive = factory.getArchive( fileName );
m_topObject = IObject( m_archive, kTop );
if ( verbose )
std::cout << "Opened archive and top object, creating drawables."
<< std::endl;
m_drawable.reset( new IObjectDrw( m_topObject, false ) );
ABCA_ASSERT( m_drawable->valid(),
"Invalid drawable for archive: " << fileName );
if ( verbose )
std::cout << "Created drawables, getting time range." << std::endl;
m_minTime = m_drawable->getMinTime();
m_maxTime = m_drawable->getMaxTime();
if ( m_minTime <= m_maxTime ) {
if ( verbose )
std::cout << "\nMin Time: " << m_minTime << " seconds " << std::endl
<< "Max Time: " << m_maxTime << " seconds " << std::endl
<< "\nLoading min time." << std::endl;
m_drawable->setTime( m_minTime );
}
else {
if ( verbose )
std::cout << "\nConstant Time." << std::endl
<< "\nLoading constant sample." << std::endl;
m_minTime = m_maxTime = 0.0;
m_drawable->setTime( 0.0 );
}
ABCA_ASSERT( m_drawable->valid(),
"Invalid drawable after reading start time" );
if ( verbose )
std::cout << "Done opening archive. Elapsed CPU time: "
<< ((float)playbackTimer.elapsed()) / CLOCKS_PER_SEC << " seconds." << std::endl;
// Bounds have been formed!
m_bounds = m_drawable->getBounds();
if ( verbose )
std::cout << "Bounds at min time: " << m_bounds.min << " to "
<< m_bounds.max << std::endl;
}
//-*****************************************************************************
void pruneTest()
{
std::string fileName = "objectPrune1.abc";
std::string fileName2 = "objectPrune2.abc";
{
OArchive archive( Alembic::AbcCoreOgawa::WriteArchive(), fileName );
OObject child( archive.getTop(), "child" );
OObject childCool( child, "cool" );
OObject childGuy( child, "guy" );
OObject childA( archive.getTop(), "childA" );
OObject childAA( childA, "A" );
OObject childB( archive.getTop(), "childB" );
OObject childBB( childB, "B" );
}
{
MetaData md;
Alembic::AbcCoreLayer::SetPrune( md, true );
OArchive archive( Alembic::AbcCoreOgawa::WriteArchive(), fileName2 );
OObject child( archive.getTop(), "child" );
OObject childGuy( child, "guy", md );
OObject childA( archive.getTop(), "childA" );
OObject childAA( childA, "A", md );
OObject childAB( childA, "B", md );
OObject childB( archive.getTop(), "childB", md );
}
{
std::vector< std::string > files;
files.push_back( fileName );
files.push_back( fileName2 );
Alembic::AbcCoreFactory::IFactory factory;
IArchive archive = factory.getArchive( files );
// child, childA, childB
TESTING_ASSERT( archive.getTop().getNumChildren() == 2 );
IObject child = archive.getTop().getChild("child");
TESTING_ASSERT( child.getNumChildren() == 1 );
TESTING_ASSERT( child.getChild("cool").valid() );
TESTING_ASSERT( child.getChild("cool").getNumChildren() == 0 );
IObject childA = archive.getTop().getChild("childA");
TESTING_ASSERT( childA.getNumChildren() == 0 );
}
}
AlembicInput::AlembicInput( const std::string &fileName )
{
m_data = boost::shared_ptr<DataMembers>( new DataMembers );
#ifdef IECOREALEMBIC_WITH_OGAWA
Alembic::AbcCoreFactory::IFactory factory;
m_data->archive = boost::shared_ptr<IArchive>( new IArchive( factory.getArchive( fileName ) ) );
if( !m_data->archive->valid() )
{
// even though the default policy for IFactory is kThrowPolicy, this appears not to
// be applied when it fails to load an archive - instead it returns an invalid archive.
throw IECore::Exception( boost::str( boost::format( "Unable to open file \"%s\"" ) % fileName ) );
}
#else
m_data->archive = boost::shared_ptr<IArchive>( new IArchive( ::Alembic::AbcCoreHDF5::ReadArchive(), fileName ) );
#endif
m_data->object = m_data->archive->getTop();
}
//-*****************************************************************************
void simpleTestIn( const std::string &iArchiveName )
{
AbcF::IFactory factory;
factory.setPolicy( ErrorHandler::kThrowPolicy );
AbcF::IFactory::CoreType coreType;
IArchive archive = factory.getArchive(iArchiveName, coreType);
IObject archiveTop = archive.getTop();
TESTING_ASSERT( archiveTop.getNumChildren() == ( size_t )NUM_TOP_CHILDREN );
for ( int i = 0 ; i < NUM_TOP_CHILDREN ; i++ )
{
std::ostringstream strm;
strm << i;
std::string cname = strm.str();
IObject obj( archiveTop, cname );
readDeepHierarchy( obj, 0, obj );
}
TESTING_ASSERT( PATHS.size() == ( size_t ) NUM_TOP_CHILDREN );
}
void readFlatHierarchy(const std::string &archiveName)
{
// Open an existing archive for reading. Indicate that we want
// Alembic to throw exceptions on errors.
AbcF::IFactory factory;
factory.setPolicy( ErrorHandler::kThrowPolicy );
AbcF::IFactory::CoreType coreType;
IArchive archive = factory.getArchive(archiveName, coreType);
IObject archiveTop = archive.getTop();
// Determine the number of (top level) children the archive has
const int numChildren = archiveTop.getNumChildren();
ABCA_ASSERT( numChildren == 10,
"Expected 10 children, found " << numChildren );
std::cout << "The archive has " << numChildren << " children:"
<< std::endl;
// Iterate through them, print out their names
for (int ii=0; ii<numChildren; ii++)
{
IObject child( archiveTop,
archiveTop.getChildHeader(ii).getName() );
std::cout << " " << child.getName();
const unsigned int children = child.getNumChildren();
std::cout << " has " << children << " children"
<< std::endl;
ABCA_ASSERT( children == 0,
"Expected no children, found " << children );
}
// Done - the archive closes itself
}
MStatus AlembicNode::compute(const MPlug & plug, MDataBlock & dataBlock)
{
MStatus status;
// update the frame number to be imported
MDataHandle speedHandle = dataBlock.inputValue(mSpeedAttr, &status);
double speed = speedHandle.asDouble();
MDataHandle offsetHandle = dataBlock.inputValue(mOffsetAttr, &status);
double offset = offsetHandle.asDouble();
MDataHandle timeHandle = dataBlock.inputValue(mTimeAttr, &status);
MTime t = timeHandle.asTime();
double inputTime = t.as(MTime::kSeconds);
double fps = getFPS();
// scale and offset inputTime.
inputTime = computeAdjustedTime(inputTime, speed, offset/fps);
// this should be done only once per file
if (mFileInitialized == false)
{
mFileInitialized = true;
//Get list of input filenames
MFnDependencyNode depNode(thisMObject());
MPlug layerFilesPlug = depNode.findPlug("abc_layerFiles");
MFnStringArrayData fnSAD( layerFilesPlug.asMObject() );
MStringArray storedFilenames = fnSAD.array();
//Legacy support for single-filename input
if( storedFilenames.length() == 0 )
{
MFileObject fileObject;
MDataHandle dataHandle = dataBlock.inputValue(mAbcFileNameAttr);
fileObject.setRawFullName(dataHandle.asString());
MString fileName = fileObject.resolvedFullName();
storedFilenames.append( fileName );
}
std::vector<std::string> abcFilenames;
for(unsigned int i = 0; i < storedFilenames.length(); i++)
abcFilenames.push_back( storedFilenames[i].asChar() );
Alembic::Abc::IArchive archive;
Alembic::AbcCoreFactory::IFactory factory;
factory.setPolicy(Alembic::Abc::ErrorHandler::kQuietNoopPolicy);
archive = factory.getArchive( abcFilenames );
if (!archive.valid())
{
MString theError = "Error opening these alembic files: ";
const unsigned int numFilenames = storedFilenames.length();
for( unsigned int i = 0; i < numFilenames; i++ )
{
theError += storedFilenames[ i ];
if( i != (numFilenames - 1) )
theError += ", ";
}
printError(theError);
}
// initialize some flags for plug update
mSubDInitialized = false;
mPolyInitialized = false;
// When an alembic cache will be imported at the first time using
// AbcImport, we need to set mIncludeFilterAttr (filterHandle) to be
// mIncludeFilterString for later use. When we save a maya scene(.ma)
// mIncludeFilterAttr will be saved. Then when we load the saved
// .ma file, mIncludeFilterString will be set to be mIncludeFilterAttr.
MDataHandle includeFilterHandle =
dataBlock.inputValue(mIncludeFilterAttr, &status);
MString& includeFilterString = includeFilterHandle.asString();
if (mIncludeFilterString.length() > 0)
{
includeFilterHandle.set(mIncludeFilterString);
dataBlock.setClean(mIncludeFilterAttr);
}
else if (includeFilterString.length() > 0)
{
mIncludeFilterString = includeFilterString;
}
MDataHandle excludeFilterHandle =
dataBlock.inputValue(mExcludeFilterAttr, &status);
MString& excludeFilterString = excludeFilterHandle.asString();
if (mExcludeFilterString.length() > 0)
{
excludeFilterHandle.set(mExcludeFilterString);
dataBlock.setClean(mExcludeFilterAttr);
}
else if (excludeFilterString.length() > 0)
{
mExcludeFilterString = excludeFilterString;
}
MFnDependencyNode dep(thisMObject());
MPlug allSetsPlug = dep.findPlug("allColorSets");
CreateSceneVisitor visitor(inputTime, !allSetsPlug.isNull(),
MObject::kNullObj, CreateSceneVisitor::NONE, "",
mIncludeFilterString, mExcludeFilterString);
visitor.walk(archive);
if (visitor.hasSampledData())
{
// information retrieved from the hierarchy traversal
// and given to AlembicNode to provide update
visitor.getData(mData);
mData.getFrameRange(mSequenceStartTime, mSequenceEndTime);
MDataHandle startFrameHandle = dataBlock.inputValue(mStartFrameAttr,
&status);
startFrameHandle.set(mSequenceStartTime*fps);
MDataHandle endFrameHandle = dataBlock.inputValue(mEndFrameAttr,
&status);
endFrameHandle.set(mSequenceEndTime*fps);
}
}
// Retime
MDataHandle cycleHandle = dataBlock.inputValue(mCycleTypeAttr, &status);
short playType = cycleHandle.asShort();
inputTime = computeRetime(inputTime, mSequenceStartTime, mSequenceEndTime,
playType);
clamp<double>(mSequenceStartTime, mSequenceEndTime, inputTime);
// update only when the time lapse is big enough
if (fabs(inputTime - mCurTime) > 0.00001)
{
mOutRead = std::vector<bool>(mOutRead.size(), false);
mCurTime = inputTime;
}
if (plug == mOutPropArrayAttr)
{
if (mOutRead[0])
{
dataBlock.setClean(plug);
return MS::kSuccess;
}
mOutRead[0] = true;
unsigned int propSize =
static_cast<unsigned int>(mData.mPropList.size());
if (propSize > 0)
{
MArrayDataHandle outArrayHandle = dataBlock.outputValue(
mOutPropArrayAttr, &status);
unsigned int outHandleIndex = 0;
MDataHandle outHandle;
// for all of the nodes with sampled attributes
for (unsigned int i = 0; i < propSize; i++)
{
// only use the handle if it matches the index.
// The index wont line up in the sparse case so we
// can just skip that element.
if (outArrayHandle.elementIndex() == outHandleIndex++)
{
outHandle = outArrayHandle.outputValue();
}
else
{
continue;
}
if (mData.mPropList[i].mArray.valid())
{
readProp(mCurTime, mData.mPropList[i].mArray, outHandle);
}
else if (mData.mPropList[i].mScalar.valid())
{
// for visibility only
if (mData.mPropList[i].mScalar.getName() ==
Alembic::AbcGeom::kVisibilityPropertyName)
{
Alembic::Util::int8_t visVal = 1;
mData.mPropList[i].mScalar.get(&visVal,
Alembic::Abc::ISampleSelector(mCurTime,
Alembic::Abc::ISampleSelector::kNearIndex ));
outHandle.setGenericBool(visVal != 0, false);
}
else
{
// for all scalar props
readProp(mCurTime, mData.mPropList[i].mScalar, outHandle);
}
}
outArrayHandle.next();
}
outArrayHandle.setAllClean();
}
}
else if (plug == mOutTransOpArrayAttr )
{
if (mOutRead[1])
{
dataBlock.setClean(plug);
return MS::kSuccess;
}
mOutRead[1] = true;
unsigned int xformSize =
static_cast<unsigned int>(mData.mXformList.size());
if (xformSize > 0)
{
MArrayDataHandle outArrayHandle =
dataBlock.outputValue(mOutTransOpArrayAttr, &status);
MPlug arrayPlug(thisMObject(), mOutTransOpArrayAttr);
MDataHandle outHandle;
unsigned int outHandleIndex = 0;
for (unsigned int i = 0; i < xformSize; i++)
{
std::vector<double> sampleList;
if (mData.mIsComplexXform[i])
{
readComplex(mCurTime, mData.mXformList[i], sampleList);
}
else
{
Alembic::AbcGeom::XformSample samp;
read(mCurTime, mData.mXformList[i], sampleList, samp);
}
unsigned int sampleSize = (unsigned int)sampleList.size();
for (unsigned int j = 0; j < sampleSize; j++)
{
// only use the handle if it matches the index.
// The index wont line up in the sparse case so we
// can just skip that element.
if (outArrayHandle.elementIndex() == outHandleIndex++)
{
outHandle = outArrayHandle.outputValue(&status);
}
else
continue;
outArrayHandle.next();
outHandle.set(sampleList[j]);
}
}
outArrayHandle.setAllClean();
}
}
else if (plug == mOutLocatorPosScaleArrayAttr )
{
if (mOutRead[8])
{
dataBlock.setClean(plug);
return MS::kSuccess;
}
mOutRead[8] = true;
unsigned int locSize =
static_cast<unsigned int>(mData.mLocList.size());
if (locSize > 0)
{
MArrayDataHandle outArrayHandle =
dataBlock.outputValue(mOutLocatorPosScaleArrayAttr, &status);
MPlug arrayPlug(thisMObject(), mOutLocatorPosScaleArrayAttr);
MDataHandle outHandle;
unsigned int outHandleIndex = 0;
for (unsigned int i = 0; i < locSize; i++)
{
std::vector< double > sampleList;
read(mCurTime, mData.mLocList[i], sampleList);
unsigned int sampleSize = (unsigned int)sampleList.size();
for (unsigned int j = 0; j < sampleSize; j++)
{
// only use the handle if it matches the index.
// The index wont line up in the sparse case so we
// can just skip that element.
if (outArrayHandle.elementIndex() == outHandleIndex++)
{
outHandle = outArrayHandle.outputValue(&status);
}
else
continue;
outArrayHandle.next();
outHandle.set(sampleList[j]);
}
}
outArrayHandle.setAllClean();
}
}
else if (plug == mOutSubDArrayAttr)
{
if (mOutRead[2])
{
// Reference the output to let EM know we are the writer
// of the data. EM sets the output to holder and causes
// race condition when evaluating fan-out destinations.
MArrayDataHandle outArrayHandle =
dataBlock.outputValue(mOutSubDArrayAttr, &status);
const unsigned int elementCount = outArrayHandle.elementCount();
for (unsigned int j = 0; j < elementCount; j++)
{
outArrayHandle.outputValue().data();
outArrayHandle.next();
}
outArrayHandle.setAllClean();
return MS::kSuccess;
}
mOutRead[2] = true;
unsigned int subDSize =
static_cast<unsigned int>(mData.mSubDList.size());
if (subDSize > 0)
{
MArrayDataHandle outArrayHandle = dataBlock.outputValue(
mOutSubDArrayAttr, &status);
MDataHandle outHandle;
for (unsigned int j = 0; j < subDSize; j++)
{
// these elements can be sparse if they have been deleted
if (outArrayHandle.elementIndex() != j)
{
continue;
}
outHandle = outArrayHandle.outputValue(&status);
outArrayHandle.next();
MObject obj = outHandle.data();
if (obj.hasFn(MFn::kMesh))
{
MFnMesh fnMesh(obj);
readSubD(mCurTime, fnMesh, obj, mData.mSubDList[j],
mSubDInitialized);
outHandle.set(obj);
}
}
mSubDInitialized = true;
outArrayHandle.setAllClean();
}
// for the case where we don't have any nodes, we want to make sure
// to push out empty meshes on our connections, this can happen if
// the input file was offlined, currently we only need to do this for
// meshes as Nurbs, curves, and the other channels don't crash Maya
else
{
MArrayDataHandle outArrayHandle = dataBlock.outputValue(
mOutSubDArrayAttr, &status);
if (outArrayHandle.elementCount() > 0)
{
do
{
MDataHandle outHandle = outArrayHandle.outputValue();
MObject obj = outHandle.data();
if (obj.hasFn(MFn::kMesh))
{
MFloatPointArray emptyVerts;
MIntArray emptyCounts;
MIntArray emptyConnects;
MFnMesh emptyMesh;
emptyMesh.create(0, 0, emptyVerts, emptyCounts,
emptyConnects, obj);
outHandle.set(obj);
}
}
while (outArrayHandle.next() == MS::kSuccess);
}
mSubDInitialized = true;
outArrayHandle.setAllClean();
}
}
else if (plug == mOutPolyArrayAttr)
{
if (mOutRead[3])
{
// Reference the output to let EM know we are the writer
// of the data. EM sets the output to holder and causes
// race condition when evaluating fan-out destinations.
MArrayDataHandle outArrayHandle =
dataBlock.outputValue(mOutPolyArrayAttr, &status);
const unsigned int elementCount = outArrayHandle.elementCount();
for (unsigned int j = 0; j < elementCount; j++)
{
outArrayHandle.outputValue().data();
outArrayHandle.next();
}
outArrayHandle.setAllClean();
return MS::kSuccess;
}
mOutRead[3] = true;
unsigned int polySize =
static_cast<unsigned int>(mData.mPolyMeshList.size());
if (polySize > 0)
{
MArrayDataHandle outArrayHandle =
dataBlock.outputValue(mOutPolyArrayAttr, &status);
MDataHandle outHandle;
for (unsigned int j = 0; j < polySize; j++)
{
// these elements can be sparse if they have been deleted
if (outArrayHandle.elementIndex() != j)
{
continue;
}
outHandle = outArrayHandle.outputValue(&status);
outArrayHandle.next();
MObject obj = outHandle.data();
if (obj.hasFn(MFn::kMesh))
{
MFnMesh fnMesh(obj);
readPoly(mCurTime, fnMesh, obj, mData.mPolyMeshList[j],
mPolyInitialized);
outHandle.set(obj);
}
}
mPolyInitialized = true;
outArrayHandle.setAllClean();
}
// for the case where we don't have any nodes, we want to make sure
// to push out empty meshes on our connections, this can happen if
// the input file was offlined, currently we only need to do this for
// meshes as Nurbs, curves, and the other channels don't crash Maya
else
{
MArrayDataHandle outArrayHandle = dataBlock.outputValue(
mOutPolyArrayAttr, &status);
if (outArrayHandle.elementCount() > 0)
{
do
{
MDataHandle outHandle = outArrayHandle.outputValue(&status);
MObject obj = outHandle.data();
if (obj.hasFn(MFn::kMesh))
{
MFloatPointArray emptyVerts;
MIntArray emptyCounts;
MIntArray emptyConnects;
MFnMesh emptyMesh;
emptyMesh.create(0, 0, emptyVerts, emptyCounts,
emptyConnects, obj);
outHandle.set(obj);
}
}
while (outArrayHandle.next() == MS::kSuccess);
}
mPolyInitialized = true;
outArrayHandle.setAllClean();
}
}
else if (plug == mOutCameraArrayAttr)
{
if (mOutRead[4])
{
dataBlock.setClean(plug);
return MS::kSuccess;
}
mOutRead[4] = true;
unsigned int cameraSize =
static_cast<unsigned int>(mData.mCameraList.size());
if (cameraSize > 0)
{
MArrayDataHandle outArrayHandle =
dataBlock.outputValue(mOutCameraArrayAttr, &status);
MPlug arrayPlug(thisMObject(), mOutCameraArrayAttr);
double angleConversion = 1.0;
switch (MAngle::uiUnit())
{
case MAngle::kRadians:
angleConversion = 0.017453292519943295;
break;
case MAngle::kAngMinutes:
angleConversion = 60.0;
break;
case MAngle::kAngSeconds:
angleConversion = 3600.0;
break;
default:
break;
}
MDataHandle outHandle;
unsigned int index = 0;
for (unsigned int cameraIndex = 0; cameraIndex < cameraSize;
cameraIndex++)
{
Alembic::AbcGeom::ICamera & cam =
mData.mCameraList[cameraIndex];
std::vector<double> array;
read(mCurTime, cam, array);
for (unsigned int dataIndex = 0; dataIndex < array.size();
dataIndex++, index++)
{
// skip over sparse elements
if (index != outArrayHandle.elementIndex())
{
continue;
}
outHandle = outArrayHandle.outputValue(&status);
outArrayHandle.next();
// not shutter angle index, so not an angle
if (dataIndex != 11)
{
outHandle.set(array[dataIndex]);
}
else
{
outHandle.set(array[dataIndex] * angleConversion);
}
} // for the per camera data handles
} // for each camera
outArrayHandle.setAllClean();
}
}
else if (plug == mOutNurbsSurfaceArrayAttr)
{
if (mOutRead[5])
{
// Reference the output to let EM know we are the writer
// of the data. EM sets the output to holder and causes
// race condition when evaluating fan-out destinations.
MArrayDataHandle outArrayHandle =
dataBlock.outputValue(mOutNurbsSurfaceArrayAttr, &status);
const unsigned int elementCount = outArrayHandle.elementCount();
for (unsigned int j = 0; j < elementCount; j++)
{
outArrayHandle.outputValue().data();
outArrayHandle.next();
}
outArrayHandle.setAllClean();
return MS::kSuccess;
}
mOutRead[5] = true;
unsigned int nSurfaceSize =
static_cast<unsigned int>(mData.mNurbsList.size());
if (nSurfaceSize > 0)
{
MArrayDataHandle outArrayHandle =
dataBlock.outputValue(mOutNurbsSurfaceArrayAttr, &status);
MDataHandle outHandle;
for (unsigned int j = 0; j < nSurfaceSize; j++)
{
// these elements can be sparse if they have been deleted
if (outArrayHandle.elementIndex() != j)
continue;
outHandle = outArrayHandle.outputValue(&status);
outArrayHandle.next();
MObject obj = outHandle.data();
if (obj.hasFn(MFn::kNurbsSurface))
{
readNurbs(mCurTime, mData.mNurbsList[j], obj);
outHandle.set(obj);
}
}
outArrayHandle.setAllClean();
}
}
else if (plug == mOutNurbsCurveGrpArrayAttr)
{
if (mOutRead[6])
{
// Reference the output to let EM know we are the writer
// of the data. EM sets the output to holder and causes
// race condition when evaluating fan-out destinations.
MArrayDataHandle outArrayHandle =
dataBlock.outputValue(mOutNurbsCurveGrpArrayAttr, &status);
const unsigned int elementCount = outArrayHandle.elementCount();
for (unsigned int j = 0; j < elementCount; j++)
{
outArrayHandle.outputValue().data();
outArrayHandle.next();
}
outArrayHandle.setAllClean();
return MS::kSuccess;
}
mOutRead[6] = true;
unsigned int nCurveGrpSize =
static_cast<unsigned int>(mData.mCurvesList.size());
if (nCurveGrpSize > 0)
{
MArrayDataHandle outArrayHandle =
dataBlock.outputValue(mOutNurbsCurveGrpArrayAttr, &status);
MDataHandle outHandle;
std::vector<MObject> curvesObj;
for (unsigned int i = 0; i < nCurveGrpSize; ++i)
{
readCurves(mCurTime, mData.mCurvesList[i],
mData.mNumCurves[i], curvesObj);
}
std::size_t numChild = curvesObj.size();
// not the best way to do this
// only reading bunches of curves based on the connections would be
// more efficient when there is a bunch of broken connections
for (unsigned int i = 0; i < numChild; i++)
{
if (outArrayHandle.elementIndex() != i)
{
continue;
}
outHandle = outArrayHandle.outputValue(&status);
outArrayHandle.next();
status = outHandle.set(curvesObj[i]);
}
outArrayHandle.setAllClean();
}
}
else
{
return MS::kUnknownParameter;
}
dataBlock.setClean(plug);
return status;
}
void errorHandlerTest(bool useOgawa)
{
{
OArchive archive;
if (useOgawa)
{
archive = OArchive( Alembic::AbcCoreOgawa::WriteArchive(),
"throwTest.abc", ErrorHandler::kThrowPolicy );
}
else
{
archive = OArchive( Alembic::AbcCoreHDF5::WriteArchive(),
"throwTest.abc", ErrorHandler::kThrowPolicy );
}
OObject archiveTop = archive.getTop();
ABCA_ASSERT( archiveTop.getErrorHandler().getPolicy() ==
ErrorHandler::kThrowPolicy, "Error: Not kThrowPolicy" );
OObject childQuiet(archiveTop, "childQuiet",
ErrorHandler::kQuietNoopPolicy );
OObject childNoisy(archiveTop, "childNoisy",
ErrorHandler::kNoisyNoopPolicy );
OObject grandchildQuiet(childQuiet, "grandchildQuiet" );
OObject grandchildNoisy(childNoisy, "grandchildNoisy" );
ABCA_ASSERT( childQuiet.getErrorHandler().getPolicy() ==
ErrorHandler::kQuietNoopPolicy, "Error: Not kQuietNoopPolicy" );
ABCA_ASSERT( childNoisy.getErrorHandler().getPolicy() ==
ErrorHandler::kNoisyNoopPolicy, "Error: Not kNoisyNoopPolicy" );
ABCA_ASSERT( grandchildQuiet.getErrorHandler().getPolicy() ==
ErrorHandler::kQuietNoopPolicy, "Error: Not kQuietNoopPolicy" );
ABCA_ASSERT( grandchildNoisy.getErrorHandler().getPolicy() ==
ErrorHandler::kNoisyNoopPolicy, "Error: Not kNoisyNoopPolicy" );
}
{
AbcF::IFactory factory;
factory.setPolicy( ErrorHandler::kThrowPolicy );
AbcF::IFactory::CoreType coreType;
IArchive archive = factory.getArchive("throwTest.abc", coreType);
IObject archiveTop = archive.getTop();
ABCA_ASSERT( archiveTop.getErrorHandler().getPolicy() ==
ErrorHandler::kThrowPolicy, "Error: Not kThrowPolicy" );
IObject childQuiet(archiveTop, "childQuiet",
ErrorHandler::kQuietNoopPolicy );
IObject childNoisy(archiveTop, "childNoisy",
ErrorHandler::kNoisyNoopPolicy );
IObject grandchildQuiet(childQuiet, "grandchildQuiet" );
IObject grandchildNoisy(childNoisy, "grandchildNoisy" );
ABCA_ASSERT( childQuiet.getErrorHandler().getPolicy() ==
ErrorHandler::kQuietNoopPolicy, "Error: Not kQuietNoopPolicy" );
ABCA_ASSERT( childNoisy.getErrorHandler().getPolicy() ==
ErrorHandler::kNoisyNoopPolicy, "Error: Not kNoisyNoopPolicy" );
ABCA_ASSERT( grandchildQuiet.getErrorHandler().getPolicy() ==
ErrorHandler::kQuietNoopPolicy, "Error: Not kQuietNoopPolicy" );
ABCA_ASSERT( grandchildNoisy.getErrorHandler().getPolicy() ==
ErrorHandler::kNoisyNoopPolicy, "Error: Not kNoisyNoopPolicy" );
}
}
void readV3fArrayProperty(const std::string &archiveName, bool useOgawa)
{
// Open an existing archive for reading. Indicate that we want
// Alembic to throw exceptions on errors.
std::cout << "Reading " << archiveName << std::endl;
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();
// Determine the number of (top level) children the archive has
const unsigned int numChildren = archiveTop.getNumChildren();
ABCA_ASSERT( numChildren == 1, "Wrong number of children (expected 1)");
std::cout << "The archive has " << numChildren << " children:"
<< std::endl;
// Iterate through them, print out their names
IObject child( archiveTop, archiveTop.getChildHeader(0).getName() );
std::cout << " named '" << child.getName() << "'";
// Properties
ICompoundProperty props = child.getProperties();
size_t numProperties = props.getNumProperties(); // only top-level props
ABCA_ASSERT( numProperties == 1,
"Expected 1 property, found " << numProperties);
std::cout << " with one property";
std::vector<std::string> propNames(1);
propNames[0] = props.getPropertyHeader(0).getName();
std::cout << " named '" << propNames[0] << "'" << std::endl;
PropertyType pType = props.getPropertyHeader(0).getPropertyType();
ABCA_ASSERT( pType == kArrayProperty,
"Expected an array property, but didn't find one" );
std::cout << " which is an array property";
DataType dType = props.getPropertyHeader(0).getDataType();
ABCA_ASSERT( dType.getPod() == kFloat32POD,
"Expected an v3f property, but didn't find one" );
// We know this is an array property (I'm eliding the if/else
// statements required to recognize and handle this properly)
IV3fArrayProperty positions( props, propNames[0] );
size_t numSamples = positions.getNumSamples();
std::cout << ".. it has " << numSamples << " samples" << std::endl;
ABCA_ASSERT( numSamples == 5, "Expected 5 samples, found " << numSamples );
TimeSamplingPtr ts = positions.getTimeSampling();
std::cout << "..with time/value pairs: " << std::endl;;
for (unsigned int ss=0; ss<numSamples; ss++)
{
std::cout << " ";
ISampleSelector iss( (index_t) ss);
std::cout << ts->getSampleTime( (index_t) ss ) << " / ";
V3fArraySamplePtr samplePtr;
positions.get( samplePtr, iss );
std::cout << "[ ";
size_t numPoints = samplePtr->size();
for ( size_t jj=0 ; jj<numPoints ; jj++ )
std::cout << (*samplePtr)[jj] << " ";
std::cout << "]" << std::endl;
if (ss == 2) // no entries in sample #2
{
ABCA_ASSERT( numPoints == 0,
"Expected an empty sample, but found " << numPoints
<< " entries." );
}
else
{
for ( size_t jj=0 ; jj<numPoints ; jj++ )
ABCA_ASSERT( (*samplePtr)[jj] == g_vectors[jj],
"Incorrect value read from archive." );
}
}
ABCA_ASSERT(
archive.getMaxNumSamplesForTimeSamplingIndex(1) == (index_t) numSamples,
"Incorrect number of max samples in readV3fArrayProperty." );
std::cout << std::endl;
// Done - the archive closes itself
double start, end;
GetArchiveStartAndEndTime( archive, start, end );
TESTING_ASSERT( almostEqual(start, 123.0) );
TESTING_ASSERT( almostEqual(end, 123.0 + 4.0 / 24.0) );
}
//-*****************************************************************************
void replaceTest()
{
std::string fileName = "objectReplace1.abc";
std::string fileName2 = "objectReplace2.abc";
{
OArchive archive( Alembic::AbcCoreOgawa::WriteArchive(), fileName );
OObject child( archive.getTop(), "child" );
OObject childCool( child, "cool" );
OObject childCooler( childCool, "cooler" );
OObject childGuy( child, "guy" );
OObject childGuyA( childGuy, "A" );
OObject childA( archive.getTop(), "childA" );
OObject childAA( childA, "A" );
OObject childB( archive.getTop(), "childB" );
OObject childBB( childB, "B" );
}
{
MetaData md;
Alembic::AbcCoreLayer::SetReplace( md, true );
OArchive archive( Alembic::AbcCoreOgawa::WriteArchive(), fileName2 );
OObject child( archive.getTop(), "child" );
OObject childGuy( child, "guy", md );
OObject childCool( child, "cool", md );
OObject childCoolA( childCool, "A" );
OObject childCoolB( childCool, "B", md );
OObject childA( archive.getTop(), "childA", md );
OObject childB( archive.getTop(), "childB", md );
OObject childBA( childB, "A", md );
OObject childBC( childB, "C", md );
OObject childBCA( childBC, "A", md );
}
{
std::vector< std::string > files;
files.push_back( fileName );
files.push_back( fileName2 );
Alembic::AbcCoreFactory::IFactory factory;
IArchive archive = factory.getArchive( files );
IObject root = archive.getTop();
// child, childA, childB
TESTING_ASSERT( root.getNumChildren() == 3 );
IObject child( root, "child" );
TESTING_ASSERT( child.getNumChildren() == 2 );
TESTING_ASSERT( IObject( child, "cool" ).valid() );
TESTING_ASSERT( IObject( child, "guy" ).valid() );
TESTING_ASSERT( IObject( child, "cool" ).getNumChildren() == 2 );
TESTING_ASSERT( IObject( child, "guy" ).getNumChildren() == 0 );
IObject childCool( child, "cool" );
TESTING_ASSERT( IObject( childCool, "A" ).valid() );
TESTING_ASSERT( IObject( childCool, "A" ).getNumChildren() == 0 );
TESTING_ASSERT( IObject( childCool, "B" ).valid() );
TESTING_ASSERT( IObject( childCool, "B" ).getNumChildren() == 0 );
IObject childA( root, "childA" );
TESTING_ASSERT( childA.getNumChildren() == 0 );
IObject childB( root, "childB" );
TESTING_ASSERT( childB.getNumChildren() == 2 );
TESTING_ASSERT( IObject( childB, "A" ).valid() );
TESTING_ASSERT( IObject( childB, "C" ).valid() );
TESTING_ASSERT( IObject( childB, "A" ).getNumChildren() == 0 );
TESTING_ASSERT( IObject( childB, "C" ).getNumChildren() == 1 );
IObject childBC( childB, "C" );
TESTING_ASSERT( IObject( childBC, "A" ).valid() );
TESTING_ASSERT( IObject( childBC, "A" ).getNumChildren() == 0 );
}
}
void emptyAndValueTest(const std::string &archiveName, bool useOgawa)
{
std::vector<std::string> strVec;
strVec.push_back( "potato" );
std::vector<C3f> colorVec;
colorVec.push_back( C3f( 0.0, 0.5, 0.75 ) );
std::vector<Alembic::Util::int32_t> intVec;
intVec.push_back(42);
StringArraySample strSamp( strVec );
C3fArraySample colorSamp( colorVec );
Int32ArraySample intSamp( intVec );
StringArraySample emptyStrSamp = StringArraySample::emptySample();
C3fArraySample emptyColorSamp = C3fArraySample::emptySample();
Int32ArraySample emptyIntSamp = Int32ArraySample::emptySample();
{
OArchive archive;
if (useOgawa)
{
archive = OArchive( Alembic::AbcCoreOgawa::WriteArchive(),
archiveName );
}
else
{
archive = OArchive( Alembic::AbcCoreHDF5::WriteArchive(),
archiveName );
}
OCompoundProperty root = archive.getTop().getProperties();
OC3fArrayProperty colorProp( root, "colors" );
OInt32ArrayProperty numProp( root, "numbers" );
AbcA::MetaData md;
SetReference( md );
OStringArrayProperty strProp( root, "strings", md );
TESTING_ASSERT( isReference( strProp.getHeader() ) );
colorProp.set( emptyColorSamp );
colorProp.set( colorSamp );
colorProp.set( emptyColorSamp );
colorProp.set( colorSamp );
numProp.set( emptyIntSamp );
numProp.set( intSamp );
numProp.set( emptyIntSamp );
numProp.set( intSamp );
strProp.set( emptyStrSamp );
strProp.set( strSamp );
strProp.set( emptyStrSamp );
strProp.set( strSamp );
}
{
StringArraySamplePtr strSampPtr;
C3fArraySamplePtr colorSampPtr;
Int32ArraySamplePtr intSampPtr;
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) );
ICompoundProperty root = archive.getTop().getProperties();
IC3fArrayProperty colorProp( root, "colors" );
IInt32ArrayProperty numProp( root, "numbers" );
IStringArrayProperty strProp( root, "strings" );
TESTING_ASSERT( isReference( strProp.getHeader() ) );
TESTING_ASSERT( colorProp.getNumSamples() == 4 );
TESTING_ASSERT( strProp.getNumSamples() == 4 );
TESTING_ASSERT( numProp.getNumSamples() == 4 );
colorProp.get( colorSampPtr, 0 );
strProp.get( strSampPtr, 0 );
numProp.get( intSampPtr, 0 );
TESTING_ASSERT( colorSampPtr->size() == 0 );
TESTING_ASSERT( strSampPtr->size() == 0 );
TESTING_ASSERT( intSampPtr->size() == 0 );
colorProp.get( colorSampPtr, 2 );
strProp.get( strSampPtr, 2 );
numProp.get( intSampPtr, 2 );
TESTING_ASSERT( colorSampPtr->size() == 0 );
TESTING_ASSERT( strSampPtr->size() == 0 );
TESTING_ASSERT( intSampPtr->size() == 0 );
colorProp.get( colorSampPtr, 1 );
strProp.get( strSampPtr, 1 );
numProp.get( intSampPtr, 1 );
TESTING_ASSERT( colorSampPtr->size() == 1 &&
colorSamp[0] == ( *colorSampPtr )[0] );
TESTING_ASSERT( strSampPtr->size() == 1 &&
strSamp[0] == ( *strSampPtr )[0] );
TESTING_ASSERT( intSampPtr->size() == 1 &&
intSamp[0] == ( *intSampPtr )[0] );
colorProp.get( colorSampPtr, 3 );
strProp.get( strSampPtr, 3 );
numProp.get( intSampPtr, 3 );
TESTING_ASSERT( colorSampPtr->size() == 1 &&
colorSamp[0] == ( *colorSampPtr )[0] );
TESTING_ASSERT( strSampPtr->size() == 1 &&
strSamp[0] == ( *strSampPtr )[0] );
TESTING_ASSERT( intSampPtr->size() == 1 &&
intSamp[0] == ( *intSampPtr )[0] );
}
}
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) );
}
}
//-*****************************************************************************
void diabolicalInstance( const std::string& iArchiveName, bool useOgawa )
{
/*
a0 b0 (points to a0)
/ |
a1 b1 (points to a1)
/ |
a2 b2 (points to b2)
*/
{
OArchive archive;
if (useOgawa)
{
archive = OArchive( Alembic::AbcCoreOgawa::WriteArchive(),
iArchiveName, ErrorHandler::kThrowPolicy );
}
else
{
archive = OArchive( Alembic::AbcCoreHDF5::WriteArchive(),
iArchiveName, ErrorHandler::kThrowPolicy );
}
OObject topobj = archive.getTop();
OObject a0( topobj, "a0" );
TESTING_ASSERT( topobj.addChildInstance( a0, "b0" ) );
OObject a1( a0, "a1" );
TESTING_ASSERT( a0.addChildInstance( a1, "b1" ) );
OObject a2( a1, "a2" );
TESTING_ASSERT( a1.addChildInstance( a2, "b2" ) );
}
{
AbcF::IFactory factory;
IArchive archive = factory.getArchive( iArchiveName );
IObject topObject = archive.getTop();
IObject a0( topObject.getChild(0) );
TESTING_ASSERT( !a0.isInstanceDescendant() );
TESTING_ASSERT( a0.getFullName() == "/a0" );
TESTING_ASSERT( !a0.getParent().isInstanceDescendant() );
TESTING_ASSERT( a0.getParent().getFullName() == "/" );
IObject b0( topObject.getChild(1) );
TESTING_ASSERT( b0.isInstanceDescendant() );
TESTING_ASSERT( b0.getName() == "b0" );
TESTING_ASSERT( b0.getFullName() == "/b0" );
TESTING_ASSERT( !b0.getParent().isInstanceDescendant() );
TESTING_ASSERT( b0.getParent().getFullName() == "/" );
IObject a0a1( a0.getChild(0) );
TESTING_ASSERT( !a0a1.isInstanceDescendant() );
TESTING_ASSERT( a0a1.getName() == "a1" );
TESTING_ASSERT( a0a1.getFullName() == "/a0/a1" );
TESTING_ASSERT( !a0a1.getParent().isInstanceDescendant() );
TESTING_ASSERT( a0a1.getParent().getName() == "a0" );
TESTING_ASSERT( a0a1.getParent().getFullName() == "/a0" );
IObject a0b1( a0.getChild(1) );
TESTING_ASSERT( a0b1.isInstanceDescendant() );
TESTING_ASSERT( a0b1.getName() == "b1" );
TESTING_ASSERT( a0b1.getFullName() == "/a0/b1" );
TESTING_ASSERT( !a0b1.getParent().isInstanceDescendant() );
TESTING_ASSERT( a0b1.getParent().getName() == "a0" );
TESTING_ASSERT( a0b1.getParent().getFullName() == "/a0" );
IObject b0a1( b0.getChild(0) );
TESTING_ASSERT( b0a1.isInstanceDescendant() );
TESTING_ASSERT( b0a1.getParent().isInstanceDescendant() );
IObject b0b1( b0.getChild(1) );
TESTING_ASSERT( b0b1.isInstanceDescendant() );
TESTING_ASSERT( b0b1.getName() == "b1" );
TESTING_ASSERT( b0b1.getFullName() == "/b0/b1" );
TESTING_ASSERT( b0b1.getParent().isInstanceDescendant() );
TESTING_ASSERT( b0b1.getParent().getName() == "b0" );
TESTING_ASSERT( b0b1.getParent().getFullName() == "/b0" );
IObject a0a1a2( a0a1.getChild(0) );
TESTING_ASSERT( !a0a1a2.isInstanceDescendant() );
TESTING_ASSERT( a0a1a2.getName() == "a2" );
TESTING_ASSERT( a0a1a2.getFullName() == "/a0/a1/a2" );
TESTING_ASSERT( !a0a1a2.getParent().isInstanceDescendant() );
TESTING_ASSERT( a0a1a2.getParent().getName() == "a1" );
TESTING_ASSERT( a0a1a2.getParent().getFullName() == "/a0/a1" );
TESTING_ASSERT( !a0a1a2.getParent().getParent().isInstanceDescendant() );
TESTING_ASSERT( a0a1a2.getParent().getParent().getName() == "a0" );
TESTING_ASSERT( a0a1a2.getParent().getParent().getFullName() == "/a0" );
IObject a0a1b2( a0a1.getChild(1) );
TESTING_ASSERT( a0a1b2.isInstanceDescendant() );
TESTING_ASSERT( a0a1b2.getName() == "b2" );
TESTING_ASSERT( a0a1b2.getFullName() == "/a0/a1/b2" );
TESTING_ASSERT( !a0a1b2.getParent().isInstanceDescendant() );
TESTING_ASSERT( a0a1b2.getParent().getName() == "a1" );
TESTING_ASSERT( a0a1b2.getParent().getFullName() == "/a0/a1" );
TESTING_ASSERT( !a0a1b2.getParent().getParent().isInstanceDescendant() );
TESTING_ASSERT( a0a1b2.getParent().getParent().getName() == "a0" );
TESTING_ASSERT( a0a1b2.getParent().getParent().getFullName() == "/a0" );
IObject a0b1a2( a0b1.getChild(0) );
TESTING_ASSERT( a0b1a2.isInstanceDescendant() );
TESTING_ASSERT( a0b1a2.getName() == "a2" );
TESTING_ASSERT( a0b1a2.getFullName() == "/a0/b1/a2" );
TESTING_ASSERT( a0b1a2.getParent().isInstanceDescendant() );
TESTING_ASSERT( a0b1a2.getParent().getName() == "b1" );
TESTING_ASSERT( a0b1a2.getParent().getFullName() == "/a0/b1" );
TESTING_ASSERT( !a0b1a2.getParent().getParent().isInstanceDescendant() );
TESTING_ASSERT( a0b1a2.getParent().getParent().getName() == "a0" );
TESTING_ASSERT( a0b1a2.getParent().getParent().getFullName() == "/a0" );
IObject a0b1b2( a0b1.getChild(1) );
TESTING_ASSERT( a0b1b2.isInstanceDescendant() );
TESTING_ASSERT( a0b1b2.getName() == "b2" );
TESTING_ASSERT( a0b1b2.getFullName() == "/a0/b1/b2" );
TESTING_ASSERT( a0b1b2.getParent().isInstanceDescendant() );
TESTING_ASSERT( a0b1b2.getParent().getName() == "b1" );
TESTING_ASSERT( a0b1b2.getParent().getFullName() == "/a0/b1" );
TESTING_ASSERT( !a0b1b2.getParent().getParent().isInstanceDescendant() );
TESTING_ASSERT( a0b1b2.getParent().getParent().getName() == "a0" );
TESTING_ASSERT( a0b1b2.getParent().getParent().getFullName() == "/a0" );
IObject b0a1a2( b0a1.getChild(0) );
TESTING_ASSERT( b0a1a2.isInstanceDescendant() );
TESTING_ASSERT( b0a1a2.getName() == "a2" );
TESTING_ASSERT( b0a1a2.getFullName() == "/b0/a1/a2" );
TESTING_ASSERT( b0a1a2.getParent().isInstanceDescendant() );
TESTING_ASSERT( b0a1a2.getParent().getName() == "a1" );
TESTING_ASSERT( b0a1a2.getParent().getFullName() == "/b0/a1" );
TESTING_ASSERT( b0a1a2.getParent().getParent().isInstanceDescendant() );
TESTING_ASSERT( b0a1a2.getParent().getParent().getName() == "b0" );
TESTING_ASSERT( b0a1a2.getParent().getParent().getFullName() == "/b0" );
IObject b0a1b2( b0a1.getChild(1) );
TESTING_ASSERT( b0a1b2.isInstanceDescendant() );
TESTING_ASSERT( b0a1b2.getName() == "b2" );
TESTING_ASSERT( b0a1b2.getFullName() == "/b0/a1/b2" );
TESTING_ASSERT( b0a1b2.getParent().isInstanceDescendant() );
TESTING_ASSERT( b0a1b2.getParent().getName() == "a1" );
TESTING_ASSERT( b0a1b2.getParent().getFullName() == "/b0/a1" );
TESTING_ASSERT( b0a1b2.getParent().getParent().isInstanceDescendant() );
TESTING_ASSERT( b0a1b2.getParent().getParent().getName() == "b0" );
TESTING_ASSERT( b0a1b2.getParent().getParent().getFullName() == "/b0" );
IObject b0b1a2( b0b1.getChild(0) );
TESTING_ASSERT( b0b1a2.isInstanceDescendant() );
TESTING_ASSERT( b0b1a2.getName() == "a2" );
TESTING_ASSERT( b0b1a2.getFullName() == "/b0/b1/a2" );
TESTING_ASSERT( b0b1a2.getParent().isInstanceDescendant() );
TESTING_ASSERT( b0b1a2.getParent().getName() == "b1" );
TESTING_ASSERT( b0b1a2.getParent().getFullName() == "/b0/b1" );
TESTING_ASSERT( b0b1a2.getParent().getParent().isInstanceDescendant() );
TESTING_ASSERT( b0b1a2.getParent().getParent().getName() == "b0" );
TESTING_ASSERT( b0b1a2.getParent().getParent().getFullName() == "/b0" );
IObject b0b1b2( b0b1.getChild(1) );
TESTING_ASSERT( b0b1b2.isInstanceDescendant() );
TESTING_ASSERT( b0b1b2.getName() == "b2" );
TESTING_ASSERT( b0b1b2.getFullName() == "/b0/b1/b2" );
TESTING_ASSERT( b0b1b2.getParent().isInstanceDescendant() );
TESTING_ASSERT( b0b1b2.getParent().getName() == "b1" );
TESTING_ASSERT( b0b1b2.getParent().getFullName() == "/b0/b1" );
TESTING_ASSERT( b0b1b2.getParent().getParent().isInstanceDescendant() );
TESTING_ASSERT( b0b1b2.getParent().getParent().getName() == "b0" );
TESTING_ASSERT( b0b1b2.getParent().getParent().getFullName() == "/b0" );
}
}
//-*****************************************************************************
int main( int argc, char *argv[] )
{
//float opt_fps = 24.0;
bool opt_all = false; // show all option
bool opt_long = false; // long listing option
bool opt_meta = false; // metadata option
bool opt_recursive = false; // recursive option
bool opt_size = false; // array sample size option
bool opt_time = false; // time info option
bool opt_values = false; // show all 0th values
int index = -1; // sample number, at tail of path
std::string desc( "abcls [OPTION] FILE[/NAME] \n"
" -a include property listings\n"
" -f show time sampling as 24 fps\n"
" -h, --help show this help message\n"
" -l long listing format\n"
" -m show archive metadata\n"
" -r list entries recursively\n"
" -s show the size of a data property sample\n"
" -t show time sampling information\n"
" -v show 0th value for all properties\n"
);
/* sigaction if available */
#if defined(_POSIX_VERSION) && (_POSIX_VERSION >= 199506L)
// seg fault handler
struct sigaction act;
sigemptyset(&act.sa_mask);
act.sa_handler = segfault_sigaction;
act.sa_flags = SA_SIGINFO;
sigaction(SIGSEGV, &act, NULL);
/* signal if available */
#elif defined(_POSIX_VERSION) || defined(_MSC_VER)
signal(SIGSEGV, segfault_sigaction);
#else
#error No signal interface available
#endif //_POSIX_VERSION
// check for min args
if ( argc < 2 ) {
std::cout << desc << std::endl;
return 0;
};
// parse args
std::vector<std::string> arguments(argv, argv + argc);
std::vector<std::string> options;
std::vector<std::string> files;
// separate file args from option args
for ( std::size_t i = 1; i < arguments.size(); i++ ) {
if ( arguments[ i ].substr( 0, 1 ) == "-" )
options.push_back( arguments[ i ] );
else
files.push_back( arguments[ i ] );
}
// help
if ( argc < 2 ||
optionExists( options, "h" ) ||
optionExists( options, "help" )
) {
std::cout << desc << std::endl;
return 0;
};
// set some flags
double fps = 1.0;
opt_all = optionExists( options, "a" );
opt_long = optionExists( options, "l" );
opt_meta = optionExists( options, "m" );
opt_recursive = optionExists( options, "r" );
opt_size = optionExists( options, "s" );
opt_time = optionExists( options, "t" );
opt_values = optionExists( options, "v" );
if ( optionExists( options, "f" ) ) {
fps = 24.0;
opt_time = true;
}
// open each file
for ( std::size_t i = 0; i < files.size(); i++ ) {
if ( files.size() > 1 )
std::cout << BOLD << files[i] << ':' << RESETCOLOR << std::endl;
std::stringstream ss( files[i] );
std::stringstream fp;
std::string segment;
std::vector<std::string> seglist;
/*
* separate file and object paths, e.g.
*
* ../dir1/foo.abc/bar/baz/index
* \_____________/\______/\____/
* file obj sample
*/
int j = 0;
while ( std::getline( ss, segment, '/' ) ) {
if ( !isFile ( fp.str() ) ) {
if ( j != 0 )
fp << "/";
fp << segment;
} else {
seglist.push_back( segment );
}
++j;
}
bool lastIsIndex = false;
if (!seglist.empty() && is_digit( seglist.back() ) ) {
index = atoi( seglist.back().c_str() );
lastIsIndex = true;
}
// open the iarchive
Abc::IArchive archive;
AbcF::IFactory factory;
factory.setPolicy(Abc::ErrorHandler::kQuietNoopPolicy);
AbcF::IFactory::CoreType coreType;
archive = factory.getArchive(std::string( fp.str() ), coreType);
// display file metadata
if ( opt_meta && seglist.size() == 0 ) {
std::cout << "Using "
<< Alembic::AbcCoreAbstract::GetLibraryVersion()
<< std::endl;;
std::string appName;
std::string libraryVersionString;
Alembic::Util::uint32_t libraryVersion;
std::string whenWritten;
std::string userDescription;
std::string coreName;
GetArchiveInfo (archive,
appName,
libraryVersionString,
libraryVersion,
whenWritten,
userDescription);
if ( coreType == AbcF::IFactory::kOgawa ) {
coreName = "Ogawa";
} else if ( coreType == AbcF::IFactory::kHDF5 ) {
coreName = "HDF5";
} else {
coreName = "Unknown";
};
if ( appName != "" ) {
std::cout << " file written by: " << appName << std::endl;
std::cout << " using Alembic : " << libraryVersionString << std::endl;
std::cout << " written on : " << whenWritten << std::endl;
std::cout << " user description : " << userDescription << std::endl;
} else {
std::cout << " (file doesn't have any ArchiveInfo)"
<< std::endl;
}
std::cout << " core type : " << coreName << std::endl;
};
if ( opt_time && seglist.size() == 0 ) {
uint32_t numTimes = archive.getNumTimeSamplings();
std::cout << std::endl << "Time Samplings: " << std::endl;
for ( uint32_t k = 0; k < numTimes; ++k ) {
AbcA::TimeSamplingPtr ts = archive.getTimeSampling( k );
index_t maxSample =
archive.getMaxNumSamplesForTimeSamplingIndex( k );
std::cout << k << " ";
printTimeSampling( ts, maxSample, fps );
}
std::cout << std::endl;
}
// walk object hierarchy and find valid objects
AbcG::IObject test = archive.getTop();
AbcG::IObject iObj = test;
while ( test.valid() && seglist.size() > 0 ) {
test = test.getChild( seglist.front() );
if ( test.valid() ) {
iObj = test;
seglist.erase( seglist.begin() );
}
}
// walk property hierarchy for most recent object
Abc::ICompoundProperty props = iObj.getProperties();
const Abc::PropertyHeader* header;
bool found = false;
bool shouldPrintValue = false;
for ( std::size_t i = 0; i < seglist.size(); ++i ) {
header = props.getPropertyHeader( seglist[i] );
if ( header && header->isCompound() ) {
Abc::ICompoundProperty ptest( props, header->getName() );
if ( ptest.valid() ) {
props = ptest;
found = true;
}
} else if ( header && header->isSimple() ) {
found = true;
// if the last value happens to be an index, and we are a
// property then dont bother checking the last item in seglist
if (lastIsIndex && i == seglist.size() - 2)
{
shouldPrintValue = true;
break;
}
} else {
std::cout << seglist[i]
<< ": Invalid object or property"
<< std::endl;
return 1;
}
}
// do stuff
if ( shouldPrintValue ) {
printValue( props, *header, index, opt_size, opt_time, fps );
} else {
if ( found && header->isCompound() )
visit( props, opt_all, opt_long, opt_meta, opt_recursive, true, opt_values );
else if ( found && header->isSimple() )
printChild( props, *header, opt_all, opt_long, opt_values );
else
visit( iObj, opt_all, opt_long, opt_meta, opt_recursive, true, opt_values );
std::cout << RESETCOLOR;
if ( !opt_long )
std::cout << std::endl;
}
}
return 0;
}
int main(int argc, char *argv[])
{
std::string toType;
std::string inFile;
std::string outFile;
std::string forceStr;
if (argc == 4)
{
toType = argv[1];
inFile = argv[2];
outFile = argv[3];
}
else if (argc == 5)
{
forceStr = argv[1];
toType = argv[2];
inFile = argv[3];
outFile = argv[4];
}
if ((argc == 4 || argc == 5) && (forceStr.empty() || forceStr == "-force"))
{
if (inFile == outFile)
{
printf("Error: inFile and outFile must not be the same!\n");
return 1;
}
if (toType != "-toHDF" && toType != "-toOgawa")
{
printf("Error: Unknown conversion type specified %s\n",
toType.c_str());
printf("Currently only -toHDF and -toOgawa are supported.\n");
return 1;
}
Alembic::AbcCoreFactory::IFactory factory;
Alembic::AbcCoreFactory::IFactory::CoreType coreType;
Alembic::Abc::IArchive archive = factory.getArchive(inFile, coreType);
if (!archive.valid())
{
printf("Error: Invalid Alembic file specified: %s\n",
inFile.c_str());
return 1;
}
else if ( forceStr != "-force" && (
(coreType == Alembic::AbcCoreFactory::IFactory::kHDF5 &&
toType == "-toHDF") ||
(coreType == Alembic::AbcCoreFactory::IFactory::kOgawa &&
toType == "-toOgawa")) )
{
printf("Warning: Alembic file specified: %s\n",inFile.c_str());
printf("is already of the type you want to convert to.\n");
printf("Please specify -force if you want to do this anyway.\n");
return 1;
}
Alembic::Abc::IObject inTop = archive.getTop();
Alembic::Abc::OArchive outArchive;
if (toType == "-toHDF")
{
outArchive = Alembic::Abc::OArchive(
Alembic::AbcCoreHDF5::WriteArchive(),
outFile, inTop.getMetaData(),
Alembic::Abc::ErrorHandler::kThrowPolicy);
}
else if (toType == "-toOgawa")
{
outArchive = Alembic::Abc::OArchive(
Alembic::AbcCoreOgawa::WriteArchive(),
outFile, inTop.getMetaData(),
Alembic::Abc::ErrorHandler::kThrowPolicy);
}
// start at 1, we don't need to worry about intrinsic default case
for (Alembic::Util::uint32_t i = 1; i < archive.getNumTimeSamplings();
++i)
{
outArchive.addTimeSampling(*archive.getTimeSampling(i));
}
Alembic::Abc::OObject outTop = outArchive.getTop();
copyObject(inTop, outTop);
return 0;
}
printf ("Usage: abcconvert [-force] OPTION inFile outFile\n");
printf ("Used to convert an Alembic file from one type to another.\n\n");
printf ("If -force is not provided and inFile happens to be the same\n");
printf ("type as OPTION no conversion will be done and a message will\n");
printf ("be printed out.\n");
printf ("OPTION has to be one of these:\n\n");
printf (" -toHDF Convert to HDF.\n");
printf (" -toOgawa Convert to Ogawa.\n");
return 1;
}
//-*****************************************************************************
void simpleTestIn( const std::string& iArchiveName )
{
AbcF::IFactory factory;
factory.setPolicy( ErrorHandler::kThrowPolicy );
AbcF::IFactory::CoreType coreType;
IArchive archive = factory.getArchive( iArchiveName, coreType );
/*
x1
/ | \
x2 x3 x2a (x2a is an instance targeting x2)
| |
x4 x5 (x5 is an instance targeting x4)
/ |
g1 g2
|
g5
*/
// an archive has a single top object which contains all its children
IObject topObject = archive.getTop();
IObject x1( topObject, "x1" );
TESTING_ASSERT( x1 != 0 );
//
// Verify the target path
IObject x2( x1, "x2" );
TESTING_ASSERT( x2.valid() );
TESTING_ASSERT( !x2.isInstanceDescendant() );
IObject x4( x2, "x4" );
TESTING_ASSERT( x4.valid() );
TESTING_ASSERT( !x4.isInstanceDescendant() );
int numChildren = x4.getNumChildren();
TESTING_ASSERT( numChildren == 2 );
TESTING_ASSERT( x4.getParent().getFullName() == x2.getFullName() );
IObject g1( x4.getChild(0) );
TESTING_ASSERT( g1 != 0 );
TESTING_ASSERT( g1.getName() == "g1" );
TESTING_ASSERT( !g1.isInstanceDescendant() );
TESTING_ASSERT( g1.getParent() != 0 );
TESTING_ASSERT( g1.getParent().getFullName() == x4.getFullName() );
IObject g2( x4.getChild(1) );
TESTING_ASSERT( g2 != 0 );
TESTING_ASSERT( g2.getName() == "g2" );
TESTING_ASSERT( !g2.isInstanceDescendant() );
TESTING_ASSERT( g2.getParent() != 0 );
TESTING_ASSERT( g2.getParent().getFullName() == x4.getFullName() );
IObject g5( g2.getChild(0) );
TESTING_ASSERT( g5 != 0 );
TESTING_ASSERT( g5.getName() == "g5" );
TESTING_ASSERT( !g5.isInstanceDescendant() );
TESTING_ASSERT( g5.getParent() != 0 );
TESTING_ASSERT( g5.getParent().getFullName() == g2.getFullName() );
//
// Verify the instance path
IObject x3( x1, "x3" );
TESTING_ASSERT( x3 != 0 );
IObject x5( x3, "x5" );
TESTING_ASSERT( x5 != 0 );
TESTING_ASSERT( x5.isInstanceDescendant() );
TESTING_ASSERT( x5.isInstanceRoot() );
TESTING_ASSERT( x5.instanceSourcePath() == x4.getFullName() );
numChildren = x5.getNumChildren();
TESTING_ASSERT( numChildren == 2 );
TESTING_ASSERT( x5.getParent().getFullName() == x3.getFullName() );
IObject g1p( x5.getChild(0) );
TESTING_ASSERT( g1p != 0 );
TESTING_ASSERT( g1p.getName() == "g1" );
TESTING_ASSERT( g1p.isInstanceDescendant() );
TESTING_ASSERT( !g1p.isInstanceRoot() );
TESTING_ASSERT( g1p.getParent() != 0 );
TESTING_ASSERT( g1p.getParent().getFullName() == x5.getFullName() );
IObject g2p( x5.getChild(1) );
TESTING_ASSERT( g2p != 0 );
TESTING_ASSERT( g2p.getName() == "g2" );
TESTING_ASSERT( g2p.isInstanceDescendant() );
TESTING_ASSERT( !g2p.isInstanceRoot() );
TESTING_ASSERT( g2p.getParent() != 0 );
TESTING_ASSERT( g2p.getParent().getFullName() == x5.getFullName() );
IObject g5p( g2p.getChild(0) );
TESTING_ASSERT( g5p != 0 );
TESTING_ASSERT( g5p.getName() == "g5" );
TESTING_ASSERT( g5p.isInstanceDescendant() );
TESTING_ASSERT( !g5p.isInstanceRoot() );
TESTING_ASSERT( g5p.getParent() != 0 );
TESTING_ASSERT( g5p.getParent().getFullName() == g2p.getFullName() );
// test x2a
IObject x2a( x1, "x2a" );
TESTING_ASSERT( x2a.valid() );
TESTING_ASSERT( x2a.isInstanceDescendant() );
TESTING_ASSERT( x2a.isInstanceRoot() );
TESTING_ASSERT( x2a.instanceSourcePath() == x2.getFullName() );
TESTING_ASSERT( x2a.getNumChildren() == 1 );
IObject x2aParent = x2a.getParent();
TESTING_ASSERT( x2aParent.getFullName() == "/x1" );
TESTING_ASSERT( !x2aParent.isInstanceDescendant() );
}
int main(int argc, char *argv[])
{
ConversionOptions options;
bool doConversion = false;
if (parseArgs( argc, argv, options, doConversion ) == false)
return 1;
if (doConversion)
{
for( std::vector<std::string>::const_iterator inFile = options.inFiles.begin(); inFile != options.inFiles.end(); inFile++ )
{
if (*inFile == options.outFile)
{
printf("Error: inFile and outFile must not be the same!\n");
return 1;
}
}
if (options.toType != IFactoryNS::kHDF5 && options.toType != IFactoryNS::kOgawa)
{
printf("Currently only -toHDF and -toOgawa are supported.\n");
return 1;
}
Alembic::AbcCoreFactory::IFactory factory;
Alembic::AbcCoreFactory::IFactory::CoreType coreType;
Alembic::Abc::IArchive archive;
if(options.inFiles.size() == 1)
{
archive = factory.getArchive(*options.inFiles.begin(), coreType);
if (!archive.valid())
{
printf("Error: Invalid Alembic file specified: %s\n",
options.inFiles.begin()->c_str());
return 1;
}
else if ( !options.force && (
(coreType == IFactoryNS::kHDF5 &&
options.toType == IFactoryNS::kHDF5) ||
(coreType == IFactoryNS::kOgawa &&
options.toType == IFactoryNS::kOgawa)) )
{
printf("Warning: Alembic file specified: %s\n", options.inFiles.begin()->c_str());
printf("is already of the type you want to convert to.\n");
printf("Please specify -force if you want to do this anyway.\n");
return 1;
}
}
else
{
archive = factory.getArchive(options.inFiles, coreType);
}
Alembic::Abc::IObject inTop = archive.getTop();
Alembic::Abc::OArchive outArchive;
if (options.toType == IFactoryNS::kHDF5)
{
outArchive = Alembic::Abc::OArchive(
Alembic::AbcCoreHDF5::WriteArchive(),
options.outFile, inTop.getMetaData(),
Alembic::Abc::ErrorHandler::kThrowPolicy);
}
else if (options.toType == IFactoryNS::kOgawa)
{
outArchive = Alembic::Abc::OArchive(
Alembic::AbcCoreOgawa::WriteArchive(),
options.outFile, inTop.getMetaData(),
Alembic::Abc::ErrorHandler::kThrowPolicy);
}
// start at 1, we don't need to worry about intrinsic default case
for (Alembic::Util::uint32_t i = 1; i < archive.getNumTimeSamplings();
++i)
{
outArchive.addTimeSampling(*archive.getTimeSampling(i));
}
Alembic::Abc::OObject outTop = outArchive.getTop();
copyObject(inTop, outTop);
}
return 0;
}
void readProperty(const std::string &archiveName)
{
// Open an existing archive for reading. Indicate that we want
// Alembic to throw exceptions on errors.
std::cout << "Reading " << archiveName << std::endl;
AbcF::IFactory factory;
factory.setPolicy( ErrorHandler::kThrowPolicy );
AbcF::IFactory::CoreType coreType;
IArchive archive = factory.getArchive(archiveName, coreType);
IObject archiveTop = archive.getTop();
// Determine the number of (top level) children the archive has
const unsigned int numChildren = archiveTop.getNumChildren();
ABCA_ASSERT( numChildren == 1, "Wrong number of children (expected 3)");
std::cout << "The archive has " << numChildren << " children:"
<< std::endl;
// Iterate through them, print out their names
IObject child( archiveTop, archiveTop.getChildHeader(0).getName() );
std::cout << " " << child.getName();
// Properties
ICompoundProperty props = child.getProperties();
size_t numProperties = props.getNumProperties(); // only top-level props
ABCA_ASSERT( numProperties == 1,
"Expected 1 property, found " << numProperties);
std::cout << " has a simple property";
std::vector<std::string> propNames(1);
propNames[0] = props.getPropertyHeader(0).getName();
std::cout << " named " << propNames[0] << std::endl;
PropertyType pType = props.getPropertyHeader(0).getPropertyType();
ABCA_ASSERT( pType == kScalarProperty,
"Expected a scalar property, but didn't find one" );
DataType dType = props.getPropertyHeader(0).getDataType();
ABCA_ASSERT( dType.getPod() == kFloat64POD,
"Expected a double (kFloat64POD) property, but didn't"
" find one" );
// We know this is a scalar property (I'm eliding the if/else
// statements required to recognize this)
IDoubleProperty mass( props, propNames[0] );
size_t numSamples = mass.getNumSamples();
std::cout << ".. it has " << numSamples << " samples" << std::endl;
ABCA_ASSERT( numSamples == 5, "Expected 5 samples, found " << numSamples );
std::cout << "..with values: ";
for (unsigned int ss=0; ss<numSamples; ss++)
{
ISampleSelector iss( (index_t) ss);
printSampleValue( mass, iss );
double massDiff = mass.getValue( iss ) - (33.0 + 0.1*ss);
ABCA_ASSERT( fabs(massDiff) < 1e-12, "Incorrect sample value read" );
}
std::cout << std::endl;
// Done - the archive closes itself
}
//-*****************************************************************************
void simpleTestIn( const std::string &iArchiveName, bool useOgawa)
{
AbcF::IFactory factory;
factory.setPolicy( ErrorHandler::kThrowPolicy );
AbcF::IFactory::CoreType coreType;
IArchive archive = factory.getArchive(iArchiveName, coreType);
TESTING_ASSERT( (useOgawa && coreType == AbcF::IFactory::kOgawa) ||
(!useOgawa && coreType == AbcF::IFactory::kHDF5) );
IObject archiveTop = archive.getTop();
IObject ac0( archiveTop, "ac0" );
IObject acc0( ac0, "acc0" );
IObject ac1( archiveTop, "ac1" );
IInt32ArrayProperty ac1iap0( ac1.getProperties(), "iap0" );
const AbcA::PropertyHeader * iap0Header =
ac1.getProperties().getPropertyHeader( "iap0" );
TESTING_ASSERT( IInt32ArrayProperty::matches( *iap0Header ) );
TESTING_ASSERT( OInt32ArrayProperty::matches( *iap0Header ) );
TESTING_ASSERT( ! IFloatArrayProperty::matches( *iap0Header ) );
TESTING_ASSERT( ! IV3fArrayProperty::matches( *iap0Header ) );
ISampleSelector ac1iap0iss;
AbcA::index_t sampIdx = ac1iap0iss.getIndex( ac1iap0.getTimeSampling(),
ac1iap0.getNumSamples() );
std::cout << "sampIdx: " << sampIdx << std::endl;
// an object contains a single compound property that contains all
// sub-properties; all property access is through that.
ICompoundProperty ac0Props = ac0.getProperties();
ICompoundProperty acc0Props = acc0.getProperties();
TESTING_ASSERT( ac0.getNumChildren() == 1 );
TESTING_ASSERT( ac0Props.getNumProperties() == 4 );
TESTING_ASSERT( acc0.getNumChildren() == 0 );
TESTING_ASSERT( acc0Props.getNumProperties() == 6 );
std::cout << "ac0 has " << ac0.getNumChildren() << " children and "
<< ac0Props.getNumProperties() << " properties." << std::endl;
std::cout << "acc0 has " << acc0.getNumChildren() << " children and "
<< acc0Props.getNumProperties() << " properties." << std::endl;
for ( size_t i = 0 ; i < acc0Props.getNumProperties() ; ++i )
{
std::cout << "acc0.getPropertyHeader( " << i << " ).getName(): "
<< acc0Props.getPropertyHeader( i ).getName() << std::endl;
}
ICompoundProperty acc0CProp0( acc0Props, "acc0CProp0" );
IInt32Property acc0cp0ip0( acc0CProp0, "acc0cp0ip0" );
IInt32Property acc0cp0ip1( acc0CProp0, "acc0cp0ip1" );
int acc0cp0ip0val = acc0cp0ip0.getValue();
int acc0cp0ip1val = acc0cp0ip1.getValue();
TESTING_ASSERT( acc0cp0ip0val == 0 );
TESTING_ASSERT( acc0cp0ip1val == 1 );
std::cout << "acc0cp0ip0 is " << acc0cp0ip0val << std::endl;
std::cout << "acc0cp0ip1 is " << acc0cp0ip1val << std::endl;
IV3fProperty ac0V3fp0( ac0Props, "ac0V3fp0", kStrictMatching );
IN3fProperty ac0N3fp0( ac0Props, "ac0N3fp0", kStrictMatching );
IP3fProperty ac0P3fp0( ac0Props, "ac0P3fp0", kStrictMatching );
// we expect this to throw when doing strict matching
TESTING_ASSERT_THROW (
IP3fProperty( ac0Props, "ac0N3fp0", kStrictMatching ),
Alembic::Util::Exception );
IInt32Property acc0ip0( acc0Props, "acc0ip0" );
IBoolProperty acc0bp0( acc0Props, "acc0bp0" );
TESTING_ASSERT( ! acc0bp0.getValue() );
std::cout << "bool scalar property acc0bp0 is false! Huzzah!"
<< std::endl;
TESTING_ASSERT( acc0ip0.getValue() == 99 );
TESTING_ASSERT( ac0V3fp0.getValue() == scalarV3fval );
TESTING_ASSERT( ac0N3fp0.getValue() == scalarV3fval );
TESTING_ASSERT( ac0P3fp0.getValue() == scalarV3fval );
std::cout << "acc0ip0 is " << acc0ip0.getValue() << std::endl;
std::cout << "ac0V3fp0 is " << ac0V3fp0.getValue() << std::endl;
IV3fArrayProperty acc0V3fap0( acc0Props, "acc0V3fap0", kStrictMatching );
const AbcA::PropertyHeader * acc0V3fap0Header =
acc0Props.getPropertyHeader( "acc0V3fap0" );
TESTING_ASSERT( OV3fArrayProperty::matches( *acc0V3fap0Header ) );
TESTING_ASSERT( IV3fArrayProperty::matches( *acc0V3fap0Header ) );
TESTING_ASSERT( ! OFloatArrayProperty::matches( *acc0V3fap0Header ) );
TESTING_ASSERT( ! IFloatArrayProperty::matches( *acc0V3fap0Header ) );
TESTING_ASSERT( ! IInt32ArrayProperty::matches( *acc0V3fap0Header ) );
TESTING_ASSERT( ! IP3fArrayProperty::matches( *acc0V3fap0Header ) );
TESTING_ASSERT( ! IV3fProperty::matches( *acc0V3fap0Header ) );
V3fArraySamplePtr acc0V3fap0SampPtr;
IP3fArrayProperty acc0P3fap0( acc0Props, "acc0P3fap0", kStrictMatching );
const AbcA::PropertyHeader * acc0P3fap0Header =
acc0Props.getPropertyHeader( "acc0P3fap0" );
TESTING_ASSERT( OP3fArrayProperty::matches( *acc0P3fap0Header ) );
TESTING_ASSERT( IP3fArrayProperty::matches( *acc0P3fap0Header ) );
TESTING_ASSERT( ! OFloatArrayProperty::matches( *acc0P3fap0Header ) );
TESTING_ASSERT( ! IFloatArrayProperty::matches( *acc0P3fap0Header ) );
TESTING_ASSERT( ! IInt32ArrayProperty::matches( *acc0P3fap0Header ) );
TESTING_ASSERT( ! IV3fArrayProperty::matches( *acc0P3fap0Header ) );
TESTING_ASSERT( ! IP3fProperty::matches( *acc0P3fap0Header ) );
P3fArraySamplePtr acc0P3fap0SampPtr;
IN3fArrayProperty acc0N3fap0( acc0Props, "acc0N3fap0", kStrictMatching );
const AbcA::PropertyHeader * acc0N3fap0Header =
acc0Props.getPropertyHeader( "acc0N3fap0" );
TESTING_ASSERT( ON3fArrayProperty::matches( *acc0N3fap0Header ) );
TESTING_ASSERT( IN3fArrayProperty::matches( *acc0N3fap0Header ) );
TESTING_ASSERT( ! OFloatArrayProperty::matches( *acc0N3fap0Header ) );
TESTING_ASSERT( ! IFloatArrayProperty::matches( *acc0N3fap0Header ) );
TESTING_ASSERT( ! IInt32ArrayProperty::matches( *acc0N3fap0Header ) );
TESTING_ASSERT( ! IV3fArrayProperty::matches( *acc0N3fap0Header ) );
TESTING_ASSERT( ! IP3fProperty::matches( *acc0N3fap0Header ) );
N3fArraySamplePtr acc0N3fap0SampPtr;
TESTING_ASSERT_THROW (
IP3fProperty( ac0Props, "acc0V3fap0", kStrictMatching ),
Alembic::Util::Exception );
IInt32ArrayProperty ac0iap0( ac0Props, "ac0iap0" );
Int32ArraySamplePtr ac0iap0SampPtr;
const size_t numReadV3fSamps = acc0V3fap0.getNumSamples();
const size_t numReadN3fSamps = acc0N3fap0.getNumSamples();
const size_t numReadP3fSamps = acc0P3fap0.getNumSamples();
const size_t numReadIntSamps = ac0iap0.getNumSamples();
TESTING_ASSERT( numReadIntSamps == numIntSamps );
TESTING_ASSERT( numReadV3fSamps == numV3fSamps );
TESTING_ASSERT( numReadN3fSamps == numV3fSamps );
TESTING_ASSERT( numReadP3fSamps == numV3fSamps );
std::cout << "acc0V3fap0 has " << numReadV3fSamps << " samples." << std::endl;
std::cout << "ac0iap0 has " << numReadIntSamps << " samples." << std::endl;
// first the V3f array property
for ( size_t i = 0 ; i < numV3fSamps ; ++i )
{
acc0V3fap0.get( acc0V3fap0SampPtr, i );
acc0N3fap0.get( acc0N3fap0SampPtr, i );
acc0P3fap0.get( acc0P3fap0SampPtr, i );
size_t numPoints = acc0V3fap0SampPtr->size();
chrono_t time = acc0V3fap0.getTimeSampling()->getSampleTime( i );
chrono_t compTime = v3fStartTime + ( i * dt );
TESTING_ASSERT( numPoints == numV3fPoints );
TESTING_ASSERT( numPoints == acc0N3fap0SampPtr->size() );
TESTING_ASSERT( numPoints == acc0P3fap0SampPtr->size() );
TESTING_ASSERT( Imath::equalWithAbsError( time, compTime,
CHRONO_EPSILON ) );
float32_t elementVal = i + time;
TESTING_ASSERT( (*acc0V3fap0SampPtr)[0][0] == elementVal );
TESTING_ASSERT( (*acc0N3fap0SampPtr)[0][0] == elementVal );
TESTING_ASSERT( (*acc0P3fap0SampPtr)[0][0] == elementVal );
std::cout << "acc0V3fap0 at sample " << i << " is at time "
<< time
<< " and has " << numPoints << " points "
<< " with the values:" << std::endl;
for ( size_t j = 0 ; j < numPoints ; ++j )
{
std::cout << (*acc0V3fap0SampPtr)[j] << ", ";
}
std::cout << std::endl << std::endl;
}
// now the int array property
for ( size_t i = 0 ; i < numIntSamps ; ++i )
{
ac0iap0.get( ac0iap0SampPtr, i );
size_t numPoints = ac0iap0SampPtr->size();
chrono_t time = ac0iap0.getTimeSampling()->getSampleTime( i );
chrono_t compTime = intStartTime + ( i * dt );
TESTING_ASSERT( Imath::equalWithAbsError( time, compTime,
CHRONO_EPSILON ) );
TESTING_ASSERT( numPoints == numIntPoints );
std::cout << "ac0iap0 at sample " << i << " is at time "
<< time
<< " and has " << numPoints << " points"
<< " with the values:" << std::endl;
for ( size_t j = 0 ; j < numPoints ; ++j )
{
Alembic::Util::int32_t val = (*ac0iap0SampPtr)[j];
TESTING_ASSERT( val == ( Alembic::Util::int32_t ) ( i + j ) );
std::cout << val << ", ";
}
std::cout << std::endl << std::endl;
}
}
void readSimpleProperties(const std::string &archiveName)
{
// Open an existing archive for reading. Indicate that we want
// Alembic to throw exceptions on errors.
AbcF::IFactory factory;
factory.setPolicy( ErrorHandler::kThrowPolicy );
AbcF::IFactory::CoreType coreType;
IArchive archive = factory.getArchive(archiveName, coreType);
IObject archiveTop = archive.getTop();
// Determine the number of (top level) children the archive has
const int numChildren = archiveTop.getNumChildren();
TESTING_ASSERT( numChildren == 4 );
std::cout << "The archive has " << numChildren << " children:"
<< std::endl;
// Iterate through them, print out their names
for (int ii=0; ii<numChildren; ii++)
{
IObject child( archiveTop, archiveTop.getChildHeader( ii ).getName() );
std::cout << " " << child.getName();
std::cout << " has " << child.getNumChildren() << " children"
<< std::endl;
// Properties
ICompoundProperty props = child.getProperties();
int numProperties = props.getNumProperties();
std::cout << " ..and " << numProperties << " simple properties"
<< std::endl;
std::vector<std::string> propNames;
for (int pp=0; pp<numProperties; pp++)
propNames.push_back( props.getPropertyHeader(pp).getName() );
for (int jj=0; jj<numProperties; jj++)
{
std::cout << " ..named " << propNames[jj] << std::endl;
std::cout << " ..with type: ";
PropertyType pType = props.getPropertyHeader(jj).getPropertyType();
if (pType == kCompoundProperty)
{
std::cout << "compound" << std::endl;
}
else if (pType == kScalarProperty)
{
std::cout << "scalar" << std::endl;
}
else if (pType == kArrayProperty)
{
std::cout << "array" << std::endl;
}
DataType dType = props.getPropertyHeader(jj).getDataType();
std::cout << " ..with POD-type: ";
switch (dType.getPod())
{
case kBooleanPOD:
std::cout << "boolean" << std::endl;
break;
// Char/UChar
case kUint8POD:
std::cout << "unsigned char" << std::endl;
break;
case kInt8POD:
std::cout << "char" << std::endl;
break;
// Short/UShort
case kUint16POD:
std::cout << "short unsigned int" << std::endl;
break;
case kInt16POD:
std::cout << "short int" << std::endl;
break;
// Int/UInt
case kUint32POD:
std::cout << "unsigned int" << std::endl;
break;
case kInt32POD:
std::cout << "int" << std::endl;
break;
// Long/ULong
case kUint64POD:
std::cout << "unsigned long int" << std::endl;
break;
case kInt64POD:
std::cout << "long int" << std::endl;
break;
// Half/Float/Double
case kFloat16POD:
std::cout << "half" << std::endl;
break;
case kFloat32POD:
std::cout << "float" << std::endl;
break;
case kFloat64POD:
std::cout << "double" << std::endl;
break;
case kStringPOD:
std::cout << "string" << std::endl;
break;
case kUnknownPOD:
default:
std::cout << " Unknown! (this is bad)" << std::endl;
};
TimeSamplingPtr ts =
GetCompoundPropertyReaderPtr(props)->
getScalarProperty( propNames[jj] )->getTimeSampling();
int numSamples = ts->getNumStoredTimes();
std::cout << " ..and "
<< ts->getTimeSamplingType() << std::endl
<< " ..and " << numSamples << " samples at times: ";
if (numSamples > 0)
{
std::cout << " ( ";
for (int ss=0; ss<numSamples; ss++)
std::cout << ts->getSampleTime(ss) << " ";
std::cout << ")";
}
std::cout << std::endl;
std::cout << " ..and values: ";
if (numSamples > 0)
{
for (int ss=0; ss<numSamples; ss++)
{
ISampleSelector iss( (index_t) ss);
switch (dType.getPod())
{
// Boolean
case kBooleanPOD:
{
IBoolProperty prop( props, propNames[jj] );
printSampleValue( prop, iss );
break;
}
// Char/UChar
case kUint8POD:
{
IUcharProperty prop( props, propNames[jj] );
printSampleValue( prop, iss );
break;
}
case kInt8POD:
{
ICharProperty prop( props, propNames[jj] );
printSampleValue( prop, iss );
break;
}
// Short/UShort
case kUint16POD:
{
IUInt16Property prop( props, propNames[jj] );
printSampleValue( prop, iss );
break;
}
case kInt16POD:
{
IInt16Property prop( props, propNames[jj] );
printSampleValue( prop, iss );
break;
}
// Int/UInt
case kUint32POD:
{
IUInt32Property prop( props, propNames[jj] );
printSampleValue( prop, iss );
break;
}
case kInt32POD:
{
IInt32Property prop( props, propNames[jj] );
printSampleValue( prop, iss );
break;
}
// Long/ULong
case kUint64POD:
{
IUInt64Property prop( props, propNames[jj] );
printSampleValue( prop, iss );
break;
}
case kInt64POD:
{
IInt64Property prop( props, propNames[jj] );
printSampleValue( prop, iss );
break;
}
// Half/Float/Double
case kFloat16POD:
// iostream doesn't understand float_16's
//printSampleValue( IHalfProperty( props, propNames[jj] ),
// iss );
break;
case kFloat32POD:
{
IFloatProperty prop( props, propNames[jj] );
printSampleValue( prop, iss );
break;
}
case kFloat64POD:
{
IDoubleProperty prop( props, propNames[jj] );
printSampleValue( prop, iss );
break;
}
case kUnknownPOD:
default:
std::cout << " Unknown! (this is bad)" << std::endl;
};
}
}
std::cout << std::endl;
std::cout << std::endl; // done parsing property
}
}
// Done - the archive closes itself
}
//-*****************************************************************************
//-*****************************************************************************
// DO IT.
//-*****************************************************************************
//-*****************************************************************************
int main( int argc, char *argv[] )
{
if (argc < 4)
{
std::cerr << "USAGE: " << argv[0] << " outFile.abc inFile1.abc"
<< " inFile2.abc (inFile3.abc ...)" << std::endl;
return -1;
}
{
size_t numInputs = argc - 2;
std::vector< chrono_t > minVec;
minVec.reserve(numInputs);
std::vector< IArchive > iArchives;
iArchives.reserve(numInputs);
std::map< chrono_t, size_t > minIndexMap;
size_t rootChildren = 0;
Alembic::AbcCoreFactory::IFactory factory;
factory.setPolicy(ErrorHandler::kThrowPolicy);
Alembic::AbcCoreFactory::IFactory::CoreType coreType;
for (int i = 2; i < argc; ++i)
{
IArchive archive = factory.getArchive(argv[i], coreType);
if (!archive.valid() || archive.getTop().getNumChildren() < 1)
{
std::cerr << "ERROR: " << argv[i] <<
" not a valid Alembic file" << std::endl;
return 1;
}
IObject iRoot = archive.getTop();
size_t numChildren = iRoot.getNumChildren();
if (i == 2)
{
rootChildren = numChildren;
}
else if (rootChildren != numChildren)
{
std::cerr << "ERROR: " << argv[i] <<
" doesn't have the same number of children as: " <<
argv[i-1] << std::endl;
}
// reorder the input files according to their mins
chrono_t min = DBL_MAX;
Alembic::Util::uint32_t numSamplings = archive.getNumTimeSamplings();
if (numSamplings > 1)
{
// timesampling index 0 is special, so it will be skipped
//
// make sure all the other timesampling objects start at
// the same time or throw here
//
min = archive.getTimeSampling(1)->getSampleTime(0);
for (Alembic::Util::uint32_t s = 2; s < numSamplings; ++s)
{
chrono_t thisMin =
archive.getTimeSampling(s)->getSampleTime(0);
if (fabs(thisMin - min) > 1e-5)
{
std::cerr << "ERROR: " << argv[i]
<< " has non-default TimeSampling objects"
<< " that don't start at the same time."
<< std::endl;
return 1;
}
}
minVec.push_back(min);
if (minIndexMap.count(min) == 0)
{
minIndexMap.insert(std::make_pair(min, i-2));
}
else if (argv[2] != argv[i])
{
std::cerr << "ERROR: overlapping frame range between "
<< argv[2] << " and " << argv[i] << std::endl;
return 1;
}
}
else
{
std::cerr << "ERROR: " << archive.getName() <<
" only has default (static) TimeSampling." << std::endl;
return 1;
}
iArchives.push_back(archive);
}
// now reorder the input nodes so they are in increasing order of their
// min values in the frame range
std::sort(minVec.begin(), minVec.end());
std::vector< IArchive > iOrderedArchives;
iOrderedArchives.reserve(numInputs);
for (size_t f = 0; f < numInputs; ++f)
{
size_t index = minIndexMap.find(minVec[f])->second;
iOrderedArchives.push_back(iArchives[index]);
}
std::string appWriter = "AbcStitcher";
std::string fileName = argv[1];
std::string userStr;
// Create an archive with the default writer
OArchive oArchive;
if (coreType == Alembic::AbcCoreFactory::IFactory::kHDF5)
{
oArchive = CreateArchiveWithInfo(
Alembic::AbcCoreHDF5::WriteArchive(),
fileName, appWriter, userStr, ErrorHandler::kThrowPolicy);
}
else if (coreType == Alembic::AbcCoreFactory::IFactory::kOgawa)
{
oArchive = CreateArchiveWithInfo(
Alembic::AbcCoreOgawa::WriteArchive(),
fileName, appWriter, userStr, ErrorHandler::kThrowPolicy);
}
OObject oRoot = oArchive.getTop();
if (!oRoot.valid())
return -1;
std::vector<IObject> iRoots;
iRoots.resize(numInputs);
for (size_t f = 0; f < rootChildren; ++f)
{
for (size_t g = 0; g < numInputs; ++g)
{
iRoots[g] = iOrderedArchives[g].getTop().getChild(f);
}
visitObjects(iRoots, oRoot);
}
// collect the top level compound property
ICompoundPropertyVec iCompoundProps;
iCompoundProps.reserve(numInputs);
for (size_t f = 0; f < numInputs; ++f)
{
iCompoundProps.push_back(iRoots[f].getParent().getProperties());
}
OCompoundProperty oCompoundProperty = oRoot.getProperties();
stitchCompoundProp(iCompoundProps, oCompoundProperty);
}
return 0;
}
//-*****************************************************************************
int main( int argc, char *argv[] )
{
bool opt_all = false;
bool opt_meta = false;
std::string desc( "abctree [OPTION] FILE[/NAME]\n"
" -a include properties listings\n"
" -h, --help prints this help message\n"
" -m print metadata\n"
);
// check for min args
if ( argc < 2 ) {
std::cout << desc << std::endl;
return 0;
};
// parse args
std::vector<std::string> arguments(argv, argv + argc);
std::vector<std::string> options;
std::vector<std::string> files;
// separate file args from option args
for ( std::size_t i = 1; i < arguments.size(); i++ ) {
if ( arguments[ i ].substr( 0, 1 ) == "-" )
options.push_back( arguments[ i ] );
else
files.push_back( arguments[ i ] );
}
// help
if ( argc < 2 ||
optionExists( options, "h" ) ||
optionExists( options, "help" )
) {
std::cout << desc << std::endl;
return 0;
};
// set some flags
opt_all = optionExists( options, "a");
opt_meta = optionExists( options, "m");
// open each file
size_t count = 0;
for ( std::size_t i = 0; i < files.size(); i++ ) {
if ( files.size() > 1 )
std::cout << BOLD << files[i] << ':' << RESETCOLOR << std::endl;
std::stringstream ss( files[i] );
std::stringstream fp;
std::string segment;
std::vector<std::string> seglist;
/*
* separate file and object paths, e.g.
*
* ../dir1/foo.abc/bar/baz
* \_____________/\______/
* file obj
*/
int j = 0;
while ( std::getline( ss, segment, '/' ) ) {
if ( !isFile ( fp.str() ) ) {
if ( j != 0 )
fp << "/";
fp << segment;
} else {
seglist.push_back( segment );
}
++j;
}
// open the iarchive
Abc::IArchive archive;
AbcF::IFactory factory;
factory.setPolicy(Abc::ErrorHandler::kQuietNoopPolicy);
AbcF::IFactory::CoreType coreType;
archive = factory.getArchive(std::string( fp.str() ), coreType);
// display file metadata
if ( opt_meta ) {
std::cout << "Using "
<< Alembic::AbcCoreAbstract::GetLibraryVersion ()
<< std::endl;;
std::string appName;
std::string libraryVersionString;
Alembic::Util::uint32_t libraryVersion;
std::string whenWritten;
std::string userDescription;
std::string coreName;
GetArchiveInfo (archive,
appName,
libraryVersionString,
libraryVersion,
whenWritten,
userDescription);
if ( coreType == AbcF::IFactory::kOgawa ) {
coreName = "Ogawa";
} else if ( coreType == AbcF::IFactory::kHDF5 ) {
coreName = "HDF5";
} else {
coreName = "Unknown";
};
if ( appName != "" ) {
std::cout << " file written by: " << appName << std::endl;
std::cout << " using Alembic : " << libraryVersionString << std::endl;
std::cout << " written on : " << whenWritten << std::endl;
std::cout << " user description : " << userDescription << std::endl;
} else {
std::cout << " (file doesn't have any ArchiveInfo)"
<< std::endl;
}
std::cout << " core type : " << coreName << std::endl;
};
// walk object hierarchy and find valid objects
AbcG::IObject test = archive.getTop();
AbcG::IObject iObj = test;
while ( test.valid() && seglist.size() > 0 ) {
test = test.getChild( seglist.front() );
if ( test.valid() ) {
iObj = test;
seglist.erase( seglist.begin() );
}
}
// walk property hierarchy for most recent valid object
Abc::ICompoundProperty props = iObj.getProperties();
const Abc::PropertyHeader* header;
bool found = false;
for ( std::size_t i = 0; i < seglist.size(); ++i ) {
header = props.getPropertyHeader( seglist[i] );
if ( header && header->isCompound() ) {
Abc::ICompoundProperty ptest( props, header->getName() );
if ( ptest.valid() ) {
props = ptest;
found = true;
}
} else if ( header && header->isSimple() ) {
found = true;
} else {
std::cout << seglist[i]
<< ": Invalid object or property"
<< std::endl;
return 1;
}
}
// walk the archive tree
if ( found )
if ( header->isCompound() )
tree( props );
else
tree( Abc::IScalarProperty( props, header->getName() ) );
else
tree( iObj, opt_all );
++count;
}
return 0;
}
//-*****************************************************************************
void sparseTest()
{
XformOp transOp( kTranslateOperation, kTranslateHint );
XformOp scaleOp( kScaleOperation, kScaleHint );
std::string nameA = "sparseXformTestA.abc";
{
OArchive archive( Alembic::AbcCoreOgawa::WriteArchive(), nameA );
OXform transStatic( OObject( archive ), "transStatic" );
XformSample asamp;
asamp.addOp( scaleOp, V3d( 2.0, 1.0, 2.0 ) );
transStatic.getSchema().set( asamp );
OXform transAnim( transStatic, "transAnim" );
XformSample bsamp;
bsamp.addOp( transOp, V3d( 3.0, 4.0, 5.0 ) );
transAnim.getSchema().set( bsamp );
bsamp[0].setTranslate( V3d( 4.0, 5.0, 6.0 ) );
transAnim.getSchema().set( bsamp );
OXform identA( transAnim, "ident" );
OXform identB( identA, "ident" );
OXform transStatic2( identB, "transStatic" );
transStatic2.getSchema().set( asamp );
OXform transAnim2( transStatic2, "transAnim" );
transAnim2.getSchema().set( bsamp );
bsamp[0].setTranslate( V3d( 5.0, 6.0, 7.0 ) );
transAnim.getSchema().set( bsamp );
}
std::string nameB = "sparseXformTestB.abc";
{
OArchive archive( Alembic::AbcCoreOgawa::WriteArchive(), nameB );
// set this now as animated translate
OXform transStatic( OObject( archive ), "transStatic", kSparse );
XformSample asamp;
asamp.addOp( transOp, V3d( 1.0, 1.0, 1.0) );
transStatic.getSchema().set( asamp );
asamp[0].setTranslate( V3d( 2.0, 2.0, 2.0 ) );
transStatic.getSchema().set( asamp );
// this one will be static
OXform transAnim( transStatic, "transAnim", kSparse );
XformSample bsamp;
bsamp.addOp( scaleOp, V3d( 0.5, 0.5, 0.5 ) );
transAnim.getSchema().set( bsamp );
// from identity to static
OXform identA( transAnim, "ident", kSparse );
identA.getSchema().set( bsamp );
// from identity to animated
OXform identB( identA, "ident", kSparse );
identB.getSchema().set( asamp );
asamp[0].setTranslate( V3d( 3.0, 3.0, 3.0 ) );
identB.getSchema().set( asamp );
// don't set anything on these so they will be identity
OXform transStatic2( identB, "transStatic", kSparse );
OXform transAnim2( transStatic2, "transAnim", kSparse );
}
{
std::vector< std::string > names;
names.push_back( nameA );
names.push_back( nameB );
Alembic::AbcCoreFactory::IFactory factory;
IArchive archive = factory.getArchive( names );
IXform transStatic( IObject( archive ), "transStatic" );
TESTING_ASSERT( !transStatic.getSchema().isConstantIdentity() );
TESTING_ASSERT( !transStatic.getSchema().isConstant() );
IXform transAnim( transStatic, "transAnim" );
TESTING_ASSERT( !transAnim.getSchema().isConstantIdentity() );
TESTING_ASSERT( transAnim.getSchema().isConstant() );
IXform identA( transAnim, "ident" );
TESTING_ASSERT( !identA.getSchema().isConstantIdentity() );
TESTING_ASSERT( identA.getSchema().isConstant() );
IXform identB( identA, "ident");
TESTING_ASSERT( !identB.getSchema().isConstantIdentity() );
TESTING_ASSERT( !identB.getSchema().isConstant() );
IXform transStatic2( identB, "transStatic" );
TESTING_ASSERT( transStatic2.getSchema().isConstantIdentity() );
IXform transAnim2( transStatic2, "transAnim" );
TESTING_ASSERT( transAnim2.getSchema().isConstantIdentity() );
}
}