def testRandomCameras( self ) :

		random.seed( 42 )
		for i in range( 40 ):
			randomCamera = maya.cmds.camera()[0]
			cortexCamera = IECoreScene.Camera()
			projection = "orthographic" if random.random() > 0.5 else "perspective"
			cortexCamera.setProjection( projection )
			cortexCamera.setAperture( imath.V2f( random.uniform( 1, 20 ), random.uniform( 1, 20 ) ) )
			cortexCamera.setApertureOffset( imath.V2f( random.uniform( -10, 10 ), random.uniform( -10, 10 ) ) )
			if projection != "orthographic":
				cortexCamera.setFocalLength( random.uniform( 2.5, 200 ) )

			cortexCamera.setClippingPlanes( random.uniform( 1, 1000 ) + imath.V2f( 0, random.uniform( 1, 1000 ) ) )

			cortexCamera.setFStop( random.uniform( 1, 10 ) )
			cortexCamera.setFocusDistance( random.uniform( 0, 1000 ) )

			if cortexCamera.getProjection() == "orthographic":
				# Remove settings which we know will fail on ortho cameras in Maya ( see test below )
				del cortexCamera.parameters()["apertureOffset"]

				# Only square apertures supported
				cortexCamera.setAperture( imath.V2f( cortexCamera.getAperture()[0] ) )

			self.assertTrue( IECoreMaya.ToMayaCameraConverter( cortexCamera ).convert( randomCamera ) )
			self.assertIECoreCamAndMayaCamEqual( cortexCamera, randomCamera )
			roundTrip = IECoreMaya.FromMayaCameraConverter( randomCamera ).convert()
			self.assertIECoreCamsAlmostEqual( cortexCamera, roundTrip )

			maya.cmds.delete( randomCamera )
    def testFilmOffset(self):

        for x in [-0.5, -0.25, 0, 0.25, 0.5]:

            maya.cmds.setAttr("perspShape.horizontalFilmOffset", x)
            self.assertNotAlmostEqual(
                maya.cmds.getAttr("frontShape.horizontalFilmOffset"),
                maya.cmds.getAttr("perspShape.horizontalFilmOffset"))

            for y in [-0.5, -0.25, 0, 0.25, 0.5]:

                maya.cmds.setAttr("perspShape.verticalFilmOffset", y)
                self.assertNotAlmostEqual(
                    maya.cmds.getAttr("frontShape.verticalFilmOffset"),
                    maya.cmds.getAttr("perspShape.verticalFilmOffset"))

                front = IECoreMaya.FromMayaCameraConverter(
                    "frontShape").convert()
                persp = IECoreMaya.FromMayaCameraConverter(
                    "perspShape").convert()
                self.assertIECoreCamsNotEqual(front, persp)

                self.failUnless(
                    IECoreMaya.ToMayaCameraConverter(persp).convert("front"))
                self.assertMayaCamsEqual("frontShape", "perspShape")
                self.assertIECoreCamAndMayaCamEqual(persp, "frontShape")

                newFront = IECoreMaya.FromMayaCameraConverter(
                    "frontShape").convert()
                self.assertIECoreCamsEqual(persp, newFront)
Beispiel #3
0
	def testWrongIECoreObject( self ) :

		converter = IECoreMaya.ToMayaCameraConverter( IECoreScene.MeshPrimitive() )

		messageHandler = IECore.CapturingMessageHandler()
		with messageHandler :
			self.assertFalse( converter.convert( "topShape" ) )

		self.assertEqual( len( messageHandler.messages ), 1 )
		self.assertEqual( messageHandler.messages[0].level, IECore.MessageHandler.Level.Warning )
		self.assertEqual( messageHandler.messages[0].context, "ToMayaCameraConverter::doConversion" )
	def testUnrepresentable( self ) :

			testCamera = maya.cmds.camera()[0]
			cortexCamera = IECoreScene.Camera()
			cortexCamera.setProjection( "orthographic" )
			cortexCamera.setAperture( imath.V2f( 1, 2 ) )
			cortexCamera.setClippingPlanes( imath.V2f( 1, 100 ) )

			self.assertTrue( IECoreMaya.ToMayaCameraConverter( cortexCamera ).convert( testCamera ) )
			self.assertIECoreCamAndMayaCamEqual( cortexCamera, testCamera )
			roundTrip = IECoreMaya.FromMayaCameraConverter( testCamera ).convert()
			self.assertIECoreCamsAlmostEqual( cortexCamera, roundTrip )

			cortexCamera.setApertureOffset( imath.V2f( 3, 4 ) )

			self.assertTrue( IECoreMaya.ToMayaCameraConverter( cortexCamera ).convert( testCamera ) )
			self.assertIECoreCamAndMayaCamEqual( cortexCamera, testCamera )
			roundTrip = IECoreMaya.FromMayaCameraConverter( testCamera ).convert()
			self.assertIECoreCamsAlmostEqual( cortexCamera, roundTrip )

			maya.cmds.delete( testCamera )
