void Example3_NurbsIn()
{
std::cout << "loading archive" << std::endl;
IArchive archive( Alembic::AbcCoreHDF5::ReadArchive(), "nurbs3.abc" );
std::cout << "making INuPatch object" << std::endl;
INuPatch myNurbs( IObject( archive, kTop) , "nurbs_surface_withW");
std::cout << "getting INuPatch schema" << std::endl;
INuPatchSchema &nurbsSchema = myNurbs.getSchema();
// get the samples from the curves
std::cout << "getting INuPatch sample" << std::endl;
INuPatchSchema::Sample nurbsSample;
nurbsSchema.get( nurbsSample );
// test the bounding box
std::cout << nurbsSample.getSelfBounds().min << std::endl;
std::cout << nurbsSample.getSelfBounds().max << std::endl;
TESTING_ASSERT( nurbsSample.getSelfBounds().min == V3d( 0.0, 0.0, -3.0 ) );
TESTING_ASSERT( nurbsSample.getSelfBounds().max == V3d( 3.0, 3.0, 3.0 ) );
std::cout << "Number of trim curves: " << nurbsSample.getTrimNumLoops() << std::endl;
TESTING_ASSERT( nurbsSample.getTrimNumLoops() == 0 );
TESTING_ASSERT( nurbsSample.hasTrimCurve() == false );
TESTING_ASSERT( nurbsSample.getPositionWeights()->size() ==
( size_t ) g_nP );
TESTING_ASSERT( nurbsSchema.isConstant() == true );
}
//-*****************************************************************************
// a recursive function that reads all inputs and write to the given oObject
// node if there's no gap in the frame range for animated nodes
//
void visitObjects(std::vector< IObject > & iObjects, OObject & oParentObj)
{
OObject outObj;
const AbcA::ObjectHeader & header = iObjects[0].getHeader();
// there are a number of things that needs to be checked for each node
// to make sure they can be properly stitched together
//
// for xform node:
// locator or normal xform node
// if an xform node, numOps and type of ops match
// static or no, and if not, timesampling type matches
// if sampled, timesampling type should match
// if sampled, no frame gaps
//
if (IXform::matches(header))
{
OXformSchema oSchema;
init< IXform,
IXformSchema,
OXform,
OXformSchema >(iObjects, oParentObj, oSchema);
outObj = oSchema.getObject();
ICompoundPropertyVec iCompoundProps;
iCompoundProps.reserve(iObjects.size());
ICompoundProperty cp = iObjects[0].getProperties();
iCompoundProps.push_back(cp);
bool isLocator = cp.getPropertyHeader("locator")?true:false;
for (size_t i = 1; i < iObjects.size(); i++)
{
ICompoundProperty cp = iObjects[i].getProperties();
iCompoundProps.push_back(cp);
}
// stitch the operations if this is an xform node
for (size_t i = 0; i < iObjects.size(); i++)
{
IXformSchema iSchema =
IXform(iObjects[i], Alembic::Abc::kWrapExisting).getSchema();
index_t numSamples = iSchema.getNumSamples();
index_t reqIdx = getIndexSample(oSchema.getNumSamples(),
oSchema.getTimeSampling(), numSamples,
iSchema.getTimeSampling());
for (; reqIdx < numSamples; reqIdx++)
{
XformSample samp = iSchema.getValue(reqIdx);
oSchema.set(samp);
}
}
// stitch "locator" if it's a locator
OCompoundProperty oCompoundProp = outObj.getProperties();
if (isLocator)
{
const PropertyHeader * propHeaderPtr =
iCompoundProps[0].getPropertyHeader("locator");
stitchScalarProp(*propHeaderPtr,
iCompoundProps,
oCompoundProp);
}
}
else if (ISubD::matches(header))
{
OSubDSchema oSchema;
init< ISubD,
ISubDSchema,
OSubD,
OSubDSchema >(iObjects, oParentObj, oSchema);
outObj = oSchema.getObject();
// stitch the SubDSchema
//
for (size_t i = 0; i < iObjects.size(); i++)
{
ISubDSchema iSchema =
ISubD(iObjects[i], Alembic::Abc::kWrapExisting).getSchema();
index_t numSamples = iSchema.getNumSamples();
IV2fGeomParam uvs = iSchema.getUVsParam();
if (i == 0 && uvs)
{
oSchema.setUVSourceName(GetSourceName(uvs.getMetaData()));
}
index_t reqIdx = getIndexSample(oSchema.getNumSamples(),
oSchema.getTimeSampling(), numSamples,
iSchema.getTimeSampling());
for (; reqIdx < numSamples; reqIdx++)
{
ISubDSchema::Sample iSamp = iSchema.getValue(reqIdx);
OSubDSchema::Sample oSamp;
Abc::P3fArraySamplePtr posPtr = iSamp.getPositions();
if (posPtr)
oSamp.setPositions(*posPtr);
Abc::V3fArraySamplePtr velocPtr = iSamp.getVelocities();
if (velocPtr)
oSamp.setVelocities(*velocPtr);
Abc::Int32ArraySamplePtr faceIndicesPtr = iSamp.getFaceIndices();
if (faceIndicesPtr)
oSamp.setFaceIndices(*faceIndicesPtr);
Abc::Int32ArraySamplePtr faceCntPtr = iSamp.getFaceCounts();
if (faceCntPtr)
oSamp.setFaceCounts(*faceCntPtr);
oSamp.setFaceVaryingInterpolateBoundary(iSamp.getFaceVaryingInterpolateBoundary());
oSamp.setFaceVaryingPropagateCorners(iSamp.getFaceVaryingPropagateCorners());
oSamp.setInterpolateBoundary(iSamp.getInterpolateBoundary());
Abc::Int32ArraySamplePtr creaseIndicesPtr = iSamp.getCreaseIndices();
if (creaseIndicesPtr)
oSamp.setCreaseIndices(*creaseIndicesPtr);
Abc::Int32ArraySamplePtr creaseLenPtr = iSamp.getCreaseLengths();
if (creaseLenPtr)
oSamp.setCreaseLengths(*creaseLenPtr);
Abc::FloatArraySamplePtr creaseSpPtr = iSamp.getCreaseSharpnesses();
if (creaseSpPtr)
oSamp.setCreaseSharpnesses(*creaseSpPtr);
Abc::Int32ArraySamplePtr cornerIndicesPtr = iSamp.getCornerIndices();
if (cornerIndicesPtr)
oSamp.setCornerIndices(*cornerIndicesPtr);
Abc::FloatArraySamplePtr cornerSpPtr = iSamp.getCornerSharpnesses();
if (cornerSpPtr)
oSamp.setCreaseSharpnesses(*cornerSpPtr);
Abc::Int32ArraySamplePtr holePtr = iSamp.getHoles();
if (holePtr)
oSamp.setHoles(*holePtr);
oSamp.setSubdivisionScheme(iSamp.getSubdivisionScheme());
// set uvs
IV2fGeomParam::Sample iUVSample;
OV2fGeomParam::Sample oUVSample;
if (uvs)
{
getOGeomParamSamp <IV2fGeomParam, IV2fGeomParam::Sample,
OV2fGeomParam::Sample>(uvs, iUVSample,
oUVSample, reqIdx);
oSamp.setUVs(oUVSample);
}
oSchema.set(oSamp);
}
}
}
else if (IPolyMesh::matches(header))
{
OPolyMeshSchema oSchema;
init< IPolyMesh,
IPolyMeshSchema,
OPolyMesh,
OPolyMeshSchema >(iObjects, oParentObj, oSchema);
outObj = oSchema.getObject();
// stitch the PolySchema
//
for (size_t i = 0; i < iObjects.size(); i++)
{
IPolyMeshSchema iSchema =
IPolyMesh(iObjects[i], Alembic::Abc::kWrapExisting).getSchema();
index_t numSamples = iSchema.getNumSamples();
IN3fGeomParam normals = iSchema.getNormalsParam();
IV2fGeomParam uvs = iSchema.getUVsParam();
if (i == 0 && uvs)
{
oSchema.setUVSourceName(GetSourceName(uvs.getMetaData()));
}
index_t reqIdx = getIndexSample(oSchema.getNumSamples(),
oSchema.getTimeSampling(), numSamples,
iSchema.getTimeSampling());
for (; reqIdx < numSamples; reqIdx++)
{
IPolyMeshSchema::Sample iSamp = iSchema.getValue(reqIdx);
OPolyMeshSchema::Sample oSamp;
Abc::P3fArraySamplePtr posPtr = iSamp.getPositions();
if (posPtr)
oSamp.setPositions(*posPtr);
Abc::V3fArraySamplePtr velocPtr = iSamp.getVelocities();
if (velocPtr)
oSamp.setVelocities(*velocPtr);
Abc::Int32ArraySamplePtr faceIndicesPtr = iSamp.getFaceIndices();
if (faceIndicesPtr)
oSamp.setFaceIndices(*faceIndicesPtr);
Abc::Int32ArraySamplePtr faceCntPtr = iSamp.getFaceCounts();
if (faceCntPtr)
oSamp.setFaceCounts(*faceCntPtr);
// set uvs
IV2fGeomParam::Sample iUVSample;
OV2fGeomParam::Sample oUVSample;
if (uvs)
{
getOGeomParamSamp <IV2fGeomParam, IV2fGeomParam::Sample,
OV2fGeomParam::Sample>(uvs, iUVSample,
oUVSample, reqIdx);
oSamp.setUVs(oUVSample);
}
// set normals
IN3fGeomParam::Sample iNormalsSample;
ON3fGeomParam::Sample oNormalsSample;
if (normals)
{
getOGeomParamSamp <IN3fGeomParam, IN3fGeomParam::Sample,
ON3fGeomParam::Sample>(normals, iNormalsSample,
oNormalsSample, reqIdx);
oSamp.setNormals(oNormalsSample);
}
oSchema.set(oSamp);
}
}
}
else if (ICamera::matches(header))
{
OCameraSchema oSchema;
init< ICamera,
ICameraSchema,
OCamera,
OCameraSchema >(iObjects, oParentObj, oSchema);
outObj = oSchema.getObject();
// stitch the CameraSchemas
//
for (size_t i = 0; i < iObjects.size(); i++)
{
ICameraSchema iSchema =
ICamera(iObjects[i], Alembic::Abc::kWrapExisting).getSchema();
index_t numSamples = iSchema.getNumSamples();
index_t reqIdx = getIndexSample(oSchema.getNumSamples(),
oSchema.getTimeSampling(), numSamples,
iSchema.getTimeSampling());
for (; reqIdx < numSamples; reqIdx++)
{
oSchema.set(iSchema.getValue(reqIdx));
}
}
}
else if (ICurves::matches(header))
{
OCurvesSchema oSchema;
init< ICurves,
ICurvesSchema,
OCurves,
OCurvesSchema >(iObjects, oParentObj, oSchema);
outObj = oSchema.getObject();
// stitch the CurvesSchemas
//
for (size_t i = 0; i < iObjects.size(); i++)
{
ICurvesSchema iSchema =
ICurves(iObjects[i], Alembic::Abc::kWrapExisting).getSchema();
IV2fGeomParam iUVs = iSchema.getUVsParam();
IN3fGeomParam iNormals = iSchema.getNormalsParam();
IFloatGeomParam iWidths = iSchema.getWidthsParam();
IFloatArrayProperty iKnots = iSchema.getKnotsProperty();
IUcharArrayProperty iOrders = iSchema.getOrdersProperty();
index_t numSamples = iSchema.getNumSamples();
index_t reqIdx = getIndexSample(oSchema.getNumSamples(),
oSchema.getTimeSampling(), numSamples,
iSchema.getTimeSampling());
for (; reqIdx < numSamples; reqIdx++)
{
ICurvesSchema::Sample iSamp = iSchema.getValue(reqIdx);
OCurvesSchema::Sample oSamp;
Abc::P3fArraySamplePtr posPtr = iSamp.getPositions();
if (posPtr)
oSamp.setPositions(*posPtr);
Abc::V3fArraySamplePtr velocPtr = iSamp.getVelocities();
if (velocPtr)
oSamp.setVelocities(*velocPtr);
oSamp.setType(iSamp.getType());
Abc::Int32ArraySamplePtr curvsNumPtr = iSamp.getCurvesNumVertices();
if (curvsNumPtr)
oSamp.setCurvesNumVertices(*curvsNumPtr);
oSamp.setWrap(iSamp.getWrap());
oSamp.setBasis(iSamp.getBasis());
Abc::FloatArraySamplePtr knotsPtr = iSamp.getKnots();
if (knotsPtr)
{
oSamp.setKnots(*knotsPtr);
}
Abc::UcharArraySamplePtr ordersPtr = iSamp.getOrders();
if (ordersPtr)
{
oSamp.setOrders(*ordersPtr);
}
IFloatGeomParam::Sample iWidthSample;
OFloatGeomParam::Sample oWidthSample;
if (iWidths)
{
getOGeomParamSamp <IFloatGeomParam, IFloatGeomParam::Sample,
OFloatGeomParam::Sample>(iWidths, iWidthSample,
oWidthSample, reqIdx);
oSamp.setWidths(oWidthSample);
}
IV2fGeomParam::Sample iUVSample;
OV2fGeomParam::Sample oUVSample;
if (iUVs)
{
getOGeomParamSamp <IV2fGeomParam, IV2fGeomParam::Sample,
OV2fGeomParam::Sample>(iUVs, iUVSample,
oUVSample, reqIdx);
oSamp.setUVs(oUVSample);
}
IN3fGeomParam::Sample iNormalsSample;
ON3fGeomParam::Sample oNormalsSample;
if (iNormals)
{
getOGeomParamSamp <IN3fGeomParam, IN3fGeomParam::Sample,
ON3fGeomParam::Sample>(iNormals, iNormalsSample,
oNormalsSample, reqIdx);
oSamp.setNormals(oNormalsSample);
}
oSchema.set(oSamp);
}
}
}
else if (IPoints::matches(header))
{
OPointsSchema oSchema;
init< IPoints,
IPointsSchema,
OPoints,
OPointsSchema >(iObjects, oParentObj, oSchema);
outObj = oSchema.getObject();
// stitch the PointsSchemas
//
for (size_t i = 0; i < iObjects.size(); i++)
{
IPointsSchema iSchema =
IPoints(iObjects[i], Alembic::Abc::kWrapExisting).getSchema();
IFloatGeomParam iWidths = iSchema.getWidthsParam();
index_t numSamples = iSchema.getNumSamples();
index_t reqIdx = getIndexSample(oSchema.getNumSamples(),
oSchema.getTimeSampling(), numSamples,
iSchema.getTimeSampling());
for (; reqIdx < numSamples; reqIdx++)
{
IPointsSchema::Sample iSamp = iSchema.getValue(reqIdx);
OPointsSchema::Sample oSamp;
Abc::P3fArraySamplePtr posPtr = iSamp.getPositions();
if (posPtr)
oSamp.setPositions(*posPtr);
Abc::UInt64ArraySamplePtr idPtr = iSamp.getIds();
if (idPtr)
oSamp.setIds(*idPtr);
Abc::V3fArraySamplePtr velocPtr = iSamp.getVelocities();
if (velocPtr)
oSamp.setVelocities(*velocPtr);
IFloatGeomParam::Sample iWidthSample;
OFloatGeomParam::Sample oWidthSample;
if (iWidths)
{
getOGeomParamSamp <IFloatGeomParam, IFloatGeomParam::Sample,
OFloatGeomParam::Sample>(iWidths, iWidthSample,
oWidthSample, reqIdx);
oSamp.setWidths(oWidthSample);
}
oSchema.set(oSamp);
}
}
}
else if (INuPatch::matches(header))
{
ONuPatchSchema oSchema;
init< INuPatch,
INuPatchSchema,
ONuPatch,
ONuPatchSchema >(iObjects, oParentObj, oSchema);
outObj = oSchema.getObject();
// stitch the NuPatchSchemas
//
for (size_t i = 0; i < iObjects.size(); i++)
{
INuPatchSchema iSchema =
INuPatch(iObjects[i], Alembic::Abc::kWrapExisting).getSchema();
index_t numSamples = iSchema.getNumSamples();
IN3fGeomParam normals = iSchema.getNormalsParam();
IV2fGeomParam uvs = iSchema.getUVsParam();
index_t reqIdx = getIndexSample(oSchema.getNumSamples(),
oSchema.getTimeSampling(), numSamples,
iSchema.getTimeSampling());
for (; reqIdx < numSamples; reqIdx++)
{
INuPatchSchema::Sample iSamp = iSchema.getValue(reqIdx);
ONuPatchSchema::Sample oSamp;
Abc::P3fArraySamplePtr posPtr = iSamp.getPositions();
if (posPtr)
oSamp.setPositions(*posPtr);
Abc::V3fArraySamplePtr velocPtr = iSamp.getVelocities();
if (velocPtr)
oSamp.setVelocities(*velocPtr);
oSamp.setNu(iSamp.getNumU());
oSamp.setNv(iSamp.getNumV());
oSamp.setUOrder(iSamp.getUOrder());
oSamp.setVOrder(iSamp.getVOrder());
Abc::FloatArraySamplePtr uKnotsPtr = iSamp.getUKnot();
if (uKnotsPtr)
oSamp.setUKnot(*uKnotsPtr);
Abc::FloatArraySamplePtr vKnotsPtr = iSamp.getVKnot();
if (vKnotsPtr)
oSamp.setVKnot(*vKnotsPtr);
IV2fGeomParam::Sample iUVSample;
OV2fGeomParam::Sample oUVSample;
if (uvs)
{
getOGeomParamSamp <IV2fGeomParam, IV2fGeomParam::Sample,
OV2fGeomParam::Sample>(uvs, iUVSample,
oUVSample, reqIdx);
oSamp.setUVs(oUVSample);
}
IN3fGeomParam::Sample iNormalsSample;
ON3fGeomParam::Sample oNormalsSample;
if (normals)
{
getOGeomParamSamp <IN3fGeomParam, IN3fGeomParam::Sample,
ON3fGeomParam::Sample>(normals, iNormalsSample,
oNormalsSample, reqIdx);
oSamp.setNormals(oNormalsSample);
}
if (iSchema.hasTrimCurve())
{
oSamp.setTrimCurve(iSamp.getTrimNumLoops(),
*(iSamp.getTrimNumCurves()),
*(iSamp.getTrimNumVertices()),
*(iSamp.getTrimOrders()),
*(iSamp.getTrimKnots()),
*(iSamp.getTrimMins()),
*(iSamp.getTrimMaxes()),
*(iSamp.getTrimU()),
*(iSamp.getTrimV()),
*(iSamp.getTrimW()));
}
oSchema.set(oSamp);
}
}
}
else
{
outObj = OObject(oParentObj, header.getName(), header.getMetaData());
// collect the top level compound property
ICompoundPropertyVec iCompoundProps(iObjects.size());
for (size_t i = 0; i < iObjects.size(); i++)
{
iCompoundProps[i] = iObjects[i].getProperties();
}
OCompoundProperty oCompoundProperty = outObj.getProperties();
stitchCompoundProp(iCompoundProps, oCompoundProperty);
}
// After done writing THIS OObject node, if input nodes have children,
// go deeper.
// Otherwise we are done here
size_t numChildren = iObjects[0].getNumChildren();
// check to make sure all of our iObjects have the same number of children
for (size_t j = 1; j < iObjects.size(); j++)
{
if (numChildren != iObjects[j].getNumChildren())
{
std::cerr << "ERROR: " << iObjects[j].getFullName() << " in " <<
iObjects[j].getArchive().getName() <<
" has a different number of children than " <<
iObjects[0].getFullName() << " in " <<
iObjects[0].getArchive().getName() << std::endl;
exit(1);
}
}
for (size_t i = 0 ; i < numChildren; i++ )
{
std::vector< IObject > iChildObjects;
for (size_t f = 0; f < iObjects.size(); f++)
{
iChildObjects.push_back(iObjects[f].getChild(i));
}
visitObjects(iChildObjects, outObj);
}
}