示例#1
0
    def testWriteGeometricTypedData(self):

        o = IECoreScene.PointsPrimitive(IECore.V3fVectorData([imath.V3f(0)]))
        o["id"] = IECoreScene.PrimitiveVariable(
            IECoreScene.PrimitiveVariable.Interpolation.Vertex,
            IECore.UInt64VectorData([0]))
        o["v3f"] = IECoreScene.PrimitiveVariable(
            IECoreScene.PrimitiveVariable.Interpolation.Vertex,
            IECore.V3fVectorData([imath.V3f(1)],
                                 IECore.GeometricData.Interpretation.Vector))
        o["n3f"] = IECoreScene.PrimitiveVariable(
            IECoreScene.PrimitiveVariable.Interpolation.Vertex,
            IECore.V3fVectorData([imath.V3f(1)],
                                 IECore.GeometricData.Interpretation.Normal))
        o["p3f"] = IECoreScene.PrimitiveVariable(
            IECoreScene.PrimitiveVariable.Interpolation.Vertex,
            IECore.V3fVectorData([imath.V3f(1)],
                                 IECore.GeometricData.Interpretation.Point))

        a = IECoreAlembic.AlembicScene("/tmp/test.abc",
                                       IECore.IndexedIO.OpenMode.Write)
        c = a.createChild("o")
        c.writeObject(o, 0)
        del a, c

        a = IECoreAlembic.AlembicScene("/tmp/test.abc",
                                       IECore.IndexedIO.OpenMode.Read)
        c = a.child("o")
        self.assertEqual(c.readObjectAtSample(0), o)
示例#2
0
    def testWriteAnimatedObject(self):

        o1 = IECoreScene.PointsPrimitive(IECore.V3fVectorData([imath.V3f(0)]))
        o1["id"] = IECoreScene.PrimitiveVariable(
            IECoreScene.PrimitiveVariable.Interpolation.Vertex,
            IECore.UInt64VectorData([0]))
        o1["test"] = IECoreScene.PrimitiveVariable(
            IECoreScene.PrimitiveVariable.Interpolation.Vertex,
            IECore.IntVectorData([1]))

        o2 = IECoreScene.PointsPrimitive(IECore.V3fVectorData([imath.V3f(1)]))
        o2["id"] = IECoreScene.PrimitiveVariable(
            IECoreScene.PrimitiveVariable.Interpolation.Vertex,
            IECore.UInt64VectorData([0]))
        o2["test"] = IECoreScene.PrimitiveVariable(
            IECoreScene.PrimitiveVariable.Interpolation.Vertex,
            IECore.IntVectorData([2]))

        a = IECoreAlembic.AlembicScene("/tmp/test.abc",
                                       IECore.IndexedIO.OpenMode.Write)
        c = a.createChild("o")
        c.writeObject(o1, 0)
        c.writeObject(o2, 1)
        del a, c

        a = IECoreAlembic.AlembicScene("/tmp/test.abc",
                                       IECore.IndexedIO.OpenMode.Read)
        c = a.child("o")

        self.assertEqual(c.numObjectSamples(), 2)

        o1r = c.readObjectAtSample(0)

        self.assertEqual(c.readObjectAtSample(0), o1)
        self.assertEqual(c.readObjectAtSample(1), o2)
示例#3
0
    def testWritePointsWithoutIDs(self):

        # IDs a required by alembic and are  generated in the writer if they're not present
        # So we should expect them to be in the deserialized alembic file.
        numParticles = 1024 * 1024 * 16
        o1 = IECoreScene.PointsPrimitive(
            IECore.V3fVectorData([imath.V3f(0)] * numParticles))

        o1["a"] = IECoreScene.PrimitiveVariable(
            IECoreScene.PrimitiveVariable.Interpolation.Vertex,
            IECore.FloatVectorData([0] * numParticles))
        o1["b"] = IECoreScene.PrimitiveVariable(
            IECoreScene.PrimitiveVariable.Interpolation.Vertex,
            IECore.FloatVectorData([1] * numParticles))

        a = IECoreAlembic.AlembicScene("/tmp/test.abc",
                                       IECore.IndexedIO.OpenMode.Write)
        c = a.createChild("o")
        c.writeObject(o1, 0)
        del a, c

        a = IECoreAlembic.AlembicScene("/tmp/test.abc",
                                       IECore.IndexedIO.OpenMode.Read)
        c = a.child("o")

        self.assertEqual(c.numObjectSamples(), 1)

        ro1 = c.readObjectAtSample(0)
        self.assertTrue("id" in ro1)
        self.assertEqual(ro1["id"].data,
                         IECore.UInt64VectorData(range(numParticles)))

        del ro1["id"]
        self.assertEqual(ro1, o1)