Beispiel #5
0
	def testWrongMayaNode( self ) :

		maya.cmds.polySphere( name="pSphere" )
		persp = IECoreMaya.FromMayaCameraConverter( "perspShape" ).convert()
		converter = IECoreMaya.ToMayaCameraConverter( persp )

		messageHandler = IECore.CapturingMessageHandler()
		with messageHandler :
			self.assertFalse( converter.convert( "pSphereShape" ) )

		self.assertEqual( len( messageHandler.messages ), 1 )
		self.assertEqual( messageHandler.messages[0].level, IECore.MessageHandler.Level.Warning )
		self.assertEqual( messageHandler.messages[0].context, "ToMayaCameraConverter::doConversion" )
	def testNewCam( self ) :

		persp = IECoreMaya.FromMayaCameraConverter( "perspShape" ).convert()

		parent = maya.cmds.createNode( "transform" )
		self.assertTrue( IECoreMaya.ToMayaCameraConverter( persp ).convert( parent ) )

		cams = maya.cmds.listRelatives( parent, children=True, fullPath=True, type="camera" )
		self.assertEqual( len(cams), 1 )
		self.assertMayaCamsEqual( "|persp|perspShape", cams[0] )
		self.assertIECoreCamAndMayaCamEqual( persp, cams[0] )

		newCam = IECoreMaya.FromMayaCameraConverter( cams[0] ).convert()
		self.assertEqual( persp.parameters(), newCam.parameters() )
	def testFocalLengthWorldScale( self ) :

			testCamera = maya.cmds.camera()[0]
			cortexCamera = IECoreScene.Camera()
			cortexCamera.setProjection( "perspective" )
			cortexCamera.setAperture( imath.V2f( 36, 24 ) )
			cortexCamera.setFocalLength( 35 )
			cortexCamera.setClippingPlanes( imath.V2f( 1, 100 ) )
			cortexCamera.setApertureOffset( imath.V2f( 0 ) )
			cortexCamera.setFocusDistance( 1 )

			self.assertTrue( IECoreMaya.ToMayaCameraConverter( cortexCamera ).convert( testCamera ) )
			self.assertIECoreCamAndMayaCamEqual( cortexCamera, testCamera )
			roundTrip = IECoreMaya.FromMayaCameraConverter( testCamera ).convert()
			self.assertIECoreCamsAlmostEqual( cortexCamera, roundTrip )

			for scale in [ 1.0, 0.01 ]:
				cortexCamera.setFocalLengthWorldScale( scale )

				self.assertTrue( IECoreMaya.ToMayaCameraConverter( cortexCamera ).convert( testCamera ) )

				sel = maya.OpenMaya.MSelectionList()
				sel.add( testCamera )
				dag = maya.OpenMaya.MDagPath()
				sel.getDagPath( 0, dag )
				fn = maya.OpenMaya.MFnCamera( dag )
				self.assertAlmostEqual( fn.focalLength(), cortexCamera.getFocalLength() * scale / 0.1, places = 6 )

				roundTrip = IECoreMaya.FromMayaCameraConverter( testCamera ).convert()
				self.assertAlmostEqual( roundTrip.getFocalLength(), cortexCamera.getFocalLength() * scale / 0.1, places = 6 )

				# Check that despite using different units for focalLength and aperture, we still get the
				# same frustum
				self.assertEqual( roundTrip.frustum(), cortexCamera.frustum() )

			maya.cmds.delete( testCamera )
	def testSmallFocalLengths( self ) :

		random.seed( 42 )
		for i in range( 40 ):
			randomCamera = maya.cmds.camera()[0]
			cortexCamera = IECoreScene.Camera()
			cortexCamera.setProjection( "perspective" )
			cortexCamera.setAperture( imath.V2f( random.uniform( 0.1, 0.5 ), random.uniform( 0.1, 0.5 ) ) )
			cortexCamera.setApertureOffset( imath.V2f( random.uniform( -0.5, 0.5 ), random.uniform( -0.5, 0.5 ) ) )
			cortexCamera.setFocalLength( random.uniform( 0.1, 1 ) )

			cortexCamera.setClippingPlanes( random.uniform( 1, 1000 ) + imath.V2f( 0, random.uniform( 1, 1000 ) ) )

			self.assertTrue( IECoreMaya.ToMayaCameraConverter( cortexCamera ).convert( randomCamera ) )
			self.assertIECoreCamAndMayaCamEqual( cortexCamera, randomCamera )

			maya.cmds.delete( randomCamera )
	def testExistingCamParent( self ) :

		maya.cmds.setAttr( "frontShape.nearClipPlane", 1 )
		maya.cmds.setAttr( "frontShape.farClipPlane", 1000 )
		maya.cmds.setAttr( "frontShape.orthographicWidth", 2 )

		self.assertMayaCamsNotEqual( "frontShape", "perspShape" )

		front = IECoreMaya.FromMayaCameraConverter( "frontShape" ).convert()
		persp = IECoreMaya.FromMayaCameraConverter( "perspShape" ).convert()
		self.assertNotEqual( front, persp )

		self.assertTrue( IECoreMaya.ToMayaCameraConverter( front ).convert( "persp" ) )
		self.assertMayaCamsEqual( "frontShape", "perspShape" )
		self.assertIECoreCamAndMayaCamEqual( front, "perspShape" )

		newPersp = IECoreMaya.FromMayaCameraConverter( "perspShape" ).convert()
		self.assertEqual( front.parameters(), newPersp.parameters() )
Beispiel #10
0
	def testExistingCamParent( self ) :

		maya.cmds.setAttr( "frontShape.nearClipPlane", 1 )
		maya.cmds.setAttr( "frontShape.farClipPlane", 1000 )
		maya.cmds.setAttr( "frontShape.horizontalFilmAperture", 2 )
		maya.cmds.setAttr( "frontShape.verticalFilmAperture", 1 )

		self.assertMayaCamsNotEqual( "frontShape", "perspShape" )

		front = IECoreMaya.FromMayaCameraConverter( "frontShape" ).convert()
		persp = IECoreMaya.FromMayaCameraConverter( "perspShape" ).convert()
		self.assertIECoreCamsNotEqual( front, persp )

		self.failUnless( IECoreMaya.ToMayaCameraConverter( front ).convert( "persp" ) )
		self.assertMayaCamsEqual( "frontShape", "perspShape" )
		self.assertIECoreCamAndMayaCamEqual( front, "perspShape" )

		newPersp = IECoreMaya.FromMayaCameraConverter( "perspShape" ).convert()
		self.assertIECoreCamsEqual( front, newPersp )
Beispiel #11
0
	def testExistingCam( self ) :

		maya.cmds.setAttr( "topShape.nearClipPlane", 1 )
		maya.cmds.setAttr( "topShape.farClipPlane", 1000 )
		maya.cmds.setAttr( "topShape.horizontalFilmAperture", 2 )
		maya.cmds.setAttr( "topShape.verticalFilmAperture", 1 )

		self.assertMayaCamsNotEqual( "perspShape", "topShape" )

		persp = IECoreMaya.FromMayaCameraConverter( "perspShape" ).convert()
		top = IECoreMaya.FromMayaCameraConverter( "topShape" ).convert()
		self.assertIECoreCamsNotEqual( persp, top )

		self.failUnless( IECoreMaya.ToMayaCameraConverter( persp ).convert( "topShape" ) )
		self.assertMayaCamsEqual( "perspShape", "topShape" )
		self.assertIECoreCamAndMayaCamEqual( persp, "topShape" )

		newTop = IECoreMaya.FromMayaCameraConverter( "topShape" ).convert()
		self.assertIECoreCamsEqual( persp, newTop )