示例#4
0
    def testReacquireChildDuringWriting(self):

        plane0 = IECoreScene.MeshPrimitive.createPlane(
            imath.Box2f(imath.V2f(-1), imath.V2f(1)))
        plane1 = IECoreScene.MeshPrimitive.createPlane(
            imath.Box2f(imath.V2f(-2), imath.V2f(2)))

        def writeHierarchy(a, plane, time):

            c = a.child(
                "c",
                IECoreScene.SceneInterface.MissingBehaviour.CreateIfMissing)
            d = c.child(
                "d",
                IECoreScene.SceneInterface.MissingBehaviour.CreateIfMissing)

            d.writeObject(plane, time)

        a = IECoreAlembic.AlembicScene("/tmp/test.abc",
                                       IECore.IndexedIO.OpenMode.Write)

        writeHierarchy(a, plane0, 0)
        writeHierarchy(a, plane1, 1)

        del a
        a = IECoreAlembic.AlembicScene("/tmp/test.abc",
                                       IECore.IndexedIO.OpenMode.Read)
        d = a.child("c").child("d")
        self.assertEqual(d.numObjectSamples(), 2)
        self.assertEqual(d.readObjectAtSample(0), plane0)
        self.assertEqual(d.readObjectAtSample(1), plane1)
示例#5
0
    def testWriteAnimatedBounds(self):

        aBound1 = imath.Box3d(imath.V3d(-2), imath.V3d(2))
        aBound2 = imath.Box3d(imath.V3d(0), imath.V3d(4))

        bBound1 = imath.Box3d(imath.V3d(-1), imath.V3d(1))
        bBound2 = imath.Box3d(imath.V3d(1), imath.V3d(3))

        a = IECoreAlembic.AlembicScene("/tmp/test.abc",
                                       IECore.IndexedIO.OpenMode.Write)
        a.writeBound(aBound1, 0)
        a.writeBound(aBound2, 1)

        b = a.createChild("b")
        b.writeBound(bBound1, 0)
        b.writeBound(bBound2, 1)

        del a, b

        a = IECoreAlembic.AlembicScene("/tmp/test.abc",
                                       IECore.IndexedIO.OpenMode.Read)
        self.assertEqual(a.numBoundSamples(), 2)
        self.assertEqual(a.readBoundAtSample(0), aBound1)
        self.assertEqual(a.readBoundAtSample(1), aBound2)
        self.assertEqual(a.readBound(0), aBound1)
        self.assertEqual(a.readBound(1), aBound2)

        b = a.child("b")
        self.assertEqual(b.numBoundSamples(), 2)
        self.assertEqual(b.readBoundAtSample(0), bBound1)
        self.assertEqual(b.readBoundAtSample(1), bBound2)
        self.assertEqual(b.readBound(0), bBound1)
        self.assertEqual(b.readBound(1), bBound2)
示例#6
0
	def testCanWeRoundTripIndexedPrimvars( self ) :

		plane = IECore.MeshPrimitive.createPlane( IECore.Box2f( IECore.V2f( -1 ), IECore.V2f( 1 ) ) )

		data = IECore.FloatVectorData( [1] )
		indices = IECore.IntVectorData( [0, 0, 0, 0] )

		primVar = IECore.PrimitiveVariable( IECore.PrimitiveVariable.Interpolation.FaceVarying, data, indices )

		plane["test"] = primVar

		outputFilename = "/tmp/test.abc"

		root = IECoreAlembic.AlembicScene( outputFilename, IECore.IndexedIO.OpenMode.Write )

		location = root.child( "object", IECore.SceneInterface.MissingBehaviour.CreateIfMissing )

		location.writeObject( plane, 0 )

		del location
		del root

		root = IECoreAlembic.AlembicScene( outputFilename, IECore.IndexedIO.OpenMode.Read )

		c = root.child( "object" )

		object = c.readObjectAtSample( 0 )

		self.assertEqual( object["test"].data, IECore.FloatVectorData( [1] ) )
		self.assertEqual( object["test"].indices, IECore.IntVectorData( [0, 0, 0, 0] ) )
示例#7
0
	def __testWriteObject( self, sourceFile, sourcePath ) :

		a1 = IECoreAlembic.AlembicScene( sourceFile, IECore.IndexedIO.OpenMode.Read )
		o1 = a1.scene( sourcePath ).readObject( 0 )

		a2 = IECoreAlembic.AlembicScene( "/tmp/test.abc", IECore.IndexedIO.OpenMode.Write )
		a2.createChild( "o" ).writeObject( o1, 0 )
		del a2

		a3 = IECoreAlembic.AlembicScene( "/tmp/test.abc", IECore.IndexedIO.OpenMode.Read )
		o2 = a3.child( "o" ).readObject( 0 )

		self.assertEqual( o2, o1 )
示例#8
0
	def testConstruction( self ) :

		fileName = os.path.dirname( __file__ ) + "/data/cube.abc"

		s = IECore.SceneInterface.create( fileName, IECore.IndexedIO.OpenMode.Read )
		self.assertEqual( s.fileName(), fileName )

		s = IECoreAlembic.AlembicScene( fileName, IECore.IndexedIO.OpenMode.Read )
		self.assertEqual( s.fileName(), fileName )
示例#9
0
	def testWriteStaticTransform( self ) :

		matrix = IECore.M44d().translate( IECore.V3d( 1 ) )

		a = IECoreAlembic.AlembicScene( "/tmp/test.abc", IECore.IndexedIO.OpenMode.Write )
		self.assertRaises( RuntimeError, a.writeTransform, IECore.M44dData( matrix ), 0 )

		b = a.createChild( "b" )
		b.writeTransform( IECore.M44dData( matrix ), 0 )
		del a, b

		a = IECoreAlembic.AlembicScene( "/tmp/test.abc", IECore.IndexedIO.OpenMode.Read )
		self.assertEqual( a.numTransformSamples(), 0 )
		self.assertEqual( a.readTransformAsMatrix( 0 ), IECore.M44d() )

		b = a.child( "b" )
		self.assertEqual( b.numTransformSamples(), 1 )
		self.assertEqual( b.readTransformAsMatrixAtSample( 0 ), matrix )
		self.assertEqual( b.readTransformAsMatrix( 0 ), matrix )
		self.assertEqual( b.readTransformAsMatrix( 0 ), matrix )
示例#10
0
	def testWriteAnimatedTransform( self ) :

		matrix1 = IECore.M44d().translate( IECore.V3d( 1 ) )
		matrix2 = IECore.M44d().translate( IECore.V3d( 2 ) )

		a = IECoreAlembic.AlembicScene( "/tmp/test.abc", IECore.IndexedIO.OpenMode.Write )

		b = a.createChild( "b" )
		b.writeTransform( IECore.M44dData( matrix1 ), 0 )
		b.writeTransform( IECore.M44dData( matrix2 ), 1 )
		del a, b

		a = IECoreAlembic.AlembicScene( "/tmp/test.abc", IECore.IndexedIO.OpenMode.Read )

		b = a.child( "b" )
		self.assertEqual( b.numTransformSamples(), 2 )
		self.assertEqual( b.readTransformAsMatrixAtSample( 0 ), matrix1 )
		self.assertEqual( b.readTransformAsMatrixAtSample( 1 ), matrix2 )
		self.assertEqual( b.readTransformAsMatrix( 0 ), matrix1 )
		self.assertEqual( b.readTransformAsMatrix( 1 ), matrix2 )
		self.assertEqual( b.readTransformAsMatrix( 0.5 ), IECore.M44d().translate( IECore.V3d( 1.5 ) ) )
示例#11
0
	def testWriteHierarchy( self ) :

		a = IECoreAlembic.AlembicScene( "/tmp/test.abc", IECore.IndexedIO.OpenMode.Write )
		a.createChild( "b" )
		c = a.child( "c", IECore.SceneInterface.MissingBehaviour.CreateIfMissing )
		self.assertEqual( a.childNames(), [ "b", "c" ] )
		self.assertEqual( c.path(), [ "c" ] )
		self.assertEqual( c.name(), "c" )

		d = c.createChild( "d" )
		self.assertEqual( a.childNames(), [ "b", "c" ] )
		self.assertEqual( c.childNames(), [ "d" ] )
		self.assertEqual( d.childNames(), [] )

		del a, c, d

		a = IECoreAlembic.AlembicScene( "/tmp/test.abc", IECore.IndexedIO.OpenMode.Read )
		self.assertEqual( a.childNames(), [ "b", "c" ] )
		self.assertEqual( a.child( "b").childNames(), [] )
		self.assertEqual( a.child( "c" ).childNames(), [ "d" ] )
		self.assertEqual( a.child( "c" ).child( "d" ).childNames(), [] )
示例#12
0
	def testWriteStaticBounds( self ) :

		aBound = IECore.Box3d( IECore.V3d( -2 ), IECore.V3d( 2 ) )
		bBound = IECore.Box3d( IECore.V3d( -1 ), IECore.V3d( 1 ) )

		a = IECoreAlembic.AlembicScene( "/tmp/test.abc", IECore.IndexedIO.OpenMode.Write )
		a.writeBound( aBound, 0 )

		b = a.createChild( "b" )
		b.writeBound( bBound, 0 )

		del a, b

		a = IECoreAlembic.AlembicScene( "/tmp/test.abc", IECore.IndexedIO.OpenMode.Read )
		self.assertEqual( a.numBoundSamples(), 1 )
		self.assertEqual( a.readBoundAtSample( 0 ), aBound )
		self.assertEqual( a.readBound( 0 ), aBound )

		b = a.child( "b" )
		self.assertEqual( b.numBoundSamples(), 1 )
		self.assertEqual( b.readBoundAtSample( 0 ), bBound )
		self.assertEqual( b.readBound( 0 ), bBound